theorem MeasureTheory.Integrable.comp_snd_map_prod_id :
    ∀ {Ω : Type u_1} {F : Type u_2} {m mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f : Ω → F}
      [inst : NormedAddCommGroup F],
      m ≤ mΩ →
        MeasureTheory.Integrable f μ →
          MeasureTheory.Integrable (fun x => f x.2) (MeasureTheory.Measure.map (fun ω => (id ω, id ω)) μ) :=
  by sorry

This theorem states that for any types `Ω` and `F`, measurable spaces `m` and `mΩ` on `Ω`, a measure `μ` on `Ω`, and a function `f : Ω → F`, under the condition that `m` is less than or equal to `mΩ` and `f` is integrable with respect to `μ`, then the function which maps each pair `x` to `f x.2` is integrable with respect to the pushforward of the measure `μ` under the function that maps each `ω` in `Ω` to the pair `(id ω, id ω)`. Here, `x.2` represents the second element of pair `x`, and `id ω` is just `ω` itself, meaning the mapping function just duplicates each element in `Ω` into a pair. This theorem characterizes a specific situation where the process of mapping measures preserves the property of integrability.

If `μ` is a measure on `Ω`, `m` and `mΩ` are measurable spaces on `Ω`, `f : Ω → F` is integrable with respect to `μ` and `m(Ω) ≤ mΩ(Ω)`, then the function mapping each pair `(ω, ω)` to `f ω.2` is integrable with respect to the pushforward of `μ` under the diagonal mapping from `Ω` to `Ω × Ω`.


theorem isIntegral_one :
    ∀ {R : Type u_1} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B], IsIntegral R 1 := by
  sorry

The theorem `isIntegral_one` states that for any commutative ring `R` and any ring `B` that has an algebra structure over `R`, the element 1 in `B` is integral over `R`. Here, being integral means that it is a root of some monic polynomial with coefficients in `R`. In other words, the number 1 satisfies a certain polynomial equation whose coefficients are chosen from the ring `R`.

In a commutative ring `R` and a commutative `R`-algebra `B`, the element 1 in `B` is a root of some monic polynomial with coefficients in `R`.


/-- **Alias** of the reverse direction of `List.length_pos`. -/
theorem List.length_pos_of_ne_nil : ∀ {α : Type u_1} {l : List α}, l ≠ [] → 0 < List.length l := by sorry

This theorem, referred to as "Alias of the reverse direction of `List.length_pos`", states that for any type `α` and any list `l` of type `α`, if `l` is not an empty list (i.e., `l ≠ []`), then the length of `l` (denoted by `List.length l`) is greater than 0 (i.e., `0 < List.length l`). This is just another way of saying that any non-empty list has a positive length.

For any list `l` of type `α` in Lean, if `l` is non-empty (`l ≠ []`), then `0 < List.length l`.


theorem PNat.one_coe : ↑1 = 1 := by sorry

This theorem states that the natural number representation of 1 is equal to 1. In other words, the coercion function (^^) applied to the positive integer 1 results in the natural number 1. This is a basic property of numbers and their representations in Lean 4.

The theorem asserts that the coercion of the constant 1 to the type of natural numbers results in the natural number 1. In mathematical notation, `1 ^^ = 1`.


theorem Finset.measurable_sum :
    ∀ {M : Type u_2} {ι : Type u_3} {α : Type u_4} [inst : AddCommMonoid M] [inst_1 : MeasurableSpace M]
      [inst_2 : MeasurableAdd₂ M] {m : MeasurableSpace α} {f : ι → α → M} (s : Finset ι),
      (∀ i ∈ s, Measurable (f i)) → Measurable fun a => Finset.sum s fun i => f i a :=
  by sorry

The theorem `Finset.measurable_sum` establishes that if we have a measurable space `M` with an additive commutative monoid structure and a binary function that is measurable, alongside another measurable space α, then for any finite set `s` of some type `ι` and a function `f` that maps each element of `s` to a measurable function from `α` to `M`, if each of these measurable functions `f i` for `i` in `s` is measurable, then the function that maps each element `a` in `α` to the sum of `f i a` as `i` ranges over `s` is also measurable. In simple terms, the sum of measurable functions over a finite set is measurable.

If `M` is a measurable space with an additive commutative monoid structure, and `f : ι → α → M` is a function where `ι` is finite and each `f i` is measurable, then the function `g : α → M` defined by `g a := ∑ i in ι, f i a` is measurable.


theorem Filter.mem_atBot : ∀ {α : Type u_3} [inst : Preorder α] (a : α), {b | b ≤ a} ∈ Filter.atBot := by sorry

The theorem `Filter.mem_atBot` states that for any type `α` with a preorder relationship, and any element `a` of `α`, the set of all elements `b` such that `b` is less than or equal to `a`, is an element of the filter `atBot`. In other words, this theorem indicates that every downward-closed set `{b | b ≤ a}` is included in the filter representing the limit towards negative infinity (`Filter.atBot`) on a preordered set.

For any preordered type `α` and element `a` in `α`, the downward-closed set `{b | b ≤ a}` is a subset of the filter `Filter.atBot`.


theorem NumberField.ComplexEmbedding.isReal_iff :
    ∀ {K : Type u_1} [inst : Field K] {φ : K →+* ℂ},
      NumberField.ComplexEmbedding.IsReal φ ↔ NumberField.ComplexEmbedding.conjugate φ = φ :=
  by sorry

This theorem establishes an equivalence for a field `K` and a map `φ` from `K` to the complex numbers `ℂ`. It states that a complex embedding `φ` is real if and only if the conjugate of this embedding `φ` is equal to `φ` itself. In other words, an embedding into the complex numbers is characterized as real if it remains unchanged under the operation of complex conjugation.

A complex embedding from a field into the complex numbers is real if and only if its conjugate equals the embedding itself.


theorem Polynomial.not_mem_support_iff :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      n ∉ Polynomial.support p ↔ Polynomial.coeff p n = 0 :=
  by sorry

The theorem `Polynomial.not_mem_support_iff` states that for any type `R` under a Semiring structure, any natural number `n`, and any polynomial `p` of type `R`, the natural number `n` is not in the support of the polynomial `p` if and only if the coefficient of `X^n` in `p` is zero. Here, the "support" of the polynomial `p` is defined as the set of all `n` for which the coefficient of `X^n` is non-zero.

For any semiring R, polynomial p of R in X, and natural number n, n is not in the support of p if and only if the coefficient of X^n in p is zero.


theorem Num.le_to_nat : ∀ {m n : Num}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem, `Num.le_to_nat`, states that for any two numerical values `m` and `n`, the condition that the natural number cast of `m` is less than or equal to the natural number cast of `n` is equivalent to the condition that `m` is less than or equal to `n`. In other words, the order relation (less than or equal to) is preserved when we cast from the `Num` type to the `Nat` type in Lean 4.

For any numerical values `m` and `n` in Lean 4, `m ≤ n` if and only if `natNum m ≤ natNum n`, where `natNum` denotes the function that casts a numerical value to a natural number.


theorem frobenius_apply_frobeniusEquiv_symm :
    ∀ (R : Type u_1) (p : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p] (x : R),
      (frobenius R p) ((RingEquiv.symm (frobeniusEquiv R p)) x) = x :=
  by sorry

The theorem `frobenius_apply_frobeniusEquiv_symm` states that for any type `R`, any natural number `p`, and any element `x` of `R`, if `R` is a commutative semiring with characteristic exponent `p` and is a perfect ring, then applying the Frobenius map (which sends `x` to `x^p`) to the inverse of the Frobenius automorphism mapped to `x`, we get back `x` itself. In other words, the Frobenius map and the inverse of the Frobenius automorphism are inverse operations to each other in the sense that their composition is the identity on `R`.

For any commutative semiring R with characteristic exponent p and perfect ring structure, the Frobenius map and the inverse of the Frobenius automorphism are inverse operations, i.e., applying the Frobenius map to the inverse of the Frobenius automorphism of an element x returns x itself.


theorem List.nthLe_rotate :
    ∀ {α : Type u} (l : List α) (n k : ℕ) (hk : k < List.length (List.rotate l n)),
      List.nthLe (List.rotate l n) k hk = List.nthLe l ((k + n) % List.length l) ⋯ :=
  by sorry

The theorem `List.nthLe_rotate` states that for any given type `α`, list `l` of type `α`, and natural numbers `n` and `k` such that `k` is less than the length of the list obtained by rotating `l` by `n`, the `k`-th element of the rotated list is the same as the `((k + n) % List.length l)`-th element of the original list `l`. In other words, if you rotate a list by `n` positions and then take the `k`-th element, it's the same as if you had taken the `((k + n) % List.length l)`-th element from the original list.

For any list `l` of length `n` and natural numbers `k` and `n`, the `k`-th element of the rotated list `l` obtained by rotating `n` positions to the right is equal to the `((k + n) % n)`-th element of the original list `l`.


theorem Filter.compl_not_mem : ∀ {α : Type u} {f : Filter α} {s : Set α} [inst : Filter.NeBot f], s ∈ f → sᶜ ∉ f := by
  sorry

The theorem `Filter.compl_not_mem` states that for any type `α`, any filter `f` on `α`, and any set `s` of type `α`, given that the filter `f` is not the bottom filter (i.e., it doesn't contain every set), if the set `s` is a member of the filter `f`, then the complement of `s` (denoted as `sᶜ`), is not a member of the filter `f`. In other words, a filter cannot contain a set and its complement at the same time, unless it is the bottom filter.

For any filter `f` on type `α` that is not the bottom filter, and any set `s` of type `α`, if `s` is in `f`, then `sᶜ` is not in `f`.


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

The theorem `AddMonoidAlgebra.modOf_apply_of_not_exists_add` states that for any type `k` with a semiring structure, any type `G` with an addition-commutative cancelable monoid structure, an instance of the monoid algebra `x` generated by `G` over `k`, and two elements `g` and `g'` from `G`, if there does not exist an element `d` in `G` such that `g'` is the sum of `g` and `d`, then applying the function `AddMonoidAlgebra.modOf` with `g` on `x` and then applying the resulting function on `g'` is equal to the application of `x` on `g'`. In other words, the function `AddMonoidAlgebra.modOf` leaves the coefficient of `g'` in the algebra `x` unchanged if `g'` cannot be expressed as the sum of `g` and another element.

If `g'` is not the sum of `g` in the additive monoid `G`, then applying `AddMonoidAlgebra.modOf` with `g` on the monoid algebra `x` over `k` leaves the coefficient of `g'` unchanged.


AEMeasurable.mono'

theorem AEMeasurable.mono' :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      {μ ν : MeasureTheory.Measure α},
      AEMeasurable f μ → MeasureTheory.Measure.AbsolutelyContinuous ν μ → AEMeasurable f ν :=
  by sorry

The theorem `AEMeasurable.mono'` states that for all types `α` and `β`, given a measurable space `α` and a measure space `β`, for a function `f` from `α` to `β`, and for any two measures `μ` and `ν` on `α`, if `f` is almost everywhere measurable with respect to `μ`, and `ν` is absolutely continuous with respect to `μ`, then `f` is also almost everywhere measurable with respect to `ν`. Here, a function is almost everywhere measurable if it agrees almost everywhere with a measurable function, and a measure `ν` is absolutely continuous with respect to another measure `μ` if whenever a set has `μ` measure zero, it also has `ν` measure zero.

If a function between measurable spaces is almost everywhere measurable with respect to one measure and absolutely continuous with respect to another measure, then it is almost everywhere measurable with respect to the second measure.


theorem MeasurableSet.subtype_image :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {s : Set α} {t : Set ↑s},
      MeasurableSet s → MeasurableSet t → MeasurableSet (Subtype.val '' t) :=
  by sorry

The theorem `MeasurableSet.subtype_image` states that for any type `α` that is equipped with a measurable space `m`, a set `s` of `α`, and a set `t` that is a subset of `s` (expressed as `Set ↑s`), if both the set `s` and the set `t` are measurable sets, then the image of `t` under the function `Subtype.val` is also a measurable set. Here, `Subtype.val` refers to the function that takes an element of a subtype and returns the corresponding element of the base type. This theorem essentially deals with the measurability of a subset after a transformation (`Subtype.val`).

If `α` is a measurable space, `s` and `t` are measurable subsets of `α`, then the image of `t` under the `Subtype.val` function is a measurable subset of `α`.


theorem tendsto_add :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [inst_2 : ContinuousAdd M] {a b : M},
      Filter.Tendsto (fun p => p.1 + p.2) (nhds (a, b)) (nhds (a + b)) :=
  by sorry

The theorem `tendsto_add` states that for any type `M` that has a topology, an addition operation, and where this addition is continuous, the function that takes a pair of elements `(p.1, p.2)` and returns their sum `p.1 + p.2` is a function that tends to the limit. More explicitly, it states that for any pair of points `(a, b)` in `M`, the sum function tends to the sum `a + b` when the pair of inputs tend to `(a, b)`. In other words, the function 'follows' the topology's sense of closeness: as the inputs get arbitrarily close to `(a, b)`, their sum gets arbitrarily close to `a + b`. This is essentially the definition of a continuous function in terms of filters and topological spaces.

Given a type `M` with a topology, an addition operation, and a continuous addition function, the sum function is continuous with respect to this topology.


theorem ProbabilityTheory.kernel.map_apply :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
      {mγ : MeasurableSpace γ} {f : β → γ} (κ : ↥(ProbabilityTheory.kernel α β)) (hf : Measurable f) (a : α),
      (ProbabilityTheory.kernel.map κ f hf) a = MeasureTheory.Measure.map f (κ a) :=
  by sorry

The theorem `ProbabilityTheory.kernel.map_apply` asserts that for all types `α`, `β`, and `γ`, along with their associated measurable spaces `mα`, `mβ`, and `mγ`, and for any function `f` from `β` to `γ` that is measurable, and for any element `κ` of the kernel of `α` and `β`, and any element `a` of type `α`, the application of the map function on the kernel `κ` with function `f` and element `a` is equal to the result of applying the measure-theory map function on `f` and `κ a`. In other words, it states that the mapping of a probability kernel coincides with the pushforward of the measure under the function `f`.

Given measurable spaces `(α, mα)`, `(β, mβ)`, `(γ, mγ)`, a measurable function `f : β → γ`, a probability kernel `κ : ∀ a : α, MeasurableSpace γ × MeasurableSet (mγ) (f a)`, and an element `a : α`, we have `κ a = (f ∘ π₁) `^{-1} `[`La ⋈ MeasurableSet.image MeasurableSet.universe `] (mβ  κ.proj₂ a)`, where `La` is the Lebesgue outer measure on `β`.


theorem Nat.coprime_or_dvd_of_prime : ∀ {p : ℕ}, Nat.Prime p → ∀ (i : ℕ), Nat.Coprime p i ∨ p ∣ i := by sorry

The theorem `Nat.coprime_or_dvd_of_prime` states that for any prime number `p` and any natural number `i`, `p` and `i` are either coprime, meaning their greatest common divisor (gcd) is 1, or `p` divides `i`. In other words, if `p` is a prime number and `i` is any natural number, then `p` and `i` either have no common factors other than 1, or `p` is a factor of `i`.

For any prime number p and natural number i, p and i are coprime or p divides i.


theorem Filter.EventuallyEq.prod_mk :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {l : Filter α} {f f' : α → β},
      f =ᶠ[l] f' → ∀ {g g' : α → γ}, g =ᶠ[l] g' → (fun x => (f x, g x)) =ᶠ[l] fun x => (f' x, g' x) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and any filter `l` on `α`, if two functions `f` and `f'` from `α` to `β` are eventually equal with respect to the filter `l`, and two other functions `g` and `g'` from `α` to `γ` are also eventually equal with respect to the same filter, then the function that maps `x` in `α` to the pair `(f x, g x)` is eventually equal to the function mapping `x` to `(f' x, g' x)` with respect to the filter `l`. In other words, if the components of two functions from `α` to the product type `(β, γ)` are each eventually equal, then the two functions themselves are eventually equal.

If functions `f` and `f'` from `α` to `β`, and functions `g` and `g'` from `α` to `γ`, are each eventually equal with respect to filter `l`, then the functions `(λ x, (f x, g x))` and `(λ x, (f' x, g' x))` from `α` to `(β × γ)` are eventually equal with respect to `l`.


theorem div_div_div_cancel_right :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {b c : G₀} (a : G₀), c ≠ 0 → a / c / (b / c) = a / b := by sorry

The theorem `div_div_div_cancel_right` is about division in a group with zero. This theorem is applicable for all types `G₀`. It states that for any elements `a`, `b`, and `c` in `G₀`, if `c` is not zero, then the result of dividing `a` by `c` and then dividing this result by the result of `b` divided by `c` is equal to `a` divided by `b`. In simpler terms, it expresses the property that $(a/c)/(b/c) = a/b$, given that $c \neq 0$.

If `c` is nonzero in a group `G₀`, then `(a / c) / (b / c) = a / b`.


theorem Mathlib.MeasureTheory.MeasurableSpace.Basic._auxLemma.25 :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set (α ⊕ β)},
      MeasurableSet s = (MeasurableSet (Sum.inl ⁻¹' s) ∧ MeasurableSet (Sum.inr ⁻¹' s)) :=
  by sorry

This theorem states that for any types `α` and `β`, and for any measurable spaces `m` on `α` and `mβ` on `β`, a set `s` of the disjoint union of `α` and `β` is measurable if and only if the preimage of `s` under the left injection (`Sum.inl`) and the preimage of `s` under the right injection (`Sum.inr`) are both measurable. In other words, a set in the disjoint union space is measurable when its corresponding subsets in the original spaces are measurable.

A set in the disjoint union of two measurable spaces is measurable if and only if its subsets under the left and right injections are measurable.


theorem Filter.limsup_le_iSup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {u : β → α},
      Filter.limsup u f ≤ ⨆ n, u n :=
  by sorry

The theorem `Filter.limsup_le_iSup` states that for any function `u` from a type `β` to a type `α` (where `α` is a complete lattice), and for any filter `f` on `β`, the limit superior (`limsup`) of `u` along `f` is less than or equal to the supremum (denoted by `⨆ n, u n`) of the values of `u`. In simpler terms, the highest value that `u` can approach using the filter `f` is always less than or equal to the highest value `u` can take.

For any complete lattice α, function u from a filter f on β to α, the limsup of u along f (limsup u f) is less than or equal to the supremum of u (⨆ n, u n).


theorem le_of_tendsto_of_tendsto :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderClosedTopology α]
      {f g : β → α} {b : Filter β} {a₁ a₂ : α} [inst_2 : Filter.NeBot b],
      Filter.Tendsto f b (nhds a₁) → Filter.Tendsto g b (nhds a₂) → f ≤ᶠ[b] g → a₁ ≤ a₂ :=
  by sorry

This theorem, `le_of_tendsto_of_tendsto`, states that for any types `α` and `β` where `α` is a topological space, a preorder, and has an order-closed topology, if we have functions `f` and `g` from `β` to `α`, a filter `b` on `β` that is not the bottom filter, and two elements `a₁`, `a₂` of `α`, then if `f` tends to `a₁` along `b`, `g` tends to `a₂` along `b` and `f` is eventually less than or equal to `g` along `b`, then `a₁` is less than or equal to `a₂`.

In terms of limits, it says that if `f` and `g` are functions such that the limit of `f` as `β` approaches a point under a certain filter is `a₁`, the limit of `g` is `a₂`, and `f(β)` is less than or equal to `g(β)` for sufficiently large `β`, then `a₁` is less than or equal to `a₂`. This theorem is a formalization of the intuitive idea in calculus that if one function is eventually less than or equal to another, then the limit of the smaller function is less than or equal to the limit of the larger one.

If `f` and `g` are functions from a filter `b` on a topological preorder `β` to a topological space `α` with order-closed topology, where `f` tends to `a₁` and `g` tends to `a₂` along `b`, and `f(x) ≤ g(x)` for all `x` in `β` that lie in the filter's limit points, then `a₁ ≤ a₂`.


theorem Set.projIcc_of_le_left :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α},
      x ≤ a → Set.projIcc a b h x = { val := a, property := ⋯ } :=
  by sorry

The theorem `Set.projIcc_of_le_left` states that for any types `α` that has a linear order, given two elements `a` and `b` in `α` where `a` is less than or equal to `b`, and any element `x` in `α` that is less than or equal to `a`, the projection of `x` onto the closed interval `[a, b]` will be `a`. In other words, if `x` is outside the interval to the left, it gets projected to the left endpoint `a`.

For any type `α` with a linear order, and elements `a ≤ b` in `α` and `x ≤ a`, the projection of `x` onto the interval `[a, b]` is equal to `a`.


theorem hasSum_ite_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (b : β)
      [inst_2 : DecidablePred fun x => x = b] (a : α), HasSum (fun b' => if b' = b then a else 0) a :=
  by sorry

The theorem `hasSum_ite_eq` states that for any types `α` and `β`, where `α` is an additive commutative monoid and also a topological space, and for any element `b` of type `β`, and for any `DecidablePred` instance that asserts whether an element equals to `b` or not, and for any element `a` of type `α`, the function that assigns `a` to `b` and `0` to all other values of type `β` has a sum, and that sum is `a`. In other words, if we sum up a function over all `b'` in `β` such that `b'` equals `b` contributes `a` to the sum and all other elements contribute `0`, then the total sum is `a`.

For any additive commutative monoid and topological space α, any type β with a DecidablePred instance, and any b ∈ β and a ∈ α, the function that maps every element to 0 except for b which maps to a, has the property that the sum of this function equals a.


theorem Set.encard_eq_one : ∀ {α : Type u_1} {s : Set α}, Set.encard s = 1 ↔ ∃ x, s = {x} := by sorry

The theorem `Set.encard_eq_one` asserts that for any type `α` and any set `s` of type `α`, the cardinality of the set `s` is one if and only if there exists an element `x` such that `s` is the set containing only `x`. In other words, a set `s` has exactly one element if and only if it is the set which consists precisely of this one specific element.

A set has exactly one element if and only if it is a singleton set containing any specific element.


/-- **Lagrange's Theorem**: The order of a subgroup divides the order of its ambient group.  -/
theorem Subgroup.card_subgroup_dvd_card :
    ∀ {α : Type u_1} [inst : Group α] [inst_1 : Fintype α] (s : Subgroup α) [inst_2 : Fintype ↥s],
      Fintype.card ↥s ∣ Fintype.card α :=
  by sorry

**Lagrange's Theorem** in group theory states that the order (number of elements) of a subgroup always divides the order of the larger (ambient) group to which it belongs. This theorem is applicable for finite groups, i.e., groups with a finite number of elements. In the Lean 4 theorem, `Subgroup.card_subgroup_dvd_card`, the order of the subgroup is represented by `Fintype.card ↥s` and the order of the ambient group is represented by `Fintype.card α`. The theorem asserts that the order of the subgroup divides (`∣`) the order of the ambient group for any group `α` and subgroup `s` of `α`.

The order of a subgroup of a finite group divides the order of the group.


theorem NNReal.rpow_mul : ∀ (x : NNReal) (y z : ℝ), x ^ (y * z) = (x ^ y) ^ z := by sorry

This theorem states that for any nonnegative real number `x` and any two real numbers `y` and `z`, the result of raising `x` to the power of the product of `y` and `z` is equal to the result of raising `x` to the power of `y`, and then raising the result to the power of `z`. In mathematical notation, this could be represented as \(x^{(y*z)} = ((x^y)^z)\). It's essentially asserting the property of exponentiation in the context of nonnegative real numbers.

For any non-negative real number x and real numbers y and z, (x^(y*z)) = (x^y)^z.


theorem Multiset.card_bind :
    ∀ {α : Type u_1} {β : Type v} (s : Multiset α) (f : α → Multiset β),
      Multiset.card (Multiset.bind s f) = Multiset.sum (Multiset.map (⇑Multiset.card ∘ f) s) :=
  by sorry

The theorem `Multiset.card_bind` states that for any type `α` and `β`, any multiset `s` of type `α`, and any function `f` that maps an element of type `α` to a multiset of type `β`, the cardinality of the multiset obtained by binding `s` with `f` is equal to the sum of the multisets obtained by mapping the function that applies the cardinality function to `f` over `s`. This can be seen as calculating the total number of elements after a transformation `f` is applied to each element in a multiset.

For any multiset `s` of type `α` and function `f` from `α` to multisets of `β`, the cardinality of the multiset obtained by binding `s` with `f` is equal to the sum of the cardinalities of the images of elements in `s` under `f`.


theorem AddSubgroup.zsmul_mem_zmultiples :
    ∀ {G : Type u_1} [inst : AddGroup G] (g : G) (k : ℤ), k • g ∈ AddSubgroup.zmultiples g := by sorry

The theorem `AddSubgroup.zsmul_mem_zmultiples` states that for any additive group `G` and any element `g` in `G` and any integer `k`, the result of scaling `g` by `k` (i.e., `k • g`) is an element of the subgroup generated by `g`. In other words, it states that any integer multiple of an element `g` of an additive group `G` remains within the subgroup generated by `g`.

For any additive group G, integer k, and element g in G, k • g is an element of the subgroup generated by g.


theorem Mathlib.Topology.MetricSpace.Basic._auxLemma.1 :
    ∀ {γ : Type w} [inst : MetricSpace γ] {x y : γ}, (dist x y = 0) = (x = y) := by sorry

This theorem from the Mathlib library in Lean 4 states that for any type `γ` that is a `MetricSpace`, and for any two elements `x` and `y` of this type, the distance between `x` and `y` being zero is equivalent to `x` being equal to `y`. In other words, in any metric space, two points are the same if and only if their distance is zero.

In any metric space, two points have zero distance if and only if they are equal.


theorem Finset.singleton_subset_set_iff : ∀ {α : Type u_1} {s : Set α} {a : α}, ↑{a} ⊆ s ↔ a ∈ s := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any element `a` of type `α`, the singleton set containing only `a` is a subset of `s` if and only if `a` is an element of `s`. In other words, every element of the singleton set `{a}` is in `s` exactly when `a` itself is in `s`. This theorem bridges the relationship between set membership and subset relation for singleton sets.

For any type `α` and set `s` of type `α`, the singleton set {`a`} is a subset of `s` if and only if `a` is an element of `s`.


/-- Composition is a continuous map from `C(X, Y) × C(Y, Z)` to `C(X, Z)`,
provided that `Y` is locally compact.
This is Prop. 9 of Chap. X, §3, №. 4 of Bourbaki's *Topologie Générale*.  -/
theorem ContinuousMap.continuous_comp' :
    ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] [inst_3 : LocallyCompactPair Y Z], Continuous fun x => ContinuousMap.comp x.2 x.1 :=
  by sorry

This theorem states that, given three topological spaces X, Y, Z and assuming that Y is locally compact, the composition operation is continuous when considering the space of continuous maps from X to Y and from Y to Z, i.e., it defines a continuous map from the pair of continuous maps (`C(X, Y)`, `C(Y, Z)`) to `C(X, Z)`. In other words, composing two continuous maps yields a continuous map. This fact is Proposition 9 from Chapter X, Section 3, Number 4 of Bourbaki's "General Topology".

The composition of two continuous functions between topological spaces is a continuous function.


WellFounded.isAsymm

theorem WellFounded.isAsymm : ∀ {α : Type u_1} {r : α → α → Prop}, WellFounded r → IsAsymm α r := by sorry

This theorem states that for any type `α` and any relation `r` on `α`, if `r` is well-founded, then `r` is also asymmetric. In other words, if `r` is a relation such that there are no infinite descending chains, then for any two elements `a` and `b` of `α`, if `a` relates to `b` and `b` relates to `a`, then `a` and `b` must be the same. This is a statement about the properties of well-founded relations in set theory.

If `r` is a well-founded relation on type `α`, then `r` is asymmetric.


theorem HomologicalComplex.eqToHom_f :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
      (h : C₁ = C₂) (n : ι), (CategoryTheory.eqToHom h).f n = CategoryTheory.eqToHom ⋯ :=
  by sorry

This theorem, `HomologicalComplex.eqToHom_f`, states that for any type `ι`, any type `V` forming a category with zero morphisms, any `ComplexShape ι`, and any two `HomologicalComplex` objects `C₁` and `C₂` in `V` shaped by `c`, if `C₁` equals `C₂` represented by an equality `h`, then for any `n` in `ι`, the function `f` applied to `n` on the morphism from `C₁` to `C₂` induced by the equality `h` (expressed as `CategoryTheory.eqToHom h`), equals to the morphism induced by some other equality. In other words, the morphism generated by the equality of two homological complexes behaves nicely with the structure of the complexes themselves.

Given two equivalent HomologicalComplexes `C₁` and `C₂` in a category `V` with zero morphisms, the induced morphism by the equivalence between them equals the morphism induced by some other equality.


theorem preimage_nhds_coinduced :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {π : α → β} {s : Set β} {a : α},
      s ∈ nhds (π a) → π ⁻¹' s ∈ nhds a :=
  by sorry

The theorem `preimage_nhds_coinduced` asserts that, for any types `α` and `β` (where `α` has a topological space structure) and any function `π` from `α` to `β`, if a set `s` of type `β` is in the neighborhood of the image of an element `a` (i.e., `s` is close to `π a`), then the preimage of `s` under `π` is in the neighborhood of `a`. In simpler terms, it ensures that if `s` is near to `π a`, then all elements in `α` that map into `s` through `π` are near to `a`.

If `π : α → β` is a continuous function, `a ∈ α`, `s ∈ β` is a neighborhood of `π(a)`, then `π⁁⁻¹(s)` is a neighborhood of `a` in `α`.


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

This theorem states that for any type `M₀` which has a multiplication operation that includes a zero element, and where zero divisors are not allowed, a product of any element `a` with itself (`a * a`) equals zero if and only if `a` is zero. In more traditional mathematical notation, this theorem is saying that for all `a` in some multiplication zero class `M₀`, `a^2 = 0` if and only if `a = 0`.

For any type `M₀` with multiplication and a zero element, without zero divisors, `a * a = 0` if and only if `a = 0`.


theorem strictMono_mul_left_of_pos :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a : α}, 0 < a → StrictMono fun x => a * x := by sorry

The theorem `strictMono_mul_left_of_pos` states that for any strictly ordered semiring `α` and any element `a` of `α`, if `a` is greater than zero, then the function that maps `x` to `a * x` is strictly monotone. In other words, if `a` is a positive element of a strictly ordered semiring, then multiplication by `a` preserves the order of elements: if `x` is less than `y`, then `a * x` is less than `a * y`.

For any strictly ordered semiring `α` and positive element `a` in `α`, the function `x ↔ a * x` is strictly increasing.


theorem mul_right_iterate :
    ∀ {G : Type u_3} [inst : Monoid G] (a : G) (n : ℕ), (fun x => x * a)^[n] = fun x => x * a ^ n := by sorry

This theorem states that for any type `G` that is a monoid and any element `a` of type `G`, if we apply the function that multiplies `x` by `a` `n` times (`(fun x => x * a)^[n]`), it is equivalent to multiplying `x` by `a` raised to the power of `n` (`fun x => x * a ^ n`). Basically, in a monoid, iteratively multiplying by `a` `n` times is the same as multiplying once by `a` to the power `n`.

For any monoid `G` and element `a` in `G`, the repeated multiplication `(a * _)^[n]` is equal to the power multiplication `(a ^ n) * _`, where `_` is an arbitrary element of `G`.


theorem Filter.Eventually.diag_of_prod_left :
    ∀ {α : Type u_1} {γ : Type u_3} {f : Filter α} {g : Filter γ} {p : (α × α) × γ → Prop},
      (∀ᶠ (x : (α × α) × γ) in (f ×ˢ f) ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p ((x.1, x.1), x.2) :=
  by sorry

The theorem `Filter.Eventually.diag_of_prod_left` states that for any types `α` and `γ`, any filters `f` on `α` and `g` on `γ`, and any property `p` on the cartesian product of `α × α` and `γ`, if `p` holds almost everywhere (except on a set of measure zero) on the product filter `(f ×ˢ f) ×ˢ g`, then `p` also holds almost everywhere on the product filter `f ×ˢ g`, when the first component of the tuples in `α × γ` is duplicated. In other words, it ensures that if a property is almost always true when considering pairs from the first filter, it remains true when we only consider the same elements from the first filter.

If a property holds almost everywhere on the product of two filters with the first component repeated, then it also holds almost everywhere on their product filter.


IsLowerSet.ordConnected

theorem IsLowerSet.ordConnected : ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, IsLowerSet s → Set.OrdConnected s :=
  by sorry

The theorem `IsLowerSet.ordConnected` states that for any type `α` with a preorder, if a set `s` of elements of type `α` is a lower set (meaning that for any two elements `a` and `b` in `α`, if `b` is less than or equal to `a` and `a` is in `s`, then `b` is also in `s`), then `s` is order-connected. In other words, this theorem asserts that every lower set in a preordered set is order-connected, where an order-connected set is one where for any two elements, every element between them is also in the set.

In a preordered set, every lower set is order-connected.


theorem Set.biInter_subset_biInter_left :
    ∀ {α : Type u_1} {β : Type u_2} {s s' : Set α} {t : α → Set β}, s' ⊆ s → ⋂ x ∈ s, t x ⊆ ⋂ x ∈ s', t x := by sorry

This theorem states that for any two types `α` and `β`, any two sets `s` and `s'` of type `α`, and a function `t` mapping from `α` to a set of type `β`, if `s'` is a subset of `s`, then the intersection over all elements in `s` of `t(x)` is a subset of the intersection over all elements in `s'` of `t(x)`. In mathematical terms, if $s' \subseteq s$, then $\bigcap_{x \in s} t(x) \subseteq \bigcap_{x \in s'} t(x)$. It essentially highlights the fact that narrowing the range of the intersection (from `s` to `s'`) does not extend the result.

If `s'` is a subset of `s` for types `α` and sets `s` and `s'` of `α`, and `t` is a function from `α` to a set of type `β`, then $\bigcap_{x \in s'} t(x) \subseteq \bigcap_{x \in s} t(x)$.


theorem Fintype.card_subtype_le :
    ∀ {α : Type u_1} [inst : Fintype α] (p : α → Prop) [inst_1 : DecidablePred p],
      Fintype.card { x // p x } ≤ Fintype.card α :=
  by sorry

The theorem `Fintype.card_subtype_le` states that, for any type `α` that is a `Fintype` (i.e., a finite type) and any predicate `p` on `α` that is decidable (i.e., for each element of `α`, it's known whether it satisfies `p` or not), the number of elements in the subtype of `α` for which `p` holds (denoted by `{ x // p x }` in Lean 4) is less than or equal to the total number of elements in `α`. In other words, the size of any subtype determined by a specific property is always less than or equal to the size of the original type.

For any finite type `α` and decidable predicate `p` on `α`, the number of elements in the subtype `{ x // p x }` is less than or equal to the cardinality of `α`.


theorem Equiv.coe_inj : ∀ {α : Sort u} {β : Sort v} {e₁ e₂ : α ≃ β}, ⇑e₁ = ⇑e₂ ↔ e₁ = e₂ := by sorry

This theorem states that for any two types `α` and `β`, and any two equivalences `e₁` and `e₂` from `α` to `β`, the application of `e₁` equals the application of `e₂` if and only if `e₁` equals `e₂`. In simpler terms, it says that if two equivalences between the same pair of types have the same effect when applied, then these two equivalences are indeed the same.

For any types `α` and `β` and equivalences `e₁` and `e₂` from `α` to `β`, `e₁ = e₂` if and only if `e₁ ∘ x = e₂ ∘ x` for all `x : α`.


AddSubsemigroup.ext

/-- Two `AddSubsemigroup`s are equal if they have the same elements. -/
theorem AddSubsemigroup.ext :
    ∀ {M : Type u_1} [inst : Add M] {S T : AddSubsemigroup M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T := by sorry

This theorem states that for any given type `M` that has an addition operation, if there are two AddSubsemigroups `S` and `T` of type `M` such that any element `x` of type `M` that is in `S` is also in `T` and vice versa, then the two AddSubsemigroups `S` and `T` are equal. An AddSubsemigroup is simply a subset of elements that still form a semigroup under the addition operation, so this theorem is essentially saying that if two subsets contain exactly the same elements, they are the same subset.

If `S` and `T` are AddSubsemigroups of type `M` with the property that every element in `S` is also in `T` and vice versa, then `S` is equal to `T`.


theorem EMetric.diam_closure :
    ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (s : Set α), EMetric.diam (closure s) = EMetric.diam s := by sorry

This theorem, `EMetric.diam_closure`, states that for any set `s` in a pseudoemetric space `α`, the diameter of the closure of `s` is equal to the diameter of `s` itself. Here, the diameter of a set in a pseudoemetric space is defined as the supremum of the extended distances between any two points in the set, and the closure of a set is the smallest closed set that contains the original set.

In a pseudometric space, the diameter of a set equals the diameter of its closure.


ContinuousAffineMap.continuous

theorem ContinuousAffineMap.continuous :
    ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R]
      [inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P]
      [inst_5 : AddCommGroup W] [inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q]
      (f : P →A[R] Q), Continuous ⇑f :=
  by sorry

This theorem asserts that for any continuous affine map `f` from a topological vector space `P` to another topological vector space `Q`, the function `f` is continuous. Here, `P` and `Q` are add-torsors over the modules `V` and `W` respectively, both of which are modules over a ring `R`. The continuity of `f` holds under the assumptions that `V` and `W` are additive commutative groups and `R` is a ring.

Given topological vector spaces P and Q over rings R, and a continuous affine map f from P to Q where P and Q are additive commutative groups, then f is a continuous function.


theorem Matrix.smul_dotProduct :
    ∀ {m : Type u_2} {R : Type u_7} {α : Type v} [inst : Fintype m] [inst_1 : Monoid R] [inst_2 : Mul α]
      [inst_3 : AddCommMonoid α] [inst_4 : DistribMulAction R α] [inst_5 : IsScalarTower R α α] (x : R) (v w : m → α),
      Matrix.dotProduct (x • v) w = x • Matrix.dotProduct v w :=
  by sorry

The theorem `Matrix.smul_dotProduct` states that for any type `m`, any Monoid `R`, any types `α`, where `α` has a multiplication operation, an addition operation and `α` is a commutative monoid, and `R` acts on `α` in a distributive manner, and also multiplication in `α` is compatible with the action of `R` on `α`, then for any element `x` of `R` and any two functions `v` and `w` from `m` to `α`, the dot product of `x` scaled `v` and `w` is equal to `x` scaled by the dot product of `v` and `w`. In other words, the scalar multiplication can be pulled out of the dot product, which is a standard property of dot products in linear algebra. In mathematical notation, for vectors `v` and `w`, and scalar `x`, this property could be written as `(x*v) . w = x * (v . w)`.

For any commutative monoid `α` with distributive `R`-action, and any `R`-module vectors `v` and `w`, the scalar multiplication `x * (v . w)` is equal to the dot product `(x * v) . w`.


theorem continuous_ultrafilter_extend :
    ∀ {α : Type u} {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : T2Space γ] [inst_2 : CompactSpace γ]
      (f : α → γ), Continuous (Ultrafilter.extend f) :=
  by sorry

The theorem `continuous_ultrafilter_extend` states that for any types `α` and `γ`, if `γ` is equipped with a topological space structure, a T2 (Hausdorff) space structure, and a compact space structure, then for any function `f` from `α` to `γ`, the extension of `f` to a function from `Ultrafilter α` to `γ` is continuous. This theorem basically establishes the continuity of the extension function when the codomain `γ` is a compact Hausdorff space.

For any type `α` and a compact Hausdorff space `γ`, the extension of a function from `α` to `γ` to an ultrafilter on `α` is a continuous function.


theorem Pi.continuous_restrict :
    ∀ {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] (S : Set ι),
      Continuous (Set.restrict S) :=
  by sorry

This theorem, named `Pi.continuous_restrict`, states that for all index types `ι` and all type families `π` indexed by `ι`, where each type in the family `π` is equipped with a topological space structure, and for any given set `S` of type `ι`, the function `Set.restrict S` is continuous. In other words, the restriction of a function to a subset `S` of its domain is always a continuous function, provided that the type of elements in `S` is `ι` and each type in the family `π` indexed by `ι` has a topology.

For any index type `ι` and type family `π` indexed by `ι`, where each `π i` has a topology, the restriction function `Set.restrict S : π i -> Set S` is continuous for every set `S` of type `ι`.


/-- If `1 < x`, then `x^k` divides `x^l` if and only if `k` is at most `l`.  -/
theorem Nat.pow_dvd_pow_iff_le_right : ∀ {x k l : ℕ}, 1 < x → (x ^ k ∣ x ^ l ↔ k ≤ l) := by sorry

This theorem states that for any natural numbers `x`, `k`, and `l`, if `x` is greater than 1, then `x` raised to the power of `k` divides `x` raised to the power of `l` if and only if `k` is less than or equal to `l`.

For any natural numbers x, k, and l, x^k divides x^l if and only if k <= l.


theorem Monotone.const_mul' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α}
      [inst_3 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1],
      Monotone f → ∀ (a : α), Monotone fun x => a * f x :=
  by sorry

The theorem 'Monotone.const_mul'' states that for all types 'α' and 'β' with 'α' being a multiplication and preorder structure and 'β' being a preorder structure, given a function 'f' from 'β' to 'α', if 'f' is a monotone function and 'a' is an element of type 'α', then the function that takes 'x' to 'a * f x' is also a monotone function. This implies that multiplication by a constant preserves the monotonicity of a function.

If f is a monotone function from a preorder (β) to a multiplication and preorder structure (α), then the function x ↔-> a * f x is also monotone.


theorem Filter.HasBasis.tendsto_left_iff :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α} {lb : Filter β}
      {f : α → β}, Filter.HasBasis la pa sa → (Filter.Tendsto f la lb ↔ ∀ t ∈ lb, ∃ i, pa i ∧ Set.MapsTo f (sa i) t) :=
  by sorry

The theorem `Filter.HasBasis.tendsto_left_iff` states that for all types `α`, `β`, and `ι`, for a given filter `la` on `α`, a filter `lb` on `β`, a function `f` from `α` to `β`, a predicate `pa` on `ι`, and a function `sa` from `ι` to a set of `α`, if `la` has a basis defined by the predicate `pa` and the function `sa`, then the function `f` tends to `lb` along `la` if and only if for every set `t` in the filter `lb`, there exists an index `i` such that `pa i` holds and the image of the set `sa i` under the function `f` is contained in `t`. In other words, it provides a characterization of the notion of the limit of a function with respect to a filter based on the basis of the filter.

A function between two types tends to a filter on the codomain along a filter on the domain if and only if the image of the basis elements of the domain filter under the function is contained in each element of the codomain filter.


theorem Finset.centerMass_mem_convexHull :
    ∀ {R : Type u_1} {E : Type u_3} {ι : Type u_5} [inst : LinearOrderedField R] [inst_1 : AddCommGroup E]
      [inst_2 : Module R E] {s : Set E} (t : Finset ι) {w : ι → R},
      (∀ i ∈ t, 0 ≤ w i) →
        (0 < Finset.sum t fun i => w i) →
          ∀ {z : ι → E}, (∀ i ∈ t, z i ∈ s) → Finset.centerMass t w z ∈ (convexHull R) s :=
  by sorry

The theorem `Finset.centerMass_mem_convexHull` states that for any type `R` that is a linear ordered field, a type `E` that is an add commutative group and a module over `R`, a type `ι`, a set `s` of type `E`, a finite set `t` of type `ι`, a weight function `w` from `ι` to `R`, and a point function `z` from `ι` to `E`, if all weights are nonnegative and the sum of the weights is positive, and each point `z i` for `i` in `t` is in the set `s`, then the center of mass of the points given by `z` with weights given by `w` is in the convex hull of the set `s`. The center of mass is computed as the scaled sum of the weighted points, where the scaling factor is the inverse of the sum of the weights. The convex hull of a set is the minimal convex set that includes the given set.

Given a linear ordered field R, an add commutative group and R-module E, a set s of points in E, a finite index set ι, a weight function w : ι -> R with nonnegative and positive sum, and a point function z : ι -> s, if every z(i) is in s, then the center of mass of z with weights w is in the convex hull of s.


theorem FirstOrder.Language.BoundedFormula.castLE.proof_2 : ∀ (_m _n : ℕ), _m ≤ _n → _m + 1 ≤ _n + 1 := by sorry

This theorem states that for any two natural numbers, `_m` and `_n`, if `_m` is less than or equal to `_n`, then `_m + 1` is also less than or equal to `_n + 1`. This property is fundamental to the order-preserving nature of natural number arithmetic.

For all natural numbers m and n, if m ≤ n then m + 1 ≤ n + 1.


theorem CategoryTheory.Limits.kernel.condition_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {Z : C} (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) (CategoryTheory.CategoryStruct.comp f h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

The theorem `CategoryTheory.Limits.kernel.condition_assoc` states that for any category `C` with zero morphisms, given objects `X` and `Y` in `C` and a morphism `f` from `X` to `Y` which has a kernel, and for any object `Z` in `C` with a morphism `h` from `Y` to `Z`, the composition of the kernel of `f` with the composition of `f` and `h` equals the composition of the zero morphism and `h`. This theorem is essentially formalising the property that the kernel of a morphism is the equalizer of that morphism and a zero morphism, and the composed morphisms associated with the kernel preserve this equality.

For any morphism `f` in a category with zero morphisms having a kernel, and any morphism `h`, the kernel of `f` is the equalizer of `f` and the composition of `h` and `f`, and the zero morphism composed with `h` is also in the equalizer, i.e., (kernel `f`) = (equalizer `(f ∘ h)` ∩ {x | zero `(h x)`}).


theorem PowerBasis.isIntegral_gen :
    ∀ {S : Type u_2} [inst : Ring S] {A : Type u_4} [inst_1 : CommRing A] [inst_2 : Algebra A S] (pb : PowerBasis A S),
      IsIntegral A pb.gen :=
  by sorry

This theorem states that, for any type `S` with a ring structure, type `A` with a commutative ring structure, and an algebra structure over `A` and `S`, given a power basis `pb` of `S` over `A`, the generator `pb.gen` of the power basis is integral over `A`. In other words, this generator is a root of some monic polynomial with coefficients in `A`.

For any ring `S` with a commutative ring `A` as an algebra, every generator `pb.gen` of a power basis of `S` over `A` is integral over `A`.


theorem CategoryTheory.MorphismProperty.comp_mem :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) {X Y Z : C}
      (f : X ⟶ Y) (g : Y ⟶ Z),
      W f →
        W g →
          ∀ [inst_1 : CategoryTheory.MorphismProperty.IsMultiplicative W], W (CategoryTheory.CategoryStruct.comp f g) :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.comp_mem` states that for any given category `C`, if a property `W` holds for morphisms in `C`, and if `W` is multiplicative, then for any three objects `X`, `Y`, and `Z` in `C`, if `f` is a morphism from `X` to `Y` and `g` is a morphism from `Y` to `Z` such that both `f` and `g` have property `W`, then the composite morphism `f ≫ g` (from `X` to `Z` via `Y`) also has property `W`.

If `C` is a category, `W` is a multiplicative property of morphisms in `C`, and `f : X → Y` and `g : Y → Z` are morphisms with property `W`, then their composite `f ≫ g : X → Z` also has property `W`.


theorem Computation.bind_pure :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Computation α),
      Computation.bind s (Computation.pure ∘ f) = Computation.map f s :=
  by sorry

The theorem `Computation.bind_pure` states that for any types `α` and `β`, and any function `f : α → β`, and any computation `s` of type `α`, binding the computation `s` with the function `f` composed with `pure` is equivalent to mapping the function `f` over the computation `s`. In other words, it means that the operation of transforming the result of a computation by applying a function (using `map`) can also be achieved by first applying the function to the result and then making a new computation that immediately terminates with that result (using `bind` with `pure ∘ f`).

For any type `α`, type `β`, function `f : α → β`, and computation `s : α`, `map f (pure s) = bind s (λ x => pure (f x))`.


ChainComplex.prev

theorem ChainComplex.prev :
    ∀ (α : Type u_2) [inst : AddRightCancelSemigroup α] [inst_1 : One α] (i : α),
      ComplexShape.prev (ComplexShape.down α) i = i + 1 :=
  by sorry

The theorem `ChainComplex.prev` states that for any type `α` with `AddRightCancelSemigroup` and `One` instances and any element `i` of type `α`, the previous element in the `ComplexShape` defined by `ComplexShape.down α` is `i + 1`. In other words, if we consider a "chain complex" with indices in `α` and with a shape determined by `ComplexShape.down`, then the element before any element `i` is always `i + 1`. It is pertinent to note that this theorem reflects the fundamental concept in homology where the differential operator maps `X i` to `X j` only when `i = j + 1`.

For any type `α` with `AddRightCancelSemigroup` and `One` instances, in the complex shape `ComplexShape.down α`, the previous element to `i` is `i + 1`.


theorem Nat.factorization_div :
    ∀ {d n : ℕ}, d ∣ n → Nat.factorization (n / d) = Nat.factorization n - Nat.factorization d := by sorry

The theorem `Nat.factorization_div` states that for any two natural numbers `d` and `n`, if `d` divides `n`, then the prime factorization of the quotient of `n` divided by `d` is equal to the difference of the prime factorizations of `n` and `d`. In other words, if we represent the count of prime factors as a function, the function value for `n / d` is the same as subtracting the function value for `d` from that for `n`.

If `d` divides `n` in the natural numbers, then the prime factorizations of `n/d` and `n - d` differ only in the number of occurrences of the prime factor `d`.


theorem CategoryTheory.MorphismProperty.IsInvertedBy.of_comp :
    ∀ {C₁ : Type u_2} {C₂ : Type u_3} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_2} C₁]
      [inst_1 : CategoryTheory.Category.{u_6, u_3} C₂] [inst_2 : CategoryTheory.Category.{u_7, u_4} C₃]
      (W : CategoryTheory.MorphismProperty C₁) (F : CategoryTheory.Functor C₁ C₂),
      CategoryTheory.MorphismProperty.IsInvertedBy W F →
        ∀ (G : CategoryTheory.Functor C₂ C₃),
          CategoryTheory.MorphismProperty.IsInvertedBy W (CategoryTheory.Functor.comp F G) :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.IsInvertedBy.of_comp` states that for any two categories `C₁`, `C₂`, and `C₃`, given a `MorphismProperty` `W` in the category `C₁` and a functor `F` from `C₁` to `C₂` which maps all morphisms in `W` to isomorphisms in `C₂`, then for any functor `G` from `C₂` to `C₃`, the composition of the functors `F` and `G` will also map all morphisms in `W` to isomorphisms in `C₃`. This theorem hence ensures that the property of mapping morphisms to isomorphisms is preserved under the composition of functors.

If functors F from C₁ to C₂ and G from C₂ to C₃ preserve a property W of morphisms in C₁, i.e., map all morphisms in W to isomorphisms in their respective categories, then the composition of F and G preserves W, mapping all morphisms in W to isomorphisms in C₃.


theorem TendstoUniformlyOn.tendstoLocallyUniformlyOn :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι} [inst_1 : TopologicalSpace α], TendstoUniformlyOn F f p s → TendstoLocallyUniformlyOn F f p s :=
  by sorry

This theorem states that for any types `α`, `β`, and `ι`, with `β` having a uniform space structure and `α` having a topological space structure, if a sequence of functions `F : ι → α → β` converges uniformly on a set `s` of type `α` to a limiting function `f : α → β` with respect to a filter `p` of type `ι`, then the sequence of functions `F` also converges locally uniformly on the set `s` to the limiting function `f`. In terms of mathematics, given any entourage of the diagonal, we can find an index in the filter such that for all subsequent indices, the function values are in the entourage for all points in the set.

Given a uniform space `(β, ε)`, a topological space `(α, τ)`, a convergent uniformly sequence of functions `F : ι → α → β`, and a filter `p` on `ι`, if `F` converges uniformly on `s subseteq α` to `f : α → β` with respect to `p`, then `F` converges locally uniformly on `s` to `f`.


theorem Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.2 :
    ∀ {α : Type u_1} {s : Set α} {m : MeasurableSpace α}, MeasurableSet sᶜ = MeasurableSet s := by sorry

This theorem states that for any type `α`, any set `s` of type `α`, and any measurable space `m` of type `α`, the complement of `s` is a measurable set if and only if `s` is a measurable set. In mathematical terms, given a measurable space `m` on a type `α`, the complement (denoted by `sᶜ`) of a set `s` in `α` is measurable if `s` itself is measurable.

For any measurable space `m` on type `α`, the complement of a measurable set `s` in `α` is also measurable.


theorem Set.Finite.isOpen_sInter :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set (Set X)}, Set.Finite s → (∀ t ∈ s, IsOpen t) → IsOpen (⋂₀ s) :=
  by sorry

The theorem `Set.Finite.isOpen_sInter` states that for any type `X` with a topological space structure, and for any set `s` which is a set of sets of `X`, if `s` is finite and each set `t` within `s` is open in the topological space, then the intersection of all sets in `s` (denoted by `⋂₀ s`) is also open in the topological space. In other words, the intersection of a finite collection of open sets in a topological space is also an open set.

The intersection of a finite number of open sets in a topological space is open.


theorem Computable.sum_casesOn :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] [inst_3 : Primcodable σ] {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ → σ},
      Computable f → Computable₂ g → Computable₂ h → Computable fun a => Sum.casesOn (f a) (g a) (h a) :=
  by sorry

The theorem `Computable.sum_casesOn` states that for any three types α, β, γ, and σ, where α, β, γ, and σ are primcodable, and given three functions `f : α → β ⊕ γ`, `g : α → β → σ`, and `h : α → γ → σ`, if `f` is computable and both `g` and `h` are computable with two arguments (computable₂), then the function that takes a value of type α and applies `f` to it to produce a value of type β or γ (β ⊕ γ), then depending on the result applies either `g` or `h` to that pair (the original α and the result β or γ), is also computable. In other words, we can always computably decide which of two computable functions to apply based on the result of another computable function.

If `f : α → β ⊕ γ` is computable, `g : α → β → σ` and `h : α → γ → σ` are computable with two arguments, then the function that applies `g` or `h` based on the result of `f` is also computable.


/-- `hasLimitsOfSizeShrink.{v u} C` tries to obtain `HasLimitsOfSize.{v u} C`
from some other `HasLimitsOfSize C`.
 -/
theorem CategoryTheory.Limits.hasLimitsOfSizeShrink :
    ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasLimitsOfSize.{max v₁ v₂, max u₁ u₂, v, u} C],
      CategoryTheory.Limits.HasLimitsOfSize.{v₁, u₁, v, u} C :=
  by sorry

The theorem `CategoryTheory.Limits.hasLimitsOfSizeShrink` in Lean 4 is stating that for any type `C` which is a category and has limits of a certain size (defined by `HasLimitsOfSize.{max v₁ v₂, max u₁ u₂, v, u} C`), we can obtain a category with limits of a smaller size (`HasLimitsOfSize.{v₁, u₁, v, u} C`). In other words, if a category has larger size limits, it can certainly handle smaller size limits.

For any category `C` with limits of size `(max v₁ v₂, max u₁ u₂)`, it has limits of size `(v₁, u₁)`.


/-- Taking the first `n` elements in `l₁ ++ l₂` is the same as appending the first `n` elements
of `l₁` to the first `n - l₁.length` elements of `l₂`.  -/
theorem List.take_append_eq_append_take :
    ∀ {α : Type u_1} {l₁ l₂ : List α} {n : ℕ},
      List.take n (l₁ ++ l₂) = List.take n l₁ ++ List.take (n - List.length l₁) l₂ :=
  by sorry

This theorem states that for any type `α`, any lists `l₁` and `l₂` of that type, and any natural number `n`, taking the first `n` elements from the list formed by appending `l₂` to the end of `l₁` is equivalent to appending the first `n - l₁.length` elements of `l₂` to the end of the first `n` elements of `l₁`. In other words, it shows how the `take` operation distributes over the concatenation of two lists.

For any type `α`, any lists `l₁` and `l₂` of length `m` and `n` respectively, and any natural number `n ≥ m`, the sublist of length `n` obtained by appending `l₂` to `l₁` is equal to the concatenation of the first `n - m` elements of `l₂` and the first `m` elements of `l₁`.


theorem WithTop.coe_one : ∀ {α : Type u} [inst : One α], ↑1 = 1 := by sorry

This theorem states that for any type `α` that has a multiplicative identity (or "one" element), the embedding of the identity element of `α` into the extended type `WithTop α` (which adds an additional "top" element to `α`) is equal to the identity of `WithTop α`. In simpler terms, it asserts that the "one" of `α` is the same as the "one" in its extended type `WithTop α`.

For any type `α` with a multiplicative identity, the identity element of `α` is equal to the multiplicative identity in the extended type `WithTop α`.


theorem Nat.lt_of_lt_pred : ∀ {m n : ℕ}, m < n - 1 → m < n := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `m` is less than `n - 1`, then `m` is also less than `n`. In other words, if a number `m` is less than another number `n` minus one, then `m` is also less than `n`. This is intuitively true because reducing `n` by one results in a number smaller than `n`, so if `m` is smaller than that, it must also be smaller than `n`.

If `m` is a natural number and `m` < `n` implies `m` < `(n - 1)`, then `m` < `n` holds in the natural numbers.


theorem nhds_eq_iInf_abs_sub :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrderedAddCommGroup α] [inst_2 : OrderTopology α]
      (a : α), nhds a = ⨅ r, ⨅ (_ : r > 0), Filter.principal {b | |a - b| < r} :=
  by sorry

This theorem states that for any type `α` that is a topological space, a linear ordered additive commutative group, and whose order induces the topology (this is generally the case for the real numbers, for example), the neighborhood filter at a point `a` (denoted `nhds a`) is equal to the infimum of the principal filters of all sets of the form `{b | |a - b| < r}`, for all positive `r`. In simpler terms, it is saying that the neighborhoods of a point in such a space can be generated by considering all the sets of points that are within a certain positive distance `r` from the point, and taking the infimum of (i.e., the smallest filter containing) the collections of all sets that contain these sets. This is an important concept in topology, as it captures the idea of 'closeness' in a rigorous way.

For any topological space `α` that is a linear ordered additive commutative group with the order inducing the topology, the neighborhood filter at a point `a` equals the infimum of the principal filters of all open balls centered at `a` with positive radius.


theorem AddEquiv.symm_apply_eq :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N) {x : N} {y : M},
      (AddEquiv.symm e) x = y ↔ x = e y :=
  by sorry

The theorem `AddEquiv.symm_apply_eq` states that for any types `M` and `N` that have an addition operation, given an additive isomorphism `e` from `M` to `N`, and any elements `x` of `N` and `y` of `M`, the inverse isomorphism of `e` applied to `x` being equal to `y` is equivalent to `x` being equal to the forward isomorphism `e` applied to `y`. In other words, if we map `y` from `M` to `N` via `e` and get `x`, then mapping `x` back to `M` via the inverse of `e` will get us `y` again. This theorem captures the idea that an isomorphism and its inverse undo each other.

Given additive types M and N with an additive isomorphism e between them, the inverse of e applied to x in N equals y in M if and only if e applied to y in M equals x in N.


theorem isIntegral_algebraMap_iff :
    ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [inst_6 : IsScalarTower R A B] {x : A},
      Function.Injective ⇑(algebraMap A B) → (IsIntegral R ((algebraMap A B) x) ↔ IsIntegral R x) :=
  by sorry

This theorem states that for any commutative rings `R` and `A`, and any ring `B`, where `A` and `B` are algebras over `R` and `A` is an algebra over `B` forming a scalar tower, given any element `x` from `A`, if the algebra map from `A` to `B` is injective, then `x` is integral over `R` with respect to the induced algebra map from `A` to `B` if and only if `x` is integral over `R`. In other words, an element is integral over `R` via the algebra map from `A` to `B` if and only if it is integral over `R` directly, given that the algebra map is injective.

For commutative rings R, A, and B, where A and B are algebras over R with A an algebra over B forming a scalar tower, if the algebra map from A to B is injective, then an element x in A is integral over R with respect to this map if and only if x is integral over R directly.


theorem CategoryTheory.Limits.fst_eq_snd_of_mono_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f],
      CategoryTheory.Limits.pullback.fst = CategoryTheory.Limits.pullback.snd :=
  by sorry

This theorem states that in any category `C`, for any objects `X` and `Y` in `C`, if there is a monomorphism `f` from `X` to `Y`, then the first projection of the pullback of `f` and `f` (i.e., `CategoryTheory.Limits.pullback.fst`) is equal to the second projection of the pullback of `f` and `f` (i.e., `CategoryTheory.Limits.pullback.snd`). In other words, in the pullback square of a monomorphism with itself, both projections are the same. A monomorphism in category theory is a morphism that is left-cancellative, meaning that if two morphisms composed with `f` give the same result, then the two morphisms must be equal.

In any category, for any monomorphism $f : X \rightarrow Y$, the first and second projections of the pullback of $f$ with itself are equal: $CategoryTheory.Limits.pullback.fst (pullback f f) = CategoryTheory.Limits.pullback.snd (pullback f f)$.


theorem Mathlib.Topology.Compactification.OnePoint._auxLemma.2 :
    ∀ {X : Type u_1} (x : X), (↑x = OnePoint.infty) = False := by sorry

This theorem states that for any type `X` and any element `x` of `X`, the assertion that `x` is equal to the point at infinity is always false. In other words, no standard point from the original space `X` can be equal to the added point at infinity in the one-point compactification of `X`.

For any type X and its element x, x is not equal to the point at infinity in the one-point compactification of X.


/-- If `u` is a uniform structures on `β` and `f : γ → β`, then
`𝒰(α, γ, comap f u) = comap (fun g ↦ f ∘ g) 𝒰(α, γ, u₁)`.  -/
theorem UniformFun.comap_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] {f : γ → β},
      UniformFun.uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (UniformFun.uniformSpace α β) :=
  by sorry

The theorem `UniformFun.comap_eq` states that for any types `α`, `β`, and `γ` such that `β` is equipped with a uniform space structure, and for any function `f` from `γ` to `β`, the uniform space of uniform convergence on `α` to `γ` is equivalent to the comap (pre-image under `f`) of the uniform space of uniform convergence on `α` to `β` under the composition operation with `f`. In simpler terms, this theorem relates the notions of uniform convergence and function composition in the context of uniform spaces.

For any uniform spaces X, Y, Z, and function f : Z → Y, the uniform convergence of functions from X to Z is equivalent to the uniform convergence of their compositions with f from X to Y.


theorem List.Lex.to_ne : ∀ {α : Type u} {l₁ l₂ : List α}, List.Lex (fun x x_1 => x ≠ x_1) l₁ l₂ → l₁ ≠ l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of this type, if there exists a lexicographical order (denoted by `List.Lex`) between `l₁` and `l₂` such that no two elements `x` and `x_1` are equal (denoted by `x ≠ x_1`), then `l₁` is not equal to `l₂`. In other words, if two lists are different in a lexicographical order which does not allow equal elements, then the lists themselves are not equal.

If `α` is a type and `l₁` and `l₂` are two lists of type `α` such that `l₁` is lexicographically smaller than `l₂` and no element in `l₁` is equal to any element in `l₂`, then `l₁ ≠ l₂`.


theorem Asymptotics.isBigOWith_const_mul_self :
    ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] (c : R) (f : α → R) (l : Filter α),
      Asymptotics.IsBigOWith ‖c‖ l (fun x => c * f x) f :=
  by sorry

The theorem `Asymptotics.isBigOWith_const_mul_self` states that for any seminormed ring `R`, a constant `c` in `R`, a function `f` from a generic type `α` to `R`, and a filter `l` on `α`, the function `c * f` is big-O of `f` with respect to the filter `l` and the constant factor `‖c‖`. In other words, the values of `c * f` are eventually bounded by `‖c‖ * ‖f‖` for the filter `l`. This means that the growth rate of the function `c * f` is at most as fast as the function `f`, up to a constant factor of `‖c‖`.

For any seminormed ring `R`, constant `c` in `R`, function `f` from a type `α` to `R`, and filter `l` on `α`, `c * f` is big-O of `f` with constant factor `‖c‖` with respect to the filter `l`.


theorem Polynomial.normalize_content :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] {p : Polynomial R},
      normalize (Polynomial.content p) = Polynomial.content p :=
  by sorry

The theorem `Polynomial.normalize_content` states that for any commutative ring `R` which is also a domain and a normalized GCD monoid, and for any polynomial `p` with coefficients in `R`, the normalized content of the polynomial (i.e., the content obtained by multiplying the GCD of the coefficients by its normalization unit) is equal to its original content. In other words, normalization does not change the content of the polynomial.

For any commutative domain and normalized GCD monoid ring R and polynomial p with coefficients in R, the normalized content of p equals its original content.


theorem HasStrictDerivAt.hasStrictFDerivAt_equiv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {f : 𝕜 → 𝕜} {f' x : 𝕜},
      HasStrictDerivAt f f' x →
        ∀ (hf' : f' ≠ 0), HasStrictFDerivAt f (↑((ContinuousLinearEquiv.unitsEquivAut 𝕜) (Units.mk0 f' hf'))) x :=
  by sorry

The theorem `HasStrictDerivAt.hasStrictFDerivAt_equiv` states that given any type `𝕜` that is a nontrivially normed field, for any function `f : 𝕜 → 𝕜`, if `f` has a strict derivative `f'` at a point `x` (in the sense that `f y - f z = (y - z) • f' + o(y - z)` as `y, z → x`), and `f'` is not zero, then `f` has a strict Frechet derivative at `x`. This Frechet derivative is given by the continuous linear equivalence induced by embedding `f'` (which is nonzero) into the group of units of `𝕜`, which is then automatically a multiplicative group with zero removed.

If `𝕜` is a nontrivially normed field, `f : 𝕜 → 𝕜` has a nonzero strict derivative `f'` at `x ∈ 𝕜`, then `f` has a strict Frechet derivative at `x` given by the continuous linear equivalence induced by `f'` embedded in the multiplicative group of units of `𝕜`.


theorem nhdsWithin_eq_nhds :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, nhdsWithin a s = nhds a ↔ s ∈ nhds a := by sorry

This theorem states that for any type `α` with a topological space structure, any element `a` of `α`, and any set `s` of `α`, the neighborhood within `s` of `a` is equal to the neighborhood of `a` if and only if `s` is a neighborhood of `a`. In other words, it describes a condition under which a "restricted" neighborhood (one confined to a certain set) is equivalent to a general neighborhood in a topological space.

For any topological space `(α, τ)` and element `a` in `α`, a set `s` is a neighborhood of `a` if and only if the neighborhood of `a` within `s` is equal to `s`.


theorem mul_boole :
    ∀ {α : Type u_1} [inst : MulZeroOneClass α] (P : Prop) [inst_1 : Decidable P] (a : α),
      (a * if P then 1 else 0) = if P then a else 0 :=
  by sorry

This theorem, `mul_boole`, states that for any type `α` that belongs to `MulZeroOneClass` (meaning `α` has multiplication, and has elements designated as zero and one), along with a proposition `P` and an element `a` of `α`, the product of `a` and `1` (if `P` is true) or `0` (if `P` is false) is equal to `a` (if `P` is true) or `0` (if `P` is false). Essentially, this theorem captures the idea that multiplicative identity and zero in a `MulZeroOneClass` work as expected in relation to a decidable proposition.

For any type `α` in `MulZeroOneClass` and proposition `P`: `(1 * a) = a <=> P` and `(0 * a) = 0 <=> ≠P`, where `<=>` denotes logical equivalence.


/-- The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later.  -/
theorem SetTheory.PGame.le_def :
    ∀ {x y : SetTheory.PGame},
      x ≤ y ↔
        (∀ (i : SetTheory.PGame.LeftMoves x),
            (∃ i', SetTheory.PGame.moveLeft x i ≤ SetTheory.PGame.moveLeft y i') ∨
              ∃ j, SetTheory.PGame.moveRight (SetTheory.PGame.moveLeft x i) j ≤ y) ∧
          ∀ (j : SetTheory.PGame.RightMoves y),
            (∃ i, x ≤ SetTheory.PGame.moveLeft (SetTheory.PGame.moveRight y j) i) ∨
              ∃ j', SetTheory.PGame.moveRight x j' ≤ SetTheory.PGame.moveRight y j :=
  by sorry

This theorem defines the order relation "less than or equal to" (≤) for pre-games in terms of the same relation two moves later. Specifically, it states that for any two pre-games x and y, x is less than or equal to y if and only if the following two conditions are met:

- For every allowed move i by the Left player in the game x, there exists either a move i' in the game y such that moving Left in x followed by i results in a game less than or equal to moving Left in y followed by i', or there exists a move j such that moving Right after moving Left in x results in a game less than or equal to y.
- For every allowed move j by the Right player in the game y, there exists either a move i such that x is less than or equal to moving Left after moving Right in y, or there exists a move j' in x such that moving Right in x results in a game less than or equal to moving Right in y.

For pre-games x and y, x ≤ y if and only if, for every move i by the Left player in x and every move j by the Right player in y, there exist corresponding moves with x ≤ moving Left after moving i in y and moving j in x ≤ moving Right in y.


theorem Finset.sup_inf_distrib_right :
    ∀ {α : Type u_2} {ι : Type u_5} [inst : DistribLattice α] [inst_1 : OrderBot α] (s : Finset ι) (f : ι → α) (a : α),
      Finset.sup s f ⊓ a = Finset.sup s fun i => f i ⊓ a :=
  by sorry

This theorem, named `Finset.sup_inf_distrib_right`, states that for any type `α` which forms a distributive lattice and also has a bottom element, any finite set `s` of elements of type `ι`, any function `f` from `ι` to `α`, and any element `a` of type `α`, the supremum (greatest element) of the image of `s` under `f`, intersected with `a`, is equal to the supremum of the image of `s` under the function that maps each element of `s` to its image under `f` intersected with `a`. In mathematical terms, it asserts that the operation of taking the supremum of a set and intersecting with an element distributes over the elements of the set: $\bigvee_{i \in s} f(i) \wedge a = \bigvee_{i \in s} (f(i) \wedge a)$.

For any distributive lattice `α` with bottom element and finite set `s` from index type `ι`, the supremum of images of `s` under `f` intersected with an element `a` is equal to the supremum of images of `s` under the function that maps each element to its intersection with `a`. In other words, $\bigvee_{i \in s} (f(i) \wedge a) = \bigvee_{i \in s} f(i) \wedge a$.


/-- Having the same density implies the underlying functions are equal almost everywhere.  -/
theorem MeasureTheory.Integrable.ae_eq_of_withDensityᵥ_eq :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_3} [inst : NormedAddCommGroup E]
      [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {f g : α → E},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ →
          MeasureTheory.Measure.withDensityᵥ μ f = MeasureTheory.Measure.withDensityᵥ μ g →
            f =ᶠ[MeasureTheory.Measure.ae μ] g :=
  by sorry

The theorem states that for any measurable space `α` and measure `μ` on that space, and for any two functions `f` and `g` from `α` to a real complete normed group `E`, if both `f` and `g` are integrable with respect to `μ`, and the measures with respect to `μ` considering `f` and `g` as densities are the same, then `f` and `g` are equal almost everywhere. In other words, if two functions have the same density with respect to a measure, they differ only on a set of measure zero.

If two integrable functions from a measurable space to a real complete normed group have the same density with respect to a measure, then they are equal almost everywhere.


theorem not_isPrimePow_zero :
    ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [inst_1 : NoZeroDivisors R], ¬IsPrimePow 0 := by sorry

The theorem `not_isPrimePow_zero` states that, for all types `R` which have an instance of `CommMonoidWithZero` and `NoZeroDivisors`, zero is not a prime power. In other words, there does not exist a prime number `p` and a positive natural number `k` such that `p` raised to the power of `k` equals zero.

For types endowed with a CommMonoidWithZero and NoZeroDivisors structure, zero has no prime power representation.


theorem Mathlib.Data.Set.Image._auxLemma.23 :
    ∀ {α : Sort u} {b : α → Sort v} {p : (x : α) → b x → Prop}, (∀ (x : α), ∃ y, p x y) = ∃ f, ∀ (x : α), p x (f x) :=
  by sorry

The theorem states that for any function `p` from pairs `(x, y)`, where `x` is of some type `α` and `y` is of type `b x`, if for every `x` in `α` there exists a `y` such that `p x y` holds, then there exists a function `f` from `α` to `b x` such that for every `x` in `α`, `p x (f x)` holds. In simpler terms, this theorem asserts the equivalence of the existence of an element for each input satisfying a property and the existence of a function encapsulating this relationship.

If for every `x` in `α`, there exists a `y` of type `b x` such that `p(x, y)` holds, then there exists a function `f` from `α` to `b` such that `p(x, f(x))` holds for all `x` in `α`.


/-- **Alias** of the forward direction of `PartialHomeomorph.IsImage.iff_preimage_eq`. -/
theorem PartialHomeomorph.IsImage.preimage_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t → e.source ∩ ↑e ⁻¹' t = e.source ∩ s :=
  by sorry

This theorem, named `PartialHomeomorph.IsImage.preimage_eq`, states the following:

For any types `X` and `Y` equipped with topological spaces, a partial homeomorphism `e` from `X` to `Y`, and sets `s` of `X` and `t` of `Y`, if `t` is an image of `s` under the partial homeomorphism `e`, then the intersection of the source of `e` with the preimage of `t` under `e` is equal to the intersection of the source of `e` with `s`.

Simply put, it means that when set `t` is formed by applying the partial homeomorphism `e` on set `s`, the elements of `s` that are mapped by `e` match exactly with those elements of `t` that are associated with the source of `e` through the inverse mapping of `e`.

If `e: X ↪ Y` is a partial homeomorphism, `s ⊆ X`, and `t = e''(s)`, then `s ∩ e^(-1)(t) = s`.


/-- Reversing the order of the points passed to `oangle` negates the angle.  -/
theorem EuclideanGeometry.oangle_rev :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] (p₁ p₂ p₃ : P),
      EuclideanGeometry.oangle p₃ p₂ p₁ = -EuclideanGeometry.oangle p₁ p₂ p₃ :=
  by sorry

The theorem `EuclideanGeometry.oangle_rev` states that for any three points `p₁`, `p₂`, and `p₃` in a 2-dimensional Euclidean space over the reals with a given orientation, the oriented angle `oangle` from `p₃` to `p₂` then to `p₁` is the negative of the oriented angle from `p₁` to `p₂` then to `p₃`. Here, `oangle` is a function representing the oriented angle between three points. This implies that reversing the order of the points results in an orientation-reversed angle.

The oriented angle from point `p₃` to `p₂` then to `p₁` is the negative of the oriented angle from `p₁` to `p₂` then to `p₃` in a 2-dimensional Euclidean space.


theorem Mathlib.Logic.Equiv.PartialEquiv._auxLemma.6 :
    ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) := by sorry

This theorem, named Mathlib.Logic.Equiv.PartialEquiv._auxLemma.6, states that for any type `α`, any element `x` of type `α`, and any two sets `a` and `b` of type `α`, the membership of `x` in the intersection of `a` and `b` is equivalent to `x` being a member of `a` and `x` being a member of `b`. This is conceptually similar to the mathematical set theory axiom that an element belongs to the intersection of two sets if and only if it belongs to both sets.

For any type `α` and sets `a` and `b` of type `α`, the element `x` belongs to the intersection `a ∩ b` if and only if `x` belongs to both `a` and `b` (i.e., `x ∈ a ∧ x ∈ b`).


theorem Mathlib.Logic.Equiv.PartialEquiv._auxLemma.7 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem states that for any type `α` and `β`, any function `f` from `α` to `β`, any set `s` of type `β`, and any element `a` of type `α`, the element `a` is in the preimage of the set `s` under the function `f` if and only if the image of `a` under `f` is in the set `s`. In mathematical terms, if we denote the preimage of a set `s` under a function `f` as `f⁻¹(s)`, then `a ∈ f⁻¹(s)` if and only if `f(a) ∈ s`.

For any function `f` from type `α` to type `β`, and sets `s ∈ β`, the element `a ∈ α` belongs to the preimage `f⁻¹(s)` if and only if the image `f(a)` is in `s`.


theorem CategoryTheory.Limits.Trident.app_zero :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)}
      (s : CategoryTheory.Limits.Trident f) (j : J),
      CategoryTheory.CategoryStruct.comp (s.π.app CategoryTheory.Limits.WalkingParallelFamily.zero) (f j) =
        s.π.app CategoryTheory.Limits.WalkingParallelFamily.one :=
  by sorry

The theorem `CategoryTheory.Limits.Trident.app_zero` states that for any category `C`, and any objects `X` and `Y` in `C`, given a function `f` from some type `J` to the Hom-set `Hom(X, Y)`, and given a trident structure `s` on `f`, for any element `j` of `J`, the composition of the morphism at the 'zero' position in the trident with `f(j)` is equal to the morphism at the 'one' position in the trident. In other words, in the context of category theory, this theorem asserts a particular commutative property of a trident structure on a parallel family of morphisms.

For any category C, given a trident structure on a family of morphisms f from an index type J to Hom(X, Y), the composition of the morphism at the 'zero' position with f(j) equals the morphism at the 'one' position for all j in J.


IsAsymm.isIrrefl

theorem IsAsymm.isIrrefl : ∀ {α : Type u} {r : α → α → Prop} [inst : IsAsymm α r], IsIrrefl α r := by sorry

This theorem states that, for any type `α` and a relation `r` over `α`, if `r` is asymmetric, then `r` is also irreflexive. In more mathematical terms, if for all `a` and `b` of type `α`, `r(a, b)` implies not `r(b, a)`, then for all `a` of type `α`, not `r(a, a)` holds. In simpler terms, if a relation doesn't allow both `r(a, b)` and `r(b, a)` to be true for any distinct elements `a` and `b`, then it also doesn't allow `r(a, a)` to be true for any element `a`.

If a relation `r` over type `α` is asymmetric (i.e., `r(a, b)` implies `not r(b, a)` for all `a` and `b`), then it is irreflexive (i.e., `not r(a, a)` for all `a` in `α`).


theorem CategoryTheory.unop_id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : Cᵒᵖ},
      (CategoryTheory.CategoryStruct.id X).unop = CategoryTheory.CategoryStruct.id X.unop :=
  by sorry

This theorem states that for any Category `C` and any object `X` in the opposite category `Cᵒᵖ`, the unop of the identity morphism on `X` is equal to the identity morphism on the unop of `X`. In more mathematical terms, it says that unopping the identity does not change the identity, i.e., if we take an object in the opposite category, its identity morphism remains the same even if we apply the unop operation.

For any category `C` and object `X` in `Cᵒᵖ`, the unop of the identity morphism on `X` equals the identity morphism on the unop of `X`. In other words, `(id_X)ᵒᵖ = id_(Xᵒᵖ)` in `C`.


theorem SimpleGraph.connected_induce_iff :
    ∀ {V : Type u} {G : SimpleGraph V} {s : Set V},
      SimpleGraph.Connected (SimpleGraph.induce s G) ↔
        SimpleGraph.Subgraph.Connected (SimpleGraph.Subgraph.induce ⊤ s) :=
  by sorry

This theorem states that for any given type `V`, a simple graph `G` of type `V`, and a set `s` of type `V`, the graph `G` is connected when induced by the set `s` if and only if the induced subgraph of `G` by the set `s` is a connected subgraph of the "top" subgraph of `G`. In other words, restricting the graph `G` to the vertices in set `s` and deleting all edges incident to vertices outside the set `s` will result in a connected graph if and only if the induced subgraph formed by considering `s` as the new vertex set and inducing edges from the original graph `G` also forms a connected subgraph. This theorem shows the equivalence of two different ways of forming subgraphs and their connection properties.

A simple graph induced by a set of vertices is connected if and only if the subgraph formed by considering that set as the new vertex set and inducing edges from the original graph is also connected.


theorem LinearMap.ker_codRestrict :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₂₁ : R₂ →+* R} (p : Submodule R M) (f : M₂ →ₛₗ[τ₂₁] M) (hf : ∀ (c : M₂), f c ∈ p),
      LinearMap.ker (LinearMap.codRestrict p f hf) = LinearMap.ker f :=
  by sorry

The theorem `LinearMap.ker_codRestrict` states that for any semirings `R` and `R₂`, any additive commutative monoids `M` and `M₂`, any `R`-module `M` and `R₂`-module `M₂`, a ring homomorphism `τ₂₁` from `R₂` to `R`, a submodule `p` of `M`, and a linear map `f` from `M₂` to `M` such that all values of `f` lie in `p`, the kernel (set of elements mapped to zero) of the linear map obtained by restricting the codomain of `f` to `p` is equal to the kernel of `f` itself. Therefore, binding the codomain does not change the elements that are mapped to zero by the linear map.

The kernel of a linear map from one R-module to another, restricted to a submodule where all its values lie, is equal to the map's kernel itself.


/-- If $x ≤ f x$ for all $x$ (we write this as `id ≤ f`), then the same is true for any iterate
`f^[n]` of `f`.  -/
theorem Function.id_le_iterate_of_id_le :
    ∀ {α : Type u_1} [inst : Preorder α] {f : α → α}, id ≤ f → ∀ (n : ℕ), id ≤ f^[n] := by sorry

This theorem states that if a function `f` applied to any `x` is always greater than or equal to `x` itself (expressed as `id ≤ f`), then this property holds true for any number of iterations of `f` on `x`. In other words, if `f(x) ≥ x` for all `x`, then `f(f(f ...(n times)... f(x))) ≥ x` for any natural number `n`. Here, `α` is a type with a preorder, meaning that it has a binary relation that is reflexive and transitive.

If `f : α -> α` satisfies `id ≤ f` (where `id` is the identity function on type `α`), then for any natural number `n`, `f^n(x) geq x` holds for all `x` in `α`. (Here, `f^n` denotes the `n`-th composition of `f` with itself.)


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

This theorem states that for any two nonnegative real numbers `x` and `y`, and any real number `z` that is greater than zero, `x` raised to the power `z` is less than or equal to `y` raised to the power `z` if and only if `x` is less than or equal to `y`. This is a property of exponents in the real number system.

For any nonnegative real numbers x and y, and positive real number z, x^z ≤ y^z if and only if x ≤ y.


theorem Set.iInter_subtype :
    ∀ {α : Type u_1} {β : Type u_2} (p : α → Prop) (s : { x // p x } → Set β),
      ⋂ x, s x = ⋂ x, ⋂ (hx : p x), s { val := x, property := hx } :=
  by sorry

This theorem states that for any two types `α` and `β`, and for any predicate `p` acting on elements of `α`, the nested intersection over all the sets `s x`, where `x` is an element of the subtype `{ x // p x }`, is equivalent to the intersection over all elements `x` and for every proof `hx` that `p x` holds, the sets `s { val := x, property := hx }`. In other words, it states that the intersection over sets using elements of a subtype is the same as the intersection over sets using elements and the corresponding proofs of a certain predicate.

For any types `α`, predicate `p` on `α`, and subsets `s` indexed by elements `x` in the subtype `{ x // p x },` the intersection of all `s x` is equal to the intersection of all sets `s { x // hx }` for every `x` and proof `hx` of `p x`.


theorem Primrec₂.natPair : Primrec₂ Nat.pair := by sorry

This theorem states that the natural number pairing function `Nat.pair` is a binary primitive recursive function. In other words, given two natural numbers as inputs, the function combines them into a single number in such a way that original numbers can be recovered from it, and this process is achieved through a sequence of basic arithmetic operations, which shows the primality of the function. The representation of this function in Lean, as `Primrec₂ Nat.pair`, underlines the computability aspect of it.

The natural number pairing function `Nat.pair` is a primitive recursive function.


theorem FirstOrder.Language.Substructure.closure_eq_of_le :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      {S : FirstOrder.Language.Substructure L M} {s : Set M},
      s ⊆ ↑S →
        S ≤ (FirstOrder.Language.Substructure.closure L).toFun s →
          (FirstOrder.Language.Substructure.closure L).toFun s = S :=
  by sorry

This theorem states that for any first-order language `L` and any type `M` with a structure for `L`, given a substructure `S` of `L` on `M`, and a set `s` of elements of `M`, if `s` is a subset of `S` and `S` is less than or equal to the substructure generated by `s`, then the substructure generated by `s` is exactly `S`. In other words, the closure operation that generates the smallest substructure containing a given set is idempotent and preserves order: if `s` is already closed (i.e., is a substructure), the closure operation doesn't change `s`, and if `s` is a proper subset of a substructure `S`, the closure operation can't "jump over" `S` to produce a larger substructure.

If `S` is a substructure of `M` in a first-order language `L`, and `s` is a subset of `M` that is closed under `S`, then `s` equals `S`.


theorem Subgroup.MemRightTransversals.mul_inv_toFun_mem :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {S : Set G} (hS : S ∈ Subgroup.rightTransversals ↑H) (g : G),
      g * (↑(Subgroup.MemRightTransversals.toFun hS g))⁻¹ ∈ H :=
  by sorry

The theorem `Subgroup.MemRightTransversals.mul_inv_toFun_mem` states that for any group `G`, subgroup `H` of `G`, and any set `S` that is a right transversal of `H` (i.e., `S` is in the set of right transversals of `H`), for any element `g` of the group `G`, the product of `g` and the inverse of the chosen representative of the right coset of `g` (which is obtained by applying the function `Subgroup.MemRightTransversals.toFun` to `g`) is an element of the subgroup `H`. In simpler terms, this theorem captures the property that multiplying an element of a group by the inverse of its representative from a right transversal, gives us an element of the original subgroup.

For any group G, subgroup H, and right transversal S of H, the product of any g in G and the inverse of its representative in S belongs to H.


theorem Multiset.fold_add :
    ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b₁ b₂ : α)
      (s₁ s₂ : Multiset α),
      Multiset.fold op (op b₁ b₂) (s₁ + s₂) = op (Multiset.fold op b₁ s₁) (Multiset.fold op b₂ s₂) :=
  by sorry

The theorem `Multiset.fold_add` states that for any type `α`, any binary operation `op` on `α` that is both commutative and associative, any two elements `b₁` and `b₂` of `α`, and any two multisets `s₁` and `s₂` of elements of `α`, the result of folding `op` over the combination of `s₁` and `s₂` starting from `op b₁ b₂` is the same as applying `op` to the result of folding `op` over `s₁` starting from `b₁` and the result of folding `op` over `s₂` starting from `b₂`. In mathematical terms, this states that for all such `op`, `b₁`, `b₂`, `s₁`, `s₂`, we have `Multiset.fold op (op b₁ b₂) (s₁ + s₂) = op (Multiset.fold op b₁ s₁) (Multiset.fold op b₂ s₂)`. This is essentially a distributive property of the `Multiset.fold` operation over multiset addition.

For any commutative and associative binary operation `op` on type `α`, and multisets `s₁` and `s₂` of `α`, we have `Multiset.fold op (op (b₁ :: s₁) b₂ :: s₂) = op (Multiset.fold op b₁ s₁) (Multiset.fold op b₂ s₂)`, where `b₁` and `b₂` are elements of `α`.


theorem List.drop_left : ∀ {α : Type u_1} (l₁ l₂ : List α), List.drop (List.length l₁) (l₁ ++ l₂) = l₂ := by sorry

This theorem states that for any type `α` and for any two lists `l₁` and `l₂` of this type, when you concatenate the two lists (`l₁ ++ l₂`) and then remove the first `List.length l₁` elements from the result, you end up with the second list `l₂`.

In other terms, if you have two lists and you append the second list to the first one, dropping the elements of the combined list that are equivalent in length to the first list will leave you with the second list. This is in line with our intuitive understanding of list concatenation and element dropping.

For any type `α` and lists `l₁` and `l₂` of length `m` and `n` respectively, `(l₁ ++ l₂).drop(m) = l₂`.


theorem AddMonoidHom.mrange_top_iff_surjective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
      AddMonoidHom.mrange f = ⊤ ↔ Function.Surjective ⇑f :=
  by sorry

The theorem `AddMonoidHom.mrange_top_iff_surjective` states that for any types `M` and `N` that are instances of the `AddZeroClass`, any type `F` that is a `FunLike` from `M` to `N` and belongs to `AddMonoidHomClass`, and any function `f` of type `F`, the range of the monoid homomorphism `f` is equal to the entire set (denoted by `⊤`) if and only if the function `f` is surjective. In other words, a monoid homomorphism from `M` to `N` covers the entire target set `N` if and only if for every element in the target set `N`, there exists an element in the source set `M` that `f` maps to it.

A monoid homomorphism between additive structures is surjective if and only if its range is the entire target set.


theorem countable_iff_exists_surjective :
    ∀ {α : Sort u} [inst : Nonempty α], Countable α ↔ ∃ f, Function.Surjective f := by sorry

This theorem, `countable_iff_exists_surjective`, states that for any type `α` (which must be nonempty), `α` is countable if and only if there exists a surjective function `f`. A surjective function `f` from type `α` to another type, is a function such that for every element in the second type, there is at least one element in the first type `α` that maps to it under `f`. In mathematical terms, this is saying that a set is countable if and only if there exists a function that is surjective (onto) from the set to the set of natural numbers.

A nonempty type `α` is countable if and only if there exists a surjective function from `α` to the natural numbers.


theorem SimpleGraph.Walk.isTrail_def :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      SimpleGraph.Walk.IsTrail p ↔ List.Nodup (SimpleGraph.Walk.edges p) :=
  by sorry

This theorem states that for any simple graph `G` with vertices of type `V`, and any walk `p` from vertex `u` to vertex `v` in `G`, the walk `p` is a trail if and only if the list of edges visited by `p` has no duplicates. In other words, a walk is defined as a trail when each edge in the graph is visited at most once.

A simple graph walk from vertex `u` to vertex `v` is a trail if and only if the set of edges visited during the walk is a subset of the graph's edge set with no repeated elements.


theorem Real.sqrt_lt_sqrt_iff : ∀ {x y : ℝ}, 0 ≤ x → (Real.sqrt x < Real.sqrt y ↔ x < y) := by sorry

The theorem `Real.sqrt_lt_sqrt_iff` states that for any two real numbers `x` and `y`, if `x` is non-negative, then the square root of `x` is less than the square root of `y` if, and only if, `x` is less than `y`. This means that the ordering of the numbers `x` and `y` is preserved when taking their square roots, as long as `x` is non-negative.

For any non-negative real numbers `x` and `y`, `sqrt x < sqrt y` if and only if `x < y`.


theorem IsLUB.isLUB_of_tendsto :
    ∀ {α : Type u} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : Preorder γ] [inst_4 : TopologicalSpace γ] [inst_5 : OrderClosedTopology γ] {f : α → γ} {s : Set α}
      {a : α} {b : γ},
      MonotoneOn f s → IsLUB s a → Set.Nonempty s → Filter.Tendsto f (nhdsWithin a s) (nhds b) → IsLUB (f '' s) b :=
  by sorry

The theorem `IsLUB.isLUB_of_tendsto` in Lean 4 states that for any types `α` and `γ`, given a topological space structure on `α`, a linear order on `α`, an order topology on `α`, a preorder on `γ`, a topological space structure on `γ`, and an order-closed topology on `γ`, along with a function `f` from `α` to `γ`, a set `s` of type `α`, and elements `a` of type `α` and `b` of type `γ`, if the function `f` is monotone on the set `s`, `a` is a least upper bound of the set `s`, the set `s` is nonempty, and `f` tends to `b` within `s` near `a`, then `b` is a least upper bound of the image of `s` under `f`.

In simpler terms, if we have a function `f` that is monotone on a nonempty set `s`, and `a` is a least upper bound of `s`, then if the function `f` continues to approach `b` as `f`s values get closer and closer to `a` within `s`, `b` will be the least upper bound of the values of `f` at `s`. This theorem is a bridging result between order theory and topology, which are two important branches of mathematics.

If `f` is a monotone function from a nonempty, order-closed set `s` with a least upper bound `a` in a topological space `α` with an order topology, and `f(a)` is a limit point of `f(s)` as `x` approaches `a` in `α`, then `f(a)` is the least upper bound of `f(s)`.