/-- The nonsingular inverse is the same as the general `Ring.inverse`.  -/
theorem Matrix.nonsing_inv_eq_ring_inverse :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      A⁻¹ = Ring.inverse A :=
  by sorry

This theorem states that for any square matrix `A` over a commutative ring `α`, where the size of the matrix is a finite type `n` with a decidable equality, the nonsingular inverse of `A` is identical to the general `Ring.inverse` of `A`. Essentially, if `A` is invertible in the matrix sense, then its matrix inverse is the same as the ring-theoretic multiplicative inverse.

For any square matrix `A` over a commutative ring `α` of finite type `n` with decidable equality, if `A` has an inverse in the matrix sense, then `A`'s matrix inverse is equal to its ring-theoretic multiplicative inverse.


theorem Int.mul_ediv_mul_of_pos : ∀ {a : ℤ} (b c : ℤ), 0 < a → a * b / (a * c) = b / c := by sorry

This theorem states that for all integers `a`, `b`, and `c`, if `a` is greater than zero, then the integer division of the product of `a` and `b` by the product of `a` and `c` equals the integer division of `b` by `c`. In mathematical terms, if $a > 0$, then $\frac{a \cdot b}{a \cdot c} = \frac{b}{c}$. This theorem is a particular case of cancelling factors in a fraction, specifically when dealing with integer division and positive integers.

For all integers a, b, and c where a > 0, the integer quotient of a * b by a * c equals the integer quotient of b by c.


theorem SetTheory.PGame.quot_left_distrib : ∀ (x y z : SetTheory.PGame), ⟦x * (y + z)⟧ = ⟦x * y⟧ + ⟦x * z⟧ := by sorry

This theorem states that for any three elements `x`, `y`, and `z` in Set Theory's PGame, the game equivalence of `x` multiplied by the game sum of `y` and `z` is equal to the game sum of the game equivalence of `x` multiplied by `y` and the game equivalence of `x` multiplied by `z`. In other words, it asserts the left-distributive property of multiplication over addition within the context of surreal number games.

For any elements `x`, `y`, and `z` in Set Theory's PGame, the game equivalence of `x` × (`y` ⊕ `z`) is equal to (`x` ⊕ₗ `y`) × `z` + (`x` ⊕ₗ `z`), where × denotes multiplication and ⊕ denotes addition in the context of surreal number games.


/-- A bounded subset has finite measure for a measure which is finite on compact sets, in a
proper space.  -/
theorem Bornology.IsBounded.measure_lt_top :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} [inst : PseudoMetricSpace α] [inst_1 : ProperSpace α]
      {μ : MeasureTheory.Measure α} [inst_2 : MeasureTheory.IsFiniteMeasureOnCompacts μ] ⦃s : Set α⦄,
      Bornology.IsBounded s → ↑↑μ s < ⊤ :=
  by sorry

The theorem `Bornology.IsBounded.measure_lt_top` states that for any type `α` that forms a measurable space, is a pseudometric space, and is a proper space with a given measure `μ` that is finite on compact sets and for any set `s` of type `α`, if `s` is bounded relative to the ambient bornology on `α`, then the measure of `s` is less than infinity. In other words, in a proper space, a bounded subset's measure is finite for a measure which is finite on compact sets.

In a proper measurable space with a finite-on-compacts measure, a bounded set has finite measure.


theorem eq_or_eq_neg_of_abs_eq :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, |a| = b → a = b ∨ a = -b := by sorry

This theorem states that for any type `α` that has an addition group structure and a linear order, given any two elements `a` and `b` from `α`, if the absolute value of `a` is equal to `b`, then `a` is either equal to `b` or the negative of `b`. In mathematical notation, this would be stated as: for all `a` and `b` in a linearly ordered additive group, if `|a| = b` then `a = b` or `a = -b`.

In an additively and linearly ordered type `α`, for all `a` and `b`, if the absolute value of `a` equals `b`, then `a` is equal to `b` or the negative of `b`.


theorem basisOfLinearIndependentOfCardEqFinrank.proof_1 :
    ∀ {K : Type u_2} {V : Type u_1} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      {ι : Type u_3} [inst_3 : Nonempty ι] [inst_4 : Fintype ι] {b : ι → V},
      LinearIndependent K b → Fintype.card ι = FiniteDimensional.finrank K V → ⊤ ≤ Submodule.span K (Set.range b) :=
  by sorry

This theorem states that for any division ring 'K' and an additively commutative group 'V' that forms a module over 'K', given a type 'ι' that is nonempty and finite, and a function 'b' from 'ι' to 'V', if the set of vectors 'b' is linearly independent over 'K' and the number of elements in 'ι' equals the rank of the module 'V' over 'K', then the total (or universal) submodule is less than or equal to the submodule spanned by the range of 'b'. In other words, the span of the range of this linearly independent function 'b' covers the entire module 'V', when the cardinality of 'ι' matches the rank of 'V'.

If 'V' is an additively commutative 'K'-module of finite rank, and 'b' is a function from a finite, nonempty set 'ι' to 'V' such that the set of vectors {b i | i ∈ ι} is linearly independent over 'K', then the submodule generated by 'b' ('span {b i | i ∈ ι}') contains the whole module 'V'.


theorem PNat.gcd_eq_left_iff_dvd : ∀ {m n : ℕ+}, m ∣ n ↔ PNat.gcd m n = m := by sorry

This theorem states that for any two positive natural numbers `m` and `n`, `m` divides `n` if and only if the greatest common divisor of `m` and `n` is `m`. In other words, a positive natural number `m` is a divisor of another positive natural number `n` if and only if the greatest common factor they share is `m`.

A positive natural number `m` divides `n` if and only if their greatest common divisor equals `m`.


theorem Filter.inter_mem_iff : ∀ {α : Type u} {f : Filter α} {s t : Set α}, s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f := by sorry

This theorem, named `Filter.inter_mem_iff`, states that for any type `α`, any filter `f` on `α`, and any two sets `s` and `t` of `α`, the intersection of `s` and `t` belongs to the filter `f` if and only if both `s` and `t` belong to the filter `f`. In other words, the intersection of two sets is a member of a given filter iff each of the sets is a member of the filter.

For any filter `f` on a type `α`, and sets `s` and `t` in `α`, `s ∩ t ∈ f` if and only if `s, t ∈ f`.


MeasureTheory.IntegrableOn.union

theorem MeasureTheory.IntegrableOn.union :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s t : Set α}
      {μ : MeasureTheory.Measure α},
      MeasureTheory.IntegrableOn f s μ → MeasureTheory.IntegrableOn f t μ → MeasureTheory.IntegrableOn f (s ∪ t) μ :=
  by sorry

The theorem `MeasureTheory.IntegrableOn.union` states that for any given measurable space `α`, normed additive commutative group `E`, a function `f` from `α` to `E`, two sets `s` and `t` of `α`, and a measure `μ` on `α`, if the function `f` is integrable on the set `s` with respect to the measure `μ` and also integrable on the set `t` with respect to the measure `μ`, then the function `f` is integrable on the union of the sets `s` and `t` with respect to the same measure `μ`.

In mathematical terms, if a function is integrable on two separate sets, it is also integrable on the union of those two sets.

If `f : α → E` is integrable with respect to measure `μ` on sets `s` and `t` of `α`, then `f` is integrable on their union `s ∪ t`.


theorem Set.le_indicator_apply :
    ∀ {α : Type u_2} {M : Type u_4} [inst : LE M] [inst_1 : Zero M] {s : Set α} {g : α → M} {a : α} {y : M},
      (a ∈ s → y ≤ g a) → (a ∉ s → y ≤ 0) → y ≤ Set.indicator s g a :=
  by sorry

This theorem, `Set.le_indicator_apply`, asserts that for any types `α` and `M` where `M` has a less than or equal to (`LE`) and a zero structure, any set `s` of type `α`, any function `g` from `α` to `M`, and any elements `a` of type `α` and `y` of type `M`, if `y` is less than or equal to `g a` whenever `a` is in `s` and `y` is less than or equal to `0` whenever `a` is not in `s`, then `y` is less than or equal to the indicator function value `Set.indicator s g a`. In other words, the indicator function value for an element with respect to a set and a function is an upper bound for `y` under these conditions.

For any set $s$ and function $g: \alpha \to M$ with $M$ having a LE and zero structure, if $y \leq g(a)$ for all $a \in s$ and $y \leq 0$ for all $a \notin s$, then $y \leq \operatorname{indicator}_s(g)(a)$.


theorem Real.injOn_sin : Set.InjOn Real.sin (Set.Icc (-(Real.pi / 2)) (Real.pi / 2)) := by sorry

The theorem `Real.injOn_sin` states that the real sine function `Real.sin` is injective, which means it does not produce the same output for two different inputs, when it is restricted to the interval `Set.Icc (-(Real.pi / 2)) (Real.pi / 2)`. In other words, for any two different numbers in the interval from negative half-pi to half-pi, their sine values are also different.

The sine function restricted to the interval `(-π/2, π/2)` is injective.


/-- If `f : α → β` is a fibration between relations `rα` and `rβ`, and `a : α` is
accessible under `rα`, then `f a` is accessible under `rβ`.  -/
theorem Acc.of_fibration :
    ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop} (f : α → β),
      Relation.Fibration rα rβ f → ∀ {a : α}, Acc rα a → Acc rβ (f a) :=
  by sorry

The theorem, `Acc.of_fibration`, states that given any types `α` and `β`, relations `rα` on `α` and `rβ` on `β`, and a function `f` from `α` to `β` that is a fibration between `rα` and `rβ`, then if an element `a` in `α` is accessible under the relation `rα`, the image of `a` under `f`, which is an element in `β`, is accessible under the relation `rβ`. Here, a function `f` is a fibration between `rα` and `rβ` if whenever an element `b` in `β` and the image of an element `a` in `α` under `f` are related by `rβ`, there exists an element `a'` in `α` such that `a'` and `a` are related by `rα` and `b` is the image of `a'` under `f`. An element is said to be accessible under a relation if it is not related to any infinite chain of elements under that relation.

If `f: α → β` is a fibration between relations `rα` on `α` and `rβ` on `β`, and `a` in `α` is accessible under `rα`, then the image `f(a)` in `β` is accessible under `rβ`.


/-- Supremum of `s i`, `i : ι`, is equal to the supremum over `t : Finset ι` of suprema
`⨆ i ∈ t, s i`. This version assumes `ι` is a `Type*`. See `iSup_eq_iSup_finset'` for a version
that works for `ι : Sort*`.  -/
theorem iSup_eq_iSup_finset :
    ∀ {α : Type u_2} {ι : Type u_5} [inst : CompleteLattice α] (s : ι → α), ⨆ i, s i = ⨆ t, ⨆ i ∈ t, s i := by sorry

This theorem states that for any types `α` and `ι` with `α` being a complete lattice, and any function `s` from `ι` to `α`, the supremum of `s i` over all `i` in `ι` is equal to the supremum over all finite subsets `t` of `ι` of the suprema of `s i` for `i` in `t`. In other words, we can find the supremum of the range of a function `s` by taking the supremum of the suprema over all finite subsets of its domain.

For any complete lattice `α` and any function `s` from a index set `ι` to `α`, the supremum of `s i` over all `i` in `ι` equals the supremum over all finite subsets `t` of `ι` of the suprema of `s i` for `i` in `t`. Equivalently, the supremum of `s` is the supremum of the finite suprema of `s` over all finite subsets of its domain.


theorem CategoryTheory.ShortComplex.exact_iff_epi :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.Limits.HasZeroObject C],
      S.g = 0 → (CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Epi S.f) :=
  by sorry

This theorem states that in any preadditive category `C` with a zero object, for a given short complex `S` in `C`, if the map `S.g` is zero, then `S` is exact if and only if `S.f` is an epimorphism. Here, an exact short complex means that the image of `S.f` matches the kernel of `S.g`, and an epimorphism is a morphism where the condition of right-cancellation holds.

In a preadditive category with a zero object, a short complex is exact if and only if its gap map is zero and its front map is an epimorphism.


Module.Ray.ind

/-- An induction principle for `Module.Ray`, used as `induction x using Module.Ray.ind`.  -/
theorem Module.Ray.ind :
    ∀ (R : Type u_1) [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {C : Module.Ray R M → Prop},
      (∀ (v : M) (hv : v ≠ 0), C (rayOfNeZero R v hv)) → ∀ (x : Module.Ray R M), C x :=
  by sorry

This theorem, `Module.Ray.ind`, provides an induction principle for the type `Module.Ray` in the context of a module over a strictly ordered commutative semiring. Given any type `R` with a strictly ordered commutative semiring structure, type `M` with an additive commutative monoid structure, and a module structure over `R` and `M`, it says that for any property `C` that might hold for an element of `Module.Ray R M`, if we can prove that this property `C` holds for every nonzero vector `v` in `M` (which is encapsulated by the `rayOfNeZero` function), then we can conclude that this property `C` holds for every element in `Module.Ray R M`.

If a property holds for every nonzero vector in a module over a strictly ordered commutative semiring, then it holds for every element in the corresponding Module.Ray.


theorem CategoryTheory.Bicategory.whiskerLeft_inv_hom :
    ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ≅ h),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft f η.inv)
          (CategoryTheory.Bicategory.whiskerLeft f η.hom) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f h) :=
  by sorry

This theorem states that for any bicategory `B` and any objects `a`, `b`, and `c` in `B`, for any morphism `f` from `a` to `b` and any isomorphism `η` from morphism `g` to `h` (both `g` and `h` are morphisms from `b` to `c`), the composition of `whiskerLeft f η.inv` with `whiskerLeft f η.hom` is equivalent to the identity morphism on the composite `f h`, where `whiskerLeft f η.inv` represents the whiskering on the left of `f` with the inverse of `η` and `whiskerLeft f η.hom` represents the whiskering on the left of `f` with `η`.

The symbol `≅` denotes an isomorphism in category theory, thus `η : g ≅ h` means `η` is an isomorphism from `g` to `h`. The whiskering of a morphism with another one, denoted `whiskerLeft f η.inv` or `whiskerLeft f η.hom`, is a concept in bicategory that generally represents a kind of transformation induced by `f`.

In simpler terms, this theorem is about a property of the whiskering operation in a bicategory, which ensures that whiskering a morphism with the inverse of an isomorphism and then whiskering the result with the original isomorphism gives you the identity morphism, keeping the morphism unchanged. This is analogous to the property of multiplication by the inverse in group theory.

For any bicategory `B`, objects `a`, `b`, `c`, morphisms `f : a → b`, `g, h : b → c`, and isomorphism `η : g ≅ h`, the composition of `whiskerLeft f η.inv` with `whiskerLeft f η.hom` is equal to the identity morphism `id_(f h)`.


theorem Submodule.mem_sup_left :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {S T : Submodule R M} {x : M}, x ∈ S → x ∈ S ⊔ T :=
  by sorry

This theorem states that for any semiring `R`, any `AddCommMonoid` `M`, and any `Module` `R M`, if `x` is an element of the submodule `S`, then `x` is also an element of the sup (supremum or least upper bound) of the submodules `S` and `T`. This implies that any element in a particular submodule is also found within the sup of that submodule and another.

For any semiring `R`, `AddCommMonoid` `M`, and `Module` `R M`, if `x` is an element of `S` and `S`, `T` are submodules of `M`, then `x` lies in the supremum of `S` and `T`.


theorem biSup_finsetSigma :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset ι)
      (t : (i : ι) → Finset (α i)) (f : Sigma α → β),
      ⨆ ij ∈ Finset.sigma s t, f ij = ⨆ i ∈ s, ⨆ j ∈ t i, f { fst := i, snd := j } :=
  by sorry

The theorem `biSup_finsetSigma` states that, for any types `ι`, function `α` from `ι` to any type, and type `β` which is a complete lattice, given a finite set `s` of type `ι`, a function `t` from `ι` to a finite set of `α i`, and a function `f` from the sigma type of `α` to `β`, the supremum of `f` over the dependent pairs `⟨i, a⟩` in the sigma finite set of `s` and `t` is equal to the double supremum first over `i` in `s` and then over `j` in `t i` of `f` applied to the pair `⟨i, j⟩`. In other words, this theorem states the equality between a single supremum over a joint set and a sequential pair of suprema over the individual sets.

For any complete lattice β, finite set s of type ι, function t from ι to finite sets of α, and function f from the sigma type of α over s and t to β, the supremum of f over the dependent pairs ⟨i, a⟩ in the sigma finite set of s and t is equal to the double supremum of f first over i in s and then over j in ti.


theorem MeasureTheory.AECover.integrable_of_lintegral_nnnorm_bounded :
    ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      {l : Filter ι} [inst_1 : NormedAddCommGroup E] [inst_2 : Filter.NeBot l] [inst_3 : Filter.IsCountablyGenerated l]
      {φ : ι → Set α},
      MeasureTheory.AECover μ l φ →
        ∀ {f : α → E} (I : ℝ),
          MeasureTheory.AEStronglyMeasurable f μ →
            (∀ᶠ (i : ι) in l, ∫⁻ (x : α) in φ i, ↑‖f x‖₊ ∂μ ≤ ENNReal.ofReal I) → MeasureTheory.Integrable f μ :=
  by sorry

This theorem states that for any types `α`, `ι`, and `E`, given a measurable space `α`, a measure `μ` on `α`, a filter `l` on `ι` that is neither bottom nor empty and is countably generated, and a sequence of sets `φ` indexed by `ι` that forms an almost everywhere cover for `μ` and `l`, for any function `f` from `α` to `E`, if `f` is almost everywhere strongly measurable with respect to `μ`, and the nonnegative extended real number integral over each set `φ i` of the nonnegative part of the norm of `f` is almost everywhere less than or equal to some real number `I`, then `f` is integrable with respect to `μ`. That is, `f` is both almost everywhere strongly measurable and has finite integral.

If `α` is a measurable space, `μ` is a measure on `α`, `l` is a countably generated, non-empty filter on `ι`, `φ` is an almost everywhere cover for `μ` and `l`, `f` is a strongly measurable function from `α` to a normed vector space `E`, and the nonnegative part of the norm of `f` is almost everywhere integrable over each `φ i` with respect to `μ` and sums up to a finite value `I`, then `f` is integrable with respect to `μ`.


theorem MeasureTheory.ae_restrict_mem₀ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → ∀ᵐ (x : α) ∂μ.restrict s, x ∈ s :=
  by sorry

The theorem `MeasureTheory.ae_restrict_mem₀` states that for any type `α`, given a measurable space `m0` over `α`, a measure `μ` on this space, and a set `s` of type `α` that is a null measurable set with respect to measure `μ`, almost every element `x` from `α` with respect to the restriction of measure `μ` to set `s` is an element of `s`. In simpler terms, the theorem is saying that under these conditions, the set `s` almost entirely consists of elements that are in `s` when we consider the measure restricted to `s`.

Given a measurable space `(α, ℳ, μ)`, if `μ(s) = 0` for a set `s ∈ ℳ`, then almost every element `x ∈ α` belongs to `s` with respect to the restriction `μ|s` of `μ` to `s`.


theorem Inducing.continuousWithinAt_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {f : α → β} {g : β → γ},
      Inducing g → ∀ {s : Set α} {x : α}, ContinuousWithinAt f s x ↔ ContinuousWithinAt (g ∘ f) s x :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ` equipped with topological structures (topological spaces), and for any functions `f` from `α` to `β` and `g` from `β` to `γ`, if `g` is an inducing function, then the continuity of `f` within a set `s` at a point `x` is equivalent to the continuity of the composite function `(g ∘ f)` within the same set `s` at the same point `x`. In more mathematical terms, if `g : β → γ` is a function that induces the topology on `β` from `γ`, then a function `f : α → β` is continuous at a point `x` relative to a subset `s` of `α` if and only if the function `g ∘ f : α → γ` is also continuous at `x` relative to `s`.

If `g : β → γ` is a topology-inducing function and `s ⊆ α`, then for any `x ∈ s` and continuous functions `f : α → β` and `g ∘ f : α → γ`, the continuity of `f` at `x` if and only if `g ∘ f` is continuous at `x`.


theorem Asymptotics.IsLittleO.const_mul_left :
    ∀ {α : Type u_1} {F : Type u_4} {R : Type u_13} [inst : Norm F] [inst_1 : SeminormedRing R] {g : α → F}
      {l : Filter α} {f : α → R}, f =o[l] g → ∀ (c : R), (fun x => c * f x) =o[l] g :=
  by sorry

This theorem states that for any types `α`, `F`, and `R`, with `F` being a normed type and `R` a semi-normed ring, and for any functions `f : α → R` and `g : α → F` that are asymptotically equivalent at a filter `l`, the asymptotic equivalence remains when `f` is multiplied by a constant `c` from `R`. In simpler words, if `f` and `g` grow at the same rate, then scaling `f` by a constant does not change its growth rate relative to `g`.

If `f : α → R`, `g : α → F`, `α` is any type, `F` is a normed type, `R` is a semi-normed ring, `l` is a filter, and `f` and `g` are asymptotically equivalent at `l`, then `cf` and `g` are asymptotically equivalent at `l` for any constant `c` from `R`.


theorem LieModuleHom.map_top :
    ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
      [inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup N]
      [inst_6 : Module R N] [inst_7 : LieRingModule L N] (f : M →ₗ⁅R,L⁆ N),
      LieSubmodule.map f ⊤ = LieModuleHom.range f :=
  by sorry

This theorem states that for any commutative ring `R`, Lie ring `L`, additive commutative groups `M` and `N`, and modules `M` and `N` over `R` that are also Lie ring modules over `L`, if `f` is a Lie module homomorphism from `M` to `N`, then the image of the entire Lie submodule of `M` under `f` is equal to the range of `f`. That is, applying `f` to every element of `M` will yield every possible output of `f`.

For any commutative ring `R`, Lie ring `L`, additive commutative groups `M` and `N` that are Lie ring modules over `L`, and a Lie module homomorphism `f` from `M` to `N` over `R`, the image of every Lie submodule of `M` under `f` equals the range of `f`.


theorem CategoryTheory.Functorial.map_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [inst_2 : CategoryTheory.Functorial F] {X Y Z : C}
      {f : X ⟶ Y} {g : Y ⟶ Z},
      CategoryTheory.map F (CategoryTheory.CategoryStruct.comp f g) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.map F f) (CategoryTheory.map F g) :=
  by sorry

This theorem, `CategoryTheory.Functorial.map_comp`, states that for any categories `C` and `D`, and for any function `F` from `C` to `D` that is functorial, and for any three objects `X`, `Y`, `Z` of `C`, and any two morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the functorial action of `F` on the composition of `f` and `g` (denoted `CategoryTheory.CategoryStruct.comp f g`) is equivalent to the composition of the functorial action of `F` on `f` and the functorial action of `F` on `g`.

In simpler terms, this theorem is asserting that mapping the composition of two morphisms under a functor is the same as first mapping the individual morphisms and then composing them - a property that is known as functor preservation of composition or simply functor composition law in category theory.

In mathematical notation, it could be expressed as `F(f ∘ g) = F(f) ∘ F(g)`, where `∘` denotes composition of morphisms and `F` is a functor.

For any functor F between categories C and D, F(f ∘ g) = F(f) ∘ F(g) for all objects X, Y, Z in C and morphisms f : X → Y and g : Y → Z.


theorem Heyting.Regular.coe_injective :
    ∀ {α : Type u_1} [inst : HeytingAlgebra α], Function.Injective Heyting.Regular.val := by sorry

This theorem states that for any type `α` which has a Heyting Algebra structure, the function `Heyting.Regular.val` that maps each `Regular α` to `α` is injective. In other words, if we have two different elements of the set `Regular α`, their images in `α` under `Heyting.Regular.val` will also be different. This injectivity property ensures that no information is lost when we apply the `Heyting.Regular.val` function, thus it uniquely identifies each `Regular α` element by its corresponding `α` element.

For any Heyting Algebra `α`, the function `Heyting.Regular.val` mapping `Regular α` to `α` is an injection.


theorem Num.ofNat'_succ : ∀ {n : ℕ}, Num.ofNat' (n + 1) = Num.ofNat' n + 1 := by sorry

The theorem `Num.ofNat'_succ` states that for any natural number `n`, the function `Num.ofNat'` applied to the successor of `n` (i.e., `n + 1`) is equal to the function `Num.ofNat'` applied to `n` incremented by one. Essentially, the theorem is stating the property that the function `Num.ofNat'` preserves the successor operation on natural numbers.

For all natural numbers `n`, `Num.ofNat' (succ n) = Num.ofNat' n + 1`.


theorem Filter.Eventually.exists_mem :
    ∀ {α : Type u} {p : α → Prop} {f : Filter α}, (∀ᶠ (x : α) in f, p x) → ∃ v ∈ f, ∀ y ∈ v, p y := by sorry

This theorem states that for any type `α`, any property `p` on elements of `α`, and any filter `f` on `α`, if it's eventually the case in filter `f` that property `p` holds for `α`, then there exists a subset `v` in filter `f` such that property `p` holds for all elements in `v`. In other words, if a property is eventually true in a filter, you can find a set within that filter where the property is always true.

If `p` is a property of type `α`, and `f` is a filter on `α` such that for all `x ∈ α`, there exists a finite sequence `(x₁, ..., xₖ)` in `f` with `xₖ ∈ f` and `p(xₖ)` holds, then there exists a subset `v ∈ f` such that for all `x ∈ v`, `p(x)` holds.


theorem Relation.reflTransGen_eq_self :
    ∀ {α : Type u_1} {r : α → α → Prop}, Reflexive r → Transitive r → Relation.ReflTransGen r = r := by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, if `r` is both reflexive (i.e., every element in `α` is related to itself under `r`) and transitive (i.e., if `x` is related to `y` and `y` is related to `z`, then `x` is also related to `z` under `r`), then the reflexive and transitive closure of `r` is equal to `r` itself. In other words, if a relation is already reflexive and transitive, applying the reflexive-transitive closure operation to it doesn't change the relation.

If a binary relation on a type is both reflexive and transitive, then its reflexive-transitive closure is equal to the relation itself.


theorem associated_mul_isUnit_left_iff :
    ∀ {β : Type u_5} [inst : Monoid β] {a u b : β}, IsUnit u → (Associated (a * u) b ↔ Associated a b) := by sorry

This theorem states that for any type `β` that has a monoid structure, and for any elements `a`, `u`, and `b` of that type, if `u` is a unit (meaning it has a two-sided inverse in the monoid), then the statement "the element `a * u` is associated with b" is equivalent to the statement "the element `a` is associated with b". In other words, multiplication by a unit on the left does not change whether two elements are associated. In mathematical terms, two elements `x` and `y` of a monoid are said to be associated if there exists a unit `u` such that `x * u = y`.

For any monoid `β` with unit `u`, if `a * u = b`, then `a` and `b` are associated. Conversely, if `a` and `b` are associated, then there exists a unit `u` such that `a * u = b`.


theorem GaloisInsertion.isLUB_of_u_image :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β],
      GaloisInsertion l u → ∀ {s : Set β} {a : α}, IsLUB (u '' s) a → IsLUB s (l a) :=
  by sorry

The theorem `GaloisInsertion.isLUB_of_u_image` states that for any types `α` and `β`, given a function `l` from `α` to `β`, a function `u` from `β` to `α`, a set `s` of type `β`, and an element `a` of type `α`, if there exists a Galois insertion between these functions `l` and `u` (indicating a certain relationship between them regarding closure operations), and `a` is a least upper bound (LUB) of the image of set `s` under function `u`, then the image of `a` under function `l` is a least upper bound of the original set `s`. This theorem is in the context of partial orderings, which are given by the `Preorder` type classes on `α` and `β`.

If there is a Galois connection between functions `l: α → β` and `u: β → α` and `a ∈ α` is the least upper bound of set `s ⊆ β` under `u`, then `l(a)` is the least upper bound of set `s` under `l`.


theorem AddOpposite.uniformContinuous_unop :
    ∀ {α : Type ua} [inst : UniformSpace α], UniformContinuous AddOpposite.unop := by sorry

This theorem states that for any type `α` that has a uniform space structure, the unop function from the additive opposite of `α` to `α` is uniformly continuous. In mathematical terms, this means irrespective of where two elements are situated in the additive opposite space, if they are sufficiently close to each other, then their images under the unop function are also close in `α`. Therefore, the unop function preserves the closeness of elements when mapping from the additive opposite space to the original space, which is the characteristic property of uniformly continuous functions.

The unop function from the additive opposite of a uniform space `α` is uniformly continuous.


theorem locallyConnectedSpace_iff_open_connected_subsets :
    ∀ {α : Type u} [inst : TopologicalSpace α],
      LocallyConnectedSpace α ↔ ∀ (x : α), ∀ U ∈ nhds x, ∃ V ⊆ U, IsOpen V ∧ x ∈ V ∧ IsConnected V :=
  by sorry

This theorem states that for any type `α` with a topological space structure, `α` is a locally connected space if and only if for every point `x` in `α`, and every neighborhood `U` of `x`, there exists a subset `V` of `U` which is not only open and contains `x`, but is also connected. In mathematical terms, a space is locally connected at a point `x` if all neighbourhoods of `x` contain an open connected subset containing `x`. This property should hold for all points in the space for it to be considered a locally connected space.

A topological space `α` is locally connected if for every point `x` in `α`, there exists an open and connected neighborhood `V` of `x`.


theorem Ideal.map_eq_top_or_isMaximal_of_surjective :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Ring S] [inst_2 : FunLike F R S]
      [inst_3 : RingHomClass F R S] (f : F),
      Function.Surjective ⇑f →
        ∀ {I : Ideal R}, Ideal.IsMaximal I → Ideal.map f I = ⊤ ∨ Ideal.IsMaximal (Ideal.map f I) :=
  by sorry

The theorem `Ideal.map_eq_top_or_isMaximal_of_surjective` states that for all types `R`, `S`, `F`, where `R` and `S` are rings, and `F` is a function-like object from `R` to `S` that is also a ring homomorphism, given a function `f` of type `F` that is surjective, and for any `I` which is a maximal ideal in `R`, the image of `I` under `f` (the mapped ideal) is either the whole ring `S` (denoted by `⊤`) or itself a maximal ideal in `S`. This theorem connects the properties of surjectivity and maximal ideals through the process of ideal mapping in the context of ring homomorphisms.

Given a surjective ring homomorphism `F` from ring `R` to ring `S`, for every maximal ideal `I` in `R`, the image `F(I)` is either `S` or a maximal ideal in `S`.


theorem Set.vadd_set_univ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {a : α}, a +ᵥ Set.univ = Set.univ := by
  sorry

This theorem states that for any type `α` which has an `AddGroup` instance, any type `β` which has an `AddAction` instance of `α` on `β`, and any element `a` of type `α`, the operation of vector addition of `a` with the universal set on `β` (denoted by `a +ᵥ Set.univ`) yields the universal set on `β` itself. This means that adding any element of the `AddGroup` to all elements in the universal set does not change the set, which corresponds to the idea that adding a group element to every point in a space (acting on the space) does not change the overall space.

For any `AddGroup` type `α`, any `AddAction` instance of `α` on type `β`, and any `α` element `a`, `a +ᵥ Set.univ = Set.univ` in type `β`.


theorem QuaternionGroup.a_one_pow : ∀ {n : ℕ} (k : ℕ), QuaternionGroup.a 1 ^ k = QuaternionGroup.a ↑k := by sorry

This theorem states that for any natural number `n` and `k`, the quaternion group element `a` raised to the power of `k` when its input parameter is `1`, is actually the same as the quaternion group element `a` when its input parameter is the natural number `k`. The `QuaternionGroup.a 1 ^ k` expression represents the quaternion group operation repeated `k` times on the element `a` with input `1`, and the theorem asserts this is equal to the quaternion group element `a` with input `k`.

For any quaternion group element `a` and natural number `k`, `QuaternionGroup.a ^ k = QuaternionGroup.a 1 ^ k`.


List.Duplicate.mem

theorem List.Duplicate.mem : ∀ {α : Type u_1} {l : List α} {x : α}, List.Duplicate x l → x ∈ l := by sorry

This theorem states that for any type 'α', any list 'l' of that type, and any element 'x' of that type, if 'x' is a duplicate in 'l' then 'x' is indeed an element of 'l'. In other words, if an element is duplicated in a list, it, therefore, must be a member of that list.

For any type 'α' and list 'l' of length greater than 0 in 'α', if 'l' contains a duplicate element 'x', then 'x' is a member of 'l'.


theorem Set.addCentralizer_eq_top_iff_subset :
    ∀ {M : Type u_1} {s : Set M} [inst : AddSemigroup M], Set.addCentralizer s = Set.univ ↔ s ⊆ Set.addCenter M := by
  sorry

This theorem states that for any type `M`, which is an additive semigroup, and any subset `s` of `M`, the centralizer of `s` is equal to the universal set if and only if `s` is a subset of the center of `M`. Here, the centralizer of a set in an additive magma is the set of all elements that commute with every element of the original set, i.e., for any element `c` in the centralizer and `m` in the set, `m + c = c + m`. The center of an additive magma is the set of all elements that commute with every other element in the magma. The universal set is the set of all elements in a given type.

For an additive semigroup M and subset s, the centralizer of s equals the universal set if and only if s is contained in the center of M.


theorem EReal.sign_mul_abs : ∀ (x : EReal), ↑(SignType.sign x) * ↑(EReal.abs x) = x := by sorry

This theorem states that for any extended real number `x` (which can range from negative infinity to positive infinity), the product of the sign of `x` and the absolute value of `x` is equal to `x` itself. Here, the sign of a number is defined as `1` if it's positive, `-1` if it's negative, and `0` if it's exactly `0`. The absolute value function maps `-∞` and `+∞` to `+∞`, and any real number to its absolute value. This theorem is analogous to the property of regular real numbers where a number is equal to the product of its sign and its absolute value.

For any extended real number x, x = abs x * sign x.


theorem Real.toNNReal_add : ∀ {r p : ℝ}, 0 ≤ r → 0 ≤ p → Real.toNNReal (r + p) = Real.toNNReal r + Real.toNNReal p := by
  sorry

The theorem `Real.toNNReal_add` states that for all real numbers `r` and `p`, if `r` and `p` are both non-negative, then the function `Real.toNNReal` applied to the sum of `r` and `p` is equal to the sum of `Real.toNNReal r` and `Real.toNNReal p`. In other words, we can either sum two non-negative real numbers first and then apply `Real.toNNReal`, or apply `Real.toNNReal` first and then sum the results, and both will give us the same output.

For all non-negative real numbers `r` and `p`, `Real.toNNReal (r + p) = Real.toNNReal r + Real.toNNReal p`.


theorem Mathlib.Order.Cover._auxLemma.2 : ∀ (p : Prop), (True ∧ p) = p := by sorry

This theorem, named `Mathlib.Order.Cover._auxLemma.2`, states that given any proposition `p`, the logical conjunction of `True` and `p` is equivalent to `p`. In other words, logically, `True` and something is always that something.

The theorem `Mathlib.Order.Cover._auxLemma.2` in Lean 4 asserts that `True` and a proposition `p` are logically equivalent (i.e., `True ∧ p` is equivalent to `p`).


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

This theorem states that for any types `α` which is a linear order and a topological space with order-closed topology, and any three elements `a`, `b` and `c` of `α`, if `a` is less than or equal to `b`, then the left-open right-infinite interval from `a` (`Set.Ioi a`) is a neighborhood within the filter of neighborhoods of the left-open right-closed interval from `b` to `c` (`Set.Ioc b c`). In other words, the open interval greater than `a` is in the neighborhood of the set of points that are strictly greater than `b` and less than or equal to `c` in this topological space.

For any linear order and topological space `α` with order-closed topology, if `a ≤ b` in `α`, then `Set.Ioi a ⊆ Set.Ioc b c` in the filter of neighborhoods of `α`.


theorem MeasureTheory.measure_smul :
    ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
      [inst_2 : MeasurableSpace G] [inst_3 : MeasurableSMul G α] (c : G) (μ : MeasureTheory.Measure α)
      [inst_4 : MeasureTheory.SMulInvariantMeasure G α μ] (s : Set α), ↑↑μ (c • s) = ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.measure_smul` states that for any group `G` of type `u`, any type `w` `α`, any measurable space `α` denoted by `m`, given `G` has a group structure and `α` has a `G`-action, and a measurable space structure and the scalar multiplication is measurable, for any element `c` in `G`, any measure `μ` on `α`, and any set `s` in `α`, with the measure `μ` being `G`-smul invariant, the measure of the scalar multiple of the set `s` by `c` is equal to the measure of the set `s`. In mathematical terms, if a group action scales the measure of sets invariantly, then the measure of a set remains unchanged when it is scaled by any element of the group.

For any measurable space `(α, m)` with a `G`-action preserving the measure `μ`, the measure of a `G`-invariant set `s` is equal to the measure of its scalar multiplication `cs` by any element `c` in `G`.


theorem Subalgebra.mem_toSubring :
    ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Subalgebra R A}
      {x : A}, x ∈ Subalgebra.toSubring S ↔ x ∈ S :=
  by sorry

This theorem states that for any given types `R` and `A`, where `R` is a commutative ring, `A` is a ring, and `A` is an algebra over `R`, and given a subalgebra `S` of `A` over `R` and an element `x` of `A`, `x` is an element of the subring of `A` obtained from the subalgebra `S` if and only if `x` is an element of the subalgebra `S`. In other words, an element belongs to the subring corresponding to a subalgebra if and only if it belongs to the original subalgebra.

For any commutative ring R, rings A over R, and subalgebras S of A over R, an element x of A belongs to the subring generated by S if and only if it belongs to S.


theorem irreducible_mul_isUnit :
    ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, IsUnit a → (Irreducible (b * a) ↔ Irreducible b) := by sorry

The theorem `irreducible_mul_isUnit` states that for any type `α` that is a monoid (denoted as `Monoid α`), and for any two elements `a` and `b` of this monoid (denoted as `a, b : α`), if `a` is a unit in this monoid (which means `a` has a two-sided inverse, denoted as `IsUnit a`), then `b * a` is irreducible if and only if `b` is irreducible. In mathematical terms, an element `b` in a monoid is called irreducible if and only if it cannot be expressed as a product of two non-unit elements.

For any monoid `α` and elements `a` and `b` in `α` with `IsUnit a`, `b` is irreducible if and only if `b * a` is irreducible.


theorem Mathlib.Order.Cover._auxLemma.5 : ∀ {a : Prop}, (¬¬a) = a := by sorry

This theorem, `Mathlib.Order.Cover._auxLemma.5`, states that for all propositions `a`, the double negation of `a` is equivalent to `a`. In the language of logic, this theorem asserts that stating "it is not the case that `a` is not true" is the same as stating "`a` is true".

The theorem asserts that the double negation of a proposition is equivalent to the proposition itself.


theorem Mathlib.Order.Cover._auxLemma.3 : ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x := by sorry

This theorem, from the `Mathlib.Order.Cover` namespace and named `_auxLemma.3`, states that for any type `α` and property `p` that each `α` might have, the statement "not all `x` in `α` have the property `p`" is logically equivalent to "there exists an `x` in `α` that does not have the property `p`". In mathematical notation, this is saying that "¬∀x, p(x)" is equivalent to "∃x, ¬p(x)".

The theorem in Lean 4's `Mathlib.Order.Cover` namespace, named `_auxLemma.3`, asserts the logical equivalence of "not all elements in type `α` have property `p`" and "there exists an element in `α` that lacks property `p`". Mathematically, "∀x ≠ some x', ¬p(x)" is equivalent to "∃x, ¬p(x)".


theorem Mathlib.Order.Cover._auxLemma.4 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem in Lean's `Mathlib.Order.Cover._auxLemma.4` states that for any pair of propositions `a` and `b`, the existence of a proof for `a` implying `b` is equivalent to the conjunction of `a` and `b`. In more mathematical terms, it says that `∃ (_ : a), b` is equivalent to `a ∧ b`.

The theorem in Lean's `Mathlib.Order.Cover._auxLemma.4` asserts that for all propositions `a` and `b`, the existence of a proof of `a` implies `b` is equivalent to `a` and `b` holding simultaneously.


theorem Filter.tendsto_atTop_atBot :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Nonempty α] [inst : SemilatticeSup α] [inst_1 : Preorder β] {f : α → β},
      Filter.Tendsto f Filter.atTop Filter.atBot ↔ ∀ (b : β), ∃ i, ∀ (a : α), i ≤ a → f a ≤ b :=
  by sorry

The theorem `Filter.tendsto_atTop_atBot` states that for any function `f` from a nonempty type `α` equipped with a semilattice and preorder structure to a type `β` with a preorder structure, `f` tends to negative infinity (represented by `Filter.atBot`) as `α` tends to positive infinity (represented by `Filter.atTop`) if and only if for every element `b` of `β`, there exists an element `i` in `α` such that for all elements `a` of `α` greater than or equal to `i`, the value of `f` at `a` is less than or equal to `b`. This essentially captures the idea that as we go to higher and higher elements in `α`, the function `f` goes to lower and lower elements in `β`.

For a function between two semilattices with preorders, it tends to negative infinity as the domain tends to positive infinity if and only if for every element in the target, there exists a domain element such that the function value is less than or equal to that target element for all greater domain elements.


theorem Inducing.mapClusterPt_iff :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Inducing f → ∀ {x : X} {l : Filter X}, MapClusterPt (f x) l f ↔ ClusterPt x l :=
  by sorry

The theorem `Inducing.mapClusterPt_iff` states that for any two topological spaces `X` and `Y`, and a function `f` from `X` to `Y` that induces the topology on `Y` from `X`, a point `x` in `X` is a cluster point of a filter `l` if and only if the image of `x` under `f` is a cluster point of the filter `l` mapped through `f`. This theorem provides a way to check if a point is a cluster point using its image under an inducing function.

For any function `f` inducing the topology on `Y` from `X`, a point `x` in `X` is a cluster point of a filter `l` if and only if the image of `x` under `f` is a cluster point of the filtered set `f""l` in `Y`.


FixedPoints.minpoly.monic

theorem FixedPoints.minpoly.monic :
    ∀ (G : Type u) [inst : Group G] (F : Type v) [inst_1 : Field F] [inst_2 : MulSemiringAction G F]
      [inst_3 : Fintype G] (x : F), Polynomial.Monic (FixedPoints.minpoly G F x) :=
  by sorry

The theorem `FixedPoints.minpoly.monic` states that for any group `G` and field `F` with a multiplicative semiring action of `G` on `F`, and any element `x` of `F`, the minimal polynomial of `x` over the subfield of fixed points of `G` in `F` is monic. In other words, the leading coefficient of the minimal polynomial is 1. This theorem holds for any finite group `G`.

The minimal polynomial of an element in a field with respect to the action of a finite group's subfield of fixed points is always monic.


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

The theorem `MvPolynomial.aevalTower_C` states that for any types `R`, `σ`, `S`, and `A` with `R`, `S`, and `A` being commutative semirings and `S` being an algebra over `R` and `A`, and given an algebra homomorphism `g` from `R` to `A` over `S`, a function `y` from `σ` to `A`, and an element `x` of `R`, the result of applying the `MvPolynomial.aevalTower` function to `g` and `y` and then applying the result to the constant polynomial `MvPolynomial.C x` is equal to `g x`. This theorem essentially links the algebra homomorphism `g` and the function `MvPolynomial.aevalTower`, when evaluated at a constant polynomial, resulting in the same value as directly applying `g` to `x`.

For any commutative semirings R, S, and A, an algebra S over R and A, an algebra homomorphism g from R to A over S, a function y from σ to A, and an element x of R, the application of `MvPolynomial.aevalTower` to g, y, and `MvPolynomial.C x` equals g(x).


theorem Filter.isCountablyGenerated_of_seq :
    ∀ {α : Type u_1} {f : Filter α}, (∃ x, f = ⨅ i, Filter.principal (x i)) → Filter.IsCountablyGenerated f := by sorry

The theorem `Filter.isCountablyGenerated_of_seq` states that for any type `α` and any filter `f` on this type, if there exists a sequence `x` such that the filter `f` is the infimum over all filters generated by the principal filter of the sequence `x`, then `f` is countably generated. In simpler terms, if a filter is the intersection of countably many filters, each generated by a set, then it's a countably generated filter.

If a filter on a type is the intersection of countably many principal filters, then it is countably generated.


theorem Mathlib.Topology.EMetricSpace.Basic._auxLemma.15 : ∀ (p : Prop), (True ∧ p) = p := by sorry

This theorem, from the Mathlib.Topology.EMetricSpace.Basic, states that for any proposition 'p', the logical conjunction of 'True' and 'p' is equivalent to 'p' itself. In other words, 'p' and 'True' logically 'and'ed together will result in 'p', reflecting the logical identity that 'True' is the identity element for logical conjunction.

The theorem asserts that for all propositions p, p and True are logically equivalent.


theorem Mathlib.Topology.EMetricSpace.Basic._auxLemma.14 :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal},
      (y ∈ EMetric.closedBall x ε) = (edist y x ≤ ε) :=
  by sorry

The theorem `Mathlib.Topology.EMetricSpace.Basic._auxLemma.14` states that for any pseudo-emetric space `α`, and any elements `x` and `y` of `α`, and for any extended nonnegative real number `ε`, `y` is in the closed ε-ball centered at `x` (denoted by `EMetric.closedBall x ε`) if and only if the extended distance (`edist`) from `y` to `x` is less than or equal to `ε`. In simple terms, it verifies that the definition of a closed ball in a pseudo-emetric space `α` correctly encapsulates all points `y` whose distance to a given point `x` is at most `ε`.

For any pseudo-metric space `α`, and any `x`, `y` in `α` and `ε` in the extended nonnegative reals, `y` belongs to the closed ε-ball centered at `x` if and only if the extended distance from `x` to `y` is less than or equal to `ε`.


theorem div_eq_div_iff :
    ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] {a b c d : G₀}, b ≠ 0 → d ≠ 0 → (a / b = c / d ↔ a * d = c * b) :=
  by sorry

This theorem states that for any commutative group with zero (a mathematical structure that has an operation combining elements in a certain way), given non-zero elements `b` and `d`, the equality of the fraction `a / b` and `c / d` is equivalent to the equality of the product `a * d` and `c * b`. In other words, cross multiplying holds in a commutative group with zero.

In a commutative group with zero, the equality of `a / b` and `c / d` implies the equality of `a * d` and `b * c`.


theorem PartialHomeomorph.map_nhdsWithin_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : X},
      x ∈ e.source → ∀ (s : Set X), Filter.map (↑e) (nhdsWithin x s) = nhdsWithin (↑e x) (↑e '' (e.source ∩ s)) :=
  by sorry

This theorem states that for any given partial homeomorphism `e` from a type `X` to a type `Y`, both endowed with a topological structure, and for any point `x` from `X` that belongs to the source of `e`, the image under `e` of the "neighborhood within" filter around `x` in any set `s` is equal to the "neighborhood within" filter around the image of `x` under `e` in the image under `e` of the intersection of `s` and the source of `e`.

In other words, the forward map of a filter behaves well under partial homeomorphisms when it comes to "neighborhood within" filters. This means that the topological properties of the neighborhoods of `x` in `X` are preserved when we move to `Y` using the partial homeomorphism `e`.

For any partial homeomorphism between topological spaces and any point in the domain, the forward image of the neighborhood filter of that point is equal to the neighborhood filter of its image under the partial homeomorphism in the image space.


theorem Mathlib.Topology.Order.ScottTopology._auxLemma.3 :
    ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], Disjoint x yᶜ = (x ≤ y) := by sorry

This theorem states that for any type `α` equipped with a Boolean algebra structure, and for any elements `x` and `y` of this type, `x` and the complement of `y` are disjoint if and only if `x` is less than or equal to `y`. Here, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element of the lattice. This is a generalization of the concept of disjoint sets in the subset lattice. Note that the complement of `y` is denoted by `yᶜ` and the bottom element of the lattice is denoted by `⊥`.

For any type `α` with a Boolean algebra structure, elements `x` and `y` are disjoint (have infimum equal to the bottom element) if and only if `x ≤ y`.


theorem Mathlib.Topology.Order.ScottTopology._auxLemma.1 :
    ∀ {α : Type u} {s t : Set α}, Set.Nonempty (s ∩ t) = ¬Disjoint s t := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, the property that the intersection of `s` and `t` is nonempty is equivalent to the negation of the property that `s` and `t` are disjoint. In other words, the intersection of `s` and `t` contains at least one element if and only if `s` and `t` are not disjoint. This generalizes the idea of disjoint sets in set theory, where two sets are considered disjoint if their intersection is empty.

For any type `α` and sets `s` and `t` of type `α`, `s` and `t` have a non-empty intersection if and only if they are not disjoint.


theorem Mathlib.Topology.Order.ScottTopology._auxLemma.2 : ∀ {a b : Prop}, (¬a → ¬b) = (b → a) := by sorry

This theorem states that for any two propositions `a` and `b`, the statement "not `a` implies not `b`" is equivalent to "if `b` then `a`". This is a fundamental theorem in logic, reflecting the principle of contraposition, which says that if a statement "if `p` then `q`" is true, then the statement "if not `q` then not `p`" is also true.

The negation of proposition `a` implies the negation of proposition `b` is equivalent to `b` implying `a`.


theorem hasStrictFDerivAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (x : E), HasStrictFDerivAt id (ContinuousLinearMap.id 𝕜 E) x :=
  by sorry

This theorem states that, for any nontrivially normed field `𝕜` and normed additive commutative group `E` that is a normed space over `𝕜`, the identity function has a strict Fréchet derivative at any point `x` in `E`. The derivative is given by the identity map itself as a continuous linear map. In other words, the rate of change of the identity function at any point is constant and equal to the identity map.

The identity function on a normed space over a nontrivially normed field has the identity map as its strict Fréchet derivative at every point.


theorem CategoryTheory.Limits.prod.lift_fst_comp_snd_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct W Y] [inst_2 : CategoryTheory.Limits.HasBinaryProduct X Z]
      (g : W ⟶ X) (g' : Y ⟶ Z),
      CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst g)
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd g') =
        CategoryTheory.Limits.prod.map g g' :=
  by sorry

This theorem states that in any category `C` with binary products, for any four objects `W`, `X`, `Y`, and `Z`, and any two morphisms `g : W ⟶ X` and `g' : Y ⟶ Z`, the composition of `g` with the projection to the first component and `g'` with the projection to the second component, when applied to the limit of the pair `(W, Y)`, is the same as the morphism induced by `g` and `g'` on the product of `W` and `Y`. This is essentially an application of the universal property of a product in category theory.

In any category with binary products, the morphism from the product of two objects to the product of their images under two morphisms is equal to the composition of the morphisms with the projections to the first and second components.


theorem Mathlib.Probability.Process.Stopping._auxLemma.5 :
    ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) := by sorry

This theorem, referred to as `Mathlib.Probability.Process.Stopping._auxLemma.5`, states that for every type `α` and sets `s` and `t` of type `α`, an element `x` of type `α` is in the set difference `s \ t` if and only if `x` is in set `s` and `x` is not in set `t`. In simpler terms, it formalizes the basic set theory property where an element is in the difference of two sets if it belongs to the first set and does not belong to the second.

For any type `α` and sets `s` and `t` of type `α`, an element `x` lies in the set difference `s \ t` if and only if it is in `s` but not in `t`.


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

This theorem states that for any type `α` with a preorder and a topological space structure, if the topological space structure is such that its open sets are exactly the upper sets, then this topology is equal to the "upper set topology" on `α`. The upper set topology is defined to be the topology whose open sets are precisely the upper sets in the preorder.

For any type `α` with a preorder, if its topological space structure makes open sets equal to upper sets in the preorder, then this topology is the upper set topology.


/-- Balls defined using the distance or the edistance coincide  -/
theorem Metric.emetric_ball_nnreal :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : NNReal}, EMetric.ball x ↑ε = Metric.ball x ↑ε := by sorry

This theorem states that in any pseudometric space (a generalization of metric spaces), the concept of an "ε-ball" centered at a point 'x', defined using either the extended distance (edistance) or the usual distance, are the same. An ε-ball is a set of all points 'y' whose (e)distance from 'x' is less than ε. Here, ε is a nonnegative real number. The theorem essentially asserts that both definitions of balls coincide in such spaces.

In any pseudometric space, the sets of points with extended distance and usual distance less than ε from a given point form identical ε-balls.


/-- Subsemiring closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`.  -/
theorem Subsemiring.closure_mono :
    ∀ {R : Type u} [inst : NonAssocSemiring R] ⦃s t : Set R⦄, s ⊆ t → Subsemiring.closure s ≤ Subsemiring.closure t :=
  by sorry

The theorem `Subsemiring.closure_mono` states that, for any type `R` that is a non-associative semiring, and for any two sets `s` and `t` of `R`, if `s` is a subset of `t`, then the subsemiring generated by `s` is a subsemiring of (or equal to) the subsemiring generated by `t`. In mathematical terms, if `s ⊆ t`, then the closure of `s` under the subsemiring operation is contained within or equal to the closure of `t` under the same operation. This demonstrates the monotonicity of the subsemiring closure operation with respect to set inclusion.

If `R` is a non-associative semiring and `s` is a subset of `t`, then the subsemiring generated by `s` is contained in or equal to the subsemring generated by `t`.


theorem AddSubmonoid.coe_iInf :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {ι : Sort u_4} {S : ι → AddSubmonoid M}, ↑(⨅ i, S i) = ⋂ i, ↑(S i) := by
  sorry

This theorem states that for any given type `M` with an additive zero structure and for any indexing type `ι`, for a family of additive submonoids `S` indexed by `ι`, the coercion of the greatest lower bound (infimum) of the submonoids `S` is equal to the intersection of the individual coercions of the submonoids `S`. In simpler terms, the elements of the smallest submonoid containing all the submonoids `S` are exactly the elements that belong to every submonoid in the collection `S`.

For any additive type `M` with zero structure and indexing type `ι`, the infimum of a family `S` of its additive submonoids equals the intersection of the submonoids' coercions.


theorem Set.encard_empty : ∀ {α : Type u_1}, Set.encard ∅ = 0 := by sorry

This theorem states that for all types `α`, the cardinality of the empty set is equal to 0. In other words, the number of elements in an empty set, irrespective of the type of the elements that could potentially be in the set, is always zero.

The theorem asserts that the empty set, regardless of its element type, has cardinality 0.


theorem List.Pairwise.iff_of_mem :
    ∀ {α : Type u_1} {R S : α → α → Prop} {l : List α},
      (∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ S a b)) → (List.Pairwise R l ↔ List.Pairwise S l) :=
  by sorry

This theorem states that for any list `l` of elements of some type `α`, and for any two relations `R` and `S` on the elements of `α`, if for all pairs of elements `a` and `b` in `l`, `a` is related to `b` by `R` if and only if `a` is related to `b` by `S`, then the list `l` is a pairwise `R`-list if and only if it is a pairwise `S`-list. Here, a pairwise `R`-list means that every pair of distinct elements in the list satisfies the relation `R`.

If for all distinct elements `a` and `b` in list `l` of type `α`, `a` is related to `b` under relations `R` if and only if they are related under `S`, then `l` is a pairwise `R`-list if and only if it is a pairwise `S`-list.


theorem Filter.mem_atBot_sets :
    ∀ {α : Type u_3} [inst : Nonempty α] [inst : SemilatticeInf α] {s : Set α},
      s ∈ Filter.atBot ↔ ∃ a, ∀ b ≤ a, b ∈ s :=
  by sorry

The theorem `Filter.mem_atBot_sets` states that for any nonempty set `s` of elements of a type `α`, where `α` is equipped with an infimum operation (forming a semilattice), `s` is in the filter `atBot` (representing the limit towards negative infinity in an ordered set) if and only if there exists an element `a` in `α` such that every element `b` less than or equal to `a` is in `s`. In simpler terms, a set is approaching negative infinity if there exists a boundary such that all elements beneath this boundary are within the set.

A nonempty set `s` of an infimum-closed type `α` is in the filter of elements approaching negative infinity if and only if it contains an element `a` such that every element less than or equal to `a` is in `s`.


theorem ArithmeticFunction.ppow_zero :
    ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R},
      ArithmeticFunction.ppow f 0 = ↑ArithmeticFunction.zeta :=
  by sorry

This theorem states that for any semiring `R` and any arithmetic function `f` from natural numbers to `R`, the pointwise power of `f` with an exponent of 0 is equal to the Dirichlet series (also known as the Riemann zeta function). In other words, when an arithmetic function is raised to the power of 0, the resulting function is a function that maps all non-zero natural numbers to 1 and 0 to 0, which is the behavior of the Riemann zeta function.

For any semiring `R` and arithmetic function `f` from natural numbers to `R`, the pointwise power `f^0` is the Dirichlet series of `f` (Riemann zeta function) which maps all non-zero natural numbers to 1 and 0 to 0.


theorem Mathlib.Algebra.Order.Floor._auxLemma.8 :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ},
      0 ≤ a → (⌊a⌋₊ < n) = (a < ↑n) :=
  by sorry

This theorem, from the 'Mathlib.Algebra.Order.Floor' section of Mathlib, states that for any type `α` equipped with the structure of a linearly ordered semiring and a floor semiring, and for any value `a` of type `α` and natural number `n`, the inequality "the floor of `a` is less than `n`" is equivalent to "a is less than the coercion of `n` to type `α`". This is true whenever `a` is non-negative. In simpler terms, if `a` is a non-negative number, then rounding `a` down to the nearest whole number and comparing that to `n` is the same as directly comparing `a` to `n`.

For any linearly ordered semiring `α` with a floor semiring, and for any non-negative `α` value `a` and natural number `n`, `floor a < n` if and only if `a < n`.


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

This theorem, from the Mathlib algebraic order and floor functions library in Lean 4, states that for any type `α` that is a linear ordered semiring and a floor semiring, and for any `α` value `a` and natural number `n`, the inequality `n` is less than the ceiling of `a` is equivalent to the inequality that the real number representation of `n` is less than `a`. The ceiling function `⌈a⌉₊` rounds `a` up to the nearest whole number, while `↑n` denotes the real number representation of `n`.

For any linear ordered semiring and floor semiring type `α` and values `a` of type `α` and `n` of type `nat`, `n < ⌈a⌉` if and only if `↑n < a`.


theorem Cardinal.le_sum : ∀ {ι : Type u_1} (f : ι → Cardinal.{max u_1 u_2}) (i : ι), f i ≤ Cardinal.sum f := by sorry

The theorem `Cardinal.le_sum` states that for any type `ι` and a function `f` mapping each element of `ι` to a cardinal number, the cardinality of any single `i` in `ι` (given by `f i`) is less than or equal to the sum of the cardinalities of all elements in `ι` (given by `Cardinal.sum f`). In other words, the size of any individual component in the disjoint union of sets (represented by the sum of cardinals) is at most the size of the entire disjoint union.

For any type `ι` and function `f` mapping each element of `ι` to a cardinal number, the cardinality of each `i` in `ι` (`f i`) is less than or equal to the sum of the cardinalities of all `i` in `ι` (`Cardinal.sum f`).


theorem Set.prod_range_range_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {m₁ : α → γ} {m₂ : β → δ},
      Set.range m₁ ×ˢ Set.range m₂ = Set.range fun p => (m₁ p.1, m₂ p.2) :=
  by sorry

The theorem `Set.prod_range_range_eq` states that for any types `α`, `β`, `γ`, and `δ` and any functions `m₁` mapping from `α` to `γ` and `m₂` mapping from `β` to `δ`, the cartesian product of the ranges of `m₁` and `m₂` is equal to the range of the function that takes a pair `(p.1, p.2)` and maps it to `(m₁ p.1, m₂ p.2)`. In other words, if you create all possible pairs from the outputs of `m₁` and `m₂`, it's the same as if you first pair up the inputs and then apply `m₁` to the first element and `m₂` to the second.

The ranges of functions `m₁ : α → γ` and `m₂ : β → δ` are equal as sets, that is, `{(m₁ x, m₂ y) | x ∈ α, y ∈ β} = {(a, b) | (x, y) ∈ α × β, a = m₁ x, b = m₂ y}`.


theorem OrderIso.isBoundedUnder_le_comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {l : Filter γ}
      {u : γ → α},
      (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => e (u x)) ↔
        Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u :=
  by sorry

The theorem `OrderIso.isBoundedUnder_le_comp` states that for any three types `α`, `β`, and `γ`, with `α` and `β` equipped with preorders, given an order isomorphism `e` from `α` to `β`, a filter `l` on `γ`, and a function `u` from `γ` to `α`, the image of the filter `l` under the function `x => e (u x)` is eventually bounded with respect to the less than or equal to relation (i.e., there exists some uniform bound from a certain point onwards) if and only if the image of filter `l` under the function `u` is eventually bounded with respect to the less than or equal to relation. In other words, the boundedness of the mapped filter under the composition of `e` and `u` is equivalent to the boundedness of the mapped filter under `u` alone.

Given an order isomorphism between preordered types `α` and `β`, and a filter on a third type `γ`, the image of the filter under the composition of the order isomorphism with a function from `γ` to `α` is eventually bounded if and only if the image of the filter under the function alone is eventually bounded.


theorem List.length_singleton : ∀ {α : Type u_1} (a : α), List.length [a] = 1 := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, the length of the list containing only `a` (`[a]`) is equal to 1. In other words, for any single-element list, its length is always 1, regardless of the type or value of the element contained in the list.

For any type `α` and any `a : α`, the length of the list `[a]` is equal to 1.


theorem Metric.subsingleton_closedBall :
    ∀ {γ : Type w} [inst : MetricSpace γ] (x : γ) {r : ℝ}, r ≤ 0 → Set.Subsingleton (Metric.closedBall x r) := by sorry

The theorem `Metric.subsingleton_closedBall` states that for any type `γ` that has a `MetricSpace` instance, any point `x` of type `γ`, and any real number `r`, if `r` is less than or equal to zero, then the closed ball centered at `x` with radius `r` is a `Subsingleton` set. In other words, a closed ball in a metric space with non-positive radius can contain at most one point.

For any metric space `(γ, d)` and point `x ∈ γ` with non-positive radius `r ∈ ℝ`, the closed ball `{y ∈ γ : d(x, y) ≤ r}` contains at most one element.


theorem Mathlib.Data.Fin.Tuple.Basic._auxLemma.6 :
    ∀ {ι : Type u} {α : ι → Type v} [inst : (i : ι) → LE (α i)] {x y : (i : ι) → α i}, (x ≤ y) = ∀ (i : ι), x i ≤ y i :=
  by sorry

This theorem, `Mathlib.Data.Fin.Tuple.Basic._auxLemma.6`, states that for all types `ι` and a type `α` that is dependent on `ι`, given an instance of a less than or equal to (`LE`) relation for every `ι`-indexed member of `α`, then for any two functions `x` and `y` mapping from `ι` to `α`, the statement "`x` is less than or equal to `y`" is equivalent to saying "for all `i` in `ι`, `x(i)` is less than or equal to `y(i)`". In other words, `x` is considered less than or equal to `y` if `x` is less than or equal to `y` for every element in the index set.

For any type `ι` and a dependent type `α`, if there is a given relation `LE` on every `ι`-indexed member of `α`, then `x ≤ y` in `α^ι` if and only if `x(i) ≤ y(i)` for all `i` in `ι`.


/-- An additive monoid `M` is finitely generated if and only if `R[M]` is of
finite type.  -/
theorem AddMonoidAlgebra.finiteType_iff_fg :
    ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid M] [inst_1 : CommRing R] [inst_2 : Nontrivial R],
      Algebra.FiniteType R (AddMonoidAlgebra R M) ↔ AddMonoid.FG M :=
  by sorry

The theorem `AddMonoidAlgebra.finiteType_iff_fg` states that for any given additive monoid `M` and commutative ring `R` with nontrivial elements, the monoid algebra `R[M]` is of finite type if and only if `M` is finitely generated. In other words, the algebra generated by `M` over `R` has finitely many basis elements if and only if `M` itself can be generated by a finite set.

The monoid algebra of a finitely generated additive monoid over a commutative ring with nontrivial elements is of finite type if and only if the monoid is itself finite.


theorem Subalgebra.copy_eq :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A) (s : Set A) (hs : s = ↑S), Subalgebra.copy S s hs = S :=
  by sorry

This theorem states that for any commutative semiring `R`, any semiring `A`, and any algebra structure on `A` over `R`, for any subalgebra `S` of `A` over `R` and a set `s` of `A`, if `s` is equal to the carrier of `S`, then the subalgebra obtained by copying `S` with carrier `s` is equal to `S` itself. In other words, creating a copy of a subalgebra with a carrier identical to the original does not change the subalgebra.

For any commutative semiring `R`, semiring `A`, algebra structure on `A` over `R`, subalgebra `S` of `A` over `R`, and set `s` equal to the carrier of `S`, the subalgebra of `A` with carrier `s` equal to `S` holds. (i.e., the subalgebra obtained by copying `S` with carrier `s` is equal to `S` itself.)


theorem norm_le_zero_iff''' :
    ∀ {E : Type u_6} [inst : SeminormedGroup E] [inst_1 : T0Space E] {a : E}, ‖a‖ ≤ 0 ↔ a = 1 := by sorry

This theorem states that for any type `E` that forms a semi-normed group with a `T0` topological space, the norm of an element `a` of `E` is less than or equal to zero if and only if `a` is equal to 1. In mathematical terms, this means that for all elements of a semi-normed group in a particular topological space, the norm of an element being less than or equal to zero is equivalent to that element being unity.

In a semi-normed group endowed with a T0 topology, an element has zero norm if and only if it is the identity.


theorem uniformContinuous_comap' :
    ∀ {α : Type ua} {β : Type ub} {γ : Type uc} {f : γ → β} {g : α → γ} [v : UniformSpace β] [u : UniformSpace α],
      UniformContinuous (f ∘ g) → UniformContinuous g :=
  by sorry

The theorem `uniformContinuous_comap'` states that for any three types `α`, `β`, and `γ`, and for any two functions `f : γ → β` and `g : α → γ`, where `α` and `β` are equipped with uniform structures, if the composition of `f` and `g` (denoted as `f ∘ g`) is uniformly continuous, then the function `g` is also uniformly continuous. In other words, if for any pair of points `x` and `y` in `α` which are sufficiently close together, `f(g(x))` and `f(g(y))` are also close together in `β`, then `g(x)` and `g(y)` are also close together. This is a property related to the preservation of the uniform continuity under function composition.

If `f : γ → β` is uniformly continuous and `g : α → γ` is such that `f ∘ g` is uniformly continuous, then `g` is uniformly continuous.


theorem List.sublist_of_cons_sublist_cons :
    ∀ {α : Type u} {l₁ l₂ : List α} {a : α}, List.Sublist (a :: l₁) (a :: l₂) → List.Sublist l₁ l₂ := by sorry

This theorem states that for any type `α` and any lists `l₁` and `l₂` of type `α`, along with any element `a` of type `α`, if `l₁` with `a` prepended is a sublist of `l₂` with `a` prepended, then `l₁` is a sublist of `l₂`. In other words, if prepending the same element does not change the sublist relationship between two lists, then the original lists had the same relationship without the prepended element.

If `l₁` is a sublist of `l₂` implies that `a :: l₁` is a sublist of `a :: l₂`, where `::` denotes list prepending and `α` is any type.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.89 :
    ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] (I : Set η) {H : (i : η) → Subgroup (f i)}
      {p : (i : η) → f i}, (p ∈ Subgroup.pi I H) = ∀ i ∈ I, p i ∈ H i :=
  by sorry

This theorem states that for any given set `I` of indices of type `η`, a family `H` of subgroups each of type `f i`, and a function `p` mapping indices of `I` to elements of the respective `f i`, `p` is a member of the product subgroup `Subgroup.pi I H` if and only if, for each index `i` in `I`, the function `p` evaluated at `i` is a member of the subgroup `H i`. This establishes a condition for membership of an element in the product of a family of subgroups.

A function `p` belongs to the product subgroup of a family `H` of subgroups indexed by `I` if and only if for all `i` in `I`, `p i` is an element of `H i`.


/-- Additive closure of an additive subsemigroup `S` equals `S` -/
theorem AddSubsemigroup.closure_eq :
    ∀ {M : Type u_1} [inst : Add M] (S : AddSubsemigroup M), AddSubsemigroup.closure ↑S = S := by sorry

The theorem `AddSubsemigroup.closure_eq` states that for any type `M` that has an addition structure, and for any additive subsemigroup `S` of `M`, the additive closure of `S` is equal to `S` itself. In other words, the closure operation, when applied to an additive subsemigroup, does not add any new elements to the subsemigroup.

For any additive subsemigroup `S` of a type `M` with addition, the additive closure of `S` equals `S`.


theorem Set.Infinite.encard_eq : ∀ {α : Type u_1} {s : Set α}, Set.Infinite s → Set.encard s = ⊤ := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, if `s` is infinite, then the cardinality of `s` (i.e., the number of elements in `s`), represented by `Set.encard s`, equals `⊤` (which stands for "infinity" in Lean 4). In essence, the theorem formalizes the intuitive concept that the cardinality of an infinite set is infinity.

If a set `s` of type `α` is infinite, then its cardinality equals the greatest cardinal number `⊤`.


theorem Mathlib.Algebra.Homology.QuasiIso._auxLemma.5 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂] (φ : S₁ ⟶ S₂),
      CategoryTheory.ShortComplex.QuasiIso φ = CategoryTheory.IsIso (CategoryTheory.ShortComplex.homologyMap φ) :=
  by sorry

This theorem from the Mathlib Algebra Homology library states that for any category `C`, which has zero morphisms, and any two short complexes `S₁` and `S₂` in `C`, if `S₁` and `S₂` both have homology and there is a morphism `φ` from `S₁` to `S₂`, then `φ` is a quasi-isomorphism in the short complex if and only if the `φ` map in homology is an isomorphism.

For any short complexes $S\_1$ and $S\_2$ in a category $C$ with zero morphisms, if $S\_1$ and $S\_2$ have homology and there's a morphism $\varphi$ from $S\_1$ to $S\_2$, then $\varphi$ is a quasi-isomorphism in the short complex if and only if the homology map $\varphi_\ast$ is an isomorphism.


/-- The closed form for the quaternion exponential on arbitrary quaternions.  -/
theorem Quaternion.exp_eq :
    ∀ (q : Quaternion ℝ),
      NormedSpace.exp ℝ q =
        NormedSpace.exp ℝ q.re •
          (↑(Real.cos ‖Quaternion.im q‖) + (Real.sin ‖Quaternion.im q‖ / ‖Quaternion.im q‖) • Quaternion.im q) :=
  by sorry

The given theorem provides a closed form for the exponential of an arbitrary quaternion. Specifically, it states that for any quaternion `q`, the exponential of `q` in the normed space over real numbers is equal to the exponential of the real part of `q` scaled by the sum of the real cosine of the norm of the imaginary part of `q` and the real sine of the norm of the imaginary part of `q` divided by the norm of the imaginary part of `q` itself, this whole sum being further scaled by the imaginary component of `q`. This result can be expressed mathematically as: `exp(q) = exp(Re(q)) * (cos(‖Im(q)‖) + sin(‖Im(q)‖) / ‖Im(q)‖ * Im(q))`.

The exponential of a quaternion q is equal to the exponential of its real part scaled by the cosine and sine of its imaginary part's norm, multiplied by the imaginary part itself: exp(q) = exp(Re(q)) * (cos(‖Im(q)‖) + sin(‖Im(q)‖)/‖Im(q)‖ * Im(q)).


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.46 :
    ∀ {G : Type u_1} [inst : Group G] {p p' : Subgroup G} {x : G}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') := by sorry

This theorem states that for any group `G`, given two subgroups `p` and `p'` of `G` and an element `x` from `G`, `x` belongs to the intersection of `p` and `p'` if and only if `x` belongs to both `p` and `p'`. This theorem is a fundamental property of the intersection operation in group theory.

For any groups G and subgroups p and p', x ∈ p ∩ p' if and only if x ∈ p and x ∈ p'.


theorem Prod.tendsto_iff :
    ∀ {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z] {X : Type u_5}
      (seq : X → Y × Z) {f : Filter X} (p : Y × Z),
      Filter.Tendsto seq f (nhds p) ↔
        Filter.Tendsto (fun n => (seq n).1) f (nhds p.1) ∧ Filter.Tendsto (fun n => (seq n).2) f (nhds p.2) :=
  by sorry

The `Prod.tendsto_iff` theorem states that for any types `Y` and `Z` with topological space structures, a type `X`, a sequence `seq` of function from `X` to the cartesian product of `Y` and `Z`, a filter `f` on `X`, and a pair `p` in `Y x Z`, the sequence `seq` tends to the neighborhood filter of `p` (i.e., the values of the sequence get arbitrarily close to `p`) if and only if both projections of the sequence (i.e., the first and second components of the pairs in the sequence), under the filter `f`, tend to the neighborhood filters of the first and the second components of `p`, respectively.

For any types `Y` and `Z` with topological spaces structures, a sequence `seq` of functions from `X` to `Y × Z`, filter `f` on `X`, and point `p` in `Y × Z`, `seq` tends to the neighborhood filter of `p` if and only if the projections of `seq` do, under `f`.


theorem Pi.uniformContinuous_precomp' :
    ∀ {ι : Type u_1} {ι' : Type u_2} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (φ : ι' → ι),
      UniformContinuous fun f j => f (φ j) :=
  by sorry

The theorem `Pi.uniformContinuous_precomp'` states that for any two types `ι` and `ι'`, a function `α : ι → Type u` mapping each element of `ι` to a type with a uniform space structure, and a function `φ : ι' → ι`, the function `f` that maps each element `j` of `ι'` to `f (φ j)`, is uniformly continuous. In other words, if `j` is sufficiently close to some other element in `ι'`, then `f (φ j)` is close to `f (φ j')` for any `j` and `j'` in `ι'`, regardless of their specific locations in `ι'`.

Given types `ι` and `ι'`, a function `α : ι → Type u` with uniform space structure, and a function `φ : ι' → ι`, the function `f : ι' → α (φ)` is uniformly continuous.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.76 :
    ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ Subgroup.subgroupOf H K) = (↑h ∈ H) := by sorry

This theorem states that for any type `G` with a group structure and any subgroups `H` and `K` of `G`, if we have an element `h` of subgroup `K`, then `h` is in the subgroup of `H` and `K` (i.e., the intersection of `H` and `K` as viewed as a subgroup of `K`) if and only if the underlying element of `h` in `G` is in `H`.

For any group `G` and subgroups `H` and `K` of `G`, an element `h` in `K` belongs to the intersection of `H` and `K` as subgroups of `G` if and only if `h` is in `H` as elements of `G`.


theorem Function.Antiperiodic.const_smul₀ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {c : α} [inst : AddCommMonoid α] [inst_1 : Neg β]
      [inst_2 : DivisionSemiring γ] [inst_3 : Module γ α],
      Function.Antiperiodic f c → ∀ {a : γ}, a ≠ 0 → Function.Antiperiodic (fun x => f (a • x)) (a⁻¹ • c) :=
  by sorry

The theorem `Function.Antiperiodic.const_smul₀` states that given types `α`, `β`, and `γ`, a function `f` from `α` to `β`, and a constant `c` of type `α`, under the conditions that `α` is an additive commutative monoid, `β` is equipped with a negation operation, `γ` is a division semiring, and `α` is a module over `γ`, if the function `f` is antiperiodic with antiperiod `c`, then for any nonzero element `a` of `γ`, the function resulting from applying `f` to the scalar multiple `a • x` is also antiperiodic, but with antiperiod `a⁻¹ • c`, where `•` denotes scalar multiplication and `a⁻¹` is the multiplicative inverse of `a`. In essence, this theorem relates the antiperiodicity of a function and a scaled version of that function.

If `f : α -> β`, `α` an additive commutative monoid, `β` a negated semiring, `γ` a division semiring, `α` a `γ`-module, `c : α`, and `f` is antiperiodic with antiperiod `c`, then for any nonzero `a : γ`, the function `x => f (a • x)` is antiperiodic with antiperiod `a⁻¹ • c`.


theorem Complex.abs_cpow_eq_rpow_re_of_nonneg :
    ∀ {x : ℝ}, 0 ≤ x → ∀ {y : ℂ}, y.re ≠ 0 → Complex.abs (↑x ^ y) = x ^ y.re := by sorry

This theorem states that for any nonnegative real number `x` and any complex number `y` with a non-zero real part, the absolute value of `x` raised to the power of `y` (where `x` is considered as a complex number) is equal to `x` raised to the power of the real part of `y`. In mathematical notation, this can be written as: for all $x \geq 0$ and $y \in \mathbb{C}$ with $\Re(y) \neq 0$, $|x^y| = x^{\Re(y)}$.

For any nonnegative real number $x$ and complex number $y$ with non-zero real part, $|x^y| = x^{\Re(y)}$.


theorem ext_nat' :
    ∀ {A : Type u_3} {F : Type u_5} [inst : FunLike F ℕ A] [inst_1 : AddMonoid A] [inst_2 : AddMonoidHomClass F ℕ A]
      (f g : F), f 1 = g 1 → f = g :=
  by sorry

The theorem `ext_nat'` states that for any two functions `f` and `g` of type `F`, where `F` is a function-like type that maps natural numbers (`ℕ`) to another type `A`, under the conditions that `A` is an additive monoid and `F` is a class of homomorphisms preserving the additive monoid structure from natural numbers to `A`, if `f` and `g` have the same output when applied to the natural number 1, then `f` and `g` must be the same function. This theorem essentially asserts the uniqueness of such functions based on their values at the point 1.

If `F` maps natural numbers to an additive monoid `A` and `f` and `g` are functions of type `F` with `f 1 = g 1`, then `f = g`.


MeasureTheory.IntegrableAtFilter.add

theorem MeasureTheory.IntegrableAtFilter.add :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
      {μ : MeasureTheory.Measure α} {l : Filter α} {f g : α → E},
      MeasureTheory.IntegrableAtFilter f l μ →
        MeasureTheory.IntegrableAtFilter g l μ → MeasureTheory.IntegrableAtFilter (f + g) l μ :=
  by sorry

The theorem `MeasureTheory.IntegrableAtFilter.add` states that for any measure space `α`, any normed add commutative group `E`, any measure `μ` on `α`, any filter `l` on `α`, and any two functions `f` and `g` from `α` to `E`, if `f` is integrable at filter `l` with respect to measure `μ` and `g` is also integrable at filter `l` with respect to measure `μ`, then the function `f + g` (which represents the pointwise addition of `f` and `g`) is also integrable at filter `l` with respect to measure `μ`. In other words, the integrability property at a filter is preserved under the addition of two integrable functions.

If `f` and `g` are integrable functions with respect to measure `μ` at filter `l` on measure space `α`, then their pointwise sum `f + g` is also integrable with respect to `μ` at `l`.


theorem tsum_subtype :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (s : Set β) (f : β → α),
      ∑' (x : ↑s), f ↑x = ∑' (x : β), Set.indicator s f x :=
  by sorry

This theorem, `tsum_subtype`, states that for any types `α` and `β`, given that `α` forms an additive commutative monoid and has a topological space structure, and for a set `s` of elements of type `β` and a function `f` from `β` to `α`, the sum of `f` over the elements of `s` is equal to the sum of the indicator function of `s` applied to `f` over all elements of `β`. Here, the indicator function of a set `s` applied to `f` and `x` returns `f x` if `x` is in `s`, and `0` otherwise.

In mathematical notation, this could be denoted as $\sum_{x \in s} f(x) = \sum_{x \in \mathbb{B}} \mathbb{1}_{s}(x) f(x)$, where $\mathbb{1}_{s}(x)$ is the indicator function of the set `s` applied to `x`.

For any additive commutative monoid type `α` with topological space structure, and for a set `s` and function `f` from a type `β` to `α`, the sum of `f` over `s` equals the sum of the indicator function of `s` applied to `f` over all elements of `β`.


AddSalemSpencer.mono

theorem AddSalemSpencer.mono :
    ∀ {α : Type u_2} [inst : AddMonoid α] {s t : Set α}, t ⊆ s → AddSalemSpencer s → AddSalemSpencer t := by sorry

This theorem states that for any type `α` that forms an additive monoid, given two sets `s` and `t` of elements of this type, if `t` is a subset of `s` and `s` is a Salem-Spencer (non-averaging) set, then `t` is also a Salem-Spencer set. In other words, the property of being a Salem-Spencer set is preserved under taking subsets. A Salem-Spencer set is defined as a set in which the average of any two distinct elements does not belong to the set, or equivalently, if the sum of two distinct elements equals twice a third element in the set, then the two original elements must be equal.

If `α` is an additive monoid type, `s` is a Salem-Spencer set, and `t` is a subset of `s`, then `t` is also a Salem-Spencer set.


theorem CategoryTheory.flat_of_preservesFiniteLimits :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] [inst_2 : CategoryTheory.Limits.HasFiniteLimits C]
      (F : CategoryTheory.Functor C D) [inst_3 : CategoryTheory.Limits.PreservesFiniteLimits F],
      CategoryTheory.RepresentablyFlat F :=
  by sorry

This theorem states that for any two categories `C` and `D`, where `C` has finite limits, if a functor `F` from `C` to `D` is known to preserve finite limits, then `F` is representably flat. In other words, if a functor takes finite limits in `C` to limits in `D` (preserves finite limits), then it has the property of being representably flat; a functor is representably flat if it reflects certain limit properties of the category structure.

If functor `F` from category `C` to category `D` preserves finite limits in `C`, then `F` is representably flat.


theorem Mathlib.Data.List.Intervals._auxLemma.3 : ∀ {n m l : ℕ}, (l ∈ List.Ico n m) = (n ≤ l ∧ l < m) := by sorry

This theorem states that for any three natural numbers `n`, `m`, and `l`, `l` is in the list `List.Ico n m` if and only if `n` is less than or equal to `l` and `l` is strictly less than `m`. In other words, `l` is a part of the list of natural numbers from `n` to `m`, excluding `m` (also known as the closed-open interval from `n` to `m`), precisely when `l` lies in the closed-open interval `[n, m)`.

The natural number `l` is in the closed-open interval `[n, m)` (i.e., belongs to `List.Ico n m`) if and only if `n <= l` and `l < m`.


theorem Mathlib.Data.List.Intervals._auxLemma.7 : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) :=
  by sorry

This theorem, `Mathlib.Data.List.Intervals._auxLemma.7`, states that for any type `α` that has a linear order, and for any two elements of this type `a` and `b`, the assertion that `a` is not less than `b` (`¬a < b`) is equivalent to the assertion that `b` is less than or equal to `a` (`b ≤ a`). This is a fundamental property of ordered types in mathematics, reflecting the relationship between inequality and order.

For any type `α` with a linear order, the negation of `a < b` is equivalent to `b ≤ a`.


theorem AlgEquiv.toLinearEquiv_apply :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (a : A₁),
      (AlgEquiv.toLinearEquiv e) a = e a :=
  by sorry

This theorem states that for any commutative semiring `R` and any two semirings `A₁` and `A₂` over `R`, if `e` is an algebra equivalence from `A₁` to `A₂`, then the application of the corresponding linear equivalence (obtained by forgetting the multiplicative structures in the algebra equivalence `e` through `AlgEquiv.toLinearEquiv`) to any element `a` of `A₁` is the same as the application of the algebra equivalence `e` to `a`. In other words, the algebra equivalence and the corresponding linear equivalence act identically on the elements of `A₁`.

For any commutative semiring `R`, if `e` is an algebra equivalence from semirings `A₁` to `A₂` over `R`, then for all `a` in `A₁`, `e a = AlgEquiv.toLinearEquiv e a`.


/-- The image of the unit ball under a continuous linear map is bounded.  -/
theorem ContinuousLinearMap.unit_le_opNorm :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
      (f : E →SL[σ₁₂] F) (x : E), ‖x‖ ≤ 1 → ‖f x‖ ≤ ‖f‖ :=
  by sorry

This theorem states that for any continuous linear map 'f' from a normed vector space 'E' over a nontrivially normed field '𝕜' to a normed vector space 'F' over a nontrivially normed field '𝕜₂', the norm of the image of any vector 'x' from 'E' (with a norm less than or equal to 1) under 'f' is less than or equal to the operator norm of 'f'. The operator norm here is the maximum multiple by which 'f' expands a vector.

For any continuous linear map $f$ from normed vector space $E$ over a nontrivially normed field $\mathbb{K}$ to normed vector space $F$ over a nontrivially normed field $\mathbb{K}_2$, the norm of $f(x)$ with respect to $F$ is less than or equal to the operator norm of $f$ times the norm of $x$ with respect to $E$, for all $x$ in $E$ with norm less than or equal to 1.


/-- The image of the filter `atTop` on `Ioi a` under the coercion equals `atTop`.  -/
theorem Filter.map_val_Ioi_atTop :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] [inst_1 : NoMaxOrder α] (a : α),
      Filter.map Subtype.val Filter.atTop = Filter.atTop :=
  by sorry

This theorem states that for any type `α` that is a semilattice with supremum and has no maximum element, and for any value `a` of the type `α`, the image of the filter `atTop` on the set of all elements greater than `a` under the function `Subtype.val` (which extracts the underlying element from a subtype), is equal to the filter `atTop`. In other words, mapping the filter of all elements larger than a given value `a` in a semi-lattice via the extraction function results in the filter of all elements in the semilattice, assuming the semilattice has no maximum element.

For any semilattice `α` without a maximum element and any `a` in `α`, the filter of elements greater than `a` maps to the entire filter `atTop` under the extraction function `Subtype.val`.


theorem measurable_biSup :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : BorelSpace α]
      [inst_3 : MeasurableSpace δ] [inst_4 : ConditionallyCompleteLinearOrder α] [inst_5 : OrderTopology α]
      [inst : SecondCountableTopology α] {ι : Type u_6} (s : Set ι) {f : ι → δ → α},
      Set.Countable s → (∀ i ∈ s, Measurable (f i)) → Measurable fun b => ⨆ i ∈ s, f i b :=
  by sorry

This theorem, 'measurable_biSup', states that for any topological space `α` that also has a measurable space structure, a Borel space structure, a conditionally complete linear order, an order topology, and a second countable topology, and for any measurable space `δ`, if we have a countable set `s` of type `ι` and a function `f` from `ι` to a function from `δ` to `α`, where every `i` in `s` yields a measurable function from `δ` to `α` when applied to `f`, then the function that maps each `b` in `δ` to the supremum over `i` in `s` of `f i b` is also measurable.

In simpler words, it's about measurability preserved under taking the supremum over a countable set of measurable functions. If every function from a countable set to our space is measurable, then the function that takes the supremum of all these functions (for each input) is also measurable.

If `α` is a topological space with measurable and Borel structures, a conditionally complete linear order, order topology, and second countable topology, and `f` is a countable family of measurable functions from a measurable space `δ` to `α`, then the function that maps each `b` in `δ` to the supremum of `f i b` over `i` in the countable set `s` is measurable.


theorem Polynomial.primPart_zero :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R],
      Polynomial.primPart 0 = 1 :=
  by sorry

This theorem states that for all types `R`, where `R` is a commutative ring, `R` forms a domain, and `R` is a normalized greatest common divisor monoid, the primitive part of the zero polynomial is equal to 1. In other words, when a polynomial is zero, its primitive part - the polynomial obtained by dividing the original polynomial by its content - is 1.

For every commutative ring `R` that is a domain and a normalized greatest common divisor monoid, the primitive part of the zero polynomial is equal to the constant polynomial 1.


IsCompact.isLindelof

/-- A compact set `s` is Lindelöf.  -/
theorem IsCompact.isLindelof : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsLindelof s := by
  sorry

The theorem `IsCompact.isLindelof` states that if a set `s` in a topological space `X` is compact, then it is also Lindelöf. In other words, for a set `s` to be compact means that for every nontrivial filter `f` that contains `s`, there exists an element `a` in `s` such that every set of `f` meets every neighborhood of `a`. If this condition is met, then the set `s` is also Lindelöf, meaning that every nontrivial filter `f` with the countable intersection property that contains `s`, has a cluster point in `s`.

A compact set in a topological space is Lindelöf. In other words, every compact set has the property that every countable intersection of open sets with the set contains a point that is a limit point of the set.


theorem mem_upperBounds_image2_of_mem_upperBounds_of_mem_lowerBounds :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Monotone (Function.swap f b)) →
        (∀ (a : α), Antitone (f a)) → a ∈ upperBounds s → b ∈ lowerBounds t → f a b ∈ upperBounds (Set.image2 f s t) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` with preorder relations, given a binary function `f` from `α` to `β` to `γ`, sets `s` of `α` and `t` of `β`, and elements `a` of `α` and `b` of `β`, if every function obtained by fixing `b` in `f` is monotone and every function obtained by fixing `a` in `f` is antitone, and if `a` is an upper bound of `s` and `b` is a lower bound of `t`, then `f(a,b)` is an upper bound of the image of `s` and `t` under `f`.

In simpler terms, if `f` increases with `a` for every fixed `b` and decreases with `b` for every fixed `a`, and `a` and `b` are upper and lower bounds of their respective sets, then `f(a,b)` is an upper bound of all values of `f` when `f` is applied to elements from `s` and `t`.

If functions `f: α → β → γ`, `s ⊆ α`, `t ⊆ β`, `a ∈ s` is an upper bound of `s`, `b ∈ t` is a lower bound of `t`, `f` is increasing in `a` for every `b` and decreasing in `b` for every `a`, then `f(a,b)` is an upper bound of `{f(x,y) | x ∈ s, y ∈ t}`.


theorem Monotone.csSup_image_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : ConditionallyCompleteLattice β] {f : α → β},
      Monotone f → ∀ {s : Set α}, Set.Nonempty s → ∀ {B : α}, B ∈ upperBounds s → sSup (f '' s) ≤ f B :=
  by sorry

The theorem `Monotone.csSup_image_le` states that given a preordered set of type `α`, a conditionally complete lattice of type `β`, a function `f` from `α` to `β` that is monotone, a nonempty set `s` of type `α`, and an element `B` of type `α` that is an upper bound for the set `s`, the supremum of the image of `s` under `f`, if it exists, is less than or equal to `f(B)`. In other words, if a function is monotone, its supremum (the least upper bound) over the image of a nonempty set is less than or equal to the value of the function at any upper bound of the original set.

If `f` is a monotone function from a preordered set `α` to a conditionally complete lattice `β`, and `s ≠ ∅` is a subset of `α` with an upper bound `B` in `α`, then the image of `s` under `f` has a supremum in `β` that is less than or equal to `f(B)`.