/-- Note that `StarModule` is quite a strong requirement; as such we also provide the following
variants which this lemma would not apply to:
* `Matrix.conjTranspose_smul_non_comm`
* `Matrix.conjTranspose_nsmul`
* `Matrix.conjTranspose_zsmul`
* `Matrix.conjTranspose_natCast_smul`
* `Matrix.conjTranspose_intCast_smul`
* `Matrix.conjTranspose_inv_natCast_smul`
* `Matrix.conjTranspose_inv_intCast_smul`
* `Matrix.conjTranspose_rat_smul`
* `Matrix.conjTranspose_ratCast_smul`
 -/
theorem Matrix.conjTranspose_smul :
    ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : Star R] [inst_1 : Star α] [inst_2 : SMul R α]
      [inst_3 : StarModule R α] (c : R) (M : Matrix m n α),
      Matrix.conjTranspose (c • M) = star c • Matrix.conjTranspose M :=
  by sorry

The theorem `Matrix.conjTranspose_smul` states that for any matrix whose entries are elements of a star-module, the conjugate transpose of the scalar multiplication of a scalar and this matrix is equal to the scalar multiplication of the star of the scalar and the conjugate transpose of the matrix. This is expressed in terms of scalar multiplication (`•`) and the star operation (`star`). In other words, given a scalar `c` and a matrix `M` with entries in a star-module, the conjugate transpose of `c` times `M` is the same as the star of `c` times the conjugate transpose of `M`. Note that `StarModule` is a strong assumption, and there are other versions of this theorem that apply when this condition isn't met.

For any scalar `c` and matrix `M` with entries in a star-module, the conjugate transpose of `c` times `M` equals the star of `c` times the conjugate transpose of `M`.


/-- If `v` is a valuation on a division ring then `v(x) = 0` iff `x = 0`.  -/
theorem Valuation.zero_iff :
    ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommMonoidWithZero Γ₀]
      [inst_2 : Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K}, v x = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any division ring `K` and any value `x` from this division ring, if `v` is a valuation on `K` into a type `Γ₀` (which is a linear ordered commutative monoid with zero where zero is not the only element), then the valuation `v(x)` equals zero if and only if `x` equals zero. This means that a valuation `v` maps zero to zero and only zero to zero in the context of a division ring.

For any division ring `K` and valuation `v` on `K` into a linear ordered commutative monoid `Γ₀` with zero, `v(x) = 0` if and only if `x = 0`.


Filter.EventuallyEq.tendsto

theorem Filter.EventuallyEq.tendsto :
    ∀ {X : Type u} {α : Type u_1} {x : X} [inst : TopologicalSpace X] {l : Filter α} {f : α → X},
      (f =ᶠ[l] fun x_1 => x) → Filter.Tendsto f l (nhds x) :=
  by sorry

The theorem `Filter.EventuallyEq.tendsto` states that for any types `X` and `α`, any point `x` of type `X`, any topological space over `X`, any filter `l` of type `α`, and any function `f` from `α` to `X`, if `f` is eventually equal (almost everywhere) to the constant function that always returns `x` (denoted as `(f =ᶠ[l] fun x_1 => x)`), then `f` tends to `x` with respect to the filter `l` (denoted as `Filter.Tendsto f l (nhds x)`).

In other words, if a function equals a constant almost everywhere with respect to some filter, then the function tends to that constant in the topological space's neighborhood filter. This is a specific instance of the concept of limit in topology.

If a function is almost equal to a constant function with respect to a filter in a topological space, then the function converges to the constant value in the filter's neighborhood filter.


theorem Polynomial.reverse_zero : ∀ {R : Type u_1} [inst : Semiring R], Polynomial.reverse 0 = 0 := by sorry

This theorem states that for any type `R`, under the assumption that `R` forms a semi-ring, the reverse of the zero polynomial is also the zero polynomial. In other words, "reading backwards" the zero polynomial still gives you the zero polynomial.

For any semi-ring `R`, the additive inverse of the zero polynomial is the zero polynomial.


theorem mem_closure_iff_nhds_basis' :
    ∀ {X : Type u} {ι : Sort w} {x : X} {t : Set X} [inst : TopologicalSpace X] {p : ι → Prop} {s : ι → Set X},
      Filter.HasBasis (nhds x) p s → (x ∈ closure t ↔ ∀ (i : ι), p i → Set.Nonempty (s i ∩ t)) :=
  by sorry

The theorem `mem_closure_iff_nhds_basis'` states that for any type `X`, subset `t` of `X`, element `x` of `X`, and a topology on `X`, along with a basis `s` indexed by `ι` for the neighborhood filter of `x` such that each set in the basis satisfies some property `p`, the element `x` is in the closure of the set `t` if and only if for all `i` in `ι` where `p i` holds, the intersection of `s i` and `t` is not empty. In simpler terms, a point is in the closure of a set if every neighborhood of the point intersects the set, considering neighborhoods from a specific basis that satisfy a certain property.

For any topological space $(X, \tau)$, subset $t \subseteq X$, point $x \in X$, and basis $s: \ι \to \mathcal{P}(X)$ for the neighborhood filter of $x$ such that each $s(i) \in \tau$ satisfies property $p$, $x \in \overline{t}$ if and only if for all $i \in \ι$ with $p(i)$, $s(i) \cap t \neq \emptyset$.


theorem nsmul_pos :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : M},
      0 < a → ∀ {k : ℕ}, k ≠ 0 → 0 < k • a :=
  by sorry

The theorem `nsmul_pos` states that for all instances of an additive monoid `M` that also have a pre-order relation and a covariant class, if a non-zero element `a` of `M` is greater than zero, then for any non-zero natural number `k`, the n-times sum (or n-smultiplication) of `a` (denoted as `k • a`) is also greater than zero. This means that repeated addition of a positive value in this structure will always yield a result that's still positive, as long as the number of repetitions is non-zero.

For any additive monoid with a pre-order relation and a covariant class, if 0 < a in M and n is a non-zero natural number, then n • a > 0.


theorem Odd.add_odd : ∀ {α : Type u_2} [inst : Semiring α] {m n : α}, Odd m → Odd n → Even (m + n) := by sorry

The theorem `Odd.add_odd` states that for any type `α` that is a semiring, given two elements `m` and `n` of that semiring, if `m` and `n` are both odd, then their sum `m + n` is even. In other words, the sum of two odd numbers is always even in any semiring.

If `m` and `n` are odd elements of a semiring, then their sum `m + n` is even.


/-- See also `nonempty_encodable`, `nonempty_fintype`.  -/
theorem nonempty_denumerable : ∀ (α : Type u_3) [inst : Countable α] [inst : Infinite α], Nonempty (Denumerable α) := by
  sorry

This theorem, `nonempty_denumerable`, states that for any type `α`, if `α` is countable and infinite, then there exists a denumerable encoding for `α`. In other words, we can list all elements of `α` in a sequence, such that any element in `α` is associated with a unique natural number. This is often used in set theory and number theory to discuss concepts such as countable infinity.

If a countable and infinite type `α` exists, then it has a denumerable encoding.


theorem MeasureTheory.measurePreserving_piUnique :
    ∀ {ι : Type u_1} [inst : Fintype ι] {π : ι → Type u_4} [inst_1 : Unique ι] {m : (i : ι) → MeasurableSpace (π i)}
      (μ : (i : ι) → MeasureTheory.Measure (π i)),
      MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piUnique π)) (MeasureTheory.Measure.pi μ) (μ default) :=
  by sorry

The theorem `MeasureTheory.measurePreserving_piUnique` states that for any finite type `ι` with a unique element, and for any measurable spaces `π i` indexed by `ι`, the function `MeasurableEquiv.piUnique π` is measure preserving. Specifically, if `μ` is a family of measures indexed by `ι`, then applying the `MeasurableEquiv.piUnique π` mapping to the product measure `MeasureTheory.Measure.pi μ` gives the same measure as `μ default`, where `default` is the unique element of `ι`. In other words, this theorem asserts that the product measure of a one-element index set behaves as expected: it is equivalent to the measure of the single indexed element.

The theorem asserts that for any finite type with a unique element and corresponding measurable spaces indexed by it, the measure preserving function `MeasurableEquiv.piUnique` maps the product measure to the measure of the unique indexed element.


theorem NNReal.nnnorm_eq : ∀ (x : NNReal), ‖↑x‖₊ = x := by sorry

This theorem establishes that for any nonnegative real number `x`, the nonnegative norm of `x` (denoted as `‖↑x‖₊`) is equal to `x` itself. In other words, when a nonnegative real number is lifted to a higher type (indicated by `↑x`), the nonnegative norm of the result remains unchanged and is the same as the original nonnegative real number. This property holds for all nonnegative real numbers.

For all non-negative real numbers x, ‖↑x‖₊ = x holds. (The non-negative norm of a lifted non-negative real number is equal to the original number.)


theorem LE.le.exists_succ_iterate :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [inst_2 : IsSuccArchimedean α] {a b : α},
      a ≤ b → ∃ n, Order.succ^[n] a = b :=
  by sorry

This theorem states that for any type `α` equipped with a pre-order structure and a successor function, and assuming that the successor function satisfies the Archimedean property, given any two elements `a` and `b` of type `α` such that `a` is less than or equal to `b`, there exists a natural number `n` such that iteratively applying the successor function to `a` `n` times yields `b`. In other words, you can reach `b` from `a` by repeatedly applying the successor function a certain number of times.

Given a pre-order type `α` with a successor function satisfying the Archimedean property, for all `a` and `b` in `α` with `a ≤ b`, there exists a natural number `n` such that `a successor^n = b`.


theorem CategoryTheory.Functor.map_surjective :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {X Y : C} (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Full F], Function.Surjective F.map :=
  by sorry

The theorem `CategoryTheory.Functor.map_surjective` states that for any two objects `X` and `Y` of category `C`, and for any functor `F` from `C` to another category `D`, if the functor `F` is full (i.e., for any morphism in `D` between the images of `X` and `Y`, there exists a morphism in `C` between `X` and `Y` that maps to it), then the `map` function of the functor `F` is surjective. In other words, for every morphism in `D` between images of objects in `C`, there exists a morphism in `C` that maps to it under the functor `F`.

If a functor between categories is full, then its map function is surjective on morphisms.


theorem IsLocalization.mk'_spec' :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
      (algebraMap R S) ↑y * IsLocalization.mk' S x y = (algebraMap R S) x :=
  by sorry

The theorem `IsLocalization.mk'_spec'` states that for any commutative semiring `R`, a submonoid `M` of `R`, a type `S` which is also a commutative semiring, an algebra structure on `R` and `S`, and an instance proving that `S` is a localization of `R` at `M`, for any elements `x` of `R` and `y` of `M`, the result of mapping `y` into `S` using the algebra structure and then multiplying by the result of localizing `x` at `y` is equal to the result of mapping `x` into `S` using the algebra structure. In mathematical terms, it says that if S is a localization of R at M, then for all x in R and y in M, we have that $ϕ(y) * (ϕ(x) / ϕ(y)) = ϕ(x)$, where $ϕ$ is the algebra map from R to S.

For any commutative semirings R and S, submonoid M of R, algebra structures on R and S, and instance of S being a localization of R at M, for all x in R and y in M, we have $ϕ(y) * (ϕ(x) / ϕ(y)) = ϕ(x)$ where $ϕ$ is the algebra map from R to S.


Subtype.preconnectedSpace

theorem Subtype.preconnectedSpace :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsPreconnected s → PreconnectedSpace ↑s := by sorry

The `Subtype.preconnectedSpace` theorem states that for any type `α` equipped with a topology (i.e., a `TopologicalSpace α`), and any set `s` of this type, if the set `s` is preconnected (as per the definition of `IsPreconnected`), then the corresponding subtype `↑s` is a preconnected space in the sense of the mathematical definition of preconnected spaces. Here, `↑s` refers to the subset of the topological space `α` that corresponds to the set `s`. In other words, this theorem links the property of being preconnected for a set in a given topological space to the property of being a preconnected space when we consider that set as a subspace of the original topological space.

If `α` is a topological space and `s ⊆ α` is preconnected, then the subspace `↑s` is a preconnected space.


theorem Fintype.subtype_card :
    ∀ {α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x), Fintype.card { x // p x } = s.card :=
  by sorry

The theorem `Fintype.subtype_card` states that for any type `α` and any property `p` of elements of that type, if there is a `Finset` `s` of elements of `α` such that an element `x` of `α` is in `s` if and only if `x` satisfies `p`, then the cardinality of the subtype of `α` consisting of elements that satisfy `p` is equal to the cardinality of `s`. In other words, the number of elements in the subtype is the same as the number of elements in the finset.

If `α` is a type and `s : Finset α` is such that the subtype of `α` consisting of elements satisfying a property `p` is equal to the elements of `s`, then the cardinality of this subtype is equal to the cardinality of `s`.


theorem IntermediateField.mem_bot :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {x : E},
      x ∈ ⊥ ↔ x ∈ Set.range ⇑(algebraMap F E) :=
  by sorry

The theorem `IntermediateField.mem_bot` states that for all fields `F` and `E`, where `E` has an algebra structure over `F`, and for any element `x` of `E`, `x` is in the smallest subfield if and only if `x` is in the range of the algebra map from `F` to `E`. In other words, the smallest subfield of `E` over `F` consists exactly of those elements of `E` that can be obtained by applying the algebra map to some element of `F`.

The smallest subfield of a field `E` algebraically extended by a field `F` equals the image of `F` under the algebra map.


theorem MeasureTheory.integral_pos_iff_support_of_nonneg :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      0 ≤ f → MeasureTheory.Integrable f μ → (0 < ∫ (x : α), f x ∂μ ↔ 0 < ↑↑μ (Function.support f)) :=
  by sorry

The theorem `MeasureTheory.integral_pos_iff_support_of_nonneg` states that for any measurable space `α`, measure `μ` on `α`, and a real-valued function `f` on `α` that is nonnegative (i.e., `f`'s value is greater than or equal to zero for all `x` in `α`), if `f` is integrable with respect to `μ`, then the integral of `f` with respect to `μ` is positive if and only if the measure of the support of `f` is positive. The "support" of a function is defined as the set of points where the function does not equal zero.

For a measurable space `(α, Σ, μ)`, a nonnegative measurable function `f` on `α`, and if the integral of `f` with respect to `μ` is finite, then the integral is positive if and only if the measure of the support of `f` is positive.


theorem OrderIso.preimage_Ici :
    ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (b : β),
      ⇑e ⁻¹' Set.Ici b = Set.Ici ((OrderIso.symm e) b) :=
  by sorry

This theorem, `OrderIso.preimage_Ici`, states that for any two types `α` and `β` that are both preordered, and for any order isomorphism `e` from `α` to `β` and any element `b` of type `β`, the preimage of the set of elements in `β` that are greater than or equal to `b` under the isomorphism `e` is equal to the set of elements in `α` that are greater than or equal to the element in `α` that `b` maps to under the inverse of the isomorphism `e`. In other words, the order isomorphism preserves the property of being greater than or equal to a certain value.

For any preordered types `α` and `β` and order isomorphism `e` from `α` to `β`, the preimage under `e` of the set `{x : β | x ≥ b}` is equal to `{x : α | e x ≥ b}`.


theorem IsPrimitiveRoot.nthRoots_eq :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {n : ℕ} {ζ : R},
      IsPrimitiveRoot ζ n →
        ∀ {α a : R}, α ^ n = a → Polynomial.nthRoots n a = Multiset.map (fun x => ζ ^ x * α) (Multiset.range n) :=
  by sorry

This theorem states that for any commutative ring `R` that is also a domain, given any natural number `n` and any element `ζ` of `R` that is a primitive `n`th root, and for any elements `α` and `a` of `R` such that `α` to the power of `n` equals `a`, the `n`th roots of `a` (solutions to `x^n = a`) are exactly the elements of the form `ζ^x * α` for `x` in the range from `0` to `n-1`. This essentially ties together the concepts of primitive roots, polynomial roots, and ranges in the context of commutative rings.

For any commutative domain `R`, any primitive `n`th root `ζ` in `R`, and any `a` in `R` with `α^n = a`, the `n` roots of `a` are `{ζ^x * α | x <- [0, n-1]}`.


Associated.separable

theorem Associated.separable :
    ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R},
      Associated f g → Polynomial.Separable f → Polynomial.Separable g :=
  by sorry

The theorem `Associated.separable` states that for any commutative semiring `R` and any two polynomials `f` and `g` over `R`, if `f` and `g` are associated (i.e., one can be obtained from the other by multiplying by a unit on the right), and if `f` is a separable polynomial (which means it is coprime with its derivative), then `g` is also a separable polynomial.

If `f` and `g` are associated polynomials over a commutative semiring, and `f` is separable, then `g` is also separable.


theorem normUnit_one :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α], normUnit 1 = 1 := by sorry

This theorem states that for any type `α` that is a `CancelCommMonoidWithZero` and a `NormalizationMonoid`, the normalization of the unit `1` is `1`. In mathematical terms, if we have a cancellative commutative monoid with zero and a normalization monoid, the norm of the multiplicative identity (which is `1`) always equals `1`.

For any cancellative commutative monoid with zero and normalization monoid, the normalization of the multiplicative identity equals 1.


theorem CategoryTheory.ShortComplex.LeftHomologyData.leftHomologyπ_comp_leftHomologyIso_hom :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S)
      [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyπ S)
          (CategoryTheory.ShortComplex.LeftHomologyData.leftHomologyIso h).hom =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso h).hom h.π :=
  by sorry

This theorem states that for any category `C` with zero morphisms, given a short complex `S` of this category with left homology, and any left homology data `h` of `S`, the composition of the morphism `leftHomologyπ` of `S` and the homomorphism of the left homology isomorphism of `h` is equal to the composition of the homomorphism of the cycles isomorphism of `h` and the morphism `π` of `h`. This essentially provides a specific equality relation for the compositions of certain morphisms and homomorphisms in the context of category theory.

For any short complex `S` in a category with zero morphisms, the composition of `leftHomologyπ` of `S` and the homomorphism of the left homology isomorphism of `h` equals the composition of the homomorphism of the cycles isomorphism of `h` and `π` of `h`.


theorem Set.InjOn.image_iInter_eq :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : Nonempty ι] {s : ι → Set α} {f : α → β},
      Set.InjOn f (⋃ i, s i) → f '' ⋂ i, s i = ⋂ i, f '' s i :=
  by sorry

The theorem `Set.InjOn.image_iInter_eq` states that for any types `α`, `β`, and `ι` (where `ι` is nonempty), a function `f` from `α` to `β`, and a family of sets `s` indexed by `ι`, if the function `f` is injective on the union of all sets in the family `s`, then the image of the intersection of all sets in the family `s` under the function `f` equals to the intersection of the images of each set in the family `s` under the function `f`. This is essentially an extension of the property of injective functions that the image of the intersection of sets is the intersection of their images.

If `f: α → β` is injective on the union of a family `{s : ι | s : Set α}`, then `f` maps the intersection of all `s` to the intersection of the images of `s` under `f`.


theorem ENNReal.continuousOn_toNNReal : ContinuousOn ENNReal.toNNReal {a | a ≠ ⊤} := by sorry

The theorem `ENNReal.continuousOn_toNNReal` states that the function `toNNReal`, which maps an extended non-negative real number to a non-negative real number (returning the number itself if it is real, and 0 if it is not), is continuous on the set of all extended non-negative real numbers that are not equal to positive infinity. In other words, `toNNReal` has the property that for every point in this set, the function `toNNReal` is continuous at that point within the set. This essentially means that `toNNReal` does not exhibit any abrupt changes in value within this set.

The extended non-negative real function `toNNReal` is continuous on the set of all extended non-negative real numbers that are finite.


theorem Fin.coeSucc_eq_succ : ∀ {n : ℕ} {a : Fin n}, Fin.castSucc a + 1 = Fin.succ a := by sorry

The theorem `Fin.coeSucc_eq_succ` states that for all natural numbers `n` and for all elements `a` of the finite set `Fin n`, the sum of the element `a` embedded into the finite set `Fin (n+1)` (performed by `Fin.castSucc a`) and `1` is equal to the successor of the element `a` in the finite set `Fin (Nat.succ n)` (performed by `Fin.succ a`). In other words, embedding `a` into a larger finite set and incrementing it yields the same result as directly getting the successor of `a` in its finite set.

For all natural numbers `n` and elements `a` in `Fin n`, `Fin.castSucc a + 1 = Fin.succ a` in `Fin (Nat.succ n)`.


theorem OrderIso.preimage_Iic :
    ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (b : β),
      ⇑e ⁻¹' Set.Iic b = Set.Iic ((OrderIso.symm e) b) :=
  by sorry

The theorem `OrderIso.preimage_Iic` states that for any two types `α` and `β` with a preorder relation, and given an order isomorphism `e` between `α` and `β`, the preimage of the left-infinite right-closed interval ending at `b` under the order isomorphism `e` is equal to the left-infinite right-closed interval ending at the inverse of `e` applied to `b`. In other words, the order isomorphism correctly maps the definitions of such intervals between the two ordered sets.

Given an order isomorphism between two preordered types, the preimage of a left-infinite right-closed interval under the order isomorphism is the left-infinite right-closed interval with the same endpoint but under the order isomorphism's inverse.


theorem List.drop_one : ∀ {α : Type u_1} (l : List α), List.drop 1 l = List.tail l := by sorry

This theorem states that for all lists `l` of any type `α`, removing the first element from the list `l` using the `List.drop` function with 1 as the argument (i.e., `List.drop 1 l`) is equivalent to obtaining the tail of the list `l` using the `List.tail` function (i.e., `List.tail l`). In other words, dropping one item from the start of a list gives the same result as retrieving the tail of the list.

For all lists `l` of type `α`, `List.drop 1 l` equals `List.tail l`.


theorem Subfield.coe_sInf : ∀ {K : Type u} [inst : DivisionRing K] (S : Set (Subfield K)), ↑(sInf S) = ⋂ s ∈ S, ↑s := by
  sorry

This theorem states that for any division ring `K` and any set `S` of subfields of `K`, the set of elements of the greatest lower bound (`sInf`) of `S` is equal to the intersection of the set of elements of all subfields in `S`. In other words, each element of the greatest lower bound subfield must be an element in all subfields in `S`. This theorem provides the condition for an element to be in the greatest lower bound of a set of subfields.

The greatest lower bound of a set `S` of subfields of a division ring `K` is the intersection of all subfields in `S`.


theorem Set.Infinite.of_image :
    ∀ {α : Type u} {β : Type v} (f : α → β) {s : Set α}, Set.Infinite (f '' s) → Set.Infinite s := by sorry

The theorem `Set.Infinite.of_image` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if the image set of `s` under `f` (denoted by `f '' s`) is infinite, then the original set `s` itself must also be infinite. In other words, if you have a function that maps elements from set `s` to another set and the resulting set is infinite, then the original set `s` must have been infinite too.

If `f` is a function from an infinite set `s` to a type `β`, then `s` is infinite.


MeasureTheory.Content.mono

theorem MeasureTheory.Content.mono :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) (K₁ K₂ : TopologicalSpace.Compacts G),
      ↑K₁ ⊆ ↑K₂ → (fun s => ↑(μ.toFun s)) K₁ ≤ (fun s => ↑(μ.toFun s)) K₂ :=
  by sorry

This theorem, `MeasureTheory.Content.mono`, states that for any type `G` that is a topological space and any measure `μ` defined on `G`, if we have two compact sets `K₁` and `K₂` such that `K₁` is a subset of `K₂`, then the measure of `K₁` is less than or equal to the measure of `K₂`. In other words, it's a monotonicity property of measure: larger (or equal) sets have larger (or equal) measure.

For any topological space `G` and measure `μ` on `G`, if `K₁` is a compact subset of `K₂`, then `μ(K₁) ≤ μ(K₂)`.


theorem dimH_iUnion :
    ∀ {X : Type u_2} [inst : EMetricSpace X] {ι : Sort u_4} [inst_1 : Countable ι] (s : ι → Set X),
      dimH (⋃ i, s i) = ⨆ i, dimH (s i) :=
  by sorry

This theorem states that for any type `X` equipped with an eMetric space structure, and for any countable index set `ι`, the Hausdorff dimension of the union of sets generated by a function `s : ι → Set X` is equal to the supremum of the Hausdorff dimensions of the individual sets `s i`. In other words, the Hausdorff dimension of the union of a countable collection of sets is the largest Hausdorff dimension of any set in the collection.

For any countable index set `ι` and function `s : ι → Set X` defining a collection of subsets of a metric space `(X, d)`, the Hausdorff dimension of their union is equal to the supremum of the Hausdorff dimensions of the individual sets.


/-- See `intervalIntegrable_rpow` for a version applying to any locally finite measure, but with a
stronger hypothesis on `r`.  -/
theorem intervalIntegral.intervalIntegrable_rpow' :
    ∀ {a b r : ℝ}, -1 < r → IntervalIntegrable (fun x => x ^ r) MeasureTheory.volume a b := by sorry

This theorem states that for any real numbers `a`, `b`, and `r` such that `r` is greater than `-1`, the function `f(x) = x^r` is interval integrable with respect to Lebesgue measure on the interval `a..b`. In other words, `f(x) = x^r` is integrable on both intervals `(a, b]` and `(b, a]`. Note that the theorem applies to any unordered interval `a..b` and one of these intervals is always empty, so this property can equivalently be expressed as `f` being integrable on `(min a b, max a b]`. A related but more generalized version of this theorem, called `intervalIntegrable_rpow`, applies to any locally finite measure, but it requires a stronger condition on `r`.

For any real numbers `a`, `b`, and `r` with `r > -1`, the function `x => x^r` is Lebesgue integrable on the interval `[min a b, max a b]`.


theorem WeakDual.eval_continuous :
    ∀ {𝕜 : Type u_2} {E : Type u_5} [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
      [inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E]
      (y : E), Continuous fun x => x y :=
  by sorry

This theorem states that for any given type 𝕜 which forms a commutative semiring,𝕜 as a topological space, 𝕜 under continuous addition, 𝕜 under continuous constant scalar multiplication, E as an additive commutative monoid, E as a 𝕜-module, and E as a topological space, the evaluation function (which takes a function 'x' and applies it to an element 'y' of E) is continuous. In other words, for any fixed element 'y' in E, the operation of applying a function to 'y' is a continuous operation.

Given a commutative semiring 𝕜, for any continuous addition, continuous scalar multiplication on the 𝕜-module E over 𝕜 as a topological space, the evaluation function from functions to E applying an element is continuous.


theorem Int.negSucc_mul_negSucc : ∀ (m n : ℕ), Int.negSucc m * Int.negSucc n = ↑(Nat.succ m) * ↑(Nat.succ n) := by sorry

This theorem, `Int.negSucc_mul_negSucc`, states that for all natural numbers `m` and `n`, the product of the negated successors of `m` and `n` in the integers is equal to the product of the successors of `m` and `n` in the natural numbers. In mathematical terms, it means that if you take two natural numbers, increment them both, negate them and then multiply, you get the same result as if you had just incremented them and then multiplied.

For all natural numbers m and n, (-(m+1) * (-(n+1)) = (m+1) * (n+1)).


theorem and_not_self_iff : ∀ (a : Prop), a ∧ ¬a ↔ False := by sorry

This theorem states that for any proposition 'a', the conjunction of 'a' and the negation of 'a' is logically equivalent to 'False'. This is derived from the principle of contradiction in classical logic, which asserts that a proposition cannot be both true and not true at the same time.

For all propositions 'a' in Lean 4, 'a' and the negation of 'a' are logically equivalent to False.


theorem Int.add_le_of_le_sub_right : ∀ {a b c : ℤ}, a ≤ c - b → a + b ≤ c := by sorry

This theorem states that for all integers `a`, `b`, and `c`, if `a` is less than or equal to `c - b`, then `a + b` is less than or equal to `c`. In terms of mathematical notation, this would be expressed as ∀a, b, c ∈ ℤ, if a ≤ c - b, then a + b ≤ c. This is a property of integer arithmetic and inequality.

For all integers `a`, `b`, and `c`, if `a ≤ c - b`, then `a + b ≤ c`.


theorem OrderIso.preimage_Ioi :
    ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (b : β),
      ⇑e ⁻¹' Set.Ioi b = Set.Ioi ((OrderIso.symm e) b) :=
  by sorry

The theorem `OrderIso.preimage_Ioi` states that for any two types `α` and `β` that have a preorder structure (meaning that they have a binary relation which is reflexive and transitive), if there exists an order isomorphism `e` between them, then the preimage of the set of all elements in `β` greater than a given element `b` under `e` is the set of all elements in `α` greater than the inverse image of `b` under the inverse of `e`. In other words, applying the order isomorphism to a right-open infinite interval in `α` maps it to the corresponding right-open infinite interval in `β`.

For any preorder structures on types `α` and `β` with an order isomorphism between them, the inverse image of elements greater than `b` in `β` under the isomorphism's inverse is equal to the set of elements greater than the inverse image of `b` in `α`.


theorem IndexedPartition.index_some :
    ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) (i : ι), hs.index (hs.some i) = i := by
  sorry

The theorem `IndexedPartition.index_some` states that for any types `ι` and `α`, and for any function `s` that maps from `ι` to a set of `α` such that `s` forms an indexed partition (as represented by `hs : IndexedPartition s`), if you pick some element from the `i`-th set in the partition (as represented by `hs.some i`), the index of that element in the partition (as represented by `hs.index (hs.some i)`) is indeed `i`. In other words, for each index `i`, the index of any element taken from the `i`-th subset in the partition is exactly `i`. This theorem is a fundamental property of indexed partitions.

For any indexed partition `s` of type `ι → set α`, the element `hs.some i` in the `i`-th subset has index `i` within the partition (represented by `hs`).


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.42 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α},
      (a - b < a) = (0 < b) :=
  by sorry

The theorem, named `Mathlib.Algebra.Order.Group.Defs._auxLemma.42`, is a statement about ordered additive groups. Specifically, for any type `α` that forms an additive group and has a less-than order relation that is compatible with its addition operation, and given any elements `a` and `b` of such a type, the theorem states that `a - b` being less than `a` is equivalent to `0` being less than `b`. In other words, in this algebraic structure, subtracting a positive number from `a` results in a number that is less than `a`.

For any additive group type `α` with a compatible order relation, `a - b < a` is equivalent to `0 < b`.


theorem Multiset.lcm_add :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (s₁ s₂ : Multiset α),
      Multiset.lcm (s₁ + s₂) = lcm (Multiset.lcm s₁) (Multiset.lcm s₂) :=
  by sorry

This theorem states that for any two multisets `s₁` and `s₂` of a type `α`, where `α` is a type with a Cancel Commutative Monoid with Zero structure and a Normalized GCD Monoid structure, the least common multiple (LCM) of the multiset resulting from the addition of `s₁` and `s₂` is equal to the least common multiple (LCM) of the LCM of `s₁` and the LCM of `s₂`. In mathematical terms, this theorem asserts the property: `lcm(lcm(s₁), lcm(s₂)) = lcm(s₁ + s₂)`. This is essentially a distributive property of the least common multiple over the addition of multisets.

For any two multisets `s₁` and `s₂` of a type `α` with Cancel Commutative Monoid with Zero and Normalized GCD Monoid structures, `lcm(lcm(s₁, s₂), lcm(s₁ + s₂)) = lcm(s₁, s₂)`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.24 :
    ∀ {α : 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 b c : α},
      (c ≤ a + -b) = (c + b ≤ a) :=
  by sorry

This theorem, `Mathlib.Algebra.Order.Group.Defs._auxLemma.24`, is a statement about groups with an order relation, specifically additively written groups (`AddGroup α`) equipped with a less than or equal to relation (`LE α`). The theorem asserts that, for any three elements `a`, `b`, `c` of such a group, the inequality `c ≤ a + -b` is equivalent to `c + b ≤ a`. This essentially expresses the concept of subtracting `b` from both sides of an inequality in the context of an additively written group. The underlying group must also satisfy a certain covariance condition for the less than or equal to relation with respect to the group operation (`CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1`).

In an additively written group equipped with a covariant order relation, the inequality `c ≤ a - b` is equivalent to `c + b ≤ a`.


theorem Multiset.coe_nodup : ∀ {α : Type u_1} {l : List α}, Multiset.Nodup ↑l ↔ List.Nodup l := by sorry

The theorem `Multiset.coe_nodup` establishes an equivalence between the property of a list not having any duplicate elements and the corresponding multiset (created from the list by disregarding order of elements) not having any duplicate elements. For any given type `α` and a list `l` of type `α`, if `l` has no duplicates, i.e., every element in `l` appears at most once, then the multiset created from `l` also has no duplicates, and vice versa.

For any type `α` and list `l` of length `n` over `α`, the list `l` has no duplicate elements if and only if the multiset obtained from `l` by disregarding order has cardinality equal to `n`.


theorem WithBot.add_eq_bot : ∀ {α : Type u} [inst : Add α] {a b : WithBot α}, a + b = ⊥ ↔ a = ⊥ ∨ b = ⊥ := by sorry

The theorem `WithBot.add_eq_bot` states that, for any type `α` that has an addition operation, and any two objects `a` and `b` of the type `WithBot α` (which extends `α` by attaching the bottom element `⊥`), the sum `a + b` equals to `⊥` if and only if either `a` is `⊥` or `b` is `⊥`. This theorem captures the intuition that in any addition operation, if one of the elements is considered as the "bottom" or undefined element, the result is also the "bottom" or undefined.

For any type `α` with addition and any `WithBot α` elements `a` and `b`, `a + b = ⊥` if and only if `a = ⊥` or `b = ⊥`.


theorem edist_add_right :
    ∀ {M : Type u} [inst : Add M] [inst_1 : PseudoEMetricSpace M] [inst_2 : IsometricVAdd Mᵃᵒᵖ M] (a b c : M),
      edist (a + c) (b + c) = edist a b :=
  by sorry

This theorem, `edist_add_right`, states that for any type `M` that has an addition operation, forms a pseudo emetric space, and has an isometric action by addition, the extended distance (`edist`) between two elements `a` and `b` of `M` remains the same when a third element `c` is added to both `a` and `b`. In mathematical terms, `edist (a + c) (b + c) = edist a b`. This is equivalent to saying that the extended metric is translation invariant in this space.

The extended metric `edist` on a type `M` with an addition operation, forming a pseudo metric space and preserving isometries, is translation invariant, i.e., `edist (a + c) (b + c) = edist a b` for all `a, b, c` in `M`.


theorem YoungDiagram.mem_iff_lt_rowLen : ∀ {μ : YoungDiagram} {i j : ℕ}, (i, j) ∈ μ ↔ j < YoungDiagram.rowLen μ i := by
  sorry

This theorem states that for any Young Diagram `μ` and natural numbers `i` and `j`, the pair `(i, j)` is an element in `μ` if and only if `j` is less than the length of the `i`-th row in the Young Diagram `μ`. That is, a pair of natural numbers `(i, j)` belongs to a Young Diagram `μ` precisely when `j` is within the range of the `i`-th row's size or length in `μ`.

For any Young Diagram `μ` and natural numbers `i` and `j`, `(i, j) ∈ μ` if and only if `j <` length of the `i`-th row in `μ`.


theorem AddAction.orbit_vadd :
    ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (g : G) (a : α),
      AddAction.orbit G (g +ᵥ a) = AddAction.orbit G a :=
  by sorry

The theorem `AddAction.orbit_vadd` establishes that for any additive group `G`, any additive action of `G` on a type `α`, and any elements `g` of `G` and `a` of `α`, the orbit under the action of `G` of the translated element `g +ᵥ a` is identically equal to the orbit of the original element `a`. In other words, translating an element by additive action does not change its orbit under the same action.

For any additive group G, any additive action of G on a type α, and all g in G and a in α, the orbit of g +ᵥ a under the action of G is identical to the orbit of a.


/-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`.  -/
theorem MonoidHomClass.lipschitz_of_bound :
    ∀ {𝓕 : Type u_1} {E : Type u_6} {F : Type u_7} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F]
      [inst_2 : FunLike 𝓕 E F] [inst_3 : MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ),
      (∀ (x : E), ‖f x‖ ≤ C * ‖x‖) → LipschitzWith (Real.toNNReal C) ⇑f :=
  by sorry

The theorem `MonoidHomClass.lipschitz_of_bound` states that for a given homomorphism `f` of seminormed groups, if there exists a real constant `C` such that for every element `x` in the domain, the norm of `f(x)` is less than or equal to `C` times the norm of `x`, then `f` is Lipschitz continuous with Lipschitz constant `C` (interpreted as a non-negative real number). This theorem is analogous to a similar condition for a linear map of normed or seminormed spaces, which can be found in the Lean Mathematical Library's analysis of normed spaces.

If a homomorphism between seminormed groups satisfies the condition that the norm of the image of any element is less than or equal to a constant times the norm of the element, then the homomorphism is Lipschitz continuous with Lipschitz constant equal to that constant.


/-- [Lemma 3.8](https://ncatlab.org/nlab/show/injective+object#preservation_of_injective_objects)
 -/
theorem CategoryTheory.EnoughInjectives.of_adjunction :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C},
      (L ⊣ R) →
        ∀ [inst_2 : CategoryTheory.Functor.PreservesMonomorphisms L]
          [inst_3 : CategoryTheory.Functor.ReflectsMonomorphisms L] [inst_4 : CategoryTheory.EnoughInjectives D],
          CategoryTheory.EnoughInjectives C :=
  by sorry

This theorem is about categories in mathematics, specifically in relation to category theory. The theorem asserts that if we have an adjunction between two categories C and D, with C and D being functors, and if the functor L preserves monomorphisms and reflects monomorphisms, and D has enough injectives, then C also has enough injectives. The term "enough injectives" in a category refers to the property that every object in the category is a subobject of an injective object. This theorem is also known as Lemma 3.8 in category theory.

If functors C and D form an adjunction, with C preserving and reflecting monomorphisms, and D has enough injectives, then category C also has enough injectives.


/-- Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `f'` is negative, then
`f` is a strictly antitone function on `D`.  -/
theorem strictAntiOn_of_deriv_neg :
    ∀ {D : Set ℝ},
      Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → (∀ x ∈ interior D, deriv f x < 0) → StrictAntiOn f D :=
  by sorry

The theorem `strictAntiOn_of_deriv_neg` states that if a function `f` is continuous on a convex (or equivalently, connected) subset `D` of the real numbers, and if `f` is differentiable on the interior of `D` with a negative derivative, then `f` is a strictly decreasing function on `D`. In other words, for any given `a` and `b` in `D`, if `a` is less than `b`, then `f(b)` is less than `f(a)`.

If a real-valued function `f` is continuous on a convex set `D` and differentiable on its interior with negatively valued derivatives, then `f` is strictly decreasing on `D`.


theorem AlgebraicGeometry.quasiCompact_respectsIso :
    CategoryTheory.MorphismProperty.RespectsIso @AlgebraicGeometry.QuasiCompact := by sorry

The theorem `AlgebraicGeometry.quasiCompact_respectsIso` states that the property of being quasi-compact in algebraic geometry respects isomorphisms. More specifically, if a morphism in a category is quasi-compact, then the composition of this morphism with any isomorphism (either before or after it) is also quasi-compact. This means that the quasi-compactness property is preserved under the composition with isomorphisms.

If a morphism in algebraic geometry is quasi-compact and if isomorphism is an isomorphism, then the composition of the morphism with isomorphism is quasi-compact.


theorem Complex.log_exp : ∀ {x : ℂ}, -Real.pi < x.im → x.im ≤ Real.pi → Complex.log (Complex.exp x) = x := by sorry

The theorem `Complex.log_exp` states that for any complex number `x`, if the imaginary part of `x` is strictly greater than negative pi and less than or equal to pi, then the logarithm of the exponential of `x` is equal to `x` itself. This captures an important property of the logarithmic and exponential functions in the complex domain, namely that the logarithm and exponential functions are inverses of each other within these bounds on the imaginary part.

For complex numbers x with imag(x) ≤ pi and imag(x) > -π, log (exp x) = x.


theorem FreeAddSemigroup.hom_ext :
    ∀ {α : Type u} {β : Type v} [inst : Add β] {f g : AddHom (FreeAddSemigroup α) β},
      ⇑f ∘ FreeAddSemigroup.of = ⇑g ∘ FreeAddSemigroup.of → f = g :=
  by sorry

The theorem `FreeAddSemigroup.hom_ext` asserts that for any two types `α` and `β`, with `β` as an additive type, and any two additive homomorphisms `f` and `g` from the free additive semigroup of `α` to `β`, if these two homomorphisms agree on the embedding of `α` into the free additive semigroup of `α`, then these homomorphisms are identical. In other words, if two additive homomorphisms from the free additive semigroup of `α` to `β` coincide on the elements of `α` (viewed as elements of the free additive semigroup of `α` via the canonical embedding), then they are the same function.

If `f` and `g` are additive homomorphisms from the free additive semigroup of `α` to an additive type `β`, and `f` and `g` agree on the embedding of `α` into the free additive semigroup of `α`, then `f` is equal to `g`.


theorem Associates.dvd_eq_le : ∀ {α : Type u_1} [inst : CommMonoid α], (fun x x_1 => x ∣ x_1) = fun x x_1 => x ≤ x_1 :=
  by sorry

This theorem states that for any type `α` that is a commutative monoid, the "divides" relation (`x` divides `x_1`) is equivalent to the "less than or equal to" relation (`x` is less than or equal to `x_1`). In other words, for any two elements in a commutative monoid, saying that one element divides the other is the same as saying that the one element is less than or equal to the other.

In a commutative monoid, the relation `x` divides `x_1` is equivalent to `x` being less than or equal to `x_1`.


theorem Mathlib.ModelTheory.Algebra.Ring.Basic._auxLemma.1 :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} {P : ((i : Fin (n + 1)) → α i) → Prop},
      (∀ (x : (i : Fin (n + 1)) → α i), P x) = ∀ (a : α 0) (v : (i : Fin n) → α (Fin.succ i)), P (Fin.cons a v) :=
  by sorry

This theorem states that for any natural number `n`, any dependent type `α` indexed by `Fin (n + 1)`, and any property `P` that takes a function from `Fin (n + 1)` to `α` and returns a proposition, the property `P` holds for all such functions if and only if it holds for all functions constructed by the `Fin.cons` method given any initial element `a : α 0` and a function `v : (i : Fin n) → α (Fin.succ i)`. In other words, a property holds for all functions from `Fin (n + 1)` to `α` if it holds for all functions formed by prepending an element to a function from `Fin n` to `α`.

For any natural number $n$, property $P$ on functions from $Fin(n+1)$ to a type $\alpha$, and given any initial element $a : \alpha 0$ and function $v : Fin(n) \to \alpha$, $P$ holds for all functions if and only if it holds for functions constructed by appending $a$ to functions from $Fin(n)$ using $Fin.cons$.


theorem MeasureTheory.measure_diff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      s₂ ⊆ s₁ → MeasurableSet s₂ → ↑↑μ s₂ ≠ ⊤ → ↑↑μ (s₁ \ s₂) = ↑↑μ s₁ - ↑↑μ s₂ :=
  by sorry

The theorem `MeasureTheory.measure_diff` states that for any type `α`, given a measurable space `m` on `α`, a measure `μ` for this space, and two sets `s₁` and `s₂` of type `α`, if `s₂` is a subset of `s₁` and `s₂` is a measurable set, and the measure of `s₂` is not infinity, then the measure of the difference of the sets `s₁` and `s₂` (that is, the measure of the set of elements in `s₁` but not in `s₂`) is equal to the difference of the measures of `s₁` and `s₂`. In other words, the measure of the set elements in `s₁` excluding those in `s₂` is equal to the measure of `s₁` minus the measure of `s₂`.

If `μ` is a finite measure on the measurable space `(α, m)` and `s₁` is a set containing `s₂` with finite measure, then `μ(s₁ \ s₂) = μ(s₁) - μ(s₂)`.


theorem CategoryTheory.Subobject.mk_le_mk_of_comm :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} {f₁ : A₁ ⟶ B} {f₂ : A₂ ⟶ B}
      [inst_1 : CategoryTheory.Mono f₁] [inst_2 : CategoryTheory.Mono f₂] (g : A₁ ⟶ A₂),
      CategoryTheory.CategoryStruct.comp g f₂ = f₁ → CategoryTheory.Subobject.mk f₁ ≤ CategoryTheory.Subobject.mk f₂ :=
  by sorry

The theorem `CategoryTheory.Subobject.mk_le_mk_of_comm` in Lean 4 states that for any category `C`, and objects `A1`, `A2` and `B` in `C`, if you have morphisms `f1` from `A1` to `B`, `f2` from `A2` to `B`, and `g` from `A1` to `A2`, such that the composition `g` followed by `f2` equals `f1`, then the subobject of `B` generated by `f1` is less than or equal to the subobject of `B` generated by `f2`. Here, `f1` and `f2` are assumed to be monomorphisms (injective morphisms), and "less than or equal to" refers to the partial order on subobjects.

If in a category `C`, morphisms `f1 : A1 -> B`, `f2 : A2 -> B`, and `g : A1 -> A2` satisfy `g * f2 = f1` and `f1`, `f2` are monomorphisms, then `f1⁁≤ f2⁁`, where `f¹⁁` and `f²⁁` denote the subobjects of `B` generated by `f1` and `f2`, respectively.


HasFDerivWithinAt.restrictScalars

theorem HasFDerivWithinAt.restrictScalars :
    ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
      [inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
      [inst_8 : NormedSpace 𝕜 F] [inst_9 : NormedSpace 𝕜' F] [inst_10 : IsScalarTower 𝕜 𝕜' F] {f : E → F}
      {f' : E →L[𝕜'] F} {s : Set E} {x : E},
      HasFDerivWithinAt f f' s x → HasFDerivWithinAt f (ContinuousLinearMap.restrictScalars 𝕜 f') s x :=
  by sorry

This theorem, `HasFDerivWithinAt.restrictScalars`, states that for any non-trivially normed fields `𝕜` and `𝕜'` and any normed algebra structure between them, given a set of elements `E` with a normed add commutative group structure and a normed space over `𝕜` and `𝕜'`, and assuming that `𝕜'` is a scalar tower over `E`, if we have another set `F` with a similar structure and `𝕜'` is a scalar tower over `F`, then for any function `f` from `E` to `F` and a continuous linear map `f'` from `E` to `F` over `𝕜'`, and a set `s` of elements in `E` and an element `x` in `E`, if `f` has a derivative within the set `s` at the point `x`, then `f` also has a derivative within the set `s` at the point `x` when we restrict the scalars to `𝕜` in the continuous linear map `f'`.

If `𝕜` and `𝕜'` are non-trivially normed fields with a normed algebra structure between them, `E` and `F` are normed spaces with commutative additive groups over `𝕜` and `𝕜'`, `𝕜'` is a scalar tower over both `E` and `F`, `f` is a function from `E` to `F` with a derivative within `s` at `x` in `E`, and `f'` is a continuous linear map from `E` to `F` over `𝕜'`, then `f` has a derivative within `s` at `x` when restricting scalars to `𝕜` in `f'`.


theorem Finset.union_eq_right : ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ∪ t = t ↔ s ⊆ t := by sorry

This theorem states that for any given type `α` that has decidable equality (meaning that given any two elements of type `α`, we can decide whether they are equal or not), and for any two finite 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 other words, if every element in `s` is also in `t`, then the union of `s` and `t` will be the same as `t`.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, `s ∪ t = t` if and only if `s ⊆ t`.


theorem Polynomial.aevalTower_C :
    ∀ {R : Type u} {S : Type v} {A' : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A']
      [inst_2 : CommSemiring S] [inst_3 : Algebra S R] [inst_4 : Algebra S A'] (g : R →ₐ[S] A') (y : A') (x : R),
      (Polynomial.aevalTower g y) (Polynomial.C x) = g x :=
  by sorry

The theorem `Polynomial.aevalTower_C` asserts that for any types `R`, `S`, and `A'` with `CommSemiring` structures and `Algebra` structures on pairs `(S, R)` and `(S, A')`, and given an algebra homomorphism `g` from `R` to `A'` over base ring `S`, a value `y` in `A'` and a constant `x` in `R`, the application of the `Polynomial.aevalTower` function to the constant polynomial `Polynomial.C x` is equal to the application of `g` to `x`. In other words, when evaluating a constant polynomial under the `aevalTower` function, it's the same as using the algebra homomorphism `g` directly on the constant.

For any commutative semirings R, S, and A' with algebra structures over S, and given an algebra homomorphism g from R to A' over S, the evaluation of the constant polynomial C(x) under Polynomial.aevalTower is equal to applying g to x.


theorem SimpleGraph.Walk.dart_fst_mem_support_of_mem_darts :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v) {d : SimpleGraph.Dart G},
      d ∈ SimpleGraph.Walk.darts p → d.toProd.1 ∈ SimpleGraph.Walk.support p :=
  by sorry

The theorem `SimpleGraph.Walk.dart_fst_mem_support_of_mem_darts` states that for any type `V`, any simple graph `G` with vertices of type `V`, any vertices `u` and `v` of type `V`, any walk `p` from `u` to `v` in the graph `G`, and any dart `d` from the graph `G`, if dart `d` is in the list of darts that the walk `p` visits in order, then the first element of the pair that the dart `d` maps to (`d.toProd.1`) is in the list of vertices that the walk `p` visits in order. In other words, if a dart is used in a walk, then its originating vertex is visited in that walk.

For any simple graph `G`, vertices `u` and `v`, walk `p` from `u` to `v`, and dart `d` in `G` on edge `(u, v)` in `p`, we have `u = fst (d.toProd)`.


theorem frontier_subset_closure : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], frontier s ⊆ closure s := by
  sorry

This theorem states that for any given type `X` and a set `s` of type `X` in a topological space, the frontier of the set `s` is a subset of the closure of the set `s`. The frontier of a set is defined as the set of points lying between the closure and interior of a set, while the closure of a set is the smallest closed set that contains the set. This theorem establishes a basic property of frontiers and closures in topological spaces.

The theorem asserts that the frontier of a set is a subset of its closure in a topological space.


theorem Commute.units_inv_right : ∀ {M : Type u_1} [inst : Monoid M] {a : M} {u : Mˣ}, Commute a ↑u → Commute a ↑u⁻¹ :=
  by sorry

This theorem states that for any type `M` equipped with a monoid structure, and any elements `a` of `M` and `u` which is a unit in `M`, if `a` and `u` commute (meaning that multiplying `a` and `u` is the same as multiplying `u` and `a`), then `a` also commutes with the inverse of `u`. In other words, if `a * u = u * a`, then it's also true that `a * u^-1 = u^-1 * a`.

If `a` is an element of a monoid `M` with unit `u`, and `a` commutes with `u` (i.e., `a * u = u * a`), then `a` commutes with the inverse of `u` (i.e., `a * u^-1 = u^-1 * a`).


theorem OrderIso.map_sInf :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β) (s : Set α),
      f (sInf s) = ⨅ a ∈ s, f a :=
  by sorry

The theorem `OrderIso.map_sInf` states that for any two types `α` and `β` equipped with a complete lattice structure, and given an order isomorphism `f` from `α` to `β` and a set of elements `s` from `α`, the image under `f` of the infimum (or greatest lower bound) of `s` in `α` is equal to the infimum of the image of `s` under `f` in `β`. In other words, the order isomorphism `f` preserves the operation of taking infima.

For order isomorphisms between complete lattices, the image of the infimum of a set under the isomorphism is equal to the infimum of the image of that set.


theorem Set.image2_right_comm :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} {s : Set α} {t : Set β}
      {u : Set γ} {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε},
      (∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b) →
        Set.image2 f (Set.image2 g s t) u = Set.image2 g' (Set.image2 f' s u) t :=
  by sorry

This theorem, `Set.image2_right_comm`, states that for all sets `s` of type `α`, `t` of type `β`, and `u` of type `γ`, and for all binary functions `f : δ → γ → ε`, `g : α → β → δ`, `f' : α → γ → δ'`, and `g' : δ' → β → ε`, if for each element `a` of `α`, `b` of `β`, and `c` of `γ`, the function `f` applied to the result of function `g` applied to `a` and `b`, and `c` (i.e., `f (g a b) c`) equals the result of function `g'` applied to the result of function `f'` applied to `a` and `c`, and `b` (i.e., `g' (f' a c) b`), then the image of function `f` across the image of function `g` across sets `s` and `t`, and set `u` equals the image of function `g'` across the image of function `f'` across sets `s` and `u`, and set `t`. This theorem basically deals with the commutativity of two different composition of functions when mapped over sets.

If for all `a : α`, `b : β`, and `c : γ`, `f (g a b) c = g' (f' a c) b`, then `(Set.image2 f (Set.image g s t)) = Set.image (g' . f') (Set.image f' s u) . t`.


theorem Nat.findGreatest_mono :
    ∀ {m : ℕ} {P Q : ℕ → Prop} [inst : DecidablePred P] {n : ℕ} [inst_1 : DecidablePred Q],
      (∀ (n : ℕ), P n → Q n) → m ≤ n → Nat.findGreatest P m ≤ Nat.findGreatest Q n :=
  by sorry

The theorem `Nat.findGreatest_mono` states that, given two natural number predicates `P` and `Q` and natural numbers `m` and `n`, if every natural number `n` that satisfies `P` also satisfies `Q`, and `m` is less than or equal to `n`, then the largest `i ≤ m` for which `P i` holds is less than or equal to the largest `i ≤ n` for which `Q i` holds. This is, if we have two properties of natural numbers such that property `Q` is stronger or equivalent to property `P` (every number that has property `P` also has property `Q`) and we are comparing numbers up to `m` for `P` and `n` for `Q` where `m ≤ n`, then the largest number that has property `P` is less than or equal to the largest number that has property `Q`. This theorem requires decidability of the predicates `P` and `Q`.

If `P` is a decidable natural number predicate that is monotonically included in another decidable natural number predicate `Q`, then the maximum natural number `i ≤ m` such that `P i` holds is less than or equal to the maximum natural number `i ≤ n` such that `Q i` holds.


/-- Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity.  -/
theorem LowerAdjoint.le_closure :
    ∀ {α : Type u_1} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α),
      x ≤ u (l.toFun x) :=
  by sorry

The theorem `LowerAdjoint.le_closure` states that for any given types `α` and `β` with preorders, and a function `u` mapping `β` to `α`, if `l` is a lower adjoint of `u`, then any element `x` from `α` is less than or equal to the result of applying `u` to the result of applying `l.toFun` to `x`. This is a property sometimes referred to as extensivity or inflationarity.

For any types with preorders `α` and `β`, and a lower adjoint `l` of a function `u` from `β` to `α`, `x ≤ u (l.toFun x)` holds for all `x` in `α`.


theorem Module.Baer.chain_linearPMap_of_chain_extensionOf :
    ∀ {R : Type u} [inst : Ring R] {Q : Type v} [inst_1 : AddCommGroup Q] [inst_2 : Module R Q] {M : Type u_1}
      {N : Type u_2} [inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module R M] [inst_6 : Module R N]
      {i : M →ₗ[R] N} {f : M →ₗ[R] Q} {c : Set (Module.Baer.ExtensionOf i f)},
      IsChain (fun x x_1 => x ≤ x_1) c → IsChain (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) '' c) :=
  by sorry

This theorem, called `Module.Baer.chain_linearPMap_of_chain_extensionOf`, states that for any ring `R`, additively commutative groups `Q`, `M`, and `N`, and modules `Q`, `M`, and `N` over `R`, given a linear map `i` from `M` to `N`, a linear map `f` from `M` to `Q`, and a set `c` of extensions of `i` to `f`, if `c` is a chain with respect to the less than or equal to relation, then the set of linear P-maps corresponding to elements of `c` is also a chain with respect to the less than or equal to relation. Here a chain is a set where for any two elements `x` and `y`, either `x` is less than or equal to `y`, `y` is less than or equal to `x`, or `x` and `y` are equal.

Given a ring `R`, additively commutative groups `Q`, `M`, and `N`, and modules `Q`, `M`, and `N` over `R`, if `i` is a linear map from `M` to `N`, `f` is a linear map from `M` to `Q`, and `c` is a chain of extensions of `i` to `f`, then the set of linear `Q`-maps corresponding to elements of `c` forms a chain.


theorem Asymptotics.IsBigO.congr_of_sub :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {l : Filter α} {f₁ f₂ : α → E'}, (fun x => f₁ x - f₂ x) =O[l] g → (f₁ =O[l] g ↔ f₂ =O[l] g) :=
  by sorry

This theorem states that for any types `α`, `F`, and `E'`, given a norm on `F` and a seminormed add commutative group on `E'`, and given functions `g : α → F` and `f₁, f₂ : α → E'`, if `(f₁ - f₂)` is big-O of `g` (denoted as `(f₁ - f₂) =O[l] g`) with respect to a filter `l`, then `f₁` is big-O of `g` if and only if `f₂` is big-O of `g`. In other words, the big-O status of `f₁` and `f₂` relative to `g` is equivalent if `(f₁ - f₂)` is also big-O of `g` under the filter `l`. This concept is from asymptotic analysis, where a function f is Big-O of g if it grows no faster than g in the limit.

If `(f₁ - f₂) =O[l] g` in Lean 4 with types `α`, `F`, and `E'`, normed group `F`, seminormed add commutative group `E'`, and functions `g : α → F`, `f₁, f₂ : α → E'`, then `f₁ =O[l] g` if and only if `f₂ =O[l] g`.


theorem unitary.star_mul_self_of_mem :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, U ∈ unitary R → star U * U = 1 := by sorry

This theorem states that for any type `R` that is a monoid with the additional structure `StarMul`, if `U` is an element of the submonoid `unitary R` (which consists of all elements `U` such that `star U * U = 1` and `U * star U = 1`), then the property `star U * U = 1` holds. In other words, for any unitary element `U`, the product of its star and itself equals the multiplicative identity of the monoid.

For any monoid `R` with `StarMul` structure and any `U` in the unitary submonoid, `star U * U = 1`.


/-- **Diagonalization theorem**, **spectral theorem** for matrices; A hermitian matrix can be
diagonalized by a change of basis.

For the spectral theorem on linear maps, see
`LinearMap.IsSymmetric.eigenvectorBasis_apply_self_apply`.  -/
theorem Matrix.IsHermitian.spectral_theorem :
    ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
      (hA : Matrix.IsHermitian A),
      Matrix.IsHermitian.eigenvectorMatrixInv hA * A =
        Matrix.diagonal (RCLike.ofReal ∘ Matrix.IsHermitian.eigenvalues hA) *
          Matrix.IsHermitian.eigenvectorMatrixInv hA :=
  by sorry

This theorem, often referred to as the Diagonalization theorem or the Spectral theorem for matrices, states that any Hermitian matrix can be diagonalized by a change of basis. More specifically, given a Hermitian matrix `A`, there exists an invertible matrix `P` (which is the inverse of the matrix constituted by the orthonormal eigenvectors of `A`), such that `P * A` equals the product of the diagonal matrix formed by the eigenvalues of `A` and `P`. This theorem is fundamental in linear algebra, as it provides a simple representation for Hermitian matrices that is easier to work with.

Given a Hermitian matrix `A`, there exists an invertible matrix `P` of orthonormal eigenvectors such that `P^*-1 * A * P` is a diagonal matrix with `A`'s eigenvalues on the diagonal.


theorem CategoryTheory.ShortComplex.homologyMap'_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃)
      (h₁ : CategoryTheory.ShortComplex.HomologyData S₁) (h₂ : CategoryTheory.ShortComplex.HomologyData S₂)
      (h₃ : CategoryTheory.ShortComplex.HomologyData S₃),
      CategoryTheory.ShortComplex.homologyMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap' φ₁ h₁ h₂)
          (CategoryTheory.ShortComplex.homologyMap' φ₂ h₂ h₃) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.homologyMap'_comp` states that for any category `C` of a certain type, given that `C` has zero morphisms, and given three short complexes `S₁`, `S₂` and `S₃` in `C`, along with morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, and their corresponding homology data `h₁`, `h₂`, and `h₃` respectively, the homology map of the composition of `φ₁` and `φ₂` from `h₁` to `h₃` is equal to the composition of the homology map of `φ₁` from `h₁` to `h₂` and the homology map of `φ₂` from `h₂` to `h₃`. This essentially expresses the compatibility of the homology maps with the composition in the category, a fundamental property in category theory.

Given categories `C` with zero morphisms, short complexes `S₁`, `S₂`, `S₃`, morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, and their corresponding homology data `h₁`, `h₂`, `h₃`, the homology maps of their composition agree: `h₃.Hom(φ₁ ∘ φ₂) = h₂.Hom(φ₁) ∘ h₁.Hom(φ₂)`.


theorem UniqueFactorizationMonoid.ne_zero_of_mem_factors :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {p a : α},
      p ∈ UniqueFactorizationMonoid.factors a → a ≠ 0 :=
  by sorry

The theorem `UniqueFactorizationMonoid.ne_zero_of_mem_factors` states that for any type `α` that has a structure of a cancel commutative monoid with zero and a unique factorization monoid, if an element `p` of `α` is in the multiset of prime factors of another element `a` of `α` (using the function `UniqueFactorizationMonoid.factors`), then `a` must not be zero.

If `p` is a factor of non-zero `a` in a cancel commutative monoid equipped with unique factorization and zero, then `p` appears in the prime factorization of `a`.


theorem Cardinal.mk_list_eq_mk : ∀ (α : Type u) [inst : Infinite α], Cardinal.mk (List α) = Cardinal.mk α := by sorry

The theorem `Cardinal.mk_list_eq_mk` states that for any type `α` which is infinite, the cardinality of the list of `α` is equal to the cardinality of `α`. In other words, the size of the set of all lists of elements of an infinite type `α` is the same as the size of the set of elements of `α` itself. This is a reflection of a characteristic property of infinite sets in set theory: an infinite set can have the same cardinality as some of its proper subsets.

For any infinite type `α`, the cardinality of `List α` equals the cardinality of `α`.


theorem MeasureTheory.snorm_eq_lintegral_rpow_nnnorm :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F],
      p ≠ 0 → p ≠ ⊤ → ∀ {f : α → F}, MeasureTheory.snorm f p μ = (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal) :=
  by sorry

This theorem states that for any non-zero and non-infinite extended nonnegative real number `p`, in a measurable space `α` with a measure `μ`, and a function `f` from `α` to any normed add commutative group `F`, the `ℒp` seminorm of `f` (denoted as `MeasureTheory.snorm f p μ`) is equal to the Lebesgue integral of the nonnegative norm of `f(x)` raised to the power of `p`, and this whole quantity raised to the power of `1 / p`. This Lebesgue integral is denoted as `(∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ)`, where `∫⁻` denotes the Lebesgue integral, and `‖f x‖₊` denotes the nonnegative norm of `f(x)`. The condition that `p ≠ 0` and `p ≠ ⊤` ensures that `p` is a positive finite number.

For any measurable function `f` from a measurable space `(α, μ)` with a finite, positive measure `μ` and a non-zero, finite real number `p`, the `ℒp` seminorm of `f` equals the `p-th` power of the Lebesgue integral of the nonnegative norm of `f(x)` raised to the power of `p`.


/-- Balls at the origin are absorbent.  -/
theorem absorbent_ball_zero :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {r : ℝ}, 0 < r → Absorbent 𝕜 (Metric.ball 0 r) :=
  by sorry

This theorem states that for any normed field `𝕜`, seminormed additive commutative group `E`, and normed space over `𝕜` and `E`, any ball centered at the origin with a positive radius `r` is an absorbent set. In other words, for every point `x` in the normed space, there exists a scalar in `𝕜` such that multiplying `x` by this scalar will result in a point inside the specified ball. This is a fundamental property in analysis and is often used in proofs related to boundedness and compactness.

For any normed field `𝕜`, seminormed additive commutative group `E`, and normed space `X` over `𝕜` and `E`, the open ball of radius `r` around the origin in `X` is absorbent.


theorem Mathlib.CategoryTheory.Sites.Sieves._auxLemma.10 :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
      (R = S) = ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f :=
  by sorry

This theorem states that for any category `C`, and any two sieves `R` and `S` on an object `X` in `C`, the sieves `R` and `S` are equal if and only if for any object `Y` in `C` and any morphism `f` from `Y` to `X`, `f` is in the sieve `R` if and only if `f` is in the sieve `S`. Essentially, two sieves are the same if they contain exactly the same morphisms.

Two sieves on an object in a category are equal if and only if they contain the same morphisms.


theorem Polynomial.monomial_mul_X :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (r : R),
      (Polynomial.monomial n) r * Polynomial.X = (Polynomial.monomial (n + 1)) r :=
  by sorry

The theorem `Polynomial.monomial_mul_X` states that for any semiring `R`, any natural number `n`, and any element `r` of `R`, the product of the monomial `r * X^n` with the polynomial variable `X` is equal to the monomial `r * X^(n+1)`. In other words, multiplying a monomial by `X` simply increments the exponent of `X` in that monomial by 1, without changing the coefficient.

For any semiring R, natural number n, and element r of R, the product of the monomial r * X^n with the polynomial variable X is equal to the monomial r * X^(n+1).


theorem BoxIntegral.Prepartition.splitMany_insert :
    ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ),
      BoxIntegral.Prepartition.splitMany I (insert p s) =
        BoxIntegral.Prepartition.splitMany I s ⊓ BoxIntegral.Prepartition.split I p.1 p.2 :=
  by sorry

The theorem `BoxIntegral.Prepartition.splitMany_insert` states that for any given box `I` of type `ι`, a finite set `s` of pairs of `ι` and real numbers, and a pair `p` of `ι` and a real number, splitting the box `I` along the hyperplanes defined by the union of `s` and `p` is equivalent to splitting the box `I` along the hyperplanes defined by `s` and then further splitting along the hyperplane defined by `p`. This splitting divides the box into sub-boxes. Here, the hyperplanes are defined by the equations `y = x` for each pair `(i, x)` in the set.

Given a box I of type ι, a finite set s of pairs (i, x) of type ι × ℝ, and a pair (j, y) of type ι × ℝ, splitting I along the hyperplanes defined by s and then further splitting along the hyperplane defined by (j, y) is equivalent to first splitting I along the hyperplanes defined by s and then splitting each sub-box along the hyperplane defined by (j, y).


theorem WithTop.iInf_coe_eq_top :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {f : ι → α},
      ⨅ x, ↑(f x) = ⊤ ↔ IsEmpty ι :=
  by sorry

This theorem states that for any type `α` with the property of `ConditionallyCompleteLinearOrderBot` (a kind of order structure) and any function `f` from some type `ι` to `α`, the infimum (greatest lower bound) of the co-domain of `f`, when considered in the extended real number line with a top element, is equal to `⊤`(top) if and only if `ι` is an empty type. In other words, if we have no inputs (i.e., `ι` is empty), then the infimum of the image of `f` is the top element.

For any function `f` from an empty type to a type `α` with the property `ConditionallyCompleteLinearOrderBot`, the infimum of the image of `f` in the extended real numbers is the top element.


theorem TrivSqZeroExt.inl_mul :
    ∀ {R : Type u} (M : Type v) [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M]
      [inst_3 : DistribMulAction Rᵐᵒᵖ M] (r₁ r₂ : R),
      TrivSqZeroExt.inl (r₁ * r₂) = TrivSqZeroExt.inl r₁ * TrivSqZeroExt.inl r₂ :=
  by sorry

This theorem, named `TrivSqZeroExt.inl_mul`, states that for any types `R` and `M`, where `R` is a monoid, `M` is an add monoid, and `R` (and its opposite) acts distributively on `M`, the multiplication in `R` respects the canonical inclusion into its trivial square-zero extension. In other words, if you have two elements `r₁` and `r₂` from `R`, then the result of mapping the product `r₁ * r₂` into the trivial square-zero extension of `R` and `M` using the canonical inclusion `TrivSqZeroExt.inl` is the same as the product of the images of `r₁` and `r₂` under the same inclusion. This theorem connects the multiplication in the original type `R` with the operation in the extension, showing that the canonical inclusion respects the multiplication operation.

For any monoid `R` and add monoid `M` with `R` (and its opposite) distributively acting on `M`, the multiplication in `R` commutes with the canonical inclusion into its trivial square-zero extension in `M`.


Substring.ValidFor.nextn

theorem Substring.ValidFor.nextn :
    ∀ {l m₁ m₂ r : List Char} {s : Substring},
      Substring.ValidFor l (m₁ ++ m₂) r s →
        ∀ (n : ℕ),
          Substring.nextn s n { byteIdx := String.utf8Len m₁ } =
            { byteIdx := String.utf8Len m₁ + String.utf8Len (List.take n m₂) } :=
  by sorry

This theorem, `Substring.ValidFor.nextn`, states that for any lists of characters `l`, `m₁`, `m₂`, and `r`, and for any substring `s` that is valid for the concatenation of `m₁` and `m₂` embedded in `l` and `r`, for any natural number `n`, the `n`-th next position in the substring `s` from the position corresponding to the UTF-8 byte length of `m₁` equals the position corresponding to the sum of the UTF-8 byte length of `m₁` and the UTF-8 byte length of the first `n` characters in `m₂`. This provides a way of finding the `n`-th next position in a valid substring that is formed by concatenating two lists of characters.

For any valid substring `s` of length `|m₁| + |m₂|` in the concatenation of lists `l` containing `m₁` and `r` containing `m₂` of UTF-8 encoded characters, the index of the `n`-th next position in `s` after the position determined by the UTF-8 byte length of `m₁` is equal to the sum of the UTF-8 byte lengths of the first `n` characters in `m₂`.


theorem Array.foldl_data_eq_bind :
    ∀ {α : Type u_1} {β : Type u_2} (l : List α) (acc : Array β) (F : Array β → α → Array β) (G : α → List β),
      (∀ (acc : Array β) (a : α), (F acc a).data = acc.data ++ G a) →
        (List.foldl F acc l).data = acc.data ++ List.bind l G :=
  by sorry

This theorem states that for any list of elements of type `α`, an array of type `β`, a function `F` that takes an array of type `β` and an element of type `α` and returns an array of type `β`, and a function `G` that takes an element of type `α` and returns a list of elements of type `β`, if for all arrays of type `β` and elements of type `α`, the data of the result of applying `F` to the array and the element is equal to the concatenation of the data of the array and the result of applying `G` to the element, then the data of the result of folding `F` over the list starting with the array is equal to the concatenation of the data of the array and the result of binding the list with `G`. This can be seen as a relationship between the fold and bind operations on lists and arrays.

If for all `β` arrays `a` and `α` elements `x`, the concatenation of `a` and `G x` is equal to the result of applying `F` to `a` and `x`, then the result of folding `F` over a list `[a] ++ xs` is equal to the array `a` concatenated with the list `map G xs`.


theorem List.Sublist.append_right :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → ∀ (l : List α), List.Sublist (l₁ ++ l) (l₂ ++ l) := by sorry

This theorem states that for any type `α`, and for any lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then for any other list `l` of type `α`, the list formed by appending `l` to `l₁` (`l₁ ++ l`) is a sublist of the list formed by appending `l` to `l₂` (`l₂ ++ l`). Here, "sublist" is used in the sense that elements of the first list appear in the second list in the same order, but possibly with other elements in between.

For any type `α` and lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then `l₁ ++ l` is a sublist of `l₂ ++ l` for any list `l` of type `α`.


theorem Polynomial.eval_one_map :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (p : Polynomial R),
      Polynomial.eval 1 (Polynomial.map f p) = f (Polynomial.eval 1 p) :=
  by sorry

The theorem `Polynomial.eval_one_map` states that for any given semirings `R` and `S`, and for any ring homomorphism `f` from `R` to `S`, and any polynomial `p` over `R`, the value of evaluating the mapped polynomial `p` (via `f`) at 1 is equivalent to applying the ring homomorphism `f` on the value of evaluating the original polynomial `p` at 1. In other words, mapping a polynomial and then evaluating at 1 is the same as evaluating the polynomial at 1 and then applying the ring homomorphism.

For any semirings R and S, ring homomorphism f from R to S, and polynomial p over R, the value of f(p(1)) equals p(1) \* f(1) in S.


theorem CategoryTheory.Limits.KernelFork.mapOfIsLimit_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} {f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} (kf : CategoryTheory.Limits.KernelFork f)
      {kf' : CategoryTheory.Limits.KernelFork f'} (hf' : CategoryTheory.Limits.IsLimit kf')
      (φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.KernelFork.mapOfIsLimit kf hf' φ)
          (CategoryTheory.Limits.Fork.ι kf') =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι kf) φ.left :=
  by sorry

This theorem states that given a category `C` with zero morphisms, for any two objects `X, Y` in `C` and a morphism `f` between them, let's say we have a kernel fork `kf` of `f`. Similarly, for any other two objects `X', Y'` in `C` and a morphism `f'` between them, if `kf'` is a kernel fork of `f'` and is a limit, and `φ` is a morphism between the arrows of `f` and `f'`, then the composition of the map of kernel fork `kf` of limit `hf'` with `φ` and the canonical projection `ι` of `kf'` is equal to the composition of the `ι` of `kf` and the left component of `φ`. In other words, this theorem is establishing a commutative property in the context of category theory, specifically around the concept of kernel forks in a category with zero morphisms.

Given categories `C` with zero morphisms, kernel forks `kf` and `kf'` of morphisms `f` and `f'` between objects `X, Y` and `X', Y'` respectively, if `kf` is the limit of `f'` and `φ` is a morphism between `f` and `f'`, then the composition of `kf`, `hf'`, `φ`, and `ι` is equal to the composition of `ι` and the left component of `φ`.


OrderRingHom.ext

theorem OrderRingHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
      [inst_3 : Preorder β] {f g : α →+*o β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two order-preserving ring homomorphisms `f` and `g` from a non-associative semiring `α`, which is also a preorder, to another non-associative semiring `β` that is a preorder, if `f` and `g` map every element of `α` to the same element in `β`, then `f` and `g` are the same homomorphism. In other words, an order-preserving ring homomorphism is uniquely determined by its action on the elements of the semiring.

If two order-preserving homomorphisms from a non-associative semiring to another non-associative semiring, both being preorders, map every element to the same image, then they are equal as homomorphisms.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.8 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Set.Nonempty (Metric.ball x ε) = (0 < ε) := by sorry

The theorem `Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.8` states that for any type `α` that is equipped with a PseudoMetricSpace structure, and any `x` of type `α` and `ε` of type real numbers (ℝ), the set of all points `y` in the metric ball centered at `x` with radius `ε` is nonempty if and only if `ε` is greater than zero. In simpler terms, it means that a ball in a pseudometric space has points inside it if its radius is positive.

For any pseudometric space (α, d), and x ∈ α and ε > 0, the metric ball B(x, ε) is nonempty.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.29 :
    ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) := by sorry

This theorem states that for any types `α` and `β`, and any elements `a₁`, `a₂` of type `α` and `b₁`, `b₂` of type `β`, the equality of the pairs `(a₁, b₁)` and `(a₂, b₂)` is equivalent to the conjunction of the equality of `a₁` and `a₂` and the equality of `b₁` and `b₂`. In simpler terms, two pairs are equal if and only if their corresponding elements are equal.

For any types `α` and `β`, and any `a₁, a₂ : α` and `b₁, b₂ : β`, `(a₁, b₁) = (a₂, b₂)` if and only if `a₁ = a₂` and `b₁ = b₂`.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.12 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
      Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, along with any functions `f : β → γ` and `g : α → β`, and any filters `x : Filter α` and `y : Filter γ`, the tendency of function `f` over the filter obtained by mapping `g` over `x` towards `y` is equivalent to the tendency of the composition of `f` and `g` over the filter `x` towards `y`. In other words, it asserts that the limits when taken in sequence or when taken after composition of functions, are the same. This is a key property in the analysis related to the continuity and limits of function compositions.

For any types `α`, `β`, and `γ`, functions `f : β → γ` and `g : α → β`, filters `x : Filter α` and `y : Filter γ`, the tendency of `f` over `g(x)` towards `y` equals the tendency of `f ∘ g` over `x` towards `y`.


theorem neg_lie :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L)
      (m : M), ⁅-x, m⁆ = -⁅x, m⁆ :=
  by sorry

This theorem, `neg_lie`, states that for any Lie ring `L`, additively commutative group `M`, and any Lie ring module (a module for a Lie ring) `L M`, for any elements `x` of `L` and `m` of `M`, the Lie bracket of `-x` and `m` is equal to the negation of the Lie bracket of `x` and `m`. In mathematical notation, this would be denoted as `-x, m = -⁅x, m⁆`. This theorem holds for all possible `x` in `L` and `m` in `M`.

For any Lie ring `L`, additively commutative group `M`, and Lie ring module `L M`, the Lie bracket of `-x` and `m` equals the negation of the Lie bracket of `x` and `m`, for all `x` in `L` and `m` in `M`.


theorem Int.mul_left_comm : ∀ (a b c : ℤ), a * (b * c) = b * (a * c) := by sorry

This theorem, `Int.mul_left_comm`, states that for any three integers `a`, `b`, and `c`, the product of `a` and the product of `b` and `c` is equal to the product of `b` and the product of `a` and `c`. In mathematical terms, this would be written as $a \cdot (b \cdot c) = b \cdot (a \cdot c)$. This property is known as the left commutativity of multiplication over the integers.

For any integers a, b, and c, a \* (b \* c) = (b \* a) \* c. (Left commutativity of multiplication over the integers)


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.48 :
    ∀ {β : Type u_2} {f : β → NNReal}, Summable f = (∑' (b : β), ↑(f b) ≠ ⊤) := by sorry

This theorem states that for any type `β` and any function `f` from `β` to nonnegative real numbers (denoted by `NNReal`), the function `f` is summable (meaning it has some infinite sum) if and only if the infinite sum of the function values (obtained by applying `f` to every element of `β` and then taking the sum) is not equal to positive infinity. This is denoted by the `≠ ⊤` symbol. In other words, it's saying that a function `f` has some infinite sum as long as that sum doesn't turn out to be infinity.

A function from a type to non-negative real numbers is summable if and only if the sum of its values is finite.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.35 :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {P : β → Prop},
      (∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) :=
  by sorry

This theorem states that for any types `α` and `β`, any filter `f` of type `α`, any function `m` from `α` to `β`, and any property `P` of type `β`, the property `P` holds eventually for all elements `b` in the filter obtained by mapping `f` through `m` if and only if `P` holds eventually for all elements `a` in `f` when applied to the function `m`. In other words, it states that mapping a filter and checking a property is the same as checking the property after applying the function inside the original filter.

For any filters $f$ on type $\alpha$, functions $m:\alpha \to \beta$, and properties $P:\beta$, $P$ holds eventually for $m(\overline{x})$ as $x$ ranges over $f$ if and only if $P$ holds eventually for $x$ as $x$ ranges over $f$.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.32 :
    ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x := by sorry

This theorem states that for any type `α` and any predicate `p` over `α`, the statement that there does not exist an `x` of type `α` such that `p(x)` holds is equivalent to the statement that for all `x` of type `α`, `p(x)` does not hold. This is a generalization of the principle of negation in classical logic, translating the non-existence of an element satisfying a property into the universal non-satisfaction of that property.

For any type `α` and predicate `p` over `α`, the lack of existence of an `x` with `p(x)` is equivalent to `p` being universally false for all `x` of type `α`.


theorem comp_le_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α], (Filter.lift' (uniformity α) fun s => compRel s s) ≤ uniformity α := by
  sorry

This theorem states that for every type `α` equipped with a UniformSpace structure, the filter obtained by lifting the uniformity of `α` using the function that computes the composition of a relation with itself, is less than or equal to the uniformity of `α`. In other words, within any uniform space, the composition operation applied to any set taken from the uniformity and then lifted onto the uniformity (a form of push-forward), will always yield a set that is still within the bounds of the original uniformity.

For any uniform space (α, υ), the self-composition lift of its uniformity is a sub-uniformity.


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

The theorem `Nat.factorial_le` states that for any two natural numbers `m` and `n`, if `m` is less than or equal to `n`, then the factorial of `m` is also less than or equal to the factorial of `n`. In other words, the factorial function on natural numbers is monotone non-decreasing. This is expressed using the notation of order in natural numbers: `m ≤ n` implies `Nat.factorial m ≤ Nat.factorial n`.

For all natural numbers m and n, if m <= n then Nat.factorial m <= Nat.factorial n.


theorem Nat.factorial_lt : ∀ {m n : ℕ}, 0 < n → (Nat.factorial n < Nat.factorial m ↔ n < m) := by sorry

This theorem, named `Nat.factorial_lt`, states that for any two natural numbers `m` and `n`, given that `n` is greater than zero, the factorial of `n` is less than the factorial of `m` if and only if `n` is less than `m`. In other words, it establishes a direct correspondence between the order of two natural numbers and the order of their factorials, under the condition that the second number is positive.

For natural numbers m and n with n > 0, m > n if and only if m! < n!.


LE.le.dual

/-- **Alias** of the reverse direction of `OrderDual.toDual_le_toDual`. -/
theorem LE.le.dual : ∀ {α : Type u_1} [inst : LE α] {a b : α}, b ≤ a → OrderDual.toDual a ≤ OrderDual.toDual b := by
  sorry

This theorem, referred to as `LE.le.dual`, states that for any type `α` that possesses a less than or equal to (`≤`) relation, if `b` is less than or equal to `a` (represented as `b ≤ a`), then the OrderDual of `a` is less than or equal to the OrderDual of `b` in the `OrderDual` of `α` (represented as `OrderDual.toDual a ≤ OrderDual.toDual b`). In other words, this theorem is saying that the order relation is reversed in the dual of a linear order.

For any type `α` with a `≤` relation, if `b ≤ a`, then `OrderDual.toDual a ≤ OrderDual.toDual b`. In other words, the order relation is reversed in the dual of a linear order.


theorem IsMulCentral.left_comm :
    ∀ {M : Type u_1} {a : M} [inst : Mul M], IsMulCentral a → ∀ (b c : M), a * (b * c) = b * (a * c) := by sorry

The theorem `IsMulCentral.left_comm` states that for any type `M` with a multiplication operation (denoted by `Mul M`), and for any element `a` of type `M` that is central with respect to multiplication (i.e., satisfies `IsMulCentral a`), the left multiplication of `a` commutes with the multiplication of any two other elements `b` and `c` of type `M`. That is, the expression `a * (b * c)` is equal to the expression `b * (a * c)`. This essentially means that `a` can be moved around in multiplication expressions without changing the result.

For any type `M` with multiplication and any central element `a` in `M`, we have `a * (b * c) = b * (a * c)` for all `b, c` in `M`.


theorem lcm_assoc :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (m n k : α),
      lcm (lcm m n) k = lcm m (lcm n k) :=
  by sorry

This theorem states that the least common multiple (LCM) operation is associative for any three elements in a certain type. In other words, for any type `α` that is a `CancelCommMonoidWithZero` and also a `NormalizedGCDMonoid`, and for any three elements `m`, `n`, and `k` of this type, the LCM of the LCM of `m` and `n` with `k` is equal to the LCM of `m` with the LCM of `n` and `k`. This is analogous to the associativity of addition or multiplication in regular arithmetic, where `(a + b) + c = a + (b + c)` or `(a * b) * c = a * (b * c)` respectively.

For any type `α` that is both a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid`, the LCM of `LCM(m, n)` and `k` equals `LCM(m, LCM(n, k))` for all `m, n, k` in `α`.


theorem CategoryTheory.Projective.projective_iff_preservesEpimorphisms_coyoneda_obj :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : C),
      CategoryTheory.Projective P ↔
        CategoryTheory.Functor.PreservesEpimorphisms (CategoryTheory.coyoneda.obj (Opposite.op P)) :=
  by sorry

This theorem states that for any category `C` and any object `P` in `C`, `P` is projective if and only if the functor `CategoryTheory.coyoneda.obj (Opposite.op P)` preserves epimorphisms. Here, "projective" means that for every epimorphism and every morphism from `P`, there exists a morphism from `P` making the relevant diagram commute. The functor `CategoryTheory.coyoneda.obj (Opposite.op P)` takes any object of the opposite category `Cᵒᵖ` to the set of morphisms from `P` to that object in `C`. "Preserves epimorphisms" means that if a morphism in the domain category is an epimorphism, then its image under the functor is also an epimorphism in the codomain category.

A object P in a category C is projective if and only if the functor taking an object to the set of morphisms from P to it preserves epimorphisms in the opposite category.


/-- A combination of two points expressed with `lineMap` lies in their affine span.  -/
theorem AffineMap.lineMap_mem_affineSpan_pair :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (r : k) (p₁ p₂ : P), (AffineMap.lineMap p₁ p₂) r ∈ affineSpan k {p₁, p₂} :=
  by sorry

The theorem `AffineMap.lineMap_mem_affineSpan_pair` states that, for any ring `k`, commutative group `V`, generic type `P`, and any points `p₁` and `p₂` of type `P`, the image of any scalar `r` of `k` under the affine map `lineMap` from `k` to `P` with `p₁` as the "start" point and `p₂` as the "end" point always lies within the affine span of the set `{p₁, p₂}`. In other words, any point that can be obtained by linearly interpolating between `p₁` and `p₂` is contained in the smallest affine subspace that contains both `p₁` and `p₂`.

For any ring `k`, commutative group `V`, and points `p₁, p₂` in `V`, the image of any scalar `r` under the affine map `lineMap` from `k` to `V` with `p₁` as the starting point and `p₂` as the ending point lies in the affine span of `{p₁, p₂}`.


CategoryTheory.Abelian.image.fac

/-- `f` factors through its image via the canonical morphism `p`.  -/
theorem CategoryTheory.Abelian.image.fac :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C] {P Q : C}
      (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Abelian.factorThruImage f) (CategoryTheory.Abelian.image.ι f) =
        f :=
  by sorry

This theorem, named `CategoryTheory.Abelian.image.fac`, states that for any category `C` with zero morphisms, kernels, and cokernels, and for any two objects `P` and `Q` in this category, any morphism `f` from `P` to `Q` factors through its image via the canonical morphism `p`. In other words, the composition of `f` with the factorization through its image, followed by the canonical morphism `p`, is equal to `f` itself. This is essential in the Abelian category theory, which studies categories that behave like the category of abelian groups, where morphisms can be "factored" in this way.

For any morphism $f$ in an Abelian category with zero morphisms, for every object $P$, there exists a commutative diagram $P \xrightarrow{f} Q \xrightarrow{p} I \xleftarrow{i} Im(f)$ such that $fi = pi$.


IsSpectralMap.continuous

theorem IsSpectralMap.continuous :
    ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
      IsSpectralMap f → Continuous f :=
  by sorry

This theorem states that for any two types `α` and `β`, each equipped with a topological space structure (`inst` and `inst_1`, respectively), if a function `f` from `α` to `β` is a spectral map (`IsSpectralMap f`), then that function `f` is continuous (`Continuous f`). In other words, spectral maps preserve the property of continuity in the context of topological spaces.

If `f` is a spectral map between topological spaces `α` and `β`, then `f` is continuous.


theorem Primrec.dom_bool : ∀ {α : Type u_1} [inst : Primcodable α] (f : Bool → α), Primrec f := by sorry

The theorem `Primrec.dom_bool` states that for any type `α`, which has a `Primcodable` instance, and for any function `f` from `Bool` to `α`, the function `f` is primitive recursive. In other words, whenever we have a function that takes a boolean value and produces an output in some type `α`, that function can be described using only the basic constructs of primitive recursion.

For any type `α` with a `Primcodable` instance and any function `f : Bool → α`, `f` is a primitive recursive function.


theorem Mathlib.Algebra.CharP.Two._auxLemma.1 : ∀ {M : Type u} [inst : Monoid M] (a : M), a * a = a ^ 2 := by sorry

This theorem, `Mathlib.Algebra.CharP.Two._auxLemma.1`, states that for any type `M` that has a `Monoid` instance and for any element `a` of type `M`, the result of multiplying `a` by itself is equivalent to `a` raised to the power of 2. In mathematical terms, for any monoid `M` and any element `a` in `M`, we have $a * a = a^2$.

For any monoid `M` and element `a` in `M`, the product of `a` with itself equals the square of `a`, i.e., `a * a = a^2`.


theorem Composition.length_gather :
    ∀ {n : ℕ} (a : Composition n) (b : Composition (Composition.length a)),
      Composition.length (Composition.gather a b) = Composition.length b :=
  by sorry

The `Composition.length_gather` theorem states that for any natural number `n` and any composition `a` of `n`, if `b` is a composition of the length of `a`, then the length of the composition formed by gathering all the blocks of `a` corresponding to a block of `b` (`Composition.gather a b`) is equal to the length of `b`. In other words, the act of gathering blocks according to another composition does not change the number of blocks in the composition.

For any natural numbers `n` and compositions `a` and `b` of `n` with `b` being a block of `a`, the length of the composition obtained by gathering all blocks of `a` corresponding to `b` is equal to the length of `b`.