theorem MvPolynomial.vars_monomial :
    ∀ {R : Type u} {σ : Type u_1} {r : R} {s : σ →₀ ℕ} [inst : CommSemiring R],
      r ≠ 0 → MvPolynomial.vars ((MvPolynomial.monomial s) r) = s.support :=
  by sorry

The theorem `MvPolynomial.vars_monomial` states that for any commutative semiring `R`, a mapping `σ` of natural numbers, and a non-zero element `r` of `R`, the set of variables appearing in the monomial generated by applying `r` to the monomial function defined by `s` is equal to the support of `s`. Here, the support of a function `s` from `σ` to natural numbers is the set of `σ` for which `s` is nonzero. This essentially means that the variables appearing in such a monomial are precisely those with non-zero exponents.

The set of variables in the monomial generated by multiplying a non-zero element with a monomial function equals the support of the function.


theorem PartialHomeomorph.nhdsWithin_target_inter :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : Y}, x ∈ e.target → ∀ (s : Set Y), nhdsWithin x (e.target ∩ s) = nhdsWithin x s :=
  by sorry

This theorem states that for any given partial homeomorphism `e` between two topological spaces `X` and `Y`, and for any point `x` in the target of `e`, the neighborhood within `x` of the intersection between the target of `e` and any set `s` is equal to the neighborhood within `x` of `s`. In other words, when considering the topology near `x`, we can disregard the parts of `s` that lie outside the target of `e`. This is a property of continuity in topology and is specific to partial homeomorphisms, which are homeomorphisms between subsets of topological spaces.

For any partial homeomorphism $e$ between topological spaces $X$ and $Y$ and any point $x$ in the target of $e$, the neighborhood filter of $x$ in the intersection of the target of $e$ and any set $s$ equals the neighborhood filter of $x$ in $s$.


theorem Topology.IsScott.topology_eq :
    ∀ (α : Type u_1) [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Topology.IsScott α],
      inst_1 = Topology.scott α :=
  by sorry

This theorem states that for any type 'α' that is preordered and is endowed with a topological space and a Scott topology, the topology of that type 'α' is equal to the Scott topology. In other words, if we have a set that carries a pre-order (which is a binary relation indicating that, for certain pairs of elements in the set, one of the elements precedes the other in some ordering sequence) and a topology (which determines the closeness structure of elements), and if this set also carries a Scott topology (which is a specific kind of topology defined as the join of the topology of upper sets and the Scott-Hausdorff topology), then this Scott topology is equivalent to the initially given topology.

For any preordered type 'α' with a topology, the Scott topology on 'α' is equal to that topology.


theorem CliffordAlgebraComplex.toComplex_ι :
    ∀ (r : ℝ), CliffordAlgebraComplex.toComplex ((CliffordAlgebra.ι CliffordAlgebraComplex.Q) r) = r • Complex.I := by
  sorry

This theorem states that for any real number `r`, applying the function `CliffordAlgebraComplex.toComplex` to the result of applying `CliffordAlgebra.ι` (the canonical linear map from a module to the Clifford Algebra of a quadratic form) with the quadratic form `CliffordAlgebraComplex.Q` (which sends elements to the negation of their square) to `r`, will yield `r` scaled by the imaginary unit `Complex.I` in the complex number field. In essence, it connects Clifford algebras over the specific quadratic form `CliffordAlgebraComplex.Q` with the field of complex numbers, stating that the complex scalar multiple of the imaginary unit can be obtained from the Clifford algebra of the real number using these functions.

For any real number `r`, `CliffordAlgebraComplex.toComplex (CliffordAlgebra.ι CliffordAlgebraComplex.Q r) = r * Complex.I`.


theorem CategoryTheory.MonoidalNatTrans.tensor_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      {D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
      {F G : CategoryTheory.LaxMonoidalFunctor C D} (self : CategoryTheory.MonoidalNatTrans F G) (X Y : C) {Z : D}
      (h : G.obj (CategoryTheory.MonoidalCategory.tensorObj X Y) ⟶ Z),
      CategoryTheory.CategoryStruct.comp (F.μ X Y)
          (CategoryTheory.CategoryStruct.comp (self.app (CategoryTheory.MonoidalCategory.tensorObj X Y)) h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorHom (self.app X) (self.app Y))
          (CategoryTheory.CategoryStruct.comp (G.μ X Y) h) :=
  by sorry

This theorem, `CategoryTheory.MonoidalNatTrans.tensor_assoc`, states that for any types `C` and `D` which are categories and monoidal categories, and any lax monoidal functors `F` and `G` from `C` to `D`, every monoidal natural transformation `self` from `F` to `G`, and any objects `X` and `Y` in `C` and object `Z` in `D` with a morphism `h` from `G` applied to the tensor product of `X` and `Y` to `Z`, the composition of the morphism `F.μ X Y` and the morphism from applying `self` to `X` tensor `Y` to `h` is equal to the composition of the tensor product of applying `self` to `X` and applying `self` to `Y` with the composition of `G.μ X Y` and `h`. In terms of category theory, this theorem is asserting the associativity of tensoring in the context of monoidal natural transformations.

For any categories and monoidal categories C and D, lax monoidal functors F and G, monoidal natural transformation self from F to G, objects X, Y in C, and object Z in D with a morphism h from G(X) ⊗(C) Y to Z, we have F(μ X Y) ⊗(D) h = (G(μ X Y) ⊗ h) ∘ (self(X) ⊗ self(Y)).


theorem CategoryTheory.Abelian.coimageImageComparison.proof_4 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C] {P Q : C}
      (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f)
          (CategoryTheory.Limits.kernel.lift (CategoryTheory.Limits.cokernel.π f) f ⋯) =
        0 :=
  by sorry

This theorem in the category theory of abelian categories, named `CategoryTheory.Abelian.coimageImageComparison.proof_4`, asserts that for any morphism `f : P ⟶ Q` in an abelian category `C` with zero morphisms, kernels, and cokernels, the composition of the morphism from the kernel of `f` to the source of `f`, with a certain lifted morphism related to the morphism from the target of `f` to the cokernel of `f`, is the zero morphism. In more mathematical terms, it states that `kernel.ι(f) ∘ kernel.lift(cokernel.π(f)) = 0`.

In an abelian category with zero morphisms, kernels, and cokernels, the composition of the inclusion morphism from the kernel of a morphism to its source, and the lifted morphism from the cokernel of the morphism to its target, is the zero morphism.


theorem CategoryTheory.Abelian.coimageImageComparison.proof_3 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasCokernels C] {P Q : C} (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.cokernel.π f) = 0 :=
  by sorry

The theorem `CategoryTheory.Abelian.coimageImageComparison.proof_3` states that for any Category `C` that has zero morphisms and cokernels, and for any morphism `f` from object `P` to `Q` in `C`, the composition of `f` and the map from the target of `f` to its cokernel is the zero morphism. In other words, given `f : P ⟶ Q`, we have `f ≫ cokernel.π f = 0`. This is a characteristic property of cokernels in category theory, which in essence captures the idea of 'quotienting out' by the image of a morphism.

For any morphism `f` in an Abelian category with zero morphisms and cokernels, `f ≫ cokernel.π f = 0`.


theorem GroupCat.epi_iff_surjective : ∀ {A B : GroupCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ Function.Surjective ⇑f :=
  by sorry

This theorem states that for any two objects `A` and `B` in the category of groups, a morphism `f` from `A` to `B` is an epimorphism if and only if the underlying function of `f` is surjective. In other words, `f` is an epimorphism in the category of groups (i.e., for any two morphisms `g, h : B ⟶ C`, if `g ∘ f = h ∘ f` then `g = h`) if and only if for every element `b` in `B` there exists an element `a` in `A` such that `f(a) = b`.

In the category of groups, a morphism is an epimorphism if and only if its underlying function is surjective.


theorem lcm_units_coe_left :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (u : αˣ) (a : α),
      lcm (↑u) a = normalize a :=
  by sorry

The theorem `lcm_units_coe_left` states that for any type `α` that is a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid`, and any unit `u` and element `a` in `α`, the least common multiple of `u` and `a` is equal to the normalization of `a`. In other words, the least common multiple of a unit and any other element in a cancel commutative monoid with zero, which also forms a normalized gcd monoid, is simply the normalized form of the other element.

For any unit `u` and element `a` in a cancel commutative monoid with zero and normalized gcd properties, the least common multiple of `u` and `a` equals the normalized form of `a`.


theorem Polynomial.smul_eq_map :
    ∀ {M : Type u_1} [inst : Monoid M] (R : Type u_2) [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] (m : M),
      HSMul.hSMul m = Polynomial.map (MulSemiringAction.toRingHom M R m) :=
  by sorry

The theorem `Polynomial.smul_eq_map` states that for any monoid `M`, semiring `R`, and a multiplication action of `M` on `R`, every element `m` of `M` induces a semiring homomorphism that maps a polynomial over `R` to a polynomial over `R`, and this homomorphism is equivalent to the left action of `m` on a polynomial. In other words, the scalar multiplication of a polynomial by `m` is the same as mapping the polynomial across a ring homomorphism defined by the action of `m`.

For any monoid action on a semiring, the induced homomorphism from an element in the monoid maps polynomials over the semiring to polynomials over the semiring, and this homomorphism is equal to the left multiplication by the element on polynomials.


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

This theorem, `max_choice`, states that for any type `α` that has a linear order, and for any two elements `a` and `b` of this type, the maximum of `a` and `b` is either `a` or `b`. In simpler words, this theorem says that for any two numbers `a` and `b`, the larger (or maximum) of the two is always either `a` or `b`.

For any type `α` with a linear order, the maximum of two elements `a` and `b` is equal to `a` if `a` is greater than or equal to `b`, and equal to `b` otherwise.


theorem tendsto_list_prod :
    ∀ {ι : Type u_1} {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Monoid M]
      [inst_2 : ContinuousMul M] {f : ι → α → M} {x : Filter α} {a : ι → M} (l : List ι),
      (∀ i ∈ l, Filter.Tendsto (f i) x (nhds (a i))) →
        Filter.Tendsto (fun b => List.prod (List.map (fun c => f c b) l)) x (nhds (List.prod (List.map a l))) :=
  by sorry

The theorem `tendsto_list_prod` states that for any type `ι`, `α`, and `M` where `M` is a topological space with a monoid structure and continuous multiplication, given a function `f` from `ι` to a function from `α` to `M`, a filter `x` on `α`, and a list `l` of elements of type `ι`, if for all elements `i` in `l`, the function `f i` tends towards the neighborhood of `a i` under the filter `x`, then the function that maps any element `b` of the filter to the product of the list obtained by mapping `f c b` over `l` also tends towards the neighborhood of the product of the list obtained by mapping `a` over `l` under the filter `x`. In other words, it says that the limit of the product of a list of functions is the product of the limits of the functions, provided each function tends to its respective limit.

Given a topological space `M` with a monoid structure and continuous multiplication, if for all `i` in a list `l` and for all `x` in a filter on the domain of a function `f` from a type `ι` to functions from an `α` to `M`, `f i(x)` converges to `a i` as `x` approaches a limit, then the function that maps `x` to the product of `f i(x)` over `l` converges to the product of `a i` over `l` as `x` approaches a limit.


theorem Equiv.Perm.Disjoint.disjoint_support :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f g : Equiv.Perm α},
      Equiv.Perm.Disjoint f g → Disjoint (Equiv.Perm.support f) (Equiv.Perm.support g) :=
  by sorry

The theorem `Equiv.Perm.Disjoint.disjoint_support` states that for any type `α` with decidable equality and finiteness, given two permutations `f` and `g` over `α`, if `f` and `g` are disjoint (i.e., for any element in `α`, it is either fixed by `f` or by `g`), then the sets of non-fixed points (or "supports") of `f` and `g` are also disjoint. Here, two sets are considered disjoint if their intersection is the empty set.

Given permutations `f` and `g` over a finite type `α` with decidable equality, if `f` and `g` are disjoint, then their non-fixed point sets are disjoint.


theorem OrderEmbedding.preimage_Icc :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ↪o β) (x y : α),
      ⇑e ⁻¹' Set.Icc (e x) (e y) = Set.Icc x y :=
  by sorry

The theorem `OrderEmbedding.preimage_Icc` states that for all types `α` and `β` which have a preorder relationship (meaning that they can be compared in a certain way), and for all order embeddings `e` from `α` into `β`, and any two elements `x` and `y` of `α`, the preimage of the closed interval `[e(x), e(y)]` under the map `e` is precisely the closed interval `[x, y]` in `α`.

In other words, if we apply the order-embedding `e` to the elements of the interval `[x, y]` in `α`, and then take the preimage under `e`, we will recover the original interval `[x, y]`. This theorem shows the preservation of the closed interval under the order-embedding and its inverse.

For any preorder types `α` and `β`, and order embedding `e` from `α` to `β`, the preimage of an interval `[e(x), e(y)]` in `β` under `e` is equal to the interval `[x, y]` in `α`.


theorem Mathlib.Topology.MetricSpace.Antilipschitz._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal}
      {f : α → β}, AntilipschitzWith K f = ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y) :=
  by sorry

The theorem `Mathlib.Topology.MetricSpace.Antilipschitz._auxLemma.1` states that for all types `α` and `β` that are pseudo metric spaces, for a nonnegative real number `K` and a function `f` from `α` to `β`, `f` is `AntilipschitzWith` `K` if and only if the distance from `x` to `y` in the space `α` is less than or equal to `K` times the distance from `f(x)` to `f(y)` in the space `β`. This theorem explicitly describes the property of a function being Antilipschitz with respect to a certain constant, which is related to the function not expanding distances between any two points.

A function between two pseudo metric spaces is Antilipschitz with constant K if and only if the distance between any two points in the first space is less than or equal to K times the distance between their images in the second space.


theorem Real.hasDerivAt_arctan' : ∀ (x : ℝ), HasDerivAt Real.arctan (1 + x ^ 2)⁻¹ x := by sorry

The theorem `Real.hasDerivAt_arctan'` states that for every real number `x`, the function `Real.arctan` has a derivative at the point `x`. The derivative of the function at `x` is given by `(1 + x ^ 2)⁻¹`. In mathematical terms, this is expressing that the derivative of the arctan function at any point x is 1/(1 + x²).

The theorem `Real.hasDerivAt_arctan` asserts that the derivative of the arctan function is 1/(1 + x²) for every real number x.


theorem dist_add_add_le :
    ∀ {E : Type u_6} [inst : SeminormedAddCommGroup E] (a₁ a₂ b₁ b₂ : E),
      dist (a₁ + a₂) (b₁ + b₂) ≤ dist a₁ b₁ + dist a₂ b₂ :=
  by sorry

This theorem states that for any type `E`, which forms a seminormed add commutative group, the distance between the sum of two elements `a₁` and `a₂` and the sum of two elements `b₁` and `b₂` is less than or equal to the sum of the distances between `a₁` and `b₁` and `a₂` and `b₂`. This is a generalization of the triangle inequality to seminormed add commutative groups.

For any seminormed add commutative group `E` and elements `a₁, a₂, b₁, b₂` in `E`, the inequality `dist (a₁ + a₂, b₁ + b₂) ≤ dist (a₁, b₁) + dist (a₂, b₂)` holds.


theorem Ordnode.Bounded.to_lt :
    ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {x y : α}, Ordnode.Bounded t ↑x ↑y → x < y := by sorry

This theorem states that for any type `α` with a preorder, and for any Ordnode `t` of type `α`, along with any two elements `x` and `y` of type `α`, if the Ordnode `t` is bounded by `x` and `y`, then `x` is strictly less than `y`. It's essentially a property of the 'bounded' condition in the context of ordered nodes or Ordnode. This theorem is proven under the assumption that the provided type `α` has a preorder, which is a binary relation that is reflexive and transitive.

If `α` is a type with a preorder, and `t` is an Ordnode of `α` bounded by elements `x` and `y` of `α`, then `x` strictly precedes `y` in the preorder.


theorem AddMonoidAlgebra.modOf_apply_of_exists_add :
    ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCancelCommMonoid G] (x : AddMonoidAlgebra k G)
      (g g' : G), (∃ d, g' = g + d) → (AddMonoidAlgebra.modOf x g) g' = 0 :=
  by sorry

The theorem `AddMonoidAlgebra.modOf_apply_of_exists_add` asserts that for any semiring `k`, any additive cancel commutative monoid `G`, any element `x` from the monoid algebra of `G` over `k`, and any elements `g` and `g'` from `G`, if there exists a member `d` from `G` such that `g'` is the sum of `g` and `d`, then the application of the function `AddMonoidAlgebra.modOf x g` to `g'` yields zero. In other words, if `g'` can be written as `g` plus some element, then `g'` gets mapped to zero by the "modulus" operation `AddMonoidAlgebra.modOf x g` in the monoid algebra.

For any semiring `k`, additive cancel commutative monoid `G`, element `x` in the monoid algebra of `G` over `k`, and elements `g` and `g'` in `G`, if there exists `d` in `G` such that `g' = g + d`, then `AddMonoidAlgebra.modOf x g (g') = 0`.


theorem IsCompact.add_closedBall :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {δ : ℝ} {s : Set E},
      IsCompact s → 0 ≤ δ → ∀ (x : E), s + Metric.closedBall x δ = x +ᵥ Metric.cthickening δ s :=
  by sorry

The theorem `IsCompact.add_closedBall` states that for any seminormed additive commutative group `E`, nonnegative real number `δ`, and a set `s` of type `E` that is compact, for any element `x` in `E`, the sum of set `s` and the closed ball centered at `x` with radius `δ` equals the sum of `x` and the `δ`-thickening of set `s`. Here, the sum of a set and a closed ball refers to the set of all sums of an element from the set and an element from the closed ball, and similarly for the sum of a point `x` and a set. The `δ`-thickening of a set `s` consists of points whose minimum distance from `s` is at most `δ`.

For any compact set $s$ in a seminormed additive commutative group $E$ and any element $x$ in $E$, the sum of $s$ and the closed ball centered at $x$ with radius $\delta$ equals the set of all sums of an element from $s$ and an element from the $\delta$-thickening of $x$ around $s$.


theorem Set.eq_singleton_or_nontrivial : ∀ {α : Type u} {a : α} {s : Set α}, a ∈ s → s = {a} ∨ Set.Nontrivial s := by
  sorry

The theorem `Set.eq_singleton_or_nontrivial` states that for any set `s` of type `α` and any element `a` of type `α`, if `a` is in `s`, then `s` is either a singleton set containing only `a` or `s` is nontrivial. In this context, a set is considered nontrivial if it contains at least two distinct elements.

If a set `s` contains an element `a`, then `s` is a singleton containing only `a` or `s` is a nontrivial set with at least two distinct elements.


theorem Pi.single_op₂ :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] {g₁ : I → Type u_4}
      {g₂ : I → Type u_5} [inst_2 : (i : I) → Zero (g₁ i)] [inst_3 : (i : I) → Zero (g₂ i)]
      (op : (i : I) → g₁ i → g₂ i → f i),
      (∀ (i : I), op i 0 0 = 0) →
        ∀ (i : I) (x₁ : g₁ i) (x₂ : g₂ i),
          Pi.single i (op i x₁ x₂) = fun j => op j (Pi.single i x₁ j) (Pi.single i x₂ j) :=
  by sorry

This theorem is known as `Pi.single_op₂`. It states that for any type `I`, and for any type functions `f`, `g₁`, and `g₂` from `I` to some other types, given that `I` has a decidable equality, and `f`, `g₁`, and `g₂` are equipped with a zero element at each `i : I`, if we have a binary operation `op : (i: I) → g₁ i → g₂ i → f i` such that `op i 0 0 = 0` for all `i : I`, then for each `i : I` and elements `x₁ : g₁ i` and `x₂ : g₂ i`, the function `Pi.single i (op i x₁ x₂)` equals the function that takes any `j : I` and maps it to `op j (Pi.single i x₁ j) (Pi.single i x₂ j)`. This theorem essentially asserts a property related to the interaction between a certain binary operation and the function `Pi.single`, which gives the value `x` at `i` and `0` elsewhere.

For any type `I` with decidable equality, functions `f, g₁, g₂ : I →* X` from `I` to some type `X`, and a binary operation `op : I → g₁ → g₂ → f`, if `op` satisfies `op i 0 0 = 0` for all `i : I`, then `Pi.single i (op i ( Pi.single i x₁ i ) ( Pi.single i x₂ i )) = λ j, op j (Pi.single i x₁ j) (Pi.single i x₂ j)` for all `x₁ : g₁ i` and `x₂ : g₂ i`.


Pi.summable

theorem Pi.summable :
    ∀ {α : Type u_1} {ι : Type u_5} {π : α → Type u_6} [inst : (x : α) → AddCommMonoid (π x)]
      [inst_1 : (x : α) → TopologicalSpace (π x)] {f : ι → (x : α) → π x},
      Summable f ↔ ∀ (x : α), Summable fun i => f i x :=
  by sorry

The theorem `Pi.summable` states that for all types `α`, `ι`, and a type function `π` from `α` to some type; given an additive commutative monoid structure and a topological space structure for every element of type `α`; and a function `f` from `ι` to a function mapping `α` to `π x`, `f` is summable if and only if for every `x` of type `α`, the function `f i x` is summable. Here, `Summable f` denotes the existence of an (possibly infinite) sum for the function `f`.

For a function `f` from an index type `ι` to functions from type `α` to a summable type `π`, `f` is summable if and only if for all `x` in `α`, the function `f i x` is summable.


theorem convex_halfspace_le :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : Module 𝕜 E] [inst_3 : OrderedAddCommMonoid β] [inst_4 : Module 𝕜 β] [inst_5 : OrderedSMul 𝕜 β]
      {f : E → β}, IsLinearMap 𝕜 f → ∀ (r : β), Convex 𝕜 {w | f w ≤ r} :=
  by sorry

This theorem, named `convex_halfspace_le`, states that for any ordered semiring `𝕜`, any additive commutative monoid `E`, any ordered additive commutative monoid `β`, any `𝕜`-module `E`, any `𝕜`-module `β`, any `𝕜`-module `β` with a partial order compatible with scalar multiplication, any linear map `f` from `E` to `β`, and any element `r` of `β`, the set of elements `w` of `E` for which `f(w)` is less than or equal to `r` is a convex set in `E`.

In simpler terms, it states that for any linear function mapping from one mathematical structure to another, the set of elements that map to a value less than or equal to a given value forms a convex set. This concept is frequently used in fields like optimization and computational geometry.

For any linear map from an additive commutative semigroup to an ordered additive commutative semigroup and any element in the image semigroup, the preimage under the map forms a convex set.


theorem OrderEmbedding.preimage_Ioc :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ↪o β) (x y : α),
      ⇑e ⁻¹' Set.Ioc (e x) (e y) = Set.Ioc x y :=
  by sorry

The theorem `OrderEmbedding.preimage_Ioc` states that for any two types `α` and `β` with a preorder relation, and for any order-embedding `e` from `α` to `β`, the preimage of the left-open right-closed interval `(e x, e y]` under the embedding `e` equals the interval `(x, y]` in `α`. In other words, if you apply `e` to each element in the interval `(x, y]` and then take the preimage under `e`, you get the interval `(x, y]` back.

For any order-embedding `e` between types `α` and `β` with preorder relations, the preimage of the interval `(e x, e y]` in `β` is equal to the interval `(x, y]` in `α`.


theorem Mathlib.Topology.MetricSpace.Isometry._auxLemma.2 :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f = ∀ (x y : α), nndist (f x) (f y) = nndist x y :=
  by sorry

The theorem `Mathlib.Topology.MetricSpace.Isometry._auxLemma.2` in natural language states: For all types `α` and `β` that are instances of `PseudoMetricSpace`, and for any function `f` from `α` to `β`, `f` is an isometry (a map preserving the extended distance between pseudoemetric spaces) if and only if for all `x` and `y` in `α`, the non-negative distance (nndist) between `f(x)` and `f(y)` in `β` is equal to the non-negative distance between `x` and `y` in `α`.

A function between two pseudo-metric spaces is an isometry if and only if it preserves non-negative distances, i.e., the distance between the images of any two points is equal to the distance between the points themselves.


theorem Mathlib.Topology.MetricSpace.Isometry._auxLemma.1 : ∀ {p q : NNReal}, (↑p = ↑q) = (p = q) := by sorry

This theorem states that for any two nonnegative real numbers 'p' and 'q', the equality of their embeddings (that is, considering 'p' and 'q' as real numbers rather than as nonnegative real numbers) is equivalent to the equality of 'p' and 'q' themselves. In other words, two nonnegative real numbers 'p' and 'q' are equal if and only if their corresponding real numbers are equal.

For any nonnegative real numbers p and q, p = q if and only if their corresponding real numbers are equal.


theorem Mathlib.Topology.MetricSpace.Isometry._auxLemma.4 : ∀ {r₁ r₂ : NNReal}, (↑r₁ = ↑r₂) = (r₁ = r₂) := by sorry

This theorem, referred to as `Mathlib.Topology.MetricSpace.Isometry._auxLemma.4`, states that for any two nonnegative real numbers `r₁` and `r₂` (denoted in Lean 4 as `{r₁ r₂ : NNReal}`), the equality of these two numbers in their lifted form (represented as `↑r₁ = ↑r₂`) is equivalent to the equality of these two numbers in their original form (represented as `r₁ = r₂`). The lifted form refers to the representation of these numbers in a different type or space.

The theorem `Mathlib.Topology.MetricSpace.Isometry._auxLemma.4` in Lean 4 states that for any nonnegative real numbers `r₁` and `r₂`, `↑r₁ = ↑r₂` if and only if `r₁ = r₂`.


theorem convex_halfspace_ge :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : Module 𝕜 E] [inst_3 : OrderedAddCommMonoid β] [inst_4 : Module 𝕜 β] [inst_5 : OrderedSMul 𝕜 β]
      {f : E → β}, IsLinearMap 𝕜 f → ∀ (r : β), Convex 𝕜 {w | r ≤ f w} :=
  by sorry

The theorem `convex_halfspace_ge` states that for any ordered semiring `𝕜`, additive commutative monoid `E`, ordered additive commutative monoid `β`, and any functions `f` from `E` to `β` that are linear maps over the semiring `𝕜`, for any `r` in `β`, the set of all `w` in `E` such that `r` is less than or equal to `f(w)` is a convex set over the semiring `𝕜`. In short, the half-space defined by the linear function `f` and the value `r` is a convex set.

For any ordered semiring 𝕜, additive commutative monoid E, ordered additive commutative monoid β, and linear function f from E to β over semiring 𝕜, the half-space {w ∈ E | r ≤ f(w)} is convex for any r ∈ β.


theorem mem_nhdsSet_iff_exists :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, s ∈ nhdsSet t ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s := by
  sorry

This theorem states that for any two sets `s` and `t` in a given topological space `X`, `s` is in the filter of neighborhoods of `t` if and only if there exists a set `U` such that `U` is open in `X`, `t` is a subset of `U`, and `U` is a subset of `s`. In other words, a set `s` is a neighborhood of another set `t` in the topological space `X` if there's an open set `U` that contains `t` and is contained in `s`.

A set is a neighborhood of another set in a topological space if and only if it contains an open set that contains the other set.


theorem MulOpposite.op_zero : ∀ (α : Type u_1) [inst : Zero α], MulOpposite.op 0 = 0 := by sorry

The theorem `MulOpposite.op_zero` states that for any type `α` that has a zero element (indicated by `[inst : Zero α]`), the "opposite" (under multiplication) of the zero element is itself. In other words, applying the `MulOpposite.op` function to zero yields zero. This is consistent with the mathematical principle that the additive identity (zero) is its own multiplicative opposite.

For any type `α` with a zero element, `MulOpposite.op (Zero α) = Zero α`.


theorem MeasureTheory.MeasurePreserving.aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.MeasurePreserving f μa μb → AEMeasurable f μa :=
  by sorry

This theorem states that for any types `α` and `β`, and any associated measurable spaces `inst` and `inst_1`, along with measures `μa` and `μb` on these spaces, if a function `f` from `α` to `β` preserves the measure (`μa` to `μb`), then `f` is almost everywhere measurable with respect to `μa`. In other words, there exists a measurable function `g` that coincides with `f` almost everywhere (except possibly on a set of measure zero).

If `α` and `β` are types with measurable spaces `inst` and `inst_1`, and measures `μa` and `μb`, and `f` is a function from `α` to `β` preserving the measure `μa` to `μb`, then `f` is almost everywhere measurable with respect to `μa`, that is, there exists a measurable function `g` such that `f = g` almost everywhere.


theorem sSup_inf_eq : ∀ {α : Type u} [inst : Order.Frame α] {s : Set α} {b : α}, sSup s ⊓ b = ⨆ a ∈ s, a ⊓ b := by sorry

This theorem, named `sSup_inf_eq`, states that for any type `α` with a frame structure (which makes it a partially ordered set with certain additional properties related to suprema and infima), for any set `s` of elements of type `α`, and for any element `b` of type `α`, the infimum of the supremum of `s` and `b` is equal to the supremum of the set of all infima of elements `a` in `s` and `b`. In mathematical notation, this can be written as: `inf(sup(s), b) = sup({inf(a, b) | a ∈ s})`.

For any frame-structured type `α` and set `s` of elements, the infimum of the supremum of `s` and an element `b` equals the supremum of the set of infima of each element in `s` and `b`. In mathematical notation: `inf(sup(s), b) = sup({inf(a, b) | a ∈ s})`.


/-- The distance between two points in a set is controlled by the diameter of the set.  -/
theorem Metric.dist_le_diam_of_mem' :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x y : α},
      EMetric.diam s ≠ ⊤ → x ∈ s → y ∈ s → dist x y ≤ Metric.diam s :=
  by sorry

This theorem states that, in a pseudo metric space, the distance between any two points in a set is bounded by the diameter of the set. Specifically, for any set within a pseudo metric space and any two points within that set, if the diameter of the set is not infinite, then the distance between the two points is less than or equal to the diameter of the set. In mathematical terms, if `s` is a set in a pseudo metric space `α`, and `x` and `y` are elements of `s` such that the diameter of `s` is not infinity, then the distance between `x` and `y` is less than or equal to the diameter of `s`.

In a pseudo metric space, the distance between any two points in a finite-diameter set is less than or equal to the diameter of the set.


theorem Mathlib.SetTheory.Cardinal.Basic._auxLemma.8 : ∀ {α : Type u_1} [inst : AddMonoidWithOne α], 2 = 1 + 1 := by
  sorry

This theorem states that for any type `α` which is an instance of the `AddMonoidWithOne` class, the number 2 is equal to the sum of 1 and 1. Here, `AddMonoidWithOne` represents a set equipped with an associative addition operation and a distinct element of the set, usually denoted as 1, that serves as a neutral element for the addition. In simpler terms, it's the mathematical way of expressing that 1 + 1 equals 2 in any additively monoidal set with a distinct 1 element.

For any type `α` instancing `AddMonoidWithOne`, 1 + 1 equals 2.


/-- **Fundamental theorem of calculus-1**, strict differentiability in the right endpoint.

If `f : ℝ → E` is integrable on `a..b` and `f x` has a finite limit `c` almost surely at `b`, then
`u ↦ ∫ x in a..u, f x` has derivative `c` at `b` in the sense of strict differentiability.  -/
theorem intervalIntegral.integral_hasStrictDerivAt_of_tendsto_ae_right :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {f : ℝ → E}
      {c : E} {a b : ℝ},
      IntervalIntegrable f MeasureTheory.volume a b →
        StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
          Filter.Tendsto f (nhds b ⊓ MeasureTheory.Measure.ae MeasureTheory.volume) (nhds c) →
            HasStrictDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) c b :=
  by sorry

The theorem, "Fundamental theorem of calculus-1, strict differentiability at the right endpoint", states that given a function `f : ℝ → E` that is interval integrable over `a..b`, and if `f(x)` has a limit `c` almost everywhere at `b`, then the function `u ↦ ∫ x in a..u, f x` has a derivative `c` at `b` in the sense of strict differentiability. In other words, if the function `f` is integrable within the interval `a..b` and converges strongly to `c` at `b`, the indefinite integral of `f` from `a` to `u` has a strict derivative of `c` at `b`.

If a real-valued function `f` is integrable over the interval `[a, b]` and has a limit `c` at `b`, then the function `F(x) = ∫[a, x], f(t) dt` is strictly differentiable at `x = b` with derivative `c`.


theorem Set.IsWF.not_lt_min :
    ∀ {α : Type u_2} [inst : Preorder α] {s : Set α} {a : α} (hs : Set.IsWF s) (hn : Set.Nonempty s),
      a ∈ s → ¬a < Set.IsWF.min hs hn :=
  by sorry

This theorem states that, for any given type `α` that has a preorder relation and any set `s` of type `α` that is well-founded and nonempty, for any element `a` that belongs to this set `s`, there cannot be an element `a` that is less than the minimum element of the set `s`. In other words, there's no element in a nonempty well-founded set that is less than the minimum element of that set.

In a nonempty, well-founded set endowed with a preorder relation, there is no element less than the minimum element.


theorem Real.sin_nonneg_of_mem_Icc : ∀ {x : ℝ}, x ∈ Set.Icc 0 Real.pi → 0 ≤ Real.sin x := by sorry

This theorem states that for any real number 'x', if 'x' lies in the interval from 0 to π (both inclusive), then the sine of 'x' is non-negative. In mathematical terms, this is saying that for all real numbers 'x', if '0 ≤ x ≤ π', then '0 ≤ sin(x)'. This result is a consequence of the properties of the sine function on the interval [0, π] in trigonometry.

For all real numbers x, if 0 ≤ x ≤ π, then 0 ≤ sin(x).


theorem PiLp.lipschitzWith_equiv_aux :
    ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)]
      [inst_1 : (i : ι) → PseudoEMetricSpace (β i)] [inst_2 : Fintype ι],
      LipschitzWith 1 ⇑(WithLp.equiv p ((i : ι) → β i)) :=
  by sorry

The theorem `PiLp.lipschitzWith_equiv_aux` states that for every extended nonnegative real number `p`, every indexed type `ι`, and for each index `i` of type `ι`, a pseudo-emetric space `β i` (where the `β` is a function from the index set `ι` to some type `u_4`), assuming that `p` is at least 1 and the index set `ι` is a finite set (Fintype), the function `WithLp.equiv p ((i : ι) → β i))` is Lipschitz continuous with constant 1. In other words, the distance between the images of any two points under this function is at most the distance between the points themselves in their original pseudo-emetric space.

For every finite indexed set `ι` and real number `p ≥ 1`, the function `WithLp.equiv p (β : ∀ i : ι, β i)` from the pseudo-metric space `(ι, d)` to the product pseudo-metric space `(Π i : ι, β i)` is Lipschitz continuous with constant 1.


theorem IsLocalization.Away.AwayMap.lift_eq :
    ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
      {P : Type u_3} [inst_3 : CommSemiring P] (x : R) [inst_4 : IsLocalization.Away x S] {g : R →+* P}
      (hg : IsUnit (g x)) (a : R), (IsLocalization.Away.lift x hg) ((algebraMap R S) a) = g a :=
  by sorry

This theorem, named `IsLocalization.Away.AwayMap.lift_eq`, states that for all types `R`, `S`, and `P` which are structures of commutative semirings with `R` and `S` being algebras, there exists an element `x` in `R` such that `S` is isomorphic to the localization of `R` at the submonoid generated by `x`. Given a ring homomorphism `g` from `R` to `P` such that `g(x)` is a unit (i.e., it has a two-sided inverse), and an element `a` in `R`, applying the lift of the localization of `R` at `x`, followed by the embedding of `R` into `S`, to `a` is equivalent to applying `g` to `a`. In other words, the diagram commutes. This theorem is fundamental in the study of localizations in algebra, linking properties of original rings to their localizations.

Given commutative semirings R, S, and P with R and S being algebras, an element x in R, a ring homomorphism g from R to P with g(x) a unit, and an element a in R, the diagram commutes: localization of R at x in S ≅ {b in S | ∃ c in R, g(c) = b and cx = xa} → a → g(a).


theorem Complex.cpow_mul :
    ∀ {x y : ℂ} (z : ℂ),
      -Real.pi < (Complex.log x * y).im → (Complex.log x * y).im ≤ Real.pi → x ^ (y * z) = (x ^ y) ^ z :=
  by sorry

The theorem `Complex.cpow_mul` states that for any complex numbers `x`, `y`, and `z`, if the imaginary part of the product of the complex logarithm of `x` and `y` is greater than `-π` and less or equal to `π`, then the power of `x` raised to the product of `y` and `z` is equal to the power of `x` raised to `y` raised to `z`. In other words, `(x^(y*z)) = ((x^y)^z)`, given the specified conditions on the imaginary part of `log(x) * y`.

If the imaginary part of the complex logarithm of complex numbers x and y satisfies the condition -π < Im(log(x) * y) <= π, then x^(y*z) = (x^y)^z.


theorem MeasureTheory.Measure.map_sum :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {ι : Type u_7}
      {m : ι → MeasureTheory.Measure α} {f : α → β},
      AEMeasurable f (MeasureTheory.Measure.sum m) →
        MeasureTheory.Measure.map f (MeasureTheory.Measure.sum m) =
          MeasureTheory.Measure.sum fun i => MeasureTheory.Measure.map f (m i) :=
  by sorry

The theorem `MeasureTheory.Measure.map_sum` states that for any types `α`, `β`, and `ι`, along with a measurable space `m0` on `α`, a measurable space instance on `β`, a function `m` from `ι` to measures on `α`, and a function `f` from `α` to `β`: If the function `f` is almost everywhere measurable with respect to the sum of the measures given by `m`, then the pushforward of the sum of the measures by the function `f` is equal to the sum of the pushforwards of the individual measures by `f`. In other words, when a function is almost everywhere measurable, mapping the function across the sum of measures is the same as summing the measures obtained by mapping the function across each individual measure.

If `m:` ι → MeasurableSpace α, `f:` α → β is almost everywhere measurable, then `∫(∑ i: ι, m i)(f) = ∑ i: ι, ∫m i(f)`.


theorem DFinsupp.not_mem_support_iff :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] {f : Π₀ (i : ι), β i} {i : ι},
      i ∉ DFinsupp.support f ↔ f i = 0 :=
  by sorry

The theorem `DFinsupp.not_mem_support_iff` states that for any types `ι` and `β`, given that `ι` has decidable equality, for every `i : ι` the type `β i` has an identified zero, and for every `i : ι` and `x : β i`,  the inequality `x ≠ 0` is decidable, if we have a function `f : Π₀ (i : ι), β i` and a term `i : ι`, then `i` is not in the support of `f` (i.e., `i ∉ DFinsupp.support f`) if and only if the value of `f` at `i` is zero (i.e., `f i = 0`). The "support" of `f` is the set of indices `i` where `f i ≠ 0`.

For any type `ι` with decidable equality and every function `f : Π₀ (i : ι), β i` over a type `β` with identified zero and decidable inequality, the index `i` is not in the support of `f` if and only if `f i` equals the identified zero.


Perfection.ext

theorem Perfection.ext :
    ∀ {R : Type u₁} [inst : CommSemiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p]
      {f g : Ring.Perfection R p}, (∀ (n : ℕ), (Perfection.coeff R p n) f = (Perfection.coeff R p n) g) → f = g :=
  by sorry

The theorem `Perfection.ext` states that for any commutative semiring `R`, any prime number `p` such that `R` has characteristic `p`, and any two elements `f` and `g` of the perfection of `R` with respect to `p`, if for all natural numbers `n` the `n`-th coefficient of `f` equals the `n`-th coefficient of `g`, then `f` and `g` are equal. In other words, two elements of the perfection of a ring are equal if and only if all their coefficients are equal.

In a commutative semiring of characteristic `p`, two elements of its perfection with respect to `p` are equal if and only if their coefficients are equal for all natural numbers.


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

This theorem states that for any type `α`, any measurable space `m0` over `α`, any measure `μ` from measure theory over `α`, and any set `s` of type `α`, the measure of the set `s` when restricted to `s` itself is the same as the original measure of the set `s`. In other words, restricting the measure to the set doesn't change the measure of the set.

For any measurable space `(α, m)`, measure `μ`, and set `s` in `α`, the measure `μ` of `s` is equal to the measure of `s` under the restriction of `μ` to `s`.


theorem Matrix.scalar_commute_iff :
    ∀ {n : Type u_3} {α : Type v} [inst : Semiring α] [inst_1 : DecidableEq n] [inst_2 : Fintype n] {r : α}
      {M : Matrix n n α}, Commute ((Matrix.scalar n) r) M ↔ r • M = MulOpposite.op r • M :=
  by sorry

This theorem, `Matrix.scalar_commute_iff`, states that for any semiring `α`, any decidable equality type `n`, any finite type `n`, any element `r` of `α`, and any `n x n` matrix `M` with entries in `α`, the scalar `r` commutes with the matrix `M` if and only if scalar multiplication of the matrix `M` by `r` is equivalent to the multiplication of `M` by the opposite of `r`. In other words, `r` and `M` commute under the operation defined by `Matrix.scalar` if and only if, when one multiplies `M` by `r` (using scalar multiplication), one obtains the same result as when one multiplies `M` by the element that represents the opposite of `r` (using the operation defined by `MulOpposite.op`).

For any semiring `α`, any finite type `n`, any element `r` of `α`, and any `n x n` matrix `M` over `α`, `r` commutes with `M` if and only if scalar multiplication by `r` is equivalent to multiplication by the opposite of `r` for matrices using the defined operations.


theorem Finset.max_insert :
    ∀ {α : Type u_2} [inst : LinearOrder α] {a : α} {s : Finset α}, Finset.max (insert a s) = max (↑a) (Finset.max s) :=
  by sorry

This theorem states that for any type `α` that has a linear order, any element `a` of type `α`, and any finite set `s` of type `α`, the maximum element of the set obtained by inserting `a` into `s` is equal to the maximum of `a` and the maximum element of `s`. The maximum of a set is defined to be the largest element if the set is not empty, and the bottom element otherwise.

For any linear order type `α`, set `s` of `α`, and element `a` of `α`, the maximum of `a` and the maximum of `s` is the maximum of `s` with `a` inserted.


theorem Polynomial.eval_smul :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Monoid S] [inst_2 : DistribMulAction S R]
      [inst_3 : IsScalarTower S R R] (s : S) (p : Polynomial R) (x : R),
      Polynomial.eval x (s • p) = s • Polynomial.eval x p :=
  by sorry

The theorem `Polynomial.eval_smul` states that for any semiring `R`, any monoid `S`, given a distributive multiplication action of `S` on `R` and a scalar tower for `S` and `R`, for any scalar `s` from `S`, any polynomial `p` over `R`, and any element `x` from `R`, the polynomial evaluation of `s` times `p` at `x` is equal to `s` times the polynomial evaluation of `p` at `x`. In other words, this theorem states that scalar multiplication commutes with polynomial evaluation.

For any semiring R, monoid S with distributive multiaction on R, scalar tower for S and R, scalar s in S, polynomial p over R, and element x in R, we have s * (p x) = (s * p) x, where * denotes scalar multiplication and polynomial evaluation.


theorem Hyperreal.infiniteNeg_mul_of_infinitePos_not_infinitesimal_neg :
    ∀ {x y : ℝ*}, Hyperreal.InfinitePos x → ¬Hyperreal.Infinitesimal y → y < 0 → Hyperreal.InfiniteNeg (x * y) := by
  sorry

The theorem states that given any two hyperreal numbers 'x' and 'y', if 'x' is positively infinite (meaning it is larger than any real number) and 'y' is not infinitesimal (meaning its standard part is not zero) and 'y' is less than zero, then the product of 'x' and 'y' is negatively infinite (meaning it is smaller than any real number).

If x is a positively infinite hyperreal number and y is a finite negative non-zero hyperreal number, then x * y is negatively infinite.


/-- The seminorm controls the Schwartz estimate for any fixed `x`.  -/
theorem SchwartzMap.le_seminorm :
    ∀ (𝕜 : Type u_1) {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
      [inst_6 : SMulCommClass ℝ 𝕜 F] (k n : ℕ) (f : SchwartzMap E F) (x : E),
      ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ (SchwartzMap.seminorm 𝕜 k n) f :=
  by sorry

This theorem, named `SchwartzMap.le_seminorm`, states the following: for any given type `𝕜`, and normed add commutative groups `E` and `F` with their normed spaces over ℝ, a normed field structure on `𝕜`, a normed space structure on `𝕜` over `F`, and a real-`𝕜`-`F` scalar multiplication commutation relation, for any given natural numbers `k` and `n`, any Schwartz Map `f` from `E` to `F`, and any element `x` from `E`, the `k`-th power of the norm of `x` times the norm of the `n`-th iterated Frechet derivative of `f` at `x` is always less than or equal to the `k`-th, `n`-th seminorm of `f`. This means that the seminorm of the Schwartz map can be used as an upper bound for the product of the `k`-th power of the norm of `x` and the norm of the `n`-th iterated Frechet derivative of the map at `x`.

For any Schwartz Map `f` from a normed space `E` to another normed space `F` over a field `𝕜`, and for any `x` in `E`, `k` natural numbers, and `n` positive integers, the `k`-th power of the norm of `x` times the norm of the `n`-th Frechet derivative of `f` at `x` is less than or equal to the `k`-th, `n`-th seminorm of `f` on `x`.


theorem NNReal.le_rpow_one_div_iff : ∀ {x y : NNReal} {z : ℝ}, 0 < z → (x ≤ y ^ (1 / z) ↔ x ^ z ≤ y) := by sorry

This theorem states that for any two nonnegative real numbers `x` and `y`, and any real number `z` that is greater than zero, `x` is less than or equal to `y` raised to the power of `1/z` if and only if `x` raised to the power of `z` is less than or equal to `y`. The theorem captures a property of the relationship between exponentiation and inequalities in the context of nonnegative real numbers.

For nonnegative real numbers x and y, and real z > 0, x <= y^(1/z) if and only if x^z <= y.


theorem AddMonoidAlgebra.support_mul :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : DecidableEq G] [inst_2 : Add G]
      (a b : AddMonoidAlgebra k G), (a * b).support ⊆ a.support + b.support :=
  by sorry

The theorem `AddMonoidAlgebra.support_mul` states that for any given types `k` and `G`, where `k` is a semiring and `G` has decidable equality and an additive structure, if `a` and `b` are elements of the monoid algebra of `G` over `k`, then the support of the product of `a` and `b` (denoted `(a * b).support`) is a subset of the sum of the supports of `a` and `b` (denoted `a.support + b.support`). Here, "support" refers to the set of nonzero elements in a given element of the monoid algebra.

For any semiring `k` and additive type `G` with decidable equality, the support of the product of two elements in the monoid algebra of `G` over `k` is a subset of the sum of their supports.


theorem Stream'.Seq.ofList_cons : ∀ {α : Type u} (a : α) (l : List α), ↑(a :: l) = Stream'.Seq.cons a ↑l := by sorry

This theorem, `Stream'.Seq.ofList_cons`, states that for all types `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, coercing (`↑`) the result of prepending `a` to `l` (denoted `a :: l`) to a sequence is equivalent to first coercing `l` to a sequence and then prepending `a` to the resulting sequence using the `Stream'.Seq.cons` function. Essentially, this theorem is establishing that the order of operations of prepending an element and converting from a list to a sequence does not matter.

For all types `α` and elements `a` of type `α` and lists `l` of type `α`, the sequence obtained by prepending `a` to `l` is equivalent to prepending `a` to the sequence obtained from `l`.


theorem Mathlib.Order.Basic._auxLemma.10 : ∀ {α : Type u} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) :=
  by sorry

This theorem states that for any type `α` equipped with a preorder, and for any two elements `a` and `b` of this type, `a` is less than `b` if and only if `a` is less than or equal to `b` and it is not the case that `b` is less than or equal to `a`.

For any preordered type `α`, elements `a` and `b` satisfy `a < b` if and only if `a ≤ b` and not `b ≤ a`.


WittVector.IsPoly.ext

theorem WittVector.IsPoly.ext :
    ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {f g : ⦃R : Type u⦄ → [inst : CommRing R] → WittVector p R → WittVector p R},
      WittVector.IsPoly p f →
        WittVector.IsPoly p g →
          (∀ (R : Type u) [_Rcr : CommRing R] (x : WittVector p R) (n : ℕ),
              (WittVector.ghostComponent n) (f x) = (WittVector.ghostComponent n) (g x)) →
            ∀ (R : Type u) [_Rcr : CommRing R] (x : WittVector p R), f x = g x :=
  by sorry

This theorem is stating that for any prime number `p` and any two functions `f` and `g` that take a `WittVector` with coefficients in a `CommRing R` and return a `WittVector` of the same kind, if both `f` and `g` are polynomials (this is what `WittVector.IsPoly p f` and `WittVector.IsPoly p g` represent), and for every commutative ring `R`, `WittVector` `x` and natural number `n`, the `n`th ghost component of `f(x)` is equal to the `n`th ghost component of `g(x)`, then `f(x)` is equal to `g(x)` for every `WittVector` `x` in the commutative ring `R`. In other words, if two polynomial functions acting on `WittVector`s give the same output when evaluated by the ghost component function for every `WittVector` and every natural number, then the two functions are the same.

If `p` is a prime number, `f` and `g` are polynomial functions taking `WittVector` arguments with coefficients in a commutative ring `R`, and for all `WittVector x` and natural number `n`, the `n`th ghost component of `f(x)` equals the `n`th ghost component of `g(x)`, then `f(x) = g(x)` for all `WittVector x` in `R`.


theorem Filter.limsup_eq_iInf_iSup_of_nat' :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {u : ℕ → α}, Filter.limsup u Filter.atTop = ⨅ n, ⨆ i, u (i + n) := by
  sorry

The theorem `Filter.limsup_eq_iInf_iSup_of_nat'` states that for any function `u` from the natural numbers to a set `α` which forms a complete lattice, the limit superior (limsup) of `u` as we approach infinity (`Filter.atTop`) is equal to the infimum (greatest lower bound) over all natural numbers `n`, of the supremum (least upper bound) over all `i`, of `u(i + n)`. In simpler terms, it defines the limsup of a sequence in terms of the sequence of the 'upper parts' of the sequence shifted by `n` for all `n` in the natural numbers.

For a complete lattice-valued function `u` from the natural numbers to a set `α`, the limsup as `n` approaches infinity is equal to the infimum over all natural numbers `n` of the supremum over all `i`, of `u(i + n)`.


theorem Function.IsPeriodicPt.const_mul :
    ∀ {α : Type u_1} {f : α → α} {x : α} {m : ℕ},
      Function.IsPeriodicPt f m x → ∀ (n : ℕ), Function.IsPeriodicPt f (n * m) x :=
  by sorry

This theorem states that for any type `α`, any function `f` from `α` to `α`, any point `x` of type `α`, and any natural number `m`, if `x` is a periodic point of `f` with period `m`, then for any natural number `n`, `x` is also a periodic point of `f` with period `n * m`. In mathematical terms, if `f^[m](x) = x`, then `f^[n*m](x) = x` for all natural numbers `n`.

If `x` is a periodic point of function `f` with period `m` in type `α`, then `x` is also a periodic point of `f` with period `n * m` for any natural number `n`.


theorem Mathlib.Order.Basic._auxLemma.27 :
    ∀ {α : Type u} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (↑x ≤ ↑y) = (x ≤ y) := by sorry

This theorem, `Mathlib.Order.Basic._auxLemma.27`, states that for any type `α` with a less than or equal to (`LE`) instance and a given property `p`, for any two subtypes `x` and `y` of `p`, the inequality between the underlying elements of `x` and `y` (`↑x ≤ ↑y`) is equivalent to the inequality between `x` and `y` themselves. In other words, the order of the elements when treated as subtypes is the same as the order of the elements in the original type.

For any type `α` with a `LE` instance and property `p`, the inequality `x ≤ y` between subtypes `x` and `y` of `p` is equivalent to `↑x ≤ ↑y` between their underlying elements.


theorem ClosureOperator.IsClosed.closure_eq :
    ∀ {α : Type u_1} [inst : PartialOrder α] {c : ClosureOperator α} {x : α}, c.IsClosed x → c x = x := by sorry

This theorem states that for any type `α`, under a partial order, given a closure operator `c` and an element `x` of type `α`, if `x` is a closed element under the closure operator `c`, then applying the closure operator `c` to `x` will not change `x`. In mathematical terms, if a set contains its closure under a closure operator, the closure of that set is equal to the set itself.

If `α` is a type with a partial order and `c` is a closure operator on `α` such that `x` is a closed element under `c`, then `c(x) = x`.


theorem Fin.predAbove_of_lt_succ :
    ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : i < Fin.succ p) (hi : optParam (i ≠ Fin.last n) ⋯),
      Fin.predAbove p i = Fin.castPred i hi :=
  by sorry

This theorem, `Fin.predAbove_of_lt_succ`, states for any natural number `n`, given `p` of type `Fin n` and `i` of type `Fin (n + 1)`. If `i` is less than `p + 1` (expressed as `Fin.succ p`), and if there exists a value (which is optional) confirming that `i` is not equal to the maximum possible value of `Fin (n + 1)` (expressed as `Fin.last n`), then applying the function `Fin.predAbove` with parameters `p` and `i` yields the same result as applying the `Fin.castPred` function on `i` with the confirmation that `i` is not the maximum value. In other words, under these conditions, these two functions behave identically.

If `i < Fin.succ p` in `Fin (n + 1)` and `i ≠ Fin.last (n + 1)`, then `Fin.predAbove p i = Fin.castPred i`.


theorem Ordinal.succ_log_def :
    ∀ {b x : Ordinal.{u_1}}, 1 < b → x ≠ 0 → Order.succ (Ordinal.log b x) = sInf {o | x < b ^ o} := by sorry

The theorem `Ordinal.succ_log_def` states that for any two ordinals `b` and `x` such that `b` is greater than 1 and `x` is not equal to zero, the successor of the ordinal logarithm of `x` with base `b` is equal to the least ordinal `o` for which `x` is less than `b` raised to the power `o`. This theorem provides a relation between the successor of an ordinal logarithm and the set of ordinals satisfying a certain inequality.

For any ordinal `x` not equal to zero and base `b` greater than 1, the successor of the ordinal logarithm of `x` with base `b` equals the least ordinal `o` such that `x` is below `b^o`.


theorem Mathlib.Data.Set.NAry._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {u : Set γ},
      (Set.image2 f s t ⊆ u) = ∀ x ∈ s, ∀ y ∈ t, f x y ∈ u :=
  by sorry

The theorem `Mathlib.Data.Set.NAry._auxLemma.1` states that for all types `α`, `β`, and `γ`, and a binary function `f : α → β → γ`, and sets `s : Set α`, `t : Set β`, and `u : Set γ`, the image of the function `f` on the sets `s` and `t` is a subset of `u` iff for any element `x` in `s` and any element `y` in `t`, the result of `f x y` is an element of `u`. In mathematical terms, the condition $(\forall x \in s, \forall y \in t, f(x, y) \in u)$ is equivalent to the statement that the image of the function `f` applied to elements of `s` and `t` is a subset of `u`.

For sets $s$ of type $\alpha$, $t$ of type $\beta$, and $u$ of type $\gamma$, and a binary function $f : \alpha \times \beta \to \gamma$, the image of $f$ on $s$ and $t$ is a subset of $u$ if and only if for all $x \in s$ and $y \in t$, $f(x, y) \in u$.


theorem Sym2.mem_mk_left : ∀ {α : Type u_1} (x y : α), x ∈ s(x, y) := by sorry

This theorem, `Sym2.mem_mk_left`, states that for any type `α` and any pair of elements `x` and `y` from this type, `x` is a member of the two-element set that is formed by `x` and `y`. In other words, for every `x` and `y`, `x` is in the symmetric pair `(x, y)`.

For any type `α` and any `x, y : α`, the pair `(x, y)` is a two-element set containing `x`.


theorem Mathlib.Data.Set.NAry._auxLemma.5 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) (s : Set α) (t : Set β),
      Set.image2 f s t = Function.uncurry f '' s ×ˢ t :=
  by sorry

The theorem `Mathlib.Data.Set.NAry._auxLemma.5` states that for any types `α`, `β`, and `γ`, and any binary function `f` from `α` and `β` to `γ`, and any sets `s` of type `α` and `t` of type `β`, the image of the binary function `f` over the sets `s` and `t` (as defined by `Set.image2`) is equal to the set obtained by uncurrying the function `f` and applying it to the Cartesian product of sets `s` and `t`. In other words, it asserts that these two different ways of mapping a binary function over two sets produce the same result set.

For any types `α`, `β`, `γ`, sets `s` of type `α`, `t` of type `β`, and binary function `f` from `α` to `β` to `γ`, `Set.image2 (f : α → β) s t = {x ∈ γ | ∃ (a ∈ s) ∃ (b ∈ t), f a b = x}`. (The set on the right-hand side is obtained by applying the uncurried function `fun x y => f x y` to the Cartesian product `s × t`.)


theorem Mathlib.Data.Set.NAry._auxLemma.6 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) {s : Set α} {t : Set β},
      Set.image2 f s t = (fun x => f x.1 x.2) '' s ×ˢ t :=
  by sorry

The theorem `Mathlib.Data.Set.NAry._auxLemma.6` states that for any types `α`, `β`, and `γ`, and any binary function `f : α → β → γ`, the image of `f` over a set `s` of type `α` and a set `t` of type `β`, denoted as `Set.image2 f s t`, is equal to the set of all possible outputs of `f` when the input is a pair `(x.1, x.2)`, where `x` ranges over the Cartesian product of the sets `s` and `t`, denoted as `s ×ˢ t`. In mathematical notation, this is equivalent to saying that the image of `f` over `s ×ˢ t` is the set `{f(x, y) | (x, y) ∈ s × t }`.

The theorem states that for any types `α`, `β`, and `γ`, and binary function `f : α → β → γ`, the set `Set.image2 f s t` equals the image of `f` over the Cartesian product `s ×ˢ t`, i.e., `{f(x, y) | (x, y) ∈ s × t}`.


theorem MeasureTheory.Measure.toSignedMeasure_sub_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [inst : MeasureTheory.IsFiniteMeasure μ]
      [inst_1 : MeasureTheory.IsFiniteMeasure ν] {i : Set α},
      MeasurableSet i →
        ↑(MeasureTheory.Measure.toSignedMeasure μ - MeasureTheory.Measure.toSignedMeasure ν) i =
          (↑↑μ i).toReal - (↑↑ν i).toReal :=
  by sorry

This theorem states that for any type `α`, measurable space `m`, measures `μ` and `ν`, and set `i` in `α`, if `i` is a measurable set and both `μ` and `ν` are finite measures, then the value of the signed measure formed by subtracting the signed measure of `ν` from the signed measure of `μ` at set `i` is equal to the difference of the real values of `μ` and `ν` at set `i`. This effectively describes the property of difference operation in the context of signed measures.

For any measurable sets `i` in a measurable space with finite measures `μ` and `ν`, the signed measure `μ - ν` of `i` equals the real number `μ(i) - ν(i)`.


/-- A finite subgroup of the unit group of an integral domain is cyclic.  -/
theorem isCyclic_of_subgroup_isDomain :
    ∀ {R : Type u_1} {G : Type u_2} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : Group G] [inst_3 : Finite G]
      (f : G →* R), Function.Injective ⇑f → IsCyclic G :=
  by sorry

The theorem `isCyclic_of_subgroup_isDomain` states that for any types `R` and `G`, with `R` being a commutative ring and `G` being a finite group, if there exists an injective function `f` from `G` to `R` where `R` is an integral domain, then the group `G` is cyclic. In other words, a finite subgroup of the unit group of an integral domain is always cyclic.

If a finite subgroup of the multiplicative group of an integral domain is injectively mapped to the domain, then the group is cyclic.


theorem AddSubmonoid.mem_top : ∀ {M : Type u_1} [inst : AddZeroClass M] (x : M), x ∈ ⊤ := by sorry

This theorem states that for any type `M` that has the structure of an additive monoid with zero (i.e., it has an operation of addition that is associative, a zero element that serves as an identity for addition, and every element has an additive inverse), every element `x` of `M` is an element of the top element (`⊤`) of the lattice of submonoids of `M`. In the context of lattice theory, the top element of a lattice is the greatest element that is greater than or equal to every other element in the lattice.

Every additive monoid with zero has the property that every element is contained in the top element of its lattice of submonoids.


theorem List.mapIdx_cons :
    ∀ {α : Type u_1} {β : Type u_2} (l : List α) (f : ℕ → α → β) (a : α),
      List.mapIdx f (a :: l) = f 0 a :: List.mapIdx (fun i => f (i + 1)) l :=
  by sorry

The `List.mapIdx_cons` theorem states that for any list `l` of elements of some type `α`, a function `f` mapping from natural numbers and elements of `α` to another type `β`, and an element `a` of type `α`, if you apply the `List.mapIdx` function to `f` and a list formed by prepending `a` to `l` (expressed as `a :: l`), the result is a list that begins with `f` applied to 0 and `a`, and continues with `List.mapIdx` applied to a function equivalent to `f` but with its first argument incremented by 1, and the original list `l`. In other words, applying `List.mapIdx` to a prepended list is the same as applying `f` to the new first element and the remaining elements of the list with the index incremented.

For any list `l` of length `n+1`, function `f : ℕ × α → β`, and element `a : α`, `List.mapIdx (λ i x, f (i+1) x)) (a :: l) = [f 0 a] ++ List.mapIdx f l`.


theorem List.perm_comm : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Perm l₁ l₂ ↔ List.Perm l₂ l₁ := by sorry

This theorem, `List.perm_comm`, is a statement about list permutations in any type `α`. Specifically, it states that for any two lists `l₁` and `l₂` of the same type, the property of `l₁` being a permutation of `l₂` is equivalent to `l₂` being a permutation of `l₁`. In other words, the permutation relation between two lists is commutative.

For any lists `l₁` and `l₂` of the same type `α`, `l₁` is a permutation of `l₂` if and only if `l₂` is a permutation of `l₁`.


theorem Int.modEq_add_fac : ∀ {a b n : ℤ} (c : ℤ), a ≡ b [ZMOD n] → a + n * c ≡ b [ZMOD n] := by sorry

This theorem, `Int.modEq_add_fac`, states that for any integers `a`, `b`, `n` and `c`, if `a` is congruent to `b` modulo `n`, then the expression `a + n * c` is also congruent to `b` modulo `n`. In other words, adding any multiple of `n` to `a` doesn't change its congruence class modulo `n`, if `a` is already congruent to `b` modulo `n`. This is a fundamental property of modular arithmetic.

If `a` is congruent to `b` modulo `n`, then `a + n*c` is congruent to `b + n*c` modulo `n` for any integer `c`.


theorem Finset.prod_pair :
    ∀ {α : Type u_3} {β : Type u_4} {f : α → β} [inst : CommMonoid β] [inst_1 : DecidableEq α] {a b : α},
      a ≠ b → (Finset.prod {a, b} fun x => f x) = f a * f b :=
  by sorry

The theorem `Finset.prod_pair` states that for any types `α` and `β`, a function `f` from `α` to `β`, a commutative monoid instance for `β`, a decidable equality instance for `α`, and any two distinct elements `a` and `b` of type `α`, the product of `f` applied to all elements in the finite set containing just `a` and `b` is equal to the product of `f a` and `f b`. In other words, if `a` and `b` are different, then applying `f` to each element of the set `{a, b}` and taking the product is the same as simply multiplying `f a` by `f b`.

For any commutative monoid `β`, decidably equal types `α` with distinct elements `a, b`, and a function `f` from `α` to `β`, the product of `f` applied to the finite set `{a, b}` is equal to the product of `f a` and `f b`.


theorem Ultrafilter.le_of_inf_neBot :
    ∀ {α : Type u} (f : Ultrafilter α) {g : Filter α}, Filter.NeBot (↑f ⊓ g) → ↑f ≤ g := by sorry

The theorem `Ultrafilter.le_of_inf_neBot` states that for any type `α`, given an ultrafilter `f` on `α` and any other filter `g` on `α`, if the infimum (greatest lower bound) of the ultrafilter and the filter is not the bottom filter (i.e., it's not the filter containing all sets), then the ultrafilter is less than or equal to the filter `g`. In other words, all sets in the ultrafilter are also in the filter `g`.

If an ultrafilter `f` on type `α` and filter `g` on `α` have a non-bottom infimum, then `f` is contained in `g`.


theorem antitone_mul_left :
    ∀ {α : Type u} [inst : OrderedSemiring α] [inst_1 : ExistsAddOfLE α]
      [inst_2 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α},
      a ≤ 0 → Antitone fun x => a * x :=
  by sorry

The theorem `antitone_mul_left` states that for all types `α` that are ordered semirings (a structure that combines properties of rings and ordered groups), and for which there exists an additive operation compatible with a partial order, and for which the relation of being less than or equal to is contravariant with respect to addition, then for any element `a` of type `α` that is less than or equal to zero, the function that multiplies `a` by an input value `x` is an antitone function. In simpler terms, if `a` is less than or equal to zero in an ordered semiring, then multiplying by `a` reverses the order of elements: if `x ≤ y`, then `a*y ≤ a*x`.

If `α` is an ordered semiring with an additive order compatible with multiplication such that `a ≤ 0` implies `a * x ≤ a * y` for all `x, y` in `α`, then `a * x ≤ a * y` implies `x ≤ y`.


theorem PrimrecPred.of_eq :
    ∀ {α : Type u_1} [inst : Primcodable α] {p q : α → Prop} [inst_1 : DecidablePred p] [inst_2 : DecidablePred q],
      PrimrecPred p → (∀ (a : α), p a ↔ q a) → PrimrecPred q :=
  by sorry

The theorem `PrimrecPred.of_eq` states that for any type `α` that has a `Primcodable` instance and any two decidable predicates `p` and `q` over `α`, if `p` is a primitive recursive predicate and for all `α`, `p a` is logically equivalent to `q a`, then `q` is also a primitive recursive predicate. Essentially, this means that if two predicates are logically equivalent and one of them is known to be primitive recursive, then the other one is also guaranteed to be primitive recursive.

If `p` is a primitive recursive predicate over type `α` and logically equivalent to decidable predicate `q`, then `q` is also primitive recursive.


theorem Complex.interior_preimage_im : ∀ (s : Set ℝ), interior (Complex.im ⁻¹' s) = Complex.im ⁻¹' interior s := by
  sorry

This theorem states that for any set `s` of real numbers, the interior of the preimage of `s` under the imaginary part function of complex numbers is equal to the preimage of the interior of `s` under the same function. That is, taking the interior of the set of complex numbers whose imaginary part is in `s` gives the same result as taking the set of complex numbers whose imaginary part is in the interior of `s`. The preimage of a set under a function consists of all elements which map into the set under the function. The interior of a set is the largest open set contained within the set, in the context of a topological space.

The interior of the preimage of a real set under the imaginary part function of complex numbers is equal to the preimage of the interior of that set.


theorem Order.bot_lt_succ :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [inst_2 : OrderBot α] [inst_3 : Nontrivial α]
      (a : α), ⊥ < Order.succ a :=
  by sorry

This theorem states that, for any type `α` that has a partial order, a successor order, a least element (`OrderBot`), and is nontrivial (i.e., has at least two distinct elements), the least element of this type is less than the successor of any element in this type. In other words, for any element `a` of the type `α`, the successor of `a` is always greater than the least element of `α`.

For any type `α` with a partial order, a successor function, a least element `OrderBot`, and at least two elements, `OrderBot` is less than every successor element.


ConvexOn.smul'

theorem ConvexOn.smul' :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : LinearOrderedCommRing 𝕜] [inst_1 : LinearOrderedCommRing E]
      [inst_2 : LinearOrderedAddCommGroup F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] [inst_5 : Module E F]
      [inst_6 : IsScalarTower 𝕜 E F] [inst_7 : SMulCommClass 𝕜 E F] [inst_8 : OrderedSMul 𝕜 F]
      [inst_9 : OrderedSMul E F] {s : Set 𝕜} {f : 𝕜 → E} {g : 𝕜 → F},
      ConvexOn 𝕜 s f →
        ConvexOn 𝕜 s g →
          (∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x) → (∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ g x) → MonovaryOn f g s → ConvexOn 𝕜 s (f • g) :=
  by sorry

This theorem, named `ConvexOn.smul'`, states that for any types `𝕜`, `E`, and `F` with the given algebraic structure (specifically, `𝕜` and `E` are linear ordered commutative rings, `F` is a linear ordered additive commutative group, `𝕜`, `E`, and `F` form modules and scalar towers, and there are ordered scalar multiplication structures defined on `𝕜` and `E` with `F`), if there is a set `s` in `𝕜` and two functions `f` and `g` from `𝕜` to `E` and `F` respectively, then if `f` and `g` are both convex on `s`, and for all `x` in `s`, `f(x)` and `g(x)` are non-negative, and moreover if `f` is monotonically increasing with `g` on `s`, then the function `f•g` (the scalar multiplication of `f` and `g`) is also convex on `s`. In simpler mathematical terms, under these conditions, the pointwise multiplication of two convex functions where one is monotonically increasing with the other, yields another convex function.

If `𝕜` is a linear ordered commutative ring, `E` is a linear ordered additive commutative group, `F` is an ordered group, `𝕜` and `E` are modules and scalar towers over `F`, and `f: 𝕜 → E` and `g: 𝕜 → F` are convex functions on a set `s` in `𝕜` with `f(x)`, `g(x)` non-negative for all `x` in `s`, and `f` monotonically increasing with `g` on `s`, then the function `f•g: 𝕜 → F` defined as `f•g(x) := f(x)*g(x)` is convex on `s`.


theorem PMF.support_bind :
    ∀ {α : Type u_1} {β : Type u_2} (p : PMF α) (f : α → PMF β),
      PMF.support (PMF.bind p f) = ⋃ a ∈ PMF.support p, PMF.support (f a) :=
  by sorry

The theorem `PMF.support_bind` states that for any probability mass function `p` of type `α` and any function `f` that takes a value of type `α` and returns a probability mass function of type `β`, the support (the set where the function is nonzero) of the result of binding `p` through `f` is equal to the union of the supports of the probability mass functions `f a` for each `a` in the support of `p`. In other words, if we create a new probability mass function by applying `f` to each possible outcome of `p`, the new function will be nonzero exactly where the individual probability mass functions given by `f a` are nonzero.

The support of the probability mass function obtained by binding another probability mass function through a function is equal to the union of the supports of the resulting functions for each input in the original support.


theorem le_of_add_le_right : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b c : α}, a + b ≤ c → b ≤ c :=
  by sorry

This theorem, `le_of_add_le_right`, states that for any type `α` that is a canonically ordered additive commutative monoid, if the sum of two elements `a` and `b` is less than or equal to a third element `c`, then `b` is also less than or equal to `c`. The variables `a`, `b`, and `c` are all elements of the type `α`. This theorem captures an essential property of numbers where if a part (`a + b`) of something is less than or equal to the whole (`c`), then any component part (`b`) of that part is also less than or equal to the whole.

If `a`, `b`, and `c` are elements of a commutative additive monoid `α` with a canonical order, then `a ≤ c` implies `b ≤ c`.


theorem CategoryTheory.Sieve.pullbackArrows_comm :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
      {X Y : C} (f : Y ⟶ X) (R : CategoryTheory.Presieve X),
      CategoryTheory.Sieve.generate (CategoryTheory.Presieve.pullbackArrows f R) =
        CategoryTheory.Sieve.pullback f (CategoryTheory.Sieve.generate R) :=
  by sorry

This theorem states that in a category 'C' having pullbacks, for any objects 'X' and 'Y' and a morphism 'f' from 'Y' to 'X', and for a presieve 'R' on 'X', the action of generating a sieve from the pullback of the presieve 'R' along the morphism 'f' is equivalent to the action of first generating a sieve from the presieve 'R' and then taking the pullback along 'f'. In other words, the operations of generating a sieve and pulling back a sieve commute with each other.

In a pullback-stable category C, for any morphism f : Y -> X and presieve R on X, the pullback of R along f is equal to the restriction of R along the pullback of f.


theorem CategoryTheory.Functor.cover_lift :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] (G : CategoryTheory.Functor C D)
      (J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D)
      [inst_2 : CategoryTheory.Functor.IsCocontinuous G J K] {U : C} {S : CategoryTheory.Sieve (G.obj U)},
      S ∈ K.sieves (G.obj U) → CategoryTheory.Sieve.functorPullback G S ∈ J.sieves U :=
  by sorry

This theorem, `CategoryTheory.Functor.cover_lift`, asserts that for any categories `C` and `D` with a functor `G` between them, if `G` is cocontinuous with respect to Grothendieck topologies `J` on `C` and `K` on `D`, then for any object `U` in `C` and any sieve `S` on `G(U)` in `D` that belongs to the topology `K`, the pullback of `S` along `G` to `U` in `C` belongs to the topology `J`. This essentially states a condition for lifting covers from the codomain to the domain of a functor in the context of Grothendieck topologies.

Given functors between categories `G: C -> D`, cocontinuous with respect to Grothendieck topologies `J` on `C` and `K` on `D`, for any object `U` in `C` and sieve `S` on `G(U)` in `D` belonging to `K`, the pullback of `S` along `G` is a subobject of `Ob(C/U)` belonging to `J`.


theorem Complex.interior_preimage_re : ∀ (s : Set ℝ), interior (Complex.re ⁻¹' s) = Complex.re ⁻¹' interior s := by
  sorry

This theorem states that for any set `s` of real numbers, the interior of the preimage of `s` under the function `Complex.re` (which takes a complex number and returns its real part) is equal to the preimage of the interior of `s` under the same function. In other words, when we take a set of real numbers, get the corresponding set of complex numbers through the real part function, and find the largest open subset of that, it's the same as if we first found the largest open subset of the original set of real numbers and then got the corresponding set of complex numbers. This theorem is about the relationship between the interior operation in topology and the function that gets the real part of a complex number.

The interior of the preimage of a real set under the real part function is equal to the preimage of the interior of that set.


theorem Ordinal.div_lt : ∀ {a b c : Ordinal.{u_4}}, b ≠ 0 → (a / b < c ↔ a < b * c) := by sorry

This theorem states that for any three ordinals `a`, `b`, and `c`, given that `b` is not equal to zero, the ordinal `a` divided by `b` is less than `c` if and only if `a` is less than the product of `b` and `c`. This establishes a relationship between ordinal division and multiplication, similar to the property in number theory that for positive numbers `a`, `b` and `c`, `a` divided by `b` is less than `c` if and only if `a` is less than `b` times `c`.

For any ordinals `a`, `b` with `b ≠ 0`, `a / b < c` if and only if `a < b * c`.


/-- If `f` is a function strictly monotone on a right neighborhood of `a` and the
image of this neighborhood under `f` meets every interval `(f a, b]`, `b > f a`, then `f` is
continuous at `a` from the right.

The assumption `hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b` is required because otherwise the
function `f : ℝ → ℝ` given by `f x = if x ≤ 0 then x else x + 1` would be a counter-example at
`a = 0`.  -/
theorem StrictMonoOn.continuousWithinAt_right_of_exists_between :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : LinearOrder β] [inst_4 : TopologicalSpace β] [inst_5 : OrderTopology β] {f : α → β} {s : Set α} {a : α},
      StrictMonoOn f s →
        s ∈ nhdsWithin a (Set.Ici a) →
          (∀ b > f a, ∃ c ∈ s, f c ∈ Set.Ioc (f a) b) → ContinuousWithinAt f (Set.Ici a) a :=
  by sorry

The theorem `StrictMonoOn.continuousWithinAt_right_of_exists_between` states that for a function `f` of type `α → β`, where both `α` and `β` are linearly ordered and equipped with a topological space and order topology, if `f` is strictly monotone on a set `s`, and `s` is within a neighborhood of `a` which includes all points greater than or equal to `a`, and for all `b` greater than `f(a)`, there exists a `c` in `s` such that `f(c)` lies in the interval `(f a, b]`, then `f` is continuous at `a` from the right.

The condition `∀ b > f a, ∃ c ∈ s, f c ∈ Set.Ioc (f a) b` is crucial to avoid counter-examples such as the function `f : ℝ → ℝ` defined by `f x = if x ≤ 0 then x else x + 1` at `a = 0`.

If a function `f` between linearly ordered and topological spaces is strictly monotone on a set `s` containing all points greater than or equal to `a`, and for all `b` greater than `f(a)`, there exists `c` in `s` with `f(c)` in the interval `(f a, b]`, then `f` is right-continuous at `a`.


theorem Cardinal.mk_singleton : ∀ {α : Type u} (x : α), Cardinal.mk ↑{x} = 1 := by sorry

This theorem states that for any type `α` and a value `x` of that type, the cardinal number (or size) of the singleton set containing `x` is 1. In other words, the cardinality of a singleton set is always 1, regardless of which type and value we use to create it.

The cardinality of a singleton set is equal to 1.


theorem Class.coe_apply : ∀ {x y : ZFSet}, ↑y x ↔ x ∈ y := by sorry

This theorem, named `Class.coe_apply`, states that for any two Zermelo-Fraenkel set theory (ZFC) sets `x` and `y`, the application of the coercion function `↑y` to `x` is equivalent to `x` being an element of `y`. The coercion function `↑y` transforms `y` from a ZFC set to a class. This theorem bridges the concept of set membership in the ZFC universe with the concept of function application in the class universe.

For any sets `x` and `y` in ZFC, `x ∈ y` if and only if `↑y x = x`.


theorem mul_self_ne_zero :
    ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [inst_1 : NoZeroDivisors M₀] {a : M₀}, a * a ≠ 0 ↔ a ≠ 0 := by sorry

This theorem states that for any type `M₀` that has the structure of a multiplication with zero (`MulZeroClass`) and has no zero divisors (`NoZeroDivisors`), an element `a` of `M₀` satisfies the property that `a * a` is not equal to zero if and only if `a` is not equal to zero. In more mathematical terms, for a ring without zero divisors, the square of an element is zero if and only if the element itself is zero.

For a ring without zero divisors, an element is non-zero if and only if its square is non-zero.


theorem NonUnitalSubring.mk'.proof_2 :
    ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (s : Set R) (sa : AddSubgroup R), ↑sa = s → s = ↑sa := by sorry

This theorem states that for any type `R` that is a non-unital non-associative ring, and for any set `s` of elements of `R` and any additive subgroup `sa` of `R`, if `s` is identical to the set of elements in the subgroup `sa` (expressed as `↑sa = s`), then the reverse is also true: the set `s` is identical to the set of elements in the subgroup `sa` (expressed as `s = ↑sa`). This asserts that the equality between a set and a subgroup in a non-unital non-associative ring is symmetric, i.e., if one can be cast to the other, the reverse is also true.

In a non-unital non-associative ring, if the set `s` is equal to the subgroup `sa` generated by `s`, then `s` is equal to its subgroup generator `sa`.


theorem PiNat.firstDiff_def :
    ∀ {E : ℕ → Type u_2} (x y : (n : ℕ) → E n), PiNat.firstDiff x y = if h : x ≠ y then Nat.find ⋯ else 0 := by sorry

The theorem `PiNat.firstDiff_def` states that for any sequence of types `E` indexed by natural numbers, and given two functions `x` and `y` from natural numbers to these types, the value of `PiNat.firstDiff x y` is defined as follows: If `x` and `y` are not equal (`x ≠ y`), then `PiNat.firstDiff x y` is the smallest natural number at which `x` and `y` differ, denoted by `Nat.find`. If `x` and `y` are equal (`x = y`), then by convention `PiNat.firstDiff x y` is set to `0`.

For any sequences `x` and `y` of types indexed by natural numbers, `PiNat.firstDiff x y` is the smallest index where `x` and `y` differ if they are not equal, and is equal to 0 if they are equal.


theorem Cardinal.mk_compl_of_infinite :
    ∀ {α : Type u_1} [inst : Infinite α] (s : Set α),
      Cardinal.mk ↑s < Cardinal.mk α → Cardinal.mk ↑sᶜ = Cardinal.mk α :=
  by sorry

This theorem, `Cardinal.mk_compl_of_infinite`, asserts that for any type `α` which is infinite, and for any set `s` of elements of this type, if the cardinality of set `s` is less than the cardinality of the type `α`, then the cardinality of the complement of set `s` (denoted `sᶜ`) is equal to the cardinality of the type `α`. In other words, for an infinite type, if a set `s` within that type has fewer elements than the type itself, the number of elements not in `s` is equal to the total number of elements in the type.

For any infinite type `α` and set `s` with strict subset inclusion `s ��subset α`, the cardinality of the complement `sᶜ` equals that of `α`.


theorem Finset.sum_indicator_eq_sum_filter :
    ∀ {ι : Type u_1} {β : Type u_4} [inst : AddCommMonoid β] {κ : Type u_6} (s : Finset ι) (f : ι → κ → β)
      (t : ι → Set κ) (g : ι → κ) [inst_1 : DecidablePred fun i => g i ∈ t i],
      (Finset.sum s fun i => Set.indicator (t i) (f i) (g i)) =
        Finset.sum (Finset.filter (fun i => g i ∈ t i) s) fun i => f i (g i) :=
  by sorry

The theorem `Finset.sum_indicator_eq_sum_filter` states that for any types `ι`, `β`, and `κ`, any additive commutative monoid `β`, any finite set `s` of type `ι`, any functions `f : ι → κ → β`, `t : ι → Set κ`, and `g : ι → κ`, under the condition that the predicate "the image of `g` is in the image of `t`" is decidable, the sum over `s` of the indicator function of `t i` applied to `f i` and `g i` is equal to the sum over the subset of `s` satisfying the predicate "the image of `g` is in the image of `t`" of `f i` applied to `g i`.

In other words, this theorem compares two methods of summing a function over a finite set: one method uses an indicator function to assign zero to elements outside a set, and the other filters out those elements before the sum. It asserts that these two methods yield the same result.

For any additive commutative monoid β, finite set s of type ι, functions f : ι → κ → β, t : ι → Set κ, and g : ι → κ, if the predicate "the image of g is in the image of t" is decidable, then the sum of indicator functions of t i applied to fi and gi over s equals the sum of fi applied to gi over the subset of s where the image of g is in the image of t.


theorem pow_le_pow_iff_left :
    ∀ {R : Type u_3} [inst : LinearOrderedSemiring R] {a b : R} {n : ℕ},
      0 ≤ a → 0 ≤ b → n ≠ 0 → (a ^ n ≤ b ^ n ↔ a ≤ b) :=
  by sorry

This theorem states that for any type `R` which is a linear ordered semiring, and for any two elements `a` and `b` of this type, and a natural number `n`, if `a` and `b` are both non-negative and `n` is non-zero, then `a` raised to the power `n` is less than or equal to `b` raised to the power of `n` if and only if `a` is less than or equal to `b`. This theorem effectively provides a way to compare powers of non-negative numbers in a linear ordered semiring.

For any linear ordered semiring (R, ≤, +, ⋅) and non-zero natural number n, a ≤ b if and only if a^n ≤ b^n.


theorem not_isMin_iff : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, ¬IsMin a ↔ ∃ b, b < a := by sorry

The theorem `not_isMin_iff` states that for any type `α` with a preorder relation, an element `a` of `α` is not a minimal element if and only if there exists an element `b` such that `b` is strictly less than `a`. Here, a minimal element is defined as an element `a` such that for all `b` in `α`, if `b` is less than or equal to `a`, then `a` is also less than or equal to `b`.

For any preordered type `α`, an element `a` is not minimal if and only if there exists `b` in `α` with `b` strictly less than `a`.


/-- The Gamma function does not vanish on `ℂ` (except at non-positive integers, where the function
is mathematically undefined and we set it to `0` by convention).  -/
theorem Complex.Gamma_ne_zero : ∀ {s : ℂ}, (∀ (m : ℕ), s ≠ -↑m) → Complex.Gamma s ≠ 0 := by sorry

This theorem states that the Gamma function, denoted as `Γ`, does not yield a zero value for any complex number `s` in the complex plane `ℂ`, except at non-positive integers. In other words, the Gamma function does not vanish anywhere on the complex plane, unless the input `s` is a non-positive integer (including zero). By convention, for these non-positive integers, the Gamma function is mathematically undefined, so we set its value to `0`.

The Gamma function `Γ(s)` never equals zero in the complex plane `ℂ`, except at non-positive integers where it is conventionally set to zero.


theorem Basis.repr_injective :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Function.Injective Basis.repr :=
  by sorry

The theorem `Basis.repr_injective` states that for any semiring `R`, any additively commutative monoid `M`, and any basis `ι` for a module `M` over the semiring `R`, the function `Basis.repr` is injective. This means that if `Basis.repr` yields the same result for two different vectors, those vectors are in fact the same. In other words, two different vectors cannot have the same coordinates with respect to the basis `ι`.

For any semiring R, additively commutative monoid M with basis ι, the representation function Basis.repr from M to R^ι is injective.


LinearMap.hasDerivAtFilter

theorem LinearMap.hasDerivAtFilter :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {L : Filter 𝕜} (e : 𝕜 →ₗ[𝕜] F), HasDerivAtFilter (⇑e) (e 1) x L :=
  by sorry

The theorem `LinearMap.hasDerivAtFilter` asserts that for any nontrivially normed field `𝕜`, a normed additive commutative group `F`, and a normed space over `𝕜` and `F`, given any point `x` from `𝕜`, a filter `L` on `𝕜`, and a linear map `e` from `𝕜` to `F`, the function obtained by applying `e` has a derivative at `x` along the filter `L`. The derivative is the result of applying `e` to `1`. This means, in simpler terms, that the function represented by the linear map `e` changes at the point `x` at a rate given by the application of `e` to `1`, as `x` approaches along the filter `L`.

Given a nontrivially normed field `𝕜`, a normed additive commutative group `F`, a normed space over `𝕜` and `F`, a point `x` in `𝕜`, a filter `L` on `𝕜`, and a linear map `e` from `𝕜` to `F`, the derivative of `e` at `x` along the filter `L` exists and is equal to `e 1`.


SimpleGraph.Subgraph.Connected.sup

theorem SimpleGraph.Subgraph.Connected.sup :
    ∀ {V : Type u} {G : SimpleGraph V} {H K : SimpleGraph.Subgraph G},
      SimpleGraph.Subgraph.Connected H →
        SimpleGraph.Subgraph.Connected K → Set.Nonempty (H ⊓ K).verts → SimpleGraph.Subgraph.Connected (H ⊔ K) :=
  by sorry

This theorem is about connected subgraphs in a simple graph. Specifically, it states that for any type `V`, any `SimpleGraph V` denoted as `G`, and any two `SimpleGraph.Subgraph G` denoted as `H` and `K`, if `H` and `K` are both connected and the intersection of their vertices (`H ⊓ K`) is not empty, then the subgraph formed by the union of `H` and `K` (`H ⊔ K`) is also connected. In other words, if two connected subgraphs share at least one vertex, their union will still form a connected subgraph.

If two connected subgraphs of a simple graph share at least one vertex, then their union is also a connected subgraph.


theorem add_tsub_cancel_iff_le :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b : α},
      a + (b - a) = b ↔ a ≤ b :=
  by sorry

This theorem, `add_tsub_cancel_iff_le`, states that for any canonically ordered additive commutative monoid `α` that also supports subtraction and ordered subtraction, given any two elements `a` and `b` of `α`, the equality `a + (b - a) = b` holds if and only if `a` is less than or equal to `b`. In simpler terms, adding `a` to the difference of `b` and `a` yields `b` if and only if `a` is not greater than `b`.

For any additive commutative monoid with subtraction and order relation, element `a` is less than or equal to `b` if and only if `a + (b - a) = b`.


theorem orderOf_units : ∀ {G : Type u_1} [inst : Monoid G] {y : Gˣ}, orderOf ↑y = orderOf y := by sorry

The theorem `orderOf_units` states that for any type `G` that is a monoid, and for any unit element `y` of `G` (denoted as `Gˣ`), the order of the coerced unit element `↑y` (which means `y` is viewed as an element of `G`) is equal to the order of `y`. In other words, the order of a unit element remains the same even when it's considered as an element of the monoid.

For any monoid `G` and unit `y` in `G`, the order of the unit `y` is equal to the order of the coerced unit `↑y` in `G`.


theorem CategoryTheory.Limits.biproduct.toSubtype_π :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      (p : J → Prop) [inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict p f)] (j : Subtype p),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.toSubtype f p)
          (CategoryTheory.Limits.biproduct.π (Subtype.restrict p f) j) =
        CategoryTheory.Limits.biproduct.π f ↑j :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.toSubtype_π`, asserts that in a category with zero morphisms and a biproduct, for a function `f` from a type `J` to a category `C`, and a proposition `p` on `J`, if we restrict `f` to the subtype of `J` where `p` holds, then the composition of the projection from the biproduct to the subtype with the projection from the biproduct to the element of the subtype, is equal to the projection from the biproduct to the preimage of the element. In mathematical terms, this means that if we have a biproduct (a "direct sum" or "coproduct" in algebra) of some objects in a category, and we consider a subset of these objects satisfying some property, then the projection map from the biproduct to an object in this subset is the same whether we consider the subset as part of the whole biproduct or as a separate biproduct of its own.

Given a category with zero morphisms and a biproduct, for a function from a type to the category and a proposition on that type, the projection from the biproduct to the subtype of satisfying the proposition is equal to the composition of the projections from the biproduct to the subtype and to the element in the subtype.


theorem contDiff_smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {n : ℕ∞}, ContDiff 𝕜 n fun p => p.1 • p.2 :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and any normed additive commutative group `F` which is also a normed space over `𝕜`, and for any natural number `n` (possibly infinity), the function that maps a pair `(𝕜, F)` to the scalar multiplication of the pair, i.e., `p.1 • p.2`, is `n`-times continuously differentiable. This implies that scalar multiplication is a smooth operation in this context.

For any nontrivially normed field `𝕜` and normed additive commutative group `F` over `𝕜` that is also a normed space, the scalar multiplication function `(𝕜, F) ↦ 𝕜 • F` is `n`-times continuously differentiable.


/-- The sum of the weights for the centroid indexed by a `Fintype`.  -/
theorem Finset.sum_centroidWeightsIndicator :
    ∀ (k : Type u_1) [inst : DivisionRing k] {ι : Type u_4} (s : Finset ι) [inst_1 : Fintype ι],
      (Finset.sum Finset.univ fun i => Finset.centroidWeightsIndicator k s i) =
        Finset.sum s fun i => Finset.centroidWeights k s i :=
  by sorry

The theorem `Finset.sum_centroidWeightsIndicator` states that for any division ring `k` and any finite type `ι`, for any finite set `s` of type `ι`, the sum of the centroid weights (given by the function `Finset.centroidWeightsIndicator`) over all elements in the universal set `Finset.univ` is equal to the sum of the centroid weights (given by the function `Finset.centroidWeights`) over the elements of `s` itself. In other words, summing the weights of the centroid of a set where the weights are defined to be zero outside the set is the same as summing the weights of the centroid over the set itself.

For any division ring `k` and finite type `ι`, the sum of centroid weights of the universal set `Finset.univ` for elements of type `ι` equals the sum of centroid weights of a finite set `s` of type `ι`.


theorem MeasureTheory.measure_union_null :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      ↑↑μ s₁ = 0 → ↑↑μ s₂ = 0 → ↑↑μ (s₁ ∪ s₂) = 0 :=
  by sorry

This theorem, `MeasureTheory.measure_union_null`, states that for any type `α` with an instance of `MeasurableSpace` and for any measure `μ` of type `MeasureTheory.Measure α`, if the measures of two sets `s₁` and `s₂` of type `Set α` are both zero, then the measure of the union of `s₁` and `s₂` is also zero. In mathematical terms, if the measures μ(s₁) and μ(s₂) are both 0, then the measure of the union of the sets, μ(s₁ ∪ s₂), is also 0. This theorem is a statement about the properties of measures in measure theory, a branch of mathematics that studies concepts such as size, volume, and quantity.

If two sets in a measurable space have zero measure, then their union also has zero measure.


Continuous.mapPullback

theorem Continuous.mapPullback :
    ∀ {X₁ : Type u_1} {X₂ : Type u_2} {Y₁ : Sort u_3} {Y₂ : Sort u_4} {Z₁ : Type u_5} {Z₂ : Type u_6}
      [inst : TopologicalSpace X₁] [inst_1 : TopologicalSpace X₂] [inst_2 : TopologicalSpace Z₁]
      [inst_3 : TopologicalSpace Z₂] {f₁ : X₁ → Y₁} {g₁ : Z₁ → Y₁} {f₂ : X₂ → Y₂} {g₂ : Z₂ → Y₂} {mapX : X₁ → X₂},
      Continuous mapX →
        ∀ {mapY : Y₁ → Y₂} {mapZ : Z₁ → Z₂},
          Continuous mapZ →
            ∀ {commX : f₂ ∘ mapX = mapY ∘ f₁} {commZ : g₂ ∘ mapZ = mapY ∘ g₁},
              Continuous (Function.mapPullback mapX mapY mapZ commX commZ) :=
  by sorry

This theorem states that for any continuous functions `mapX : X₁ → X₂` and `mapZ : Z₁ → Z₂`, and two commutative diagrams `f₂ ∘ mapX = mapY ∘ f₁` and `g₂ ∘ mapZ = mapY ∘ g₁` where `f₁ : X₁ → Y₁`, `g₁ : Z₁ → Y₁`, `f₂ : X₂ → Y₂`, `g₂ : Z₂ → Y₂` and `mapY : Y₁ → Y₂`, the function obtained by pulling back along `mapX`, `mapY`, and `mapZ` is also continuous. In other words, the pullback of continuous maps is still continuous under the given commutative conditions. Here, (`X₁`, `X₂`, `Y₁`, `Y₂`, `Z₁`, `Z₂`) are types equipped with topological space structures.

Given continuous functions `mapX: X₁ -> X₂`, `mapZ: Z₁ -> Z₂`, and commutative diagrams `f₂ ∘ mapX = mapY ∘ f₁` and `g₂ ∘ mapZ = mapY ∘ g₁` with `f₁: X₁ -> Y₁`, `g₁: Z₁ -> Y₁`, `f₂: X₂ -> Y₂`, `g₂: Z₂ -> Y₂`, and `mapY: Y₁ -> Y₂` on topological spaces `X₁`, `X₂`, `Y₁`, `Y₂`, `Z₁`, and `Z₂`, the pullback function `(mapX ∘ mapY ∘ mapZ)` is continuous.