theorem Multiset.cons_coe : ∀ {α : Type u_1} (a : α) (l : List α), a ::ₘ ↑l = ↑(a :: l) := by sorry

This theorem, `Multiset.cons_coe`, states that for any given type `α` and any element `a` of type `α` and list `l` of type `α`, prepending (`cons`) the element `a` to the multiset that results from coercing (`↑`) the list `l` to a multiset equals the multiset that results from coercing the list obtained by prepending `a` to `l`. In other words, prepending an element to a list and then converting it to a multiset is the same as converting the list to a multiset and then prepending the element.

For any type `α` and element `a` of type `α` and list `l` of type `α`, the multiset obtained by prepending `a` to the multiset of `l` is equal to the multiset obtained by coercing the list obtained by prepending `a` to `l`.


theorem Polynomial.C_injective : ∀ {R : Type u} [inst : Semiring R], Function.Injective ⇑Polynomial.C := by sorry

The theorem `Polynomial.C_injective` states that for any type `R` with a semiring structure, the function `Polynomial.C` is injective. In other words, if `Polynomial.C` maps two elements in `R` to the same polynomial, then those two elements were originally the same. This means that distinct elements of `R` are mapped to distinct constant polynomials by `Polynomial.C`.

For any semiring `R`, the constant polynomial map `Polynomial.C` is an injection from `R` to the polynomial ring over `R`.


/-- If one adds to a vector `m'` another vector `m`, but only for coordinates in a finset `t`, then
the image under a multilinear map `f` is the sum of `f (s.piecewise m m')` along all subsets `s` of
`t`. This is mainly an auxiliary statement to prove the result when `t = univ`, given in
`map_add_univ`, although it can be useful in its own right as it does not require the index set `ι`
to be finite. -/
theorem MultilinearMap.map_piecewise_add :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : DecidableEq ι] (m m' : (i : ι) → M₁ i)
      (t : Finset ι),
      f (Finset.piecewise t (m + m') m') = Finset.sum (Finset.powerset t) fun s => f (Finset.piecewise s m m') :=
  by sorry

This theorem states that for a multilinear map `f` and two vectors `m` and `m'`, if you add `m` to `m'` but only at coordinates specified by a finset `t`, then the result of applying `f` to this new vector is equal to the sum of applying `f` to the piecewise addition of `m` and `m'` over all subsets of `t`. This result is expressed as `f (Finset.piecewise t (m + m') m') = Finset.sum (Finset.powerset t) fun s => f (Finset.piecewise s m m')`. This theorem is primarily used as an auxiliary statement for proving another result where `t` is the universal set, although it might be useful in its own right given that it does not require the index set `ι` to be finite.

For a multilinear map `f`, the application of `f` to the piecewise sum of two vectors with respect to a finite set `t` is equal to the sum of the applications of `f` to the piecewise sums of the vectors over all subsets of `t`.


theorem PadicInt.norm_le_pow_iff_mem_span_pow :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]) (n : ℕ), ‖x‖ ≤ ↑p ^ (-↑n) ↔ x ∈ Ideal.span {↑p ^ n} := by sorry

The theorem `PadicInt.norm_le_pow_iff_mem_span_pow` states that for any natural number `p` which is prime, any p-adic integer `x`, and any natural number `n`, the norm of `x` is less than or equal to `p` raised to the power of `-n` if and only if `x` is in the ideal generated by `p^n`. This provides a connection between the p-adic norm of an integer and its membership in certain types of ideals in the ring of p-adic integers.

For a prime number p and p-adic integer x, x belongs to the ideal generated by p^n if and only if the norm of x is less than or equal to p^(-n).


/-- `affineCombination` gives the sum with any base point, when the
sum of the weights is 1.  -/
theorem Finset.affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p : ι → P),
      (Finset.sum s fun i => w i) = 1 →
        ∀ (b : P), (Finset.affineCombination k s p) w = (Finset.weightedVSubOfPoint s p b) w +ᵥ b :=
  by sorry

The theorem `Finset.affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one` states that for any base point `b`, the affine combination of a set of points `p` with weights `w`, provided by the function `Finset.affineCombination`, equals the vector addition of `b` and the weighted difference of points `p` and `b`, provided by the function `Finset.weightedVSubOfPoint`, when the sum of the weights `w` is equal to 1. Here, `s` is a finite set of indices, `ι` is the index type, `k` is the scalar field (which forms a ring), `V` is a commutative group under addition, `P` is a space equipped with a distinguished point (an affine space), and `S` is an additively translatable point in `P`.

For any finite set of points `p` in an affine space `P` with weights `w` summing to 1 in a scalar field `k`, the affine combination of `p` with weights `w` is equal to the point in `P` obtained by vector adding the base point `b` to the weighted difference of `p` and `b`.


theorem Finsupp.mapDomain_equiv_apply :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α ≃ β} (x : α →₀ M) (a : β),
      (Finsupp.mapDomain (⇑f) x) a = x (f.symm a) :=
  by sorry

The theorem `Finsupp.mapDomain_equiv_apply` states that for all types `α`, `β`, `M` where `M` is an additive commutative monoid, and for all equivariant functions `f : α ≃ β`, if `x` is a finitely supported function from `α` to `M` and `a` is a value in `β`, then applying the function `Finsupp.mapDomain` to `f` and `x` (which results in a new finitely supported function), and then applying this function to `a`, is equivalent to directly applying the original finitely supported function `x` to the inverse image of `a` under the function `f`. In other words, the mapped domain function applied to `a` is equal to the original function applied to the preimage of `a` under the equivalence `f`.

For all equivariant functions `f : α ≃ β`, finitely supported functions `x : α →ℙF M`, and values `a : β`, `Finsupp.mapDomain x f a = x (f⁻¹' a)`.


theorem HahnSeries.single_coeff_of_ne :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] {a b : Γ} {r : R},
      b ≠ a → ((HahnSeries.single a) r).coeff b = 0 :=
  by sorry

The theorem `HahnSeries.single_coeff_of_ne` states that for any two distinct elements `a` and `b` of a partially ordered set `Γ` and any element `r` of a ring `R` with zero, the coefficient of `b` in the Hahn series obtained by assigning the coefficient `r` to `a` and zero to all other elements of `Γ` is zero. In other words, if `b` is not equal to `a`, the `b` coefficient of the Hahn series that has `r` at `a` and zero elsewhere is zero.

For any distinct elements `a, b` in a partially ordered set `Γ` and any ring `R` with zero, the coefficient of `b` in the Hahn series assigning `r` to `a` and zero to other elements is zero.


theorem LinearIsometry.isComplete_image_iff :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} {𝓕 : Type u_10} [inst : Semiring R]
      [inst_1 : Semiring R₂] {σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂]
      [inst_4 : Module R E] [inst_5 : Module R₂ E₂] [inst_6 : FunLike 𝓕 E E₂]
      [inst : SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) {s : Set E}, IsComplete (⇑f '' s) ↔ IsComplete s :=
  by sorry

This theorem states that given several structures, including two semirings `R` and `R₂`, two seminormed additive commutative groups `E` and `E₂`, two modules `E` over `R` and `E₂` over `R₂`, a semilinear isometry class between `E` and `E₂`, and a function `f` from `E` to `E₂`, a set `s` in `E` is complete if and only if the image of `s` under the function `f` is complete. Here, a set is complete if every Cauchy filter that contains the set has a limit within the set.

Given semirings R and R₂, seminormed additive commutative groups E and E₂, modules E over R and E₂ over R₂, a semilinear isometry between E and E₂, and a function f: E → E₂: For a set s ⊆ E, s is complete if and only if the image of s under f is complete.


theorem CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono'_p :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : CategoryTheory.ShortComplex.RightHomologyData S₂)
      [inst_2 : CategoryTheory.Epi φ.τ₁] [inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
      (CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono' φ h).p =
        CategoryTheory.CategoryStruct.comp φ.τ₂ h.p :=
  by sorry

This theorem is in the context of category theory, specifically the study of short complexes. A short complex in a category is a sequence of objects and morphisms with certain interacting properties. The theorem states that for any category `C` with zero morphisms and any short complexes `S₁` and `S₂` in `C`, given a morphism `φ` from `S₁` to `S₂` and a right homology data `h` for `S₂`, if `φ.τ₁` is an epimorphism, `φ.τ₂` is an isomorphism, and `φ.τ₃` is a monomorphism, then the morphism `p` obtained from `φ` and `h` using `RightHomologyData.ofEpiOfIsIsoOfMono'` is equal to the composition of `φ.τ₂` and `h.p`. The terms epimorphism, isomorphism, and monomorphism refer to specific types of morphisms in category theory, with epimorphisms generalizing the concept of surjectivity, isomorphisms generalizing bijections, and monomorphisms generalizing injections.

Given short complexes $S\_1$ and $S\_2$ in a category $C$ with zero morphisms, a morphism $\varphi : S\_1 \to S\_2$, and right homology data $h$ for $S\_2$, if $\varphi.\tau\_1$ is an epimorphism, $\varphi.\tau\_2$ is an isomorphism, and $\varphi.\tau\_3$ is a monomorphism, then $RightHomologyData.ofEpiOfIsIsoOfMono' (\varphi, h) = \varphi.\tau\_2 \circ h.p$.


CategoryTheory.ExponentialIdeal.mk'

/-- To show `i` is an exponential ideal it suffices to show that `A ⟹ iB` is "in" `D` for any `A` in
`C` and `B` in `D`.
 -/
theorem CategoryTheory.ExponentialIdeal.mk' :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₁, u₂} D] (i : CategoryTheory.Functor D C)
      [inst_2 : CategoryTheory.Limits.HasFiniteProducts C] [inst_3 : CategoryTheory.CartesianClosed C],
      (∀ (B : D) (A : C), (A ⟹ i.obj B) ∈ CategoryTheory.Functor.essImage i) → CategoryTheory.ExponentialIdeal i :=
  by sorry

This theorem states that for any categories `C` and `D`, with `C` having finite products and being cartesian closed, and any functor `i` from `D` to `C`, `i` is an exponential ideal if for any object `A` in `C` and `B` in `D`, `A ⟹ i.obj B` (the exponential object of `A` and `i.obj B` in `C`) lies in the essential image of the functor `i`. Here, the essential image of a functor is the category of objects in the target category that are isomorphic to an object in the image of the functor.

For any functor i from category D to a cartesian closed category C with finite products, i is an exponential ideal if and only if the exponential objects A⊤B of any objects A in C and B in D lie in the essential image of i.


theorem Subgroup.subgroupOf_inj :
    ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ K : Subgroup G},
      Subgroup.subgroupOf H₁ K = Subgroup.subgroupOf H₂ K ↔ H₁ ⊓ K = H₂ ⊓ K :=
  by sorry

This theorem states that for any type 'G' with group structure, and for any subgroups 'H₁', 'H₂' and 'K' of 'G', the injection of 'H₁' into 'K' is the same as the injection of 'H₂' into 'K' if and only if the intersection of 'H₁' and 'K' is equal to the intersection of 'H₂' and 'K'. In other words, it says that two subgroups are mapped to the same subgroup of 'K' by the function 'Subgroup.subgroupOf', precisely when their intersections with 'K' are the same.

For any groups G, subgroups H1, H2, and K, the injection of H1 into K equals the injection of H2 into K if and only if the intersections H1 ∩ K and H2 ∩ K are equal.


theorem Mathlib.CategoryTheory.Groupoid.Subgroupoid._auxLemma.2 :
    ∀ {α : Sort u_1} {p : α → Prop} {a : α} {h : p a} {a' : α} {h' : p a'},
      ({ val := a, property := h } = { val := a', property := h' }) = (a = a') :=
  by sorry

This theorem states that for any sort `α`, any predicate `p` over `α`, any two elements `a` and `a'` of `α` such that `p` holds for `a` and `a'` respectively, the equality of the two pairs `{ val := a, property := h }` and `{ val := a', property := h' }` (constructed with the elements and their properties) is the same as the equality of `a` and `a'`. Simply put, two such pairs are equal if and only if the elements they are constructed with are equal, irrespective of the properties.

Given any sort `α`, predicate `p` over `α`, and elements `a` and `a'` of `α` such that `p(a)` and `p(a')` hold, the pairs `{val := a, property := h}` and `{val := a', property := h'}` are equal if and only if `a` and `a'` are equal.


ContDiffWithinAt.sub

/-- The difference of two `C^n` functions within a set at a point is `C^n` within this set
at this point.  -/
theorem ContDiffWithinAt.sub :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      {n : ℕ∞} {s : Set E} {f g : E → F},
      ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → ContDiffWithinAt 𝕜 n (fun x => f x - g x) s x :=
  by sorry

The theorem `ContDiffWithinAt.sub` states that if we have two functions, `f` and `g`, that are `C^n` continuous (i.e., continuously differentiable up to the nth derivative) at a point `x` within a given set `s` in a normed space over a nontrivially normed field, then the function that is the difference of `f` and `g` is also `C^n` continuous at the same point `x` within the same set `s`. This theorem is applicable in the context of analysis in normed spaces.

If `f` and `g` are `C^n` continuous at `x` in set `s` of a normed space over a nontrivially normed field, then `f - g` is also `C^n` continuous at `x` in `s`.


theorem Finset.diag_union_offDiag :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), Finset.diag s ∪ Finset.offDiag s = s ×ˢ s := by sorry

This theorem states that for any finite set `s` of type `α`, where `α` has decidable equality, the union of the diagonal and off-diagonal of `s` equals the cartesian product of `s` with itself. In other words, the set of all pairs `(a, a)` where `a` is in `s` (denoted as `Finset.diag s`), combined with the set of all pairs `(a, b)` where `a` and `b` are different elements in `s` (denoted as `Finset.offDiag s`), covers the entire set of all possible pairs that can be formed from elements in `s` (denoted as `s ×ˢ s`).

For any finite set `s` of type `α` with decidable equality, `Finset.diag s ∪ Finset.offDiag s = s ×ˢ s`.


theorem contDiffWithinAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {n : ℕ∞} {s : Set E} {x : E}, ContDiffWithinAt 𝕜 n id s x :=
  by sorry

This theorem, `contDiffWithinAt_id`, states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, normed space over `𝕜` and `E`, a set `s` of elements of type `E`, a point `x` in `E`, and a natural number or infinity `n`, the identity function is continuously differentiable within the set `s` at the point `x`. In other words, it expresses the fact that the identity function is as smooth as you like (up to and including infinitely differentiable) at any point in any normed vector space.

For any non-trivially normed field `𝕜`, normed additive commutative group `E`, and for any set `s` of elements in `E`, point `x` in `E`, and natural number or infinity `n`, the identity function on `E` is `n`-times differentiable at `x` within `s`.


theorem ZMod.expand_card :
    ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : Polynomial (ZMod p)), (Polynomial.expand (ZMod p) p) f = f ^ p := by
  sorry

This theorem states that for every prime number `p` and any polynomial `f` with coefficients in the integers modulo `p`, when we expand the polynomial `f` by a factor of `p` (i.e., transform each term `aₙ xⁿ` to `aₙ xⁿᵖ`), the result is equivalent to raising the polynomial `f` to the power of `p`. In mathematical terms, for every prime `p` and a polynomial `f` in ℤ/pℤ, (f(x))^p is the same as f(x^p).

For every prime number `p`, expanding a polynomial `f` in ℤ/pℤ by a factor of `p` is equivalent to raising `f` to the power of `p`.


theorem Function.FactorsThrough.extend_apply :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : α → γ},
      Function.FactorsThrough g f → ∀ (e' : β → γ) (a : α), Function.extend f g e' (f a) = g a :=
  by sorry

The theorem `Function.FactorsThrough.extend_apply` states that for any types `α`, `β`, and `γ`, and any functions `f : α → β`, `g : α → γ`, if `g` factors through `f` (i.e., if `f a = f b` implies that `g a = g b` for any `a` and `b` in `α`), then for every function `e' : β → γ` and every element `a` of `α`, the function `Function.extend f g e'` evaluated at `f a` is equal to `g a`. This theorem effectively asserts that the extension of `g` via `f` and `e'` maintains the original behavior of `g` when evaluated at `f a`.

If `f` and `g` are functions with `g` factoring through `f`, then `Function.extend f g e' (f a)` equals `g a` for all `e' : β → γ` and `a : α`.


/-- The **Cayley-Hamilton Theorem**, that the characteristic polynomial of a linear map, applied
to the linear map itself, is zero.

See `Matrix.aeval_self_charpoly` for the equivalent statement about matrices.  -/
theorem LinearMap.aeval_self_charpoly :
    ∀ {R : Type u} {M : Type v} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : Module.Free R M] [inst_4 : Module.Finite R M] (f : M →ₗ[R] M),
      (Polynomial.aeval f) (LinearMap.charpoly f) = 0 :=
  by sorry

The theorem `LinearMap.aeval_self_charpoly` is a formalization of the well-known Cayley-Hamilton Theorem in the context of linear maps. The theorem states that for any commutative ring `R` and any `R`-module `M`, if `f` is a linear map from `M` to `M`, the characteristic polynomial of `f`, when evaluated at `f` itself, yields zero. This can be thought of as the linear map satisfying its own characteristic equation. This theorem is closely related to the equivalent statement about matrices, `Matrix.aeval_self_charpoly`.

For any commutative ring `R` and `R`-module `M`, if `f` is a linear map from `M` to `M`, then the characteristic polynomial of `f` evaluated at `f` is zero.


theorem LipschitzWith.comp_memℒp :
    ∀ {p : ENNReal} {α : Type u_5} {E : Type u_6} {F : Type u_7} {K : NNReal} [inst : MeasurableSpace α]
      {μ : MeasureTheory.Measure α} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F] {f : α → E}
      {g : E → F}, LipschitzWith K g → g 0 = 0 → MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp (g ∘ f) p μ :=
  by sorry

This theorem states that if a function `g` is Lipschitz continuous with a nonnegative real constant `K` and `g(0) = 0`, and a function `f` belongs to the space of `p`-integrable functions (in the sense of `MeasureTheory.Memℒp`), then the composition of `g` and `f` (i.e., `g ∘ f`) also belongs to this space of `p`-integrable functions. Here, `p` is an extended nonnegative real number (which can be infinity), and `f` and `g` are functions from a measurable space `α` to normed add-commutative groups `E` and `F` respectively. The measure on the space `α` is given by `μ`.

If `g` is a Lipschitz continuous function with `g(0) = 0` and has a nonnegative real constant `K`, and `f` is `p`-integrable, then the composition `g ∘ f` is also `p`-integrable for any extended nonnegative real number `p`.


theorem ZFSet.mem_sep : ∀ {p : ZFSet → Prop} {x y : ZFSet}, y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y := by sorry

The theorem `ZFSet.mem_sep` states that for any property `p` and any sets `x` and `y` in the Zermelo-Fraenkel set theory universe, `y` belongs to the set of elements in `x` that satisfy `p` if and only if `y` is an element of `x` and `y` satisfies the property `p`. In other words, it formalizes the notion of set membership for a subset defined by a property in ZF set theory. This theorem is essentially the mathematical version of the principle of restricted comprehension in set theory.

For any set X and property p, y is in the subset of X satisfying p if and only if y is in X and has property p.


theorem Ordinal.lsub_eq_blsub :
    ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}),
      Ordinal.lsub (Ordinal.familyOfBFamily o f) = Ordinal.blsub o f :=
  by sorry

This theorem states that for any ordinal `o` and a function `f` mapping each ordinal less than `o` to an ordinal, the least strict upper bound of the family of ordinals (mapped by `f` and indexed by the set of ordinals less than `o`) obtained through the function `Ordinal.familyOfBFamily` is equal to the least strict upper bound of the same family of ordinals directly obtained through `f` using the function `Ordinal.blsub`. In other words, the operations `Ordinal.lsub` and `Ordinal.blsub` yield the same result when applied to the same set of ordinals under the conditions mentioned.

For any ordinal `o` and function `f` mapping ordinals less than `o` to ordinals, `Ordinal.lsub (Ordinal.familyOfBFamily o f) = Ordinal.blsub (∑ (x : Ordinal) in set.Ico 0 o) (λ (x : Ordinal), f x)`.


theorem Nat.Iio_eq_range : Finset.Iio = Finset.range := by sorry

This theorem states that the function `Finset.Iio`, which creates a finite set of elements `x` such that `x` is less than a given input `a`, is equivalent to the function `Finset.range`, which creates a set of natural numbers less than a given natural number `n`. In other words, for any natural number `n`, the set of natural numbers less than `n` can be produced by either of these two functions.

The functions `Finset.Iio` and `Finset.range` yield equivalent finite sets of natural numbers, specifically, `Finset.Iio a` is equivalent to `Finset.range (Pred a)`, where `Pred` is the predicate function.


theorem Projectivization.Subspace.mem_add :
    ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      (T : Projectivization.Subspace K V) (v w : V) (hv : v ≠ 0) (hw : w ≠ 0) (hvw : v + w ≠ 0),
      Projectivization.mk K v hv ∈ T → Projectivization.mk K w hw ∈ T → Projectivization.mk K (v + w) hvw ∈ T :=
  by sorry

The theorem `Projectivization.Subspace.mem_add` states that for any field `K`, vector space `V` over `K`, a subspace `T` of the projectivization of `V`, and non-zero vectors `v`, `w` in `V` such that their sum `v + w` is also non-zero, if the projectivization of `v` is in `T` and the projectivization of `w` is in `T`, then the projectivization of `v + w` is also in `T`. In other words, this theorem asserts that the subspace `T` of the projectivization of a vector space is closed under addition.

Given a field `K`, a vector space `V` over `K`, a subspace `T` of the projectivization of `V`, and non-zero vectors `v`, `w` in `V` such that `v + w` is non-zero, if the projectivizations of `v` and `w` belong to `T`, then the projectivization of `v + w` also belongs to `T`.


/-- A special case of `Finset.sup_eq_iSup` that omits the useless `x ∈ univ` binder.  -/
theorem Finset.sup_univ_eq_iSup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Fintype α] [inst_1 : CompleteLattice β] (f : α → β),
      Finset.sup Finset.univ f = iSup f :=
  by sorry

The theorem `Finset.sup_univ_eq_iSup` states that for every function `f` from a type `α` to a type `β`, where `α` is a finite type and `β` is a complete lattice, the supremum of the function `f` over the universal set of `α` (i.e., `Finset.sup Finset.univ f`) is equal to the indexed supremum of the function `f` (i.e., `iSup f`). In terms of set theory, it means that taking the supremum of `f` over all elements of `α` (since `Finset.univ` contains all elements of `α`) is equivalent to taking the supremum of `f` over its range.

For a function `f` from a finite type `α` to a complete lattice `β`, `Finset.sup Finset.univ f` equals `iSup f`.


theorem Matrix.cons_add_cons :
    ∀ {α : Type u} {n : ℕ} [inst : Add α] (x : α) (v : Fin n → α) (y : α) (w : Fin n → α),
      Matrix.vecCons x v + Matrix.vecCons y w = Matrix.vecCons (x + y) (v + w) :=
  by sorry

The theorem `Matrix.cons_add_cons` states that for any type `α` that has an addition operation, any natural number `n`, and any two elements `x` and `y` of type `α`, as well as any two vectors `v` and `w` of length `n` with elements of type `α`, the sum of two vectors constructed by prepending `x` and `y` to `v` and `w`, respectively, is a new vector constructed by prepending the sum of `x` and `y` to the sum of `v` and `w`. In essence, it states that the operation of constructing a vector by prepending an element commutes with vector addition.

For any type `α` with addition, and vectors `v`, `w` of length `n` over `α`, the operation of prepending an element to a vector commutes with vector addition: `[x] ++ (v ++ w) = ([x] ++ v) ++ w`, where `[x]` is the vector prepended with `x`.


theorem FirstOrder.Language.ElementaryEmbedding.map_fun :
    ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] (φ : FirstOrder.Language.ElementaryEmbedding L M N) {n : ℕ}
      (f : L.Functions n) (x : Fin n → M),
      φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure.funMap f (⇑φ ∘ x) :=
  by sorry

The theorem `FirstOrder.Language.ElementaryEmbedding.map_fun` asserts that for any first-order language `L`, types `M` and `N` with structures as `FirstOrder.Language.Structure`, and an elementary embedding `φ` from `M` to `N`, for any function symbol `f` in `L` and for any map `x` from `Fin n → M`, where `n` is the arity of the function, the image of the interpretation of `f` in `M` under `φ` is equal to the interpretation of `f` in `N`. This embedding is done by mapping the arguments of `f` in `M` to `N` according to `φ` before applying `f`. This states that the elementary embedding `φ` preserves the interpretation of the function symbols in the language `L`.

For any first-order language L, structures M and N, and elementary embedding φ from M to N, if f is a function symbol in L and x is a map from Fin n to M (where n is the arity of f), then the interpretation of f in N under φ is equal to the application of f to the images of x under φ.


theorem Computation.mem_map :
    ∀ {α : Type u} {β : Type v} (f : α → β) {a : α} {s : Computation α}, a ∈ s → f a ∈ Computation.map f s := by sorry

This theorem states that for any types `α` and `β`, a function `f` from `α` to `β`, a value `a` of type `α`, and a computation `s` of type `α`, if `a` is a result of the computation `s`, then `f(a)` is a result of the computation obtained by applying `f` to all results of `s` (i.e., `f(a)` is in the computation resulting from the mapping of `f` over `s`).

For any functions `f` and computations `s` from type `α` to type `β`, and value `a` of type `α` being a result of `s`, `f(a)` is a result of the application of `f` to the results of `s`.


theorem MeasureTheory.Measure.MutuallySingular.add_left :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν₁ ν₂ : MeasureTheory.Measure α},
      MeasureTheory.Measure.MutuallySingular ν₁ μ →
        MeasureTheory.Measure.MutuallySingular ν₂ μ → MeasureTheory.Measure.MutuallySingular (ν₁ + ν₂) μ :=
  by sorry

This theorem, `MeasureTheory.Measure.MutuallySingular.add_left`, asserts that if two measures `ν₁` and `ν₂` are each mutually singular with a measure `μ` in a given measurable space, then the sum of `ν₁` and `ν₂` is also mutually singular with `μ`. In terms of measure theory, two measures are said to be mutually singular if there exists a measurable set for which one measure is zero while the complement of the set is zero for the other measure. So, the theorem essentially states that the property of mutual singularity with respect to a given measure is preserved under the addition of the mutually singular measures.

If measures `ν₁` and `ν₂` are mutually singular with measure `μ` in a measurable space, then `ν₁ + ν₂` is mutually singular with `μ`.


theorem Finset.compl_insert :
    ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α} [inst_1 : DecidableEq α] {a : α},
      (insert a s)ᶜ = Finset.erase sᶜ a :=
  by sorry

The theorem `Finset.compl_insert` states that for any type `α` that has finite instances (denoted by `[Fintype α]`), any set `s` of this type `α` (denoted by `s : Finset α`), any element `a` of type `α` (denoted by `a : α`), and given that `α` has decidable equality (`[DecidableEq α]`), the complement of the set that results from inserting element `a` into set `s` (`(insert a s)ᶜ`) is equal to the set obtained by erasing the element `a` from the complement of set `s` (`Finset.erase sᶜ a`). This theorem basically provides us with a property of set complements in the context of finite sets.

For any finite type `α` with decidable equality, the complement of `insert a s` equals `Finset.erase sᶜ a`.


Normal.splits

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

The theorem `Normal.splits` asserts that for any fields `F` and `K` with an algebra structure between them, if `K` is a normal extension of `F`, then for any element `x` of `K`, the minimal polynomial of `x` over `F` splits over `K`. This implies that either the minimal polynomial is zero or all of its irreducible factors have degree 1 when considered as a polynomial over `K`. The algebra structure provides an embedding of `F` in `K`, and the "splits" property is defined with respect to this embedding.

If `F` is a subfield of `K` with an algebra structure, and `K` is a normal extension of `F`, then every irreducible factor of the minimal polynomial of any element `x` in `K` over `F` has degree 1.


theorem Real.continuous_arctan : Continuous Real.arctan := by sorry

This theorem states that the arctan function, which is the inverse of the tangent function, is continuous. In the context of real numbers, a function is continuous if the function does not have any jumps, breaks, or holes. Specifically, the Real.arctan function takes a real number input and returns a real number output, and this output changes smoothly as the input changes. The theorem implies that for any value in the domain of the function, a small change in the input will result in a small change in the output; there are no sudden or abrupt changes in the value of the function.

The arctan function is a continuous real-valued function.


theorem IsUnit.div_self : ∀ {α : Type u} [inst : DivisionMonoid α] {a : α}, IsUnit a → a / a = 1 := by sorry

The theorem `IsUnit.div_self` states that for any type `α`, which is a division monoid (a type of monoid with a division operation), and for any element `a : α`, if `a` is a unit (i.e., it has a two-sided inverse), then dividing `a` by itself yields 1. This property is a common one in mathematical structures with division, where any non-zero element divided by itself equals the multiplicative identity, which is 1 in this case.

If `α` is a division monoid and `a : α` is a unit, then `a * (a ^ -1) = a ^ -1 * a = 1`, where `*` denotes division and `^` denotes exponentiation.


theorem homotopyEquivalences_subset_quasiIso :
    ∀ {ι : Type u_2} (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      (c : ComplexShape ι) [inst_2 : CategoryTheory.CategoryWithHomology C],
      HomologicalComplex.homotopyEquivalences C c ⊆ HomologicalComplex.quasiIso C c :=
  by sorry

The theorem `homotopyEquivalences_subset_quasiIso` states that for every type `ι`, category `C` (with operations of addition) and complex shape `c`, the set of homotopy equivalences on the homological complex `C c` is a subset of the set of quasi-isomorphisms on the same homological complex. Here, `CategoryTheory.Category.{v, u} C` and `CategoryTheory.Preadditive C` are typeclass assumptions stating that `C` is a category and is preadditive (i.e., its morphisms have a compatible notion of addition), and `CategoryTheory.CategoryWithHomology C` is a typeclass assumption asserting that the category `C` has a defined notion of homology.

The set of homotopy equivalences between complexes in a preadditive category with homology is a subset of the quasi-isomorphisms between the same complexes.


/-- See `Infinite.exists_superset_card_eq` for a version that, for an `s : Finset α`,
provides a superset `t : Finset α`, `s ⊆ t` such that `t.card` is fixed.  -/
theorem Infinite.exists_subset_card_eq : ∀ (α : Type u_4) [inst : Infinite α] (n : ℕ), ∃ s, s.card = n := by sorry

This theorem, `Infinite.exists_subset_card_eq`, asserts that for any infinite type `α` and any natural number `n`, there exists a finite set `s` of type `α` such that the cardinality of `s` equals `n`. In other words, it is always possible to find a finite subset of an infinite set that has exactly `n` elements. The theorem refers to `Infinite.exists_superset_card_eq` for a similar assertion that instead provides a superset of a given set with a fixed cardinality.

For any infinite type `α` and natural number `n`, there exists a finite subset of `α` with cardinality equal to `n`.


theorem Filter.tendsto_atTop_add_const_left :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommGroup β] (l : Filter α) {f : α → β} (C : β),
      Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => C + f x) l Filter.atTop :=
  by sorry

The theorem `Filter.tendsto_atTop_add_const_left` states that for any types `α` and `β`, where `β` is an ordered additive commutative group, any filter `l` on `α`, any function `f` from `α` to `β`, and any constant `C` of type `β`, if the function `f` tends to infinity (`Filter.atTop`) as we approach the points defined by the filter `l`, then the function which adds the constant `C` to each value of `f` also tends to infinity as we approach the points defined by `l`. In mathematical terms, if $\lim_{x \to l} f(x) = \infty$, then $\lim_{x \to l} (C + f(x)) = \infty$.

If a filter `l` on type `α` and a function `f:` `α` → `β` (where `β` is an ordered additive commutative group) tend to infinity at `l`, then the function `C + f` also tends to infinity at `l`, for any constant `C` of type `β`.


theorem Option.eq_some_of_isSome :
    ∀ {α : Type u_1} {o : Option α} (h : Option.isSome o = true), o = some (Option.get o h) := by sorry

This theorem states that for all types `α` and for any option `o` of type `α`, if the function `Option.isSome` returns `true` when applied to `o`, then `o` must be equal to `some` applied to `Option.get o h`. In other words, if an option `o` is not `none`, it must be `some a` for some `a` and we can retrieve `a` using `Option.get`. This theorem asserts that `Option.isSome` and `Option.get` are consistent with each other.

If `Option.isSome o` holds for an option `o` of type `α`, then `o = some (Option.get o)`.


/-- A special case of `Summable.map_iff_of_leftInverse` for convenience -/
theorem Summable.map_iff_of_equiv :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
      [inst_2 : AddCommMonoid γ] [inst_3 : TopologicalSpace γ] {G : Type u_5} [inst_4 : EquivLike G α γ]
      [inst_5 : AddEquivClass G α γ] (g : G),
      Continuous ⇑g → Continuous (EquivLike.inv g) → (Summable (⇑g ∘ f) ↔ Summable f) :=
  by sorry

This theorem, named `Summable.map_iff_of_equiv`, states a special condition for the equivalence of summability of two functions. Specifically, for any types `α`, `β`, `γ`, and `G`, with `α` and `γ` equipped with an add commutative monoid structure and a topological space structure, and `G` is of equivalence-like type between `α` and `γ` and also forms an additive equivalence class between `α` and `γ`, we consider a function `f` from `β` to `α` and a function `g` from `G`. If the application of `g` (denoted as `⇑g`) and the inversion of `g` (denoted as `EquivLike.inv g`) are both continuous functions, then the summability of the composition of `g` and `f` (denoted as `⇑g ∘ f`) is equivalent to the summability of `f`. In simpler terms, under these conditions, if the infinite sum of the function values obtained by applying `f` and then `g` exists, then the infinite sum of the function values obtained by applying `f` also exists, and vice versa.

If `g` is an additive equivalence class between `α` and `γ`, is an equivalence-like type between them, forms continuous functions, and `f` is a function from `β` to `α`, then the summability of `g ∘ f` is equivalent to the summability of `f`.


theorem Matrix.PosDef.re_dotProduct_pos :
    ∀ {n : Type u_2} {𝕜 : Type u_4} [inst : Fintype n] [inst_1 : RCLike 𝕜] {M : Matrix n n 𝕜},
      Matrix.PosDef M → ∀ {x : n → 𝕜}, x ≠ 0 → 0 < RCLike.re (Matrix.dotProduct (star x) (Matrix.mulVec M x)) :=
  by sorry

The theorem `Matrix.PosDef.re_dotProduct_pos` states that for any type `n` with a finite number of instances, any `𝕜` which is a RC-like structure (an algebraic structure that behaves like the complex numbers), and any given matrix `M` with dimensions `n x n` and entries in `𝕜`, if `M` is positive definite, then for any non-zero vector `x` with entries in `𝕜`, the real part of the dot product of the conjugate of `x` and the vector obtained by multiplying `M` with `x` is greater than zero. The dot product is computed as the sum of the entrywise products, and the real part is extracted using the `RCLike.re` function. This essentially states that the real part of the conjugate transpose of a vector times a positive definite matrix times the vector itself is always positive for non-zero vectors, a key property of positive definite matrices.

For any non-zero vector x and positive definite matrix M of compatible dimensions over an RC-like structure 𝕜, the real part of the dot product of the conjugate of x and the product of M and x is positive.


theorem AddMonoidHom.map_dfinsupp_sumAddHom :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] {R : Type u_1} {S : Type u_2} [inst_1 : AddCommMonoid R]
      [inst_2 : AddCommMonoid S] [inst_3 : (i : ι) → AddZeroClass (β i)] (h : R →+ S) (f : Π₀ (i : ι), β i)
      (g : (i : ι) → β i →+ R),
      h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => AddMonoidHom.comp h (g i)) f :=
  by sorry

This theorem states that for any type `ι`, a function `β` from `ι` to another type, a type `R` with addition and commutativity, a type `S` with addition and commutativity, a function `h` that is an additive monoid homomorphism from `R` to `S`, a function `f` from a partially defined function (`DFinsupp`) from `ι` to `β i`, and a function `g` that for each `ι` maps `β i` to `R` through an additive monoid homomorphism, the composition of `h` with the sum (respecting the additive structure) of the partially defined function `f` through `g` is equal to the sum (respecting the additive structure) of `f` through the composition of `h` and `g`. This means that the sum and composition operations involved here are interchangeable, a property often known in mathematics as "commutativity".

For any additive monoid homomorphisms h: R → S, functions f: ι → β with values in a type endowed with an additive structure, and g: β → R, the sum of the function composition h ∘ g with the sum of f (respecting additive structures) is equal to the sum of f through the composition h ∘ g.


theorem Mathlib.Combinatorics.Young.YoungDiagram._auxLemma.29 :
    ∀ {w : List ℕ} {hw : List.Sorted (fun x x_1 => x ≥ x_1) w} {c : ℕ × ℕ},
      (c ∈ YoungDiagram.ofRowLens w hw) = ∃ (h : c.1 < List.length w), c.2 < List.get w { val := c.1, isLt := h } :=
  by sorry

This theorem states that for any list `w` of natural numbers that is sorted in non-increasing order (`hw` is the proof of this property), and for any pair of natural numbers `c`, the pair `c` is in the YoungDiagram formed from the list `w` if and only if there exists a proof `h` such that the first element of `c`, `c.1`, is less than the length of the list `w` and the second element of `c`, `c.2`, is less than the element at index `c.1` in the list `w`.

For a sorted list `w` of natural numbers and a pair `c`, `c` is in the Young Diagram formed from `w` if and only if `c.1 < length w` and `c.2 < w!(c.1)`.


theorem add_upperClosure :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (s t : Set α), s + ↑(upperClosure t) = ↑(upperClosure (s + t)) := by
  sorry

This theorem states that for any ordered additive commutative group `α` and any sets `s` and `t` of elements of `α`, the set obtained by adding every element of `s` to every element of the upper closure of `t` (the set of all elements greater than or equal to some element in `t`) is equal to the upper closure of the set obtained by adding every element of `s` to every element of `t`. In other words, the process of adding a set to the upper closure of another set is the same as first adding the two sets and then taking the upper closure.

For any ordered additive commutative group `α` and sets `s` and `t`, the upper closure of `s` + upper closure(`t`) equals the upper closure of `s` + `t`.


theorem Nat.mod_add_div' : ∀ (a b : ℕ), a % b + a / b * b = a := by sorry

This theorem states that for any two natural numbers `a` and `b`, the sum of the remainder of `a` divided by `b` (`a % b`) and the product of the quotient of `a` divided by `b` (`a / b`) and `b` is equal to `a`. In mathematical terms, this can be written as `a mod b + ⌊a / b⌋ * b = a`. It essentially describes a property of the division algorithm in the natural numbers.

For any natural numbers `a` and `b`, the theorem asserts that `a = (a % b) + ⌊a / b⌋ * b`.


theorem Set.vsub_self_mono : ∀ {α : Type u_2} {β : Type u_3} [inst : VSub α β] {s t : Set β}, s ⊆ t → s -ᵥ s ⊆ t -ᵥ t :=
  by sorry

This theorem, `Set.vsub_self_mono`, states that for any types `α` and `β`, if `α` has a vector subtraction structure (`VSub`), and `s` and `t` are sets of type `β`, then if `s` is a subset of `t`, it follows that the vector difference of `s` with itself (`s -ᵥ s`) is a subset of the vector difference of `t` with itself (`t -ᵥ t`). This theorem essentially guarantees that taking vector differences of sets respects the subset relation.

If `α` has a vector subtraction structure and `s` is a subset of `t` in type `β`, then `s -ᵥ s` is a subset of `t -ᵥ t`.


theorem AddCommGroup.DirectLimit.map_apply_of :
    ∀ {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : DecidableEq ι] [inst_2 : (i : ι) → AddCommGroup (G i)]
      {f : (i j : ι) → i ≤ j → G i →+ G j} {G' : ι → Type v'} [inst_3 : (i : ι) → AddCommGroup (G' i)]
      {f' : (i j : ι) → i ≤ j → G' i →+ G' j} (g : (i : ι) → G i →+ G' i)
      (hg : ∀ (i j : ι) (h : i ≤ j), AddMonoidHom.comp (g j) (f i j h) = AddMonoidHom.comp (f' i j h) (g i)) {i : ι}
      (x : G i),
      (AddCommGroup.DirectLimit.map g hg) ((AddCommGroup.DirectLimit.of G f i) x) =
        (AddCommGroup.DirectLimit.of G' f' i) ((g i) x) :=
  by sorry

This theorem states that for any type `ι` with a preorder, and families of additive commutative groups `G` and `G'` indexed by `ι`, if we have morphisms `f` and `f'` between elements of these families respecting the preorder, and a family of morphisms `g` from `G` to `G'` such that the composition of `g` and `f` yields the same result as the composition of `f'` and `g`, then for any `i` in `ι` and any element `x` of `G i`, the result of applying the direct limit map from `G` to `G'` to the image of `x` under the direct limit map of `G` is equal to the result of applying the direct limit map of `G'` to the image of `x` under `g i`. In more mathematical terms, this theorem essentially verifies that a certain diagram in the category of additive commutative groups commutes.

Given additive commutative groups indexed by a preordered type `ι`, if morphisms `f`, `f'`, and a family of morphisms `g` respect the preorder and commute, then the direct limit of `g` applied to the direct limit of `G` is equal to the direct limit of `g` applied to the direct limit of `G'` when applied to any element of `G`.


theorem Nat.ble_eq_true_of_le : ∀ {n m : ℕ}, n ≤ m → Nat.ble n m = true := by sorry

This theorem states that for every pair of natural numbers `n` and `m`, if `n` is less than or equal to `m`, then the result of the function `Nat.ble n m` (which checks if `n` is less than or equal to `m` and returns a boolean) is `true`. Essentially, this theorem formalizes part of the definition of the "less than or equal to" relation for natural numbers in terms of a boolean function.

For all natural numbers `n` and `m`, `Nat.ble n m` holds if and only if `n` is less than or equal to `m`.


/-- As a binary function, `Fin.cons` is injective.  -/
theorem Fin.cons_injective2 : ∀ {n : ℕ} {α : Fin (n + 1) → Type u}, Function.Injective2 Fin.cons := by sorry

The theorem `Fin.cons_injective2` states that, for any natural number `n` and any function `α` from `Fin (n + 1)` to some type `u`, the `Fin.cons` function, considered as a binary function, is injective. In mathematical terms, if you add an element at the beginning of an `n`-tuple using `Fin.cons` to get an `n+1`-tuple, then no two different pairs of an element and an `n`-tuple will result in the same `n+1`-tuple. This injectivity property ensures that you can uniquely recover the original pair from the resulting `n+1`-tuple.

For any natural number `n` and any function `α : Fin (n + 1) → u`, the function `Fin.cons : ∀ i : Fin n, α i → α (Fin.pred i) × α i → Fin (n + 1) × α i` is injective.


theorem Set.inter_eq_iInter : ∀ {α : Type u_1} {s₁ s₂ : Set α}, s₁ ∩ s₂ = ⋂ b, bif b then s₁ else s₂ := by sorry

This theorem states that for any type `α` and any two sets `s₁` and `s₂` of type `α`, the intersection of `s₁` and `s₂` is equivalent to the intersection over all `b` such that if `b` is true, then we consider `s₁`, else we consider `s₂`. In other words, the intersection of the two sets `s₁` and `s₂` is the same as the intersection of all elements from either `s₁` or `s₂` depending on whether a certain condition `b` is met.

For any type `α` and sets `s₁`, `s₂` of type `α`, the intersection of `s₁` and `s₂` equals the intersection of `s₁` if a condition `b` holds, and the intersection of `s₂` otherwise.


theorem subset_add_closure_zero :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] (s : Set G), s ⊆ s + closure {0} := by sorry

This theorem states that for any type `G` which is a topological space and an additive group, and for any set `s` of type `G`, `s` is a subset of the set obtained by adding `s` and the closure of the singleton set containing only the additive identity (0). In simpler terms, every element of `s` is also an element of the set formed by adding `s` and the closure of the set containing just 0.

For any topological additive group `G` and subset `s` of `G`, `s` is contained in the set `s ∪ {0} ⊔ cl {0}`, where `cl` denotes the topological closure and `⊔` denotes the set union with the closure.


theorem Mathlib.Logic.Nonempty._auxLemma.6 : ∀ {α : Sort u_2} {p : α → Prop}, Nonempty (Subtype p) = ∃ a, p a := by
  sorry

This theorem states that for any type `α` and any property `p` that `α` might have, there exists a nonempty subtype of `α` that satisfies `p` if and only if there exists an element `a` of `α` that satisfies `p`. In other words, we can find a nonempty subtype of `α` with property `p` if we can find at least one instance of `α` that has property `p`.

For any type `α` and property `p`, there exists a nonempty subtype of `α` with property `p` if and only if there exists an element `a` in `α` with property `p`.


theorem Mathlib.Data.PNat.Defs._auxLemma.4 : ∀ (n : ℕ+), (↑n = 0) = False := by sorry

This theorem, `Mathlib.Data.PNat.Defs._auxLemma.4`, states that for any positive natural number `n`, the predicate that `n` equals zero is always false. In other words, it means that no positive natural number can be zero. The `Nat+` refers to the set of positive natural numbers, and `n` is a member of this set. The `↑n = 0` is the predicate under consideration, where `↑n` is the operation of embedding `n` into the naturals (which doesn't change its value), and `0` is the natural number zero.

For any positive natural number `n`, the predicate `n = 0` is false.


theorem OnePoint.isOpen_iff_of_mem :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set (OnePoint X)},
      OnePoint.infty ∈ s → (IsOpen s ↔ IsClosed (OnePoint.some ⁻¹' s)ᶜ ∧ IsCompact (OnePoint.some ⁻¹' s)ᶜ) :=
  by sorry

The theorem `OnePoint.isOpen_iff_of_mem` states that for any topological space `X` and any set `s` of the one-point extension of `X` where the point at infinity is a member of `s`, then `s` is open if and only if the preimage of `s` under the embedding of `X` into its one-point extension, denoted as `OnePoint.some`, is closed and compact. The preimage of `s` is the subset of `X` that is mapped to `s` by `OnePoint.some`, and the notation `(OnePoint.some ⁻¹' s)ᶜ` means the complement of this preimage, i.e., the set of all points in `X` not in this preimage. The theorem essentially connects the openness of a set in the one-point extension of a topological space with the closure and compactness of a related set in the original space.

A set in the one-point extension of a topological space is open if and only if its preimage under the embedding is closed and compact.


/-- A bounded function `u` is in particular eventually bounded.  -/
theorem Filter.isBoundedUnder_of :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {f : Filter β} {u : β → α},
      (∃ b, ∀ (x : β), r (u x) b) → Filter.IsBoundedUnder r f u :=
  by sorry

The theorem `Filter.isBoundedUnder_of` states that for any types `α` and `β`, a relation `r` on `α`, a filter `f` on `β`, and a function `u` from `β` to `α`, if there exists a value `b` in `α` such that `r (u x) b` holds true for every `x` in `β`, then the image of the filter `f` under `u` is eventually bounded with respect to the relation `r`. In other words, if the function `u` is bounded by some uniform bound, then the values it takes on the elements of the filter `f` are also eventually bounded.

If a relation is satisfied by the image of every element in a filter under a function, then the filter's image under that function is bounded with respect to the relation.


theorem AddSubgroup.mem_sup :
    ∀ {C : Type u_6} [inst : AddCommGroup C] {s t : AddSubgroup C} {x : C}, x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x :=
  by sorry

This theorem states that for any type `C` which forms an additive commutative group, and for any two additive subgroups `s` and `t` of this group, an element `x` belongs to the supremum (join) of `s` and `t` if and only if there exist elements `y` in `s` and `z` in `t` such that their sum `y + z` equals `x`.

For any additive commutative group `C` and subgroups `s` and `t`, an element `x` is in the supremum of `s` and `t` if and only if there exist `y` in `s` and `z` in `t` such that `x = y + z`.


theorem Finset.image₂_right_comm :
    ∀ {α : Type u_1} {β : Type u_3} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} [inst : DecidableEq δ]
      [inst_1 : DecidableEq δ'] [inst_2 : DecidableEq ε] {s : Finset α} {t : Finset β} {γ : Type u_14} {u : Finset γ}
      {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε},
      (∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b) →
        Finset.image₂ f (Finset.image₂ g s t) u = Finset.image₂ g' (Finset.image₂ f' s u) t :=
  by sorry

The theorem `Finset.image₂_right_comm` states that for all types `α`, `β`, `δ`, `δ'`, `ε`, `γ`, given two binary functions `f : δ → γ → ε` and `g : α → β → δ`, a third binary function `f' : α → γ → δ'`, a fourth binary function `g' : δ' → β → ε`, and three finite sets `s : Finset α`, `t : Finset β`, and `u : Finset γ`, if for every `a` in `α`, `b` in `β`, and `c` in `γ`, `f` applied to `g` of `a` and `b` and `c` equals `g'` applied to `f'` of `a` and `c` and `b`, then the image of `f` over the cartesian product of the image of `g` over the cartesian product of `s` and `t` and `u` equals the image of `g'` over the cartesian product of the image of `f'` over the cartesian product of `s` and `u` and `t`.

In simpler terms, the theorem says that if `f` and `g'` commute under certain conditions and `g` and `f'` play a similar role, then the image sets obtained by these functions on the given finite sets will also commute.

If functions `f`, `g`, `f'`, and `g'` satisfy `f(g(x, y)) = g'(f'(x, y))` for all `x` in the domain of `f'` and `y` in the domain of `g`, then the images of `f` and `g'` over the cartesian products of their respective domains and finite sets `s`, `t`, and `u` commute.


Monotone.iterate

theorem Monotone.iterate : ∀ {α : Type u} [inst : Preorder α] {f : α → α}, Monotone f → ∀ (n : ℕ), Monotone f^[n] := by
  sorry

The theorem `Monotone.iterate` states that for any type `α` with a preorder, and any monotone function `f : α → α`, the `n`-th iterate of `f`, denoted by `f^[n]`, is also a monotone function. Here, the `n`-th iterate of `f` is the function obtained by composing `f` with itself `n` times, i.e., applying `f` `n` times successively. In other words, if `f` preserves the order of elements, so does any number of successive applications of `f`.

For any type `α` with a preorder and any monotone function `f : α → α`, the `n`-th iterate `f^[n]` is also a monotone function.


/-- Uses `right` co(ntra)variant. -/
theorem Right.neg_nonpos_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, -a ≤ 0 ↔ 0 ≤ a :=
  by sorry

The theorem `Right.neg_nonpos_iff` states that for any type `α` that forms an additive group and has a less than or equal to (`≤`) relation, where this relation is compatible with the group operation under swapping of arguments (i.e., it is right covariant), then for any element `a` of this type `α`, `-a` is less than or equal to `0` if and only if `0` is less than or equal to `a`. This theorem essentially captures the property that negating an element reverses its comparison with zero.

For any additive group type `α` with a right covariant `≤` relation, `-a ≤ 0` if and only if `0 ≤ a`.


theorem MvPowerSeries.inv_mul_cancel :
    ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] (φ : MvPowerSeries σ k),
      (MvPowerSeries.constantCoeff σ k) φ ≠ 0 → φ⁻¹ * φ = 1 :=
  by sorry

This theorem states that for any type `σ`, any field `k`, and any multivariate formal power series `φ` with coefficients in `k` indexed by `σ`, if the constant coefficient of `φ` is non-zero, then the product of the inverse of `φ` and `φ` itself is equal to 1. In other words, a multivariate formal power series with a non-zero constant coefficient has a multiplicative inverse, meaning it is a unit in the ring of multivariate formal power series. Therefore, this theorem is essentially showing that non-zero constant terms allow for a division operation in the ring of such power series.

For any field `k` and multivariate formal power series `φ` over `k` with non-zero constant coefficient, `φ` and its multiplicative inverse `φ⁻¹` satisfy `φ * φ⁻¹ = 1`.


theorem Finset.iSup_insert :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] [inst_1 : DecidableEq α] (a : α) (s : Finset α)
      (t : α → β), ⨆ x ∈ insert a s, t x = t a ⊔ ⨆ x ∈ s, t x :=
  by sorry

The theorem `Finset.iSup_insert` states that for any types `α` and `β`, where `β` forms a complete lattice, and for any decidable equality on `α`, if we have a function `t` from `α` to `β`, an element `a` of type `α`, and a finite set `s` of type `α`, then the supremum (i.e., the least upper bound) of the function `t` over the set obtained by inserting `a` into `s` is equal to the supremum of `t a` and the supremum of `t` over `s`. In other words, adding an element to a finite set and taking the supremum does not change the value if the supremum was already taken of the set and the element.

For any complete lattice β and decidable equality on type α, if t is a function from α to β, a is an element of α, and s is a finite set of α, then the supremum of t over s with a inserted is equal to the supremum of t(a) and the supremum of t over s.


theorem Mathlib.Order.LiminfLimsup._auxLemma.15 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

This theorem, named `_auxLemma.15` in the `Mathlib.Order.LiminfLimsup` namespace, states that for all types `α` and `ι`, and for any element `x` from `α` and any function `s` mapping from `ι` to `Set α`, the proposition "x belongs to the union over i of the sets `s i`" is equivalent to "there exists an `i` such that `x` belongs to the set `s i`". In mathematical terms, it captures the idea that an element is in the union of a collection of sets if and only if it's in at least one of the sets in the collection.

For any type `α`, element `x` from `α`, and function `s` mapping from an index type `ι` to sets of `α`, `x` belongs to the union of `s i` for some `i` if and only if `x` is in some `s i`.


theorem Mathlib.Order.LiminfLimsup._auxLemma.16 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i := by sorry

This theorem states that for any type `α`, any type `ι` (which doesn't need to be a type in the traditional sense, but can be any kind of logical collection), any element `x` of type `α`, and any function `s` from `ι` to sets of `α`, the membership of `x` in the intersection over all `i` from `ι` of the sets `s i` is equivalent to the statement that for all `i` in `ι`, `x` is a member of the set `s i`. In simpler terms, an element belongs to the intersection of a collection of sets if and only if it belongs to each set in the collection.

For any type `α`, any collection `ι`, element `x` of type `α`, and function `s : ι → sets α`, we have `x ∈ ∩ₛ i : ι, s i ↔ ∀ i, x ∈ s i`.


theorem Mathlib.Data.List.Sigma._auxLemma.14 :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b c : α},
      (a + b ≤ a + c) = (b ≤ c) :=
  by sorry

This theorem, named `Mathlib.Data.List.Sigma._auxLemma.14`, states that for any type `α`, given it has an addition operation, a less or equal to relation, is covariant in its operation, and is contravariant in its operation, for any elements `a`, `b`, and `c` of type `α`, the statement `(a + b ≤ a + c)` is equivalent to `(b ≤ c)`. In simpler words, if you have two quantities `b` and `c`, and you add the same value `a` to both of them, the inequality relationship between `b` and `c` remains the same.

For any type `α` with covariant and contravariant addition and a reflexive, transitive less-than or equal relation, `(a + b ≤ a + c)` if and only if `(b ≤ c)`.


HasDerivAt.sub

theorem HasDerivAt.sub :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {f' g' : F} {x : 𝕜},
      HasDerivAt f f' x → HasDerivAt g g' x → HasDerivAt (fun x => f x - g x) (f' - g') x :=
  by sorry

The theorem `HasDerivAt.sub` states that for any type `𝕜` which forms a nontrivial normed field and any type `F` which forms a normed additively commutative group and a normed space over `𝕜`, if the function `f` has a derivative `f'` at a point `x` and the function `g` has a derivative `g'` at the same point `x`, then the function that sends `x` to `f x - g x` has a derivative `f' - g'` at the point `x`. In other words, the derivative of the difference of two functions at a point is equal to the difference of their derivatives at that point.

If `f` and `g` are differentiable functions at point `x` in a normed additively commutative group and normed space over a nontrivial normed field, then `(f - g)'(x) = f'(x) - g'(x)`.


theorem Finset.disjoint_iff_inter_eq_empty :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, Disjoint s t ↔ s ∩ t = ∅ := by sorry

This theorem is about finite sets (or "finsets") in a type `α` that has a decidable equality relation. It states that for any two finsets `s` and `t` in `α`, `s` and `t` are disjoint if and only if the intersection of `s` and `t` is the empty set. Here, two finsets are defined to be disjoint if their infimum (greatest lower bound) is the smallest possible element, which in this case is represented by the empty set. This theorem essentially provides a characterization of disjointness in terms of the intersection operation.

Two finsets in a type with decidable equality are disjoint if and only if their intersection is the empty set.


theorem HasSum.hasSum_compl_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] {f : β → α} {a₁ a₂ : α} {s : Set β},
      HasSum (f ∘ Subtype.val) a₁ → (HasSum (f ∘ Subtype.val) a₂ ↔ HasSum f (a₁ + a₂)) :=
  by sorry

The theorem `HasSum.hasSum_compl_iff` states that for any types `α` and `β`, where `α` is an additive commutative group and also a topological additive group, and for any function `f` from `β` to `α`, and any `α` values `a₁` and `a₂`, and any set `s` of type `β`, if the composition of `f` and the subtype value function has a sum `a₁`, then the composition of `f` and the subtype value function has a sum `a₂` if and only if the function `f` itself has a sum equal to `a₁ + a₂`. This theorem is about the relationship between the sum of function values over a set and the sum of function values over the complement of the set.

For an additive commutative and topological group α, function f from β to α, and any sets s and its complement in β, if the sum of f over s equals a1 and the sum of f over the complement equals a2, then f has a sum equal to a1 + a2.


theorem CategoryTheory.Subobject.isIso_arrow_iff_eq_top :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y : C} (P : CategoryTheory.Subobject Y),
      CategoryTheory.IsIso (CategoryTheory.Subobject.arrow P) ↔ P = ⊤ :=
  by sorry

This theorem states that for any category `C` and object `Y` in `C`, a subobject `P` of `Y` in the category theory context has an isomorphism from the underlying object to the ambient object (the `arrow` of the subobject `P`), if and only if the subobject `P` is the top element (i.e., the largest subobject). In other words, the `arrow` morphism of a subobject is an isomorphism if and only if that subobject is the greatest possible subobject of the given object.

For any object Y and subobject P in a category C, the subobject P has an isomorphism to Y if and only if P is the top element in the subobject lattice of Y.


theorem edist_le_zero : ∀ {γ : Type w} [inst : EMetricSpace γ] {x y : γ}, edist x y ≤ 0 ↔ x = y := by sorry

This theorem states that for any given type `γ` that is an instance of an extended metric space, the extended distance (`edist`) between any two points `x` and `y` of type `γ` is less than or equal to zero if and only if `x` and `y` are the same point. This is a characterization of the non-negativity property of distances in metric spaces.

For any extended metric space `γ`, the extended distance `edist` between points `x` and `y` of type `γ` is non-negative and equals zero if and only if `x` and `y` are equal.


theorem Set.projIic_coe : ∀ {α : Type u_1} [inst : LinearOrder α] {b : α} (x : ↑(Set.Iic b)), Set.projIic b ↑x = x := by
  sorry

This theorem states that for any type `α` equipped with a linear order, and for any element `b` from `α`, the projection of any element `x` from the left-infinite right-closed interval `(-∞, b]` (denoted as `Set.Iic b`), back onto itself via the `Set.projIic` function, yields the original element `x` itself. In other words, the `Set.projIic` function acts as an identity on the elements of the interval `(-∞, b]`.

For any type `α` with a linear order and any `b` in `α`, the `Set.projIic` function maps elements in the left-infinite right-closed interval `(-∞, b]` to themselves.


theorem Multiset.subset_zero : ∀ {α : Type u_1} {s : Multiset α}, s ⊆ 0 ↔ s = 0 := by sorry

The theorem `Multiset.subset_zero` states that for any type `α` and any multiset `s` of type `α`, `s` is a subset of the empty multiset if and only if `s` is the empty multiset itself. Here, the empty multiset is represented by `0`. This theorem essentially says that the only subset of the empty multiset is the empty multiset itself.

A multiset `s` of type `α` is equal to the empty multiset (represented by `0`) if and only if `s` is a subset of the empty multiset.


theorem Mathlib.Data.Nat.ChineseRemainder._auxLemma.1 : ∀ {a b : ℕ}, (a ≡ b [MOD 1]) = True := by sorry

This theorem states that for any two natural numbers 'a' and 'b', the equivalence of 'a' and 'b' modulo 1 is always true. In mathematical terms, it means that 'a' and 'b' leave the same remainder when divided by 1, which is always true because any number divided by 1 leaves no remainder.

For all natural numbers a and b, a = b mod 1.


/-- A `k`-algebra homomorphism from `MonoidAlgebra k G` is uniquely defined by its
values on the functions `single a 1`.  -/
theorem MonoidAlgebra.algHom_ext :
    ∀ {k : Type u₁} {G : Type u₂} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u₃} [inst_2 : Semiring A]
      [inst_3 : Algebra k A] ⦃φ₁ φ₂ : MonoidAlgebra k G →ₐ[k] A⦄,
      (∀ (x : G), φ₁ (MonoidAlgebra.single x 1) = φ₂ (MonoidAlgebra.single x 1)) → φ₁ = φ₂ :=
  by sorry

This theorem states that for any given commutative semiring `k`, monoid `G`, semiring `A`, and `k`-algebra `A`, an algebra homomorphism from the monoid algebra `MonoidAlgebra k G` to `A` is uniquely determined by its values on the functions `MonoidAlgebra.single a 1` for all `a` in `G`. In other words, if two such homomorphisms `φ₁` and `φ₂` agree on the values of `MonoidAlgebra.single a 1` for every `a` in `G`, then they must be the same homomorphism.

Given a commutative semiring `k`, a monoid `G`, a semiring `A`, and a `k`-algebra `A`, any two algebra homomorphisms from `MonoidAlgebra k G` to `A` that agree on the values of `MonoidAlgebra.single a 1` for all `a` in `G` are equal.


theorem Polynomial.smeval_def :
    ∀ {R : Type u_3} [inst : Semiring R] (p : Polynomial R) {S : Type u_4} [inst_1 : AddCommMonoid S] [inst_2 : Pow S ℕ]
      [inst_3 : MulActionWithZero R S] (x : S), Polynomial.smeval p x = Polynomial.sum p (Polynomial.smul_pow x) :=
  by sorry

The theorem `Polynomial.smeval_def` states that for any semiring `R`, polynomial `p` over `R`, and for any type `S` forming an additive commutative monoid with a power operation and a scalar multiplication with zero, the evaluation of the polynomial `p` at an element `x` of `S` (`Polynomial.smeval p x`) is equal to the sum of the function applied to the coefficients of the polynomial `p` where the function is the scalar multiplication of the coefficient to the power of its corresponding term index (`Polynomial.sum p (Polynomial.smul_pow x)`). In essence, this theorem links polynomial evaluation with summing over scalar multiplication and powers, given specific algebraic structures.

For any semiring `R`, polynomial `p` over `R`, and type `S` with additive commutative monoid, power operation, and scalar multiplication with zero, the evaluation of polynomial `p` at an element `x` of `S` equals the sum of the scalar multiplication of the coefficient by the power of its term index. (i.e., `Polynomial.smeval p x = Polynomial.sum p (Polynomial.smul_pow x)`)


theorem WeierstrassCurve.Affine.map_addX :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R) {A : Type v} [inst_1 : CommRing A] (φ : R →+* A)
      (x₁ x₂ L : R), (W.map φ).toAffine.addX (φ x₁) (φ x₂) (φ L) = φ (W.addX x₁ x₂ L) :=
  by sorry

The theorem `WeierstrassCurve.Affine.map_addX` states that for any commutative ring `R`, a Weierstrass curve `W` over `R`, a commutative ring `A`, a ring homomorphism `φ` from `R` to `A`, and any three elements `x₁`, `x₂`, `L` of `R`, the result of adding `x₁` and `x₂` under the `addX` operation on the curve `W`, and then mapping the result via `φ` to the ring `A`, is the same as first mapping `x₁`, `x₂` and `L` to `A` via `φ` and then performing the `addX` operation in the affine Weierstrass curve over `A` obtained by mapping `W` via `φ`. This theorem essentially asserts that the `addX` operation on Weierstrass curves is compatible with ring homomorphisms.

Given a Weierstrass curve `W` over a commutative ring `R`, a ring homomorphism `φ` from `R` to a commutative ring `A`, and elements `x₁`, `x₂`, `L` in `R`, the affine `addX` operation on `W` commutes with the application of `φ`, i.e., `φ(x₁ +ₗ[R] x₂) = φ(x₁) +ₗ[A] φ(x₂)` in the affine Weierstrass curve over `A`.


theorem Mathlib.Data.Fintype.Pi._auxLemma.1 :
    ∀ {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (x : α) → β x}, (f₁ = f₂) = ∀ (a : α), f₁ a = f₂ a := by sorry

This theorem from the Mathlib Data.Fintype.Pi module states that for any types `α` and `β` (where `β` is a function from `α`), and for any two functions `f₁` and `f₂` from `α` to `β`, the equality of `f₁` and `f₂` is equivalent to the equality of `f₁ a` and `f₂ a` for all `a` in `α`. In other words, two functions are considered equal if they produce the same output for every input from the domain.

For functions `f₁` and `f₂` from type `α` to type `β`, `f₁ = f₂` if and only if `∀ a ∈ α, f₁ a = f₂ a`.


theorem AddSubmonoid.coe_iSup_of_directed :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {ι : Sort u_4} [inst_1 : Nonempty ι] {S : ι → AddSubmonoid M},
      Directed (fun x x_1 => x ≤ x_1) S → ↑(⨆ i, S i) = ⋃ i, ↑(S i) :=
  by sorry

The theorem `AddSubmonoid.coe_iSup_of_directed` states that for any type `M` equipped with an `AddZeroClass` structure, any sort `ι` which is nonempty, and any index mapping `S` from `ι` to additive submonoids of `M`, if the given family of submonoids `S` is directed with respect to the `≤` relation, then the union of the carrier sets of all submonoids in the family is equal to the carrier of the supremum of these submonoids. Here, "supremum" (denoted `⨆ i, S i`) is in the sense of complete lattices and the carrier of a submonoid is the set of elements in that submonoid.

For any type `M` with an `AddZeroClass` structure, if `ι` is a nonempty sort and `S : ι → additive submonoids of M` is a directed family, then the carrier of the supremum of `S` equals the union of the carriers of all submonoids in `S`.


theorem TrivSqZeroExt.continuous_fst :
    ∀ {R : Type u_3} {M : Type u_4} [inst : TopologicalSpace R] [inst_1 : TopologicalSpace M],
      Continuous TrivSqZeroExt.fst :=
  by sorry

This theorem states that for any types `R` and `M`, if `R` and `M` are both topological spaces, then the canonical projection `TrivSqZeroExt.fst`, which maps from `TrivSqZeroExt R M` to `R`, is a continuous function. This means that the preimage of any open set in `R` under the function `TrivSqZeroExt.fst` is also an open set in `TrivSqZeroExt R M`.

The canonical projection of the trivial square zero extension of topological spaces `R` and `M`, `TrivSqZeroExt.fst : TrivSqZeroExt R M → R`, is a continuous function.


theorem LieAlgebra.derivedSeriesOfIdeal_le_self :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
      (k : ℕ), LieAlgebra.derivedSeriesOfIdeal R L k I ≤ I :=
  by sorry

The theorem `LieAlgebra.derivedSeriesOfIdeal_le_self` states that for any commutative ring `R` and a Lie ring `L` that has a structure of a Lie algebra over `R`, for any Lie ideal `I` of `L` and any natural number `k`, the `k`-th derived series of the Lie ideal `I` is a subset of `I` itself. In other words, applying the derived series operation `k` times to the Lie ideal `I` will not produce any elements outside `I`.

For any commutative ring R, Lie algebra L over R, Lie ideal I of L, and natural number k, the k-th derived series of I is contained in I.


theorem MulChar.ofUnitHom_coe :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ) (a : Rˣ),
      (MulChar.ofUnitHom f) ↑a = ↑(f a) :=
  by sorry

The theorem `MulChar.ofUnitHom_coe` states that for any two types `R` and `R'` where `R` is a commutative monoid and `R'` is a commutative monoid with zero, a homomorphism `f` from the group of units of `R` to the group of units of `R'`, and a unit `a` of `R`, applying the function `MulChar.ofUnitHom` to the homomorphism `f` and then applying the resulting function to the canonical embedding of `a` in `R` is equal to the canonical embedding of `f a` in `R'`. In other words, the function `MulChar.ofUnitHom` preserves the action of the homomorphism `f` on the units of `R`.

Given commutative monoids R and R' with zero, a homomorphism f from the group of units of R to the group of units of R', and a unit a in R, the application of MulChar.ofUnitHom to f and then to the canonical embedding of a in R equals the canonical embedding of f(a) in R'.


theorem Primrec.dom_denumerable :
    ∀ {α : Type u_4} {β : Type u_5} [inst : Denumerable α] [inst_1 : Primcodable β] {f : α → β},
      Primrec f ↔ Nat.Primrec fun n => Encodable.encode (f (Denumerable.ofNat α n)) :=
  by sorry

The theorem `Primrec.dom_denumerable` states that for any types `α` and `β`, where `α` is denumerable (i.e., there exists a one-to-one correspondence between the elements of `α` and the natural numbers) and `β` is primcodable (i.e., it can be encoded as a natural number), a function `f` from `α` to `β` is primitive recursive (after encoding its input and output as natural numbers) if and only if the function that takes a natural number `n`, decodes it into an element of `α`, applies `f` and then encodes the result is primitive recursive in the natural numbers.

For any denumerable type `α` and primcodable type `β`, a function `f` from `α` to `β` is primitive recursive if and only if the function that decodes a natural number into an element of `α`, applies `f` to it, and encodes the result as a natural number is primitive recursive.


theorem Ordering.Compares.eq_eq :
    ∀ {α : Type u_1} [inst : Preorder α] {o : Ordering} {a b : α},
      Ordering.Compares o a b → (o = Ordering.eq ↔ a = b) :=
  by sorry

The theorem `Ordering.Compares.eq_eq` states that for all types `α` that have an associated preorder relation, and for any instance of ordering `o` and two elements `a` and `b` of type `α`, if `a` and `b` have the ordering relation `o` between them, then `o` is equal to "equal" if and only if `a` is equal to `b`. In other words, this theorem establishes a correspondence between the equality of the ordering `o` to "equal" and the equality of the two elements `a` and `b` in the context of a preorder.

For any preorder relation `o` on type `α`, if `a` and `b` have the ordering relation `o` and are equal, then `o` is the reflexive and symmetric relation equal to equality on `α`.


ProbabilityTheory.kernel.IndepSets.symm

theorem ProbabilityTheory.kernel.IndepSets.symm :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set (Set Ω)},
      ProbabilityTheory.kernel.IndepSets s₁ s₂ κ μ → ProbabilityTheory.kernel.IndepSets s₂ s₁ κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.IndepSets.symm` states that for any types `α` and `Ω`, measurable spaces `_mα` and `_mΩ`, an instance `κ` of a probability kernel from `α` to `Ω`, a measure `μ` on `α`, and two sets of sets `s₁` and `s₂` in `Ω`, if the sets `s₁` and `s₂` are independent with respect to kernel `κ` and measure `μ`, then the sets `s₂` and `s₁` are also independent with respect to the same kernel and measure. This is a symmetry property of independent sets in the context of probability theory and measure spaces.

If sets $S\_1$ and $S\_2$ are independent in the probability measure $\mu$ with respect to the kernel $\kappa$ from $\alpha$ to $\Omega$, then $S\_2$ and $S\_1$ are also independent in the same measure $\mu$ and kernel $\kappa$.


theorem Finset.card_image₂_singleton_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α) {b : β},
      (Function.Injective fun a => f a b) → (Finset.image₂ f s {b}).card = s.card :=
  by sorry

The theorem `Finset.card_image₂_singleton_right` states that for any types `α`, `β`, and `γ`, given a binary function `f : α → β → γ` and a finite set `s : Finset α`, if `f` is injective when its second argument is a particular element `b : β`, then the cardinality of the image of `f` applied to `s` and the singleton set `{b}` is equal to the cardinality of `s`. In simpler terms, if applying `f` to each element in `s` and a fixed `b` produces unique results, then the number of such unique results is the same as the number of elements in `s`.

If `f : α -> β -> γ` is a function, `s : Finset α`, and `b : β` are such that `f` is injective on `{a : α | exists b', f a b = b}`, then `#(map (lambda x, f x b) s) = #s`.


/-- See also `Nat.cast_pos`, specialised for an `OrderedSemiring`.  -/
theorem Nat.cast_pos' :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : NeZero 1] {n : ℕ}, 0 < ↑n ↔ 0 < n :=
  by sorry

This theorem states that for any natural number `n`, `n` is greater than 0 if and only if the casted `n` in some type `α` is greater than 0. Here, `α` is a type that is an additive monoid with a unit element, has a partial order, satisfies the covariant law for addition and order, includes 0 and 1 with 0 less than or equal to 1, and where 1 is not equal to 0. The casting operation is from natural numbers to `α`.

For any natural number `n` and type `α` that is an additive monoid with a unit, has a partial order, satisfies the covariant law for addition and order, includes 0 and 1 with 0 less than 1, and where 1 is not equal to 0, the natural number `n` is greater than 0 if and only if the casted `n` in `α` is greater than its zero element.


theorem NormedAddGroupHom.comp_assoc :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} {V₃ : Type u_4} [inst : SeminormedAddCommGroup V₁]
      [inst_1 : SeminormedAddCommGroup V₂] [inst_2 : SeminormedAddCommGroup V₃] {V₄ : Type u_5}
      [inst_3 : SeminormedAddCommGroup V₄] (h : NormedAddGroupHom V₃ V₄) (g : NormedAddGroupHom V₂ V₃)
      (f : NormedAddGroupHom V₁ V₂),
      NormedAddGroupHom.comp (NormedAddGroupHom.comp h g) f = NormedAddGroupHom.comp h (NormedAddGroupHom.comp g f) :=
  by sorry

The theorem `NormedAddGroupHom.comp_assoc` states that for all seminormed additive commutative groups `V₁`, `V₂`, `V₃`, and `V₄`, and for all normed group homomorphisms `h` from `V₃` to `V₄`, `g` from `V₂` to `V₃`, and `f` from `V₁` to `V₂`, the composition of normed group homomorphisms is associative. This means that composing `h` and `g` first, and then composing the result with `f` is equal to first composing `g` and `f`, and then composing `h` with the result.

For all seminormed additive commutative groups V₁, V₂, V₃, V₄, and normed group homomorphisms f : V₁ → V₂, g : V₂ → V₃, and h : V₃ → V₄, the associativity of composition holds: h ∘ g ∘ f = g ∘ f ∘ h.


theorem ProbabilityTheory.IdentDistrib.of_ae_eq :
    ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace γ]
      {μ : MeasureTheory.Measure α} {f g : α → γ},
      AEMeasurable f μ → f =ᶠ[MeasureTheory.Measure.ae μ] g → ProbabilityTheory.IdentDistrib f g μ μ :=
  by sorry

The theorem `ProbabilityTheory.IdentDistrib.of_ae_eq` states that for any measurable spaces `α` and `γ`, and a measure `μ` on `α`, if a function `f` from `α` to `γ` is almost everywhere measurable with respect to `μ`, and `f` is almost everywhere equal to another function `g` (also from `α` to `γ`) with respect to the same measure `μ`, then the identity distribution property holds for `f` and `g` with respect to measure `μ`. The identity distribution property in probability theory typically means that the distribution of `f` and `g` under the measure `μ` are the same.

If measurable functions `f` and `g` on measurable spaces `α` with respect to measure `μ` are almost everywhere equal, then they have the same distribution under `μ`.


theorem Mathlib.LinearAlgebra.Lagrange._auxLemma.1 :
    ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) := by sorry

This theorem, from the `Mathlib.LinearAlgebra.Lagrange` library, states that for any type `G` that forms an additive group, given any two elements `a` and `b` of that group, the condition that the difference of `a` and `b` equals zero is equivalent to the condition that `a` equals `b`. In other words, in any additive group, subtracting an element from itself always results in the zero element.

In an additive group, the difference of any two elements is the zero element if and only if the elements are equal.


theorem List.mapIdx_eq_enum_map :
    ∀ {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β),
      List.mapIdx f l = List.map (Function.uncurry f) (List.enum l) :=
  by sorry

This theorem states that for any list `l` of type `α` and a two-argument function `f` that takes a natural number and an element of type `α` and returns an element of type `β`, the function `List.mapIdx` applied to `f` and `l` is equal to the function `List.map` applied to the uncurried version of `f` and the enumerated version of `l`. In other words, mapping a function over the indices and elements of a list is the same as enumerating the list (pairing each element with its index) and then mapping the function over these pairs.

For any list `l` of type `α` and two-argument function `f` from `Nat × α` to `β`, `List.mapIdx f l` equals `List.map (λ (i, x), f i x) (Enumerable.enumType l)`.


/-- An `AddSubgroup` is closed under subtraction. -/
theorem AddSubgroup.sub_mem :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x y : G}, x ∈ H → y ∈ H → x - y ∈ H := by sorry

This theorem states that an additive subgroup (`AddSubgroup`) is closed under subtraction. Specifically, for any type `G` that forms an additive group, and any `AddSubgroup` `H` of this `G`, if `x` and `y` are elements of `H`, then the result of subtracting `y` from `x` (denoted as `x - y`) is also an element of `H`. Here, closed under subtraction means that subtraction of any two elements in the subgroup will always result in another element within the same subgroup.

For any additive subgroup `H` of an additive group `G`, if `x, y ∈ H`, then `x - y ∈ H`.


AnalyticAt.sub

theorem AnalyticAt.sub :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F} {x : E},
      AnalyticAt 𝕜 f x → AnalyticAt 𝕜 g x → AnalyticAt 𝕜 (f - g) x :=
  by sorry

The theorem `AnalyticAt.sub` states that for any types `𝕜`, `E`, `F` where `𝕜` is a nontrivially normed field, `E` and `F` are normed additive commutative groups, and `E`, `F` are normed spaces over `𝕜`, if we have two functions `f` and `g` from `E` to `F` and if both `f` and `g` are analytic at a point `x` in `E`, then the function `f - g` is also analytic at `x`. In mathematical terms, this states that the difference of two analytic functions is also analytic.

If `𝕜` is a nontrivially normed field and `f`, `g` are analytic functions from the normed additive commutative groups and normed spaces `E` and `F` over `𝕜`, then the difference `f - g` is also analytic at any point `x` in `E`.


theorem Cardinal.toENatAux_eq_top : ∀ {a : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → Cardinal.toENatAux a = ⊤ := by sorry

This theorem states that for any cardinal number `a`, if `a` is greater than or equal to `ℵ₀` (the smallest infinite cardinal, i.e., the cardinality of the set of natural numbers), then the function `toENatAux` applied to `a` gives the extended natural number `⊤` (representing infinity). This means that any cardinality that is at least as large as the cardinality of the set of natural numbers is mapped to infinity by the `toENatAux` function.

For any cardinal number `a ≥ ℵ₀`, the function `toENatAux` maps `a` to the extended natural number `⊤`.


/-- Dedekind's linear independence of characters  -/
theorem linearIndependent_monoidHom :
    ∀ (G : Type u_8) [inst : Monoid G] (L : Type u_9) [inst_1 : CommRing L] [inst_2 : NoZeroDivisors L],
      LinearIndependent L fun f => ⇑f :=
  by sorry

"Dedekind's Linear Independence of Characters" theorem states that for any monoid `G` and any commutative ring `L` that has no zero divisors, the set of all functions from `G` to `L` that are monoid homomorphisms (i.e., respect the operation of the monoid and map the identity element of the monoid to the identity element of the ring) is linearly independent over `L`. In other words, no non-trivial linear combination of these functions can result in the zero function.

The set of monoid homomorphisms from a monoid to a commutative ring without zero divisors is linearly independent.


theorem contDiffOn_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {n : ℕ∞} {s : Set E}, ContDiffOn 𝕜 n id s :=
  by sorry

This theorem, `contDiffOn_id`, states that for any non-trivially normed field `𝕜`, any normed additive commutative group `E` that is also a normed space over `𝕜`, any extended natural number `n`, and any set `s` of elements of type `E`, the identity function is continuously differentiable on `s` up to the `n`th derivative. In other words, the identity function maintains its smoothness up to the `n`th derivative for any elements in the given set in the given normed space.

For any non-trivially normed field `𝕜`, normed additive commutative group `E` over `𝕜`, extended natural number `n`, and set `s` in `E`, the identity function is `n`-times differentiable on `s`.


theorem MeasureTheory.Measure.QuasiMeasurePreserving.preimage_ae_eq :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μa : MeasureTheory.Measure α}
      {μb : MeasureTheory.Measure β} {f : α → β} {s t : Set β},
      MeasureTheory.Measure.QuasiMeasurePreserving f μa μb →
        s =ᶠ[MeasureTheory.Measure.ae μb] t → f ⁻¹' s =ᶠ[MeasureTheory.Measure.ae μa] f ⁻¹' t :=
  by sorry

This theorem states that for any two types `α` and `β`, with measurable spaces `m0` and `inst` respectively, and measures `μa` and `μb` on `α` and `β` respectively, and any function `f` from `α` to `β`, and any two sets `s` and `t` of `β`, if `f` is a quasi-measure preserving function from `μa` to `μb`, and the sets `s` and `t` are equal almost everywhere with respect to the measure `μb`, then the preimages of `s` and `t` under `f` are equal almost everywhere with respect to the measure `μa`. In other words, the preimage under a quasi-measure preserving function preserves the "almost everywhere" property from the codomain to the domain.

If `f` is a quasi-measure preserving function between measurable spaces `(α, m0, μa)` and `(β, inst, μb)`, and sets `s` and `t` in `β` are equal almost everywhere with respect to `μb`, then `f⁻¹(s)` and `f⁻¹(t)` are equal almost everywhere with respect to `μa`.


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

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the union of `s` and `t` is equal to `t` if and only if `s` is a subset of `t`. In terms of set theory, it is stating that a set `s` unioned with another set `t` results in the set `t` itself only when all elements of `s` are already in `t`, which is the definition of `s` being a subset of `t`.

For sets `s` and `t` of type `α`, `s ∪ t = t` if and only if `s ⊆ t`.


Set.Countable.isSeparable

theorem Set.Countable.isSeparable :
    ∀ {α : Type u} [t : TopologicalSpace α] {s : Set α}, Set.Countable s → TopologicalSpace.IsSeparable s := by sorry

This theorem states that for any set `s` of a certain type `α` in a topological space `α`, if `s` is countable, then `s` is separable. In mathematical terms, if there exists an injective map from `s` to the set of natural numbers (denoting that `s` is countable), then there exists a countable set `c` whose closure contains `s` (denoting that `s` is separable in the topological space).

If a countable set `s` in a topological space has an injective map to the natural numbers, then it is separable.


InfClosed.preimage

theorem InfClosed.preimage :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {s : Set α}
      [inst_2 : FunLike F β α] [inst_3 : InfHomClass F β α], InfClosed s → ∀ (f : F), InfClosed (⇑f ⁻¹' s) :=
  by sorry

The theorem `InfClosed.preimage` states that for any types `F`, `α`, and `β`, where `α` and `β` are both semilattices with an infimum operation (i.e., a binary operation that returns the greatest lower bound of two elements), if we have a function-like object `f` from `β` to `α` that respects the infimum operation (expressed by the `InfHomClass` attribute), and if a set `s` of elements of type `α` is inf-closed (meaning that the infimum of any two elements in the set is also in the set), then the preimage of `s` under `f` (i.e., the set of all elements of type `β` that `f` maps into `s`) is also inf-closed.

If `f` is a function-like object from a semilattice `β` to a semilattice `α` preserving infima, and `s` is an inf-closed set in `α`, then the preimage of `s` under `f` is also inf-closed in `β`.


Pairwise.aedisjoint

theorem Pairwise.aedisjoint :
    ∀ {ι : Type u_1} {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : ι → Set α},
      Pairwise (Disjoint on f) → Pairwise (MeasureTheory.AEDisjoint μ on f) :=
  by sorry

The theorem `Pairwise.aedisjoint` says that for any type `ι`, any measurable space `α`, any measure `μ` on `α`, and any function `f` from `ι` to the sets of `α`, if every two distinct sets in the image of `f` are disjoint (in the sense that their infimum is the bottom element), then every two distinct sets in the image of `f` are also almost everywhere disjoint with respect to measure `μ` (that is, their intersection has measure zero).

For any measurable space `(α, Σ, μ)`, measurable function `f : ι → Σ`, and pairwise disjoint image sets `{f i, i ∈ ι}`, we have `∀ i ≠ j, μ(f i ∩ f j) = 0`.


/-- A uniform space is complete provided that (a) its uniformity filter has a countable basis;
(b) any sequence satisfying a "controlled" version of the Cauchy condition converges.  -/
theorem UniformSpace.complete_of_convergent_controlled_sequences :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] [inst : Filter.IsCountablyGenerated (uniformity α)]
      (U : ℕ → Set (α × α)),
      (∀ (n : ℕ), U n ∈ uniformity α) →
        (∀ (u : ℕ → α),
            (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Filter.Tendsto u Filter.atTop (nhds a)) →
          CompleteSpace α :=
  by sorry

This theorem states that a uniform space is complete if it satisfies two conditions:

(a) its uniformity filter has a countable basis. This is represented in Lean 4 by the typeclass instance `Filter.IsCountablyGenerated (uniformity α)`.

(b) any sequence in the space that satisfies a "controlled" version of the Cauchy condition converges. Specifically, for any sequence `u : ℕ → α`, if for every natural number `N` and every pair of indices `m` and `n` greater than or equal to `N`, `(u m, u n)` falls within the `N`th set `U N` from the countable basis of the uniformity filter, then there exists an element `a` in the space such that the sequence `u` converges to `a` at infinity. This is represented by `∃ a, Filter.Tendsto u Filter.atTop (nhds a)` in Lean 4.

If these conditions are met, then the space is a complete space, as indicated by `CompleteSpace α` in Lean 4.

A uniform space is complete if and only if its uniformity filter has a countable basis and every Cauchy sequence in the space converges to a limit in the space.


theorem MeasureTheory.hasFiniteIntegral_toReal_of_lintegral_ne_top :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      ∫⁻ (x : α), f x ∂μ ≠ ⊤ → MeasureTheory.HasFiniteIntegral (fun x => (f x).toReal) μ :=
  by sorry

The theorem `MeasureTheory.hasFiniteIntegral_toReal_of_lintegral_ne_top` states that for any measurable space `α` with measure `μ`, and any function `f` mapping from `α` to the extended non-negative real numbers (`ENNReal`), if the Lebesgue integral (notated as `∫⁻ (x : α), f x ∂μ`) of `f` with respect to `μ` is not infinite (i.e., `≠ ⊤`), then the function `f` when converted to real numbers (i.e., `(fun x => (f x).toReal)`) has a finite integral. In essence, if a function's integral over a measurable space is finite when using extended nonnegative real numbers, it remains finite when we restrict our attention to real numbers.

If a measurable function from a measurable space to extended non-negative real numbers has a finite Lebesgue integral, then its integral over real numbers is also finite.


LinearIsometryEquiv.injective

theorem LinearIsometryEquiv.injective :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂), Function.Injective ⇑e :=
  by sorry

The theorem `LinearIsometryEquiv.injective` states that for any two types `R` and `R₂`, which are semirings, any two types `E` and `E₂`, which are seminormed additive commutative groups and modules over `R` and `R₂` respectively, and given two ring homomorphisms `σ₁₂` from `R` to `R₂` and `σ₂₁` from `R₂` to `R`, that form an inverse pair, then for any linear isometry equivalence `e` between `E` and `E₂`, the function represented by `e` is injective. In other words, if `e` maps two elements in `E` to the same element in `E₂`, then the two original elements in `E` were the same.

Given semirings R and R₂, seminormed additive commutative groups and modules E, E₂ over R and R₂ respectively, and ring homomorphisms σ₁₂ from R to R₂ and σ₂₁ from R₂ to R forming an inverse pair, any linear isometry e between E and E₂ implies that e is injective.


theorem ceilDiv_le_iff_le_smul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : CeilDiv α β] {a : α} {b c : β}, 0 < a → (b ⌈/⌉ a ≤ c ↔ b ≤ a • c) :=
  by sorry

This theorem states that for any types `α` and `β` that are ordered additive commutative monoids, with `α` being a scalar multiplication zero class and `β` having a ceiling division operation, and given elements `a` of `α` and `b` and `c` of `β` such that `a` is positive, then `b` ceiling divided by `a` is less than or equal to `c` if and only if `b` is less than or equal to `a` times `c`. In mathematical notation, this is saying that if $0 < a$ then $b ⌈/⌉ a ≤ c$ if and only if $b ≤ a \cdot c$.

For any ordered additive commutative monoids `α` and `β` with `α` a scalar multiplication zero class, `β` having a ceiling division operation, and `a` a positive element of `α`, the ceiling division `b ⌈/⌉ a` of `b` by `a` in `β` is less than or equal to `c` if and only if `b` is less than or equal to `a` multiplied by `c` in `β`.


theorem Int.sign_zero : Int.sign 0 = 0 := by sorry

The theorem `Int.sign_zero` asserts that the sign of the integer 0 is also 0. In other words, when the function `Int.sign` is applied to the integer 0, it returns 0, which is consistent with the definition of the sign function that assigns `0` to `0`, `1` to positive integers, and `-1` to negative integers.

The sign of integer 0 is 0. (or equivalently, Int.sign 0 = 0)


theorem Multiset.powersetAux_eq_map_coe :
    ∀ {α : Type u_1} {l : List α}, Multiset.powersetAux l = List.map Multiset.ofList (List.sublists l) := by sorry

The theorem `Multiset.powersetAux_eq_map_coe` states that for all types `α` and for all lists `l` of type `α`, the function `Multiset.powersetAux`, when applied to `l`, is equivalent to mapping the function `Multiset.ofList` over all the sublists of `l`. This means that the powerset of a multiset, generated by `Multiset.powersetAux`, can be generated by taking all the sublists of the original list and converting each sublist into a multiset.

For all types α and lists l of α, the function Multiset.powersetAux(l) is equivalent to mapping Multiset.ofList over all sublists of l, i.e., Multiset.powersetAux(l) = {Multiset.ofList(s) : s ⊆ l}.


Filter.Tendsto.Icc

theorem Filter.Tendsto.Icc :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] {l₁ l₂ : Filter α}
      [inst_1 : Filter.TendstoIxxClass Set.Icc l₁ l₂] {lb : Filter β} {u₁ u₂ : β → α},
      Filter.Tendsto u₁ lb l₁ →
        Filter.Tendsto u₂ lb l₁ → Filter.Tendsto (fun x => Set.Icc (u₁ x) (u₂ x)) lb (Filter.smallSets l₂) :=
  by sorry

The theorem `Filter.Tendsto.Icc` states that for any types `α` and `β`, with `α` having a preorder structure, any filters `l₁` and `l₂` on `α`, and any functions `u₁` and `u₂` from `β` to `α`, if we have `Filter.Tendsto u₁ lb l₁` and `Filter.Tendsto u₂ lb l₁`, i.e., the functions `u₁` and `u₂` tend to filters `l₁` as the input points tend to filter `lb`, then the function that maps `x` to the closed interval `[u₁(x), u₂(x)]` also tends to the filter of small sets of `l₂` as `x` tends to filter `lb`. Here, `Filter.TendstoIxxClass Set.Icc l₁ l₂` is an assumption that the interval function `Set.Icc` tends from `l₁` to `l₂`, and `Filter.smallSets l₂` represents the largest filter containing all powersets of members of `l₂`.

For filters `l₁` and `l₂` on a preordered type `α`, and functions `u₁` and `u₂` from a type `β` to `α`, if `u₁` and `u₂` tend to filters `l₁` and `l₁` is contained in the domain of convergence of `Set.Icc` with respect to `l₂`, then the function that maps `x` to the closed interval `[u₁(x), u₂(x)]` tends to the filter of small sets of `l₂`.