theorem LocallyConstant.congrLeftₐ.proof_1 :
    ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
      Continuous ⇑(Homeomorph.symm e) :=
  by sorry

This theorem, `LocallyConstant.congrLeftₐ.proof_1`, states that for all types `X` and `Y`, where both `X` and `Y` are equipped with a topological space structure (symbolized by `TopologicalSpace X` and `TopologicalSpace Y`), if there exists a homeomorphism `e` from `X` to `Y`, then the inverse function of `e` is continuous. The inverse function is obtained by applying the `Homeomorph.symm` operation to `e`. In mathematical terms, given a homeomorphism $\approx_t : X \rightarrow Y$, its inverse $\approx_t^{-1} : Y \rightarrow X$ is always continuous.

If `X` and `Y` are topological spaces with a homeomorphism `e : X ≈ Y`, then the inverse `e⁻¹` of `e` is a continuous function from `Y` to `X`.


theorem Primrec.nat_mul : Primrec₂ fun x x_1 => x * x_1 := by sorry

This theorem states that the multiplication of two natural numbers is a binary primitive recursive function. In other words, the function `f(x, x_1) = x * x_1` is primitive recursive, where `x` and `x_1` are natural numbers. Primitive recursive functions are a class of functions which are computable in a certain sense, and this theorem confirms that natural number multiplication falls into this category.

The natural number multiplication function is primitive recursive.


theorem Associates.one_le : ∀ {α : Type u_1} [inst : CommMonoid α] {a : Associates α}, 1 ≤ a := by sorry

The theorem `Associates.one_le` states that, for any commutative monoid `α` and any element `a` of the set of associates of `α`, the monoid unit (1) is less than or equal to `a`. In other words, for any `a` in the quotient of a commutative monoid by the associated relation (two elements `x` and `y` are associated if there is a unit `u` such that `x * u = y`), `1` is not greater than `a`.

For any commutative monoid and any element in its associated equivalence class, the monoid unit is less than or equal to that element.


theorem YoungDiagram.rowLens_sorted :
    ∀ (μ : YoungDiagram), List.Sorted (fun x x_1 => x ≥ x_1) (YoungDiagram.rowLens μ) := by sorry

This theorem states that for any Young diagram `μ`, the list of its row lengths, obtained by the function `YoungDiagram.rowLens`, is sorted in a non-increasing order. In other words, for any two elements `x` and `x_1` in the list, `x` is greater than or equal to `x_1`. The relation `x ≥ x_1` is a "greater than or equal to" relation, which is transitive and antisymmetric.

For any Young diagram, the list of its row lengths, as obtained by `YoungDiagram.rowLens`, is non-decreasing.


/-- **Alias** of `not_btw_of_sbtw`. -/
theorem SBtw.sbtw.not_btw : ∀ {α : Type u_1} [inst : CircularPreorder α] {a b c : α}, sbtw a b c → ¬btw c b a := by
  sorry

This theorem states that for any type `α` that has a CircularPreorder relation, and for any three elements `a`, `b`, and `c` of this type, if 'strictly between' (`sbtw`) relation holds for `a`, `b`, `c` (i.e., `b` is strictly between `a` and `c`), then 'between' (`btw`) relation cannot hold for `c`, `b`, `a` (i.e., `b` cannot be between `c` and `a`). In other words, if `b` is strictly between `a` and `c`, then `b` cannot be between `a` and `c` in the reverse order.

If `β:` CircularPreorder α, `a b c:` α, and `b` is strictly between `a` and `c` (`b sbtw a c`), then `b` is not between `c` and `a` (`~b btw c a`).


theorem Nat.le_findGreatest :
    ∀ {m : ℕ} {P : ℕ → Prop} [inst : DecidablePred P] {n : ℕ}, m ≤ n → P m → m ≤ Nat.findGreatest P n := by sorry

This theorem, `Nat.le_findGreatest`, asserts that for any natural number `m` and a decidable predicate `P` (a predicate for which we can definitively say whether it is true or false), if `m` is less than or equal to `n` and `P(m)` holds true, then `m` is less than or equal to the greatest natural number `i` less than or equal to `n` for which `P(i)` holds. In other words, if `m` satisfies the predicate `P` and is within the bounds of `n`, it cannot be larger than the greatest such number that fulfills these conditions.

For all natural numbers `m` and `n` and decidable predicate `P`, if `m` is less than or equal to `n` and `P(m)` holds, then `m` is less than or equal to the greatest `i` less than or equal to `n` with `P(i)` holding.


/-- If a Cauchy sequence has a convergent subsequence, then it converges.  -/
theorem tendsto_nhds_of_cauchySeq_of_subseq :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : Preorder β] {u : β → α},
      CauchySeq u →
        ∀ {ι : Type u_1} {f : ι → β} {p : Filter ι} [inst_1 : Filter.NeBot p],
          Filter.Tendsto f p Filter.atTop →
            ∀ {a : α}, Filter.Tendsto (u ∘ f) p (nhds a) → Filter.Tendsto u Filter.atTop (nhds a) :=
  by sorry

The theorem `tendsto_nhds_of_cauchySeq_of_subseq` states that for any Cauchy sequence `u` in a uniform space `α` (with `α` ordered in a certain way), if there exists a subsequence `f` (indexed over some set `ι`) that converges to some limit `a`, then the original sequence `u` also converges to the same limit `a`. Here, the convergence of the subsequence `f` is defined as the fact that for every neighborhood of `a`, there exists a point in the filter `p` (which is assumed to be non-empty) such that all subsequent elements of the sequence are in that neighborhood. Similarly, the convergence of the original sequence is defined as the fact that for every neighborhood of `a`, there exists a point beyond which all elements of the sequence are in that neighborhood.

If a Cauchy sequence in a uniform space converges through a subsequence to a limit, then the original sequence converges to the same limit.


theorem Set.SurjOn.mapsTo_invFunOn :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} [inst : Nonempty α],
      Set.SurjOn f s t → Set.MapsTo (Function.invFunOn f s) t s :=
  by sorry

This theorem states that for all types `α` and `β`, for any sets `s` of type `α` and `t` of type `β`, and for any function `f` from `α` to `β`, given that `α` is nonempty, if `f` is a surjective function from `s` to `t`, then the inverse function of `f` on the domain `s` maps `t` into `s`. In other words, if for every element in `t`, there is an element in `s` such that the function `f` applied on this element of `s` gives the element of `t` (which is the definition of surjectivity of `f` from `s` to `t`), then every element of `t`, when the inverse function is applied on it, will fall into set `s`.

If `α` is nonempty and `f` is a surjective function from a set `s` of type `α` to a set `t` of type `β`, then the inverse function of `f` maps `t` into `s`.


CategoryTheory.Abelian.coimage.fac

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

The theorem `CategoryTheory.Abelian.coimage.fac` asserts that for any categories `C` with zero morphisms, kernels, and cokernels, and for any morphism `f` from `P` to `Q` in `C`, the composition of the canonical morphism `π` (the projection onto the coimage of `f`) and the factorization of `f` through its coimage is equal to `f` itself. Essentially, it encapsulates the property that any morphism in an Abelian category factors through its coimage, with the factorization being mediated by the canonical projection onto the coimage.

In an Abelian category with zero morphisms, for any morphism `f`, the composition of `f` with the canonical projection onto the coimage of `f` is equal to the factorization of `f` through its coimage.


theorem List.Func.get_eq_default_of_le :
    ∀ {α : Type u} [inst : Inhabited α] (k : ℕ) {as : List α}, List.length as ≤ k → List.Func.get k as = default := by
  sorry

The theorem `List.Func.get_eq_default_of_le` states that for any type `α` that has a default value (`Inhabited α`), any natural number `k`, and any list `as` of type `α`, if the length of the list `as` is less than or equal to `k`, then accessing the `k`-th element of the list `as` by the function `List.Func.get` will return the default value. In other words, if you try to access an element at an index that is out of the bounds of the list, the function returns the default value for that type.

For any type `α` with a default value and any list `as` of length `k` or less of type `α`, `List.Func.get as (k) = default_value`.


theorem Set.Ico_subset_Ioo_left :
    ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₁ < a₂ → Set.Ico a₂ b ⊆ Set.Ioo a₁ b := by sorry

The theorem `Set.Ico_subset_Ioo_left` states that for any type `α` that has a pre-order relation defined, given three elements `a₁`, `a₂`, and `b` of type `α` where `a₁` is less than `a₂`, the left-closed right-open interval `[a₂, b)` is a subset of the left-open right-open interval `(a₁, b)`. This means all elements `x` that satisfy the inequality `a₂ ≤ x < b` also satisfy `a₁ < x < b`.

For any pre-ordered type `α` and elements `a₁ < a₂` of `α`, the interval `[a₂, b)` is a subset of `(a₁, b)`. That is, for all `x`, if `a₂ ≤ x < b`, then `a₁ < x < b`.


Set.IsPWO.add

theorem Set.IsPWO.add :
    ∀ {α : Type u_1} {s t : Set α} [inst : OrderedCancelAddCommMonoid α],
      Set.IsPWO s → Set.IsPWO t → Set.IsPWO (s + t) :=
  by sorry

This theorem states that for any two sets `s` and `t` of an ordered cancellative commutative monoid `α`, if both sets are partially well-ordered (PWO), then their sum set (the set of all elements that can be written as the sum of an element from `s` and an element from `t`) is also partially well-ordered. Being partially well-ordered means that any infinite sequence from the set contains a monotone subsequence of length 2, or equivalently, an infinite monotone subsequence. In the context of an ordered cancellative commutative monoid, monotone refers to the partial order defined by the monoid operation.

In an ordered cancellative commutative monoid, if two partially well-ordered sets have the property that any infinite sequence contains a monotonic subsequence of length 2 using the monoid operation, then their sum set is also partially well-ordered.


theorem Int.clog_of_one_le_right :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] (b : ℕ) {r : R},
      1 ≤ r → Int.clog b r = ↑(Nat.clog b ⌈r⌉₊) :=
  by sorry

The theorem `Int.clog_of_one_le_right` states that for any semifield `R` that is linearly ordered and a floor semiring, given a natural number `b` and a value `r` from `R` such that `r` is greater than or equal to 1, the least power of `b` such that `r` is less than or equal to `b` to the power of the logarithm of `r` with base `b` (represented by `Int.clog b r`) equals the upper logarithm of the ceiling of `r` in base `b` (represented by `Nat.clog b ⌈r⌉₊`). In other words, when `r` is at least 1, the integer logarithm function `Int.clog` behaves the same as the natural logarithm function `Nat.clog` applied to the ceiling of `r`.

For any semifield `R` that is linearly ordered and a floor semiring, the integer logarithm `Int.clog b r` equals the upper logarithm `Nat.clog b ⌈r⌉₊` when `r` is a positive element in `R`.


theorem Set.pairwise_insert :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
      Set.Pairwise (insert a s) r ↔ Set.Pairwise s r ∧ ∀ b ∈ s, a ≠ b → r a b ∧ r b a :=
  by sorry

This theorem states that for any type `α`, relation `r` of type `α → α → Prop`, set `s` of type `Set α`, and element `a` of type `α`, the relation `r` holds pairwise on the set resulting from inserting `a` into `s` if and only if the relation `r` holds pairwise on the original set `s` and for every element `b` in `s`, if `a` is not equal to `b`, then the relation `r` holds for both `a` and `b` and vice versa.

For any type `α`, set `s` of elements from `α`, and relation `r` on `α`, if `r` holds pairwise on `s ∪ {a}`, where `a` is an element not in `s`, if and only if `r` holds pairwise on `s` and `r` holds for all distinct `a, b` in `s ∪ {a}`, then `r` is an equivalence relation on `s ∪ {a}`.


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

This theorem, `Real.sqrt_eq_iff_sq_eq`, states that for any two real numbers `x` and `y`, both of which are non-negative, the square root of `x` equals `y` if and only if `y` squared equals `x`. In other words, it establishes a precise relationship between the square root function and the squaring operation on the real numbers, specifically on the non-negative part of the real line.

For non-negative real numbers x and y, x = y^2 if and only if sqrt x = y.


theorem MeasureTheory.mem_spanningSetsIndex :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ]
      (x : α), x ∈ MeasureTheory.spanningSets μ (MeasureTheory.spanningSetsIndex μ x) :=
  by sorry

The theorem `MeasureTheory.mem_spanningSetsIndex` states that for any given measurable space `α` and any sigma-finite measure `μ` on this space, for any element `x` in `α`, `x` belongs to the spanning set indexed by the `spanningSetsIndex` of `x`.

In other words, this theorem states that the `spanningSetsIndex` function correctly identifies the least index of the finite spanning set, in a monotone collection of sets that span the universe and have finite measure, that contains a given element `x`.

For any measurable space `α` and sigma-finite measure `μ`, and for any `x` in `α`, there exists an index `i` such that `x` is in the i-th set of the finite, monotone collection `spanningSetsIndex μ x`.


theorem contDiffOn_top :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F}, ContDiffOn 𝕜 ⊤ f s ↔ ∀ (n : ℕ), ContDiffOn 𝕜 (↑n) f s :=
  by sorry

The theorem `contDiffOn_top` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, normed spaces over `𝕜` of `E` and `F`, a set `s` of elements of type `E`, and a function `f` from `E` to `F`, the function `f` is continuously differentiable on the set `s` at all orders if and only if the function `f` is continuously differentiable on the set `s` at each natural number order.

A function between two normed spaces is continuously differentiable on a set at all orders if and only if it is continuously differentiable at each natural number order on that set.


theorem Filter.comap_lift_eq2 :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : β → α} {g : Set β → Filter γ},
      Monotone g → Filter.lift (Filter.comap m f) g = Filter.lift f (g ∘ Set.preimage m) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, given a filter `f` of type `α`, a function `m` mapping `β` to `α`, and a function `g` which maps a set of type `β` to a filter of type `γ`, and assuming that `g` is a monotone function, the filter obtained by lifting the filter `f` comapped through `m` over `g` is equal to the filter obtained by lifting `f` over the composition of `g` and the preimage of `m`. In other words, the operation of "comapping" a filter through a function and then "lifting" it over a monotone function can be rearranged as "lifting" the original filter over the composition of the monotone function and the preimage of the original function. This establishes a certain commutativity property between the "lift" and "comap" operations in the context of filters.

Given filters `f` of type `α`, function `m` from `β` to `α`, monotone function `g` from sets of type `β` to filters of type `γ`, the lifting of `f` through `m` over `g` equals the lifting of `f` over `g` composed with the preimage of `m`.


theorem Absorbs.mono_right :
    ∀ {M : Type u_1} {α : Type u_2} [inst : Bornology M] [inst_1 : SMul M α] {s t₁ t₂ : Set α},
      Absorbs M s t₁ → t₂ ⊆ t₁ → Absorbs M s t₂ :=
  by sorry

The theorem `Absorbs.mono_right` states that for all types `M` and `α`, where `M` has a Bornology structure and `α` has a scalar multiplication structure, if a set `s` absorbs another set `t₁` and `t₂` is a subset of `t₁`, then `s` also absorbs `t₂`. Here, a set `s` absorbing another set `t` is defined such that `t` is contained in all scalings of `s` by all but a bounded set of elements in `M`.

If `M` is a type with a Bornology structure, `α` is a type with a scalar multiplication structure, `s` absorbs `t₁`, and `t₂` is a subset of `t₁`, then `s` absorbs `t₂`.


theorem Mathlib.CategoryTheory.Triangulated.TriangleShift._auxLemma.1 :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y)
      (g : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) =
        self.map (CategoryTheory.CategoryStruct.comp f g) :=
  by sorry

This theorem states that for any two categories `C` and `D`, given a functor `self` from `C` to `D` and three objects `X`, `Y`, and `Z` in `C` with morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the composition of the images of `f` and `g` under `self` is equal to the image under `self` of the composition of `f` and `g` in `C`. In other words, the functor `self` preserves the composition of morphisms, a property known as functoriality.

For any functors `self: C → D` between categories `C` and `D`, and objects `X, Y, Z` in `C` with morphisms `f: X → Y` and `g: Y → Z`, the equality `self(f ∘ g) = self(f) ∘ self(g)` holds.


theorem Lists'.mem_of_subset' :
    ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ Lists'.toList l₁ → a ∈ l₂ := by sorry

The theorem `Lists'.mem_of_subset'` states that for any type `α`, any ZFA list `a` of type `α`, and any two proper ZFA prelists `l₁` and `l₂` of type `α`, if `l₁` is a subset of `l₂`, and `a` is an element in the list obtained by converting `l₁` to a list of ZFA lists, then `a` is an element of `l₂`. In other words, if a ZFA list is in the list version of a proper ZFA prelist, and that prelist is also a subset of another one, then that ZFA list is also in the larger prelist.

If `l₁` is a proper ZFA prelist that is a subset of another proper ZFA prelist `l₂`, and `a` is an element of the list obtained from `l₁`, then `a` is an element of `l₂`.


theorem Nat.succ_le : ∀ {n m : ℕ}, Nat.succ n ≤ m ↔ n < m := by sorry

This theorem, `Nat.succ_le`, states that for all natural numbers `n` and `m`, the successor of `n` (which is `n` plus one, represented as `Nat.succ n`) is less than or equal to `m` if and only if `n` is strictly less than `m`. In other words, adding one to a natural number `n` results in a number that is less than or equal to `m` exactly when `n` itself is less than `m`.

For all natural numbers `n` and `m`, `Nat.succ n <= m` if and only if `n < m`.


/-- The real inner product of two vectors, divided by the product of their
norms, has absolute value at most 1.  -/
theorem abs_real_inner_div_norm_mul_norm_le_one :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
      |⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)| ≤ 1 :=
  by sorry

This theorem states that for any type `F` that is a normed-additive-commutative-group and an inner-product-space over the real numbers, for any two vectors `x` and `y` in `F`, the absolute value of the real inner product of `x` and `y` divided by the product of their norms is always less than or equal to 1. This is related to the idea that the cosine of the angle between two non-zero vectors in an inner product space is given by the ratio of the inner product of the vectors and the product of their norms.

For any normed-additive-commutative-group and inner-product-space F over the real numbers, and any vectors x and y in F, the absolute value of their inner product is less than or equal to the product of their norms.


/-- On a finite-dimensional space, a linear map is injective if and only if it is surjective.  -/
theorem LinearMap.injective_iff_surjective :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      [inst_3 : FiniteDimensional K V] {f : V →ₗ[K] V}, Function.Injective ⇑f ↔ Function.Surjective ⇑f :=
  by sorry

This theorem states that for any finite-dimensional vector space over a division ring, a linear map on that space is injective if and only if it is surjective. In other words, in such a space, if a linear map never maps different vectors to the same vector (injectivity), then it must map some vector to every possible vector in the space (surjectivity), and vice versa.

In a finite-dimensional vector space over a division ring, a linear map is both injective and surjective if and only if it is bijective.


/-- Multiplication with a natural in an `AddLocalization` is defined as
`n • ⟨a, b⟩ = ⟨n • a, n • b⟩`.

This is a separate `irreducible` def to ensure the elaborator doesn't waste its time
trying to unify some huge recursive definition with itself, but unfolded one step less. -/
theorem AddLocalization.nsmul_def :
    ∀ {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M), AddLocalization.nsmul S = AddMonoid.nsmul := by
  sorry

The theorem `AddLocalization.nsmul_def` states that for any type `M` that forms an additive commutative monoid and any additive submonoid `S` of `M`, the operation of multiplication with a natural number in an `AddLocalization` is defined the same way as the multiplication by a natural number in the `AddMonoid`. In other words, the function `AddLocalization.nsmul S` which multiplies a natural number with an element of the `AddLocalization` of `S` is equivalent to the function `AddMonoid.nsmul`, which multiplies a natural number with an element of the `AddMonoid` of `M`.

For any additive commutative monoid M and its submonoid S, the multiplication by a natural number in the AddLocalization of S is equivalent to the multiplication by a natural number in the AddMonoid of M.


theorem symmDiff_right_involutive :
    ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] (a : α), Function.Involutive fun x => symmDiff a x := by sorry

The theorem `symmDiff_right_involutive` states that for all types `α` that form a `GeneralizedBooleanAlgebra`, the symmetric difference operation with a fixed element `a` is an involutive function. In other words, applying the symmetric difference operation twice with the same element `a` results in the original value. In mathematical terms, this can be expressed as `symmDiff a (symmDiff a x) = x` for all `x` in `α`. The symmetric difference operation is defined as `(A \ B) ⊔ (B \ A)`, where `\` denotes set difference and `⊔` denotes the supremum operation.

For any type `α` that forms a `GeneralizedBooleanAlgebra`, the symmetric difference operation with a fixed element `a` is involutive, that is, `symmDiff a (symmDiff a x) = x` for all `x` in `α`.


theorem CategoryTheory.Limits.Concrete.isColimit_exists_rep :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {J : Type w}
      [inst_2 : CategoryTheory.Category.{r, w} J] (F : CategoryTheory.Functor J C)
      [inst_3 : CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)]
      {D : CategoryTheory.Limits.Cocone F},
      CategoryTheory.Limits.IsColimit D → ∀ (x : (CategoryTheory.forget C).obj D.pt), ∃ j y, (D.ι.app j) y = x :=
  by sorry

This theorem, `CategoryTheory.Limits.Concrete.isColimit_exists_rep`, states that for any type `C` that has a category structure and is a concrete category, along with any type `J` that also has a category structure, and any functor `F` from `J` to `C`. If `F` preserves colimits under the forgetful functor (which maps `C` to the type `w`) and `D` is a cocone over `F`, then for any `IsColimit` of the cocone `D`, for any object `x` in the image under the forgetful functor of the vertex of the cocone, there exists a `j` in `J` and `y` in the domain of the morphism `D.ι.app j` such that `D.ι.app j` of `y` equals `x`. This theorem basically states the condition for an object to be a colimit in the concrete category.

For a concrete category `C` with a forgetful functor `w` to Type, if functor `F: J → C` preserves colimits under `w` and `D: J → C` is a cocone over `F` with `IsColimit D`, then for each object `x` in the image of `w` on the vertex of `D`, there exists `j` in `J` and `y` in the domain of `D.ι.app j` such that `D.ι.app j(y) = x`.


theorem Nat.lt_of_add_lt_add_left : ∀ {k m n : ℕ}, n + k < n + m → k < m := by sorry

This theorem states that for all natural numbers `k`, `m`, and `n`, if `n + k` is less than `n + m`, then `k` is less than `m`. Essentially, it uses the property of addition to compare two natural numbers: if adding the same number `n` to two numbers `k` and `m` results in a smaller sum for `k`, then `k` must be smaller than `m`.

For all natural numbers `k` and `m`, if `n + k` < `n + m`, then `k` < `m`.


Subgroup.Normal.comap

theorem Subgroup.Normal.comap :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup N},
      Subgroup.Normal H → ∀ (f : G →* N), Subgroup.Normal (Subgroup.comap f H) :=
  by sorry

The theorem `Subgroup.Normal.comap` states that for any groups `G` and `N`, any subgroup `H` of `N`, and any monoid homomorphism `f` from `G` to `N`, if the subgroup `H` is normal, then the preimage of `H` along `f` is also a normal subgroup of `G`. The preimage of a subgroup along a monoid homomorphism is defined by the function `Subgroup.comap`.

In mathematical terms, if `H` is a normal subgroup of `N` and `f: G -> N` is a homomorphism, then `f^-1(H)`, the preimage of `H` under `f`, is a normal subgroup of `G`.

If `H` is a normal subgroup of group `N` and `f` is a homomorphism from group `G` to `N`, then the preimage `f^-1(H)` is a normal subgroup of `G`.


/-- `cyclotomic n ℤ` is the minimal polynomial of a primitive `n`-th root of unity `μ`.  -/
theorem Polynomial.cyclotomic_eq_minpoly :
    ∀ {n : ℕ} {K : Type u_2} [inst : Field K] {μ : K},
      IsPrimitiveRoot μ n → 0 < n → ∀ [inst_1 : CharZero K], Polynomial.cyclotomic n ℤ = minpoly ℤ μ :=
  by sorry

The theorem `Polynomial.cyclotomic_eq_minpoly` states that for any positive natural number `n`, any field `K` with characteristic zero, and any value `μ` in `K` that is a primitive `n`-th root of unity, the `n`-th cyclotomic polynomial with integer coefficients (`Polynomial.cyclotomic n ℤ`) is equal to the minimal polynomial of `μ` over the integers (`minpoly ℤ μ`).

For any positive integer `n` and any primitive `n`-th root of unity `μ` in a field `K` of characteristic zero, the `n`-th cyclotomic polynomial with integer coefficients equals the minimal polynomial of `μ` over the integers.


theorem Localization.localRingHom_to_map :
    ∀ {R : Type u_1} [inst : CommSemiring R] {P : Type u_3} [inst_1 : CommSemiring P] (I : Ideal R)
      [hI : Ideal.IsPrime I] (J : Ideal P) [inst_2 : Ideal.IsPrime J] (f : R →+* P) (hIJ : I = Ideal.comap f J) (x : R),
      (Localization.localRingHom I J f hIJ) ((algebraMap R (Localization.AtPrime I)) x) =
        (algebraMap P (Localization.AtPrime J)) (f x) :=
  by sorry

This theorem states that for any commutative semiring `R`, another commutative semiring `P`, a prime ideal `I` of `R`, and a prime ideal `J` of `P`, if there is a ring homomorphism `f` from `R` to `P` such that `I` is the preimage of `J` under `f`, then for any element `x` of `R`, the image of `x` under the ring homomorphism induced by the localization of `R` at `I` to the localization of `P` at `J` (denoted `Localization.localRingHom I J f hIJ`) followed by the embedding of `R` into the localization of `R` at `I` (denoted `algebraMap R (Localization.AtPrime I)`) is equal to the image of the image of `x` under `f` under the embedding of `P` into the localization of `P` at `J` (denoted `algebraMap P (Localization.AtPrime J)`). In mathematical notation, this means that if $f: R \rightarrow P$ is a ring homomorphism and $I$ is the preimage of a prime ideal $J$ in $P$ under $f$, then for any $x \in R$ we have
$$(\text{Localization.localRingHom } I J f hIJ) \circ (\text{algebraMap } R \rightarrow \text{Localization.AtPrime } I) (x) = (\text{algebraMap } P \rightarrow \text{Localization.AtPrime } J) \circ f(x)$$

For any commutative semirings `R` and `P`, prime ideals `I` of `R` and `J` of `P`, and a ring homomorphism `f` from `R` to `P` with `I` the preimage of `J` under `f`, the images of any element `x` in `R` under the respective local ring homomorphisms and embeddings are equal: `(Localization.localRingHom I J f hIJ) (algebraMap R (Localization.AtPrime I) x) = algebraMap P (Localization.AtPrime J) (f x)`.


theorem tendsto_norm_cocompact_atTop :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] [inst_1 : ProperSpace E],
      Filter.Tendsto norm (Filter.cocompact E) Filter.atTop :=
  by sorry

The theorem `tendsto_norm_cocompact_atTop` states that for any type `E` that is equipped with a semi-normed additive group structure and is also a proper space (i.e., every closed ball is compact), the norm function tends to infinity (`Filter.atTop`) when the filter tends towards the complement of compact sets (`Filter.cocompact E`). In other words, as we move away from compact sets in this space, the norm of the elements tends to increase without bound.

For any proper, semi-normed additive group `E`, the norm function `norm : E → ℝ` tends to infinity as the filter approaches the complement of compact sets.


theorem uniqueDiffOn_Icc : ∀ {a b : ℝ}, a < b → UniqueDiffOn ℝ (Set.Icc a b) := by sorry

The theorem `uniqueDiffOn_Icc` asserts that for any two real numbers `a` and `b` where `a` is less than `b`, the left-closed right-closed interval from `a` to `b` (denoted as `[a, b]` in mathematics) possesses a unique differential structure. In other words, there is a unique way to do calculus (take derivative, integrate, etc.) on the interval `[a, b]`.

For any real numbers `a` < `b`, the interval `[a, b]` has a unique differential structure.


theorem CategoryTheory.ShortComplex.moduleCatCyclesIso_hom_subtype :
    ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.moduleCatCyclesIso S).hom
          (Submodule.subtype (LinearMap.ker S.g)) =
        CategoryTheory.ShortComplex.iCycles S :=
  by sorry

The theorem `CategoryTheory.ShortComplex.moduleCatCyclesIso_hom_subtype` states that for any given type `R` equipped with a ring structure and for any short complex `S` over the category of `R`-modules, the composition of the morphism corresponding to the isomorphism between the abstract `S.cycles` of the homology API and the more concrete description as the kernel of `S.g`, with the embedding of the submodule corresponding to the kernel of `S.g` into the ambient space, is equal to the inclusion morphism from `S.cycles` to `S.X₂` in the short complex `S`. This theorem is about the relationship between different ways of expressing cycles in a short complex of modules in category theory.

The isomorphism between the cycles of a short complex of R-modules and the kernel of its differential, followed by the embedding of the cycle submodule into the module of degree 2, is equal to the inclusion map.


theorem Cardinal.ofENat_le_aleph0 : ∀ (n : ℕ∞), ↑n ≤ Cardinal.aleph0 := by sorry

This theorem states that for any extended natural number `n` (which could be a standard natural number or positive infinity), the cardinality of `n` is less than or equal to `ℵ₀`, the smallest infinite cardinal, which corresponds to the cardinality of the set of natural numbers. In other words, no extended natural number can have a cardinality greater than the size of the set of natural numbers.

For any extended natural number `n`, its cardinality is bounded above by that of the set of natural numbers, i.e., ℵ₀.


theorem MeasureTheory.memℒp_zero_iff_aestronglyMeasurable :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
      {f : α → E}, MeasureTheory.Memℒp f 0 μ ↔ MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

This theorem states that for any types `α` and `E`, if `α` is a measurable space, `μ` is a measure on `α`, and `E` is a normed additive commutative group, then a function `f` from `α` to `E` belongs to the space `ℒp` for `p=0` with respect to the measure `μ` if and only if `f` is "almost everywhere strongly measurable" with respect to `μ`. Here, "almost everywhere strongly measurable" means that `f` is almost everywhere equal to the limit of a sequence of simple functions. In the context of the `ℒp` space for `p=0`, a function belongs to this space if it is almost everywhere strongly measurable and the essential supremum of the function is finite.

A function from a measurable space to a normed additive commutative group belongs to the ℒp space for p=0 with respect to a measure if and only if it is almost everywhere strongly measurable.


theorem Nat.min_self : ∀ (a : ℕ), min a a = a := by sorry

This theorem states that for every natural number `a`, the minimum of `a` and `a` is always `a` itself. The minimum function `min` is used to determine the lesser of two values. In this case, since the two values are the same, the result is always that value.

For all natural numbers a, a is the minimum value of a and a.


theorem Multiset.dedup_cons_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α},
      a ∉ s → Multiset.dedup (a ::ₘ s) = a ::ₘ Multiset.dedup s :=
  by sorry

The theorem `Multiset.dedup_cons_of_not_mem` states that for all types `α` that have decidable equality, for each element `a` of type `α`, and for each multiset `s` of type `α`, if `a` does not belong to `s`, then removing duplicates from the multiset that results from consing `a` onto `s` is equivalent to consing `a` onto the multiset that results from removing duplicates from `s`. In other words, if `a` is not already in `s`, then we can add `a` to `s` either before or after removing duplicates from `s`, and we will get the same result.

If `α` has decidable equality, for all `a` not in multiset `s` of type `α`, the multisets `{a} ∪ M.dedup s` and `M.dedup (s ∪ {a})` are equal.


theorem Filter.le_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {g : Filter ((i : ι) → α i)},
      g ≤ Filter.pi f ↔ ∀ (i : ι), Filter.Tendsto (Function.eval i) g (f i) :=
  by sorry

The theorem `Filter.le_pi` states that for any index type `ι`, any type function `α` indexed by `ι`, any family of filters `f` indexed by `ι`, and any filter `g` on the product type, the filter `g` is less than or equal to the product filter `π f` if and only if for every index `i` in `ι`, the function `Function.eval i` tends to the filter `f i` when taking `g` as the domain. In other words, this theorem characterizes when a filter `g` on the product type can be "lower-bounded" by a given product of filters, in terms of the convergence properties of the projections at each coordinate.

For any index type `ι`, any type family `f : ι → Filter α`, and any filter `g : Filter (Π i, α i)`, `g ≤ ⨅ i, f i` if and only if `Function.eval i (g) ≤ f i` for all `i` in `ι`.


Affine.Simplex.ext

/-- Two simplices are equal if they have the same points.  -/
theorem Affine.Simplex.ext :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {n : ℕ} {s1 s2 : Affine.Simplex k P n},
      (∀ (i : Fin (n + 1)), s1.points i = s2.points i) → s1 = s2 :=
  by sorry

This theorem states that, given two simplices `s1` and `s2`, each with `n + 1` points, which exist within a module with a ring of type `k`, a commutative group of type `V`, and an additive torsor of type `P`, if every corresponding point of `s1` and `s2` are equivalent (i.e., the `i`-th point of `s1` is equal to the `i`-th point of `s2` for all `i`), then the two simplices `s1` and `s2` are equal.

Given two simplices `s1` and `s2` with `n + 1` points in a module over a ring `k`, with a commutative group `V` and an additive torsor `P`, if each point of `s1` is equivalent to the corresponding point of `s2`, then `s1` and `s2` are equal.


theorem MeasureTheory.FiniteMeasure.eq_of_forall_toMeasure_apply_eq :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ ν : MeasureTheory.FiniteMeasure Ω),
      (∀ (s : Set Ω), MeasurableSet s → ↑↑↑μ s = ↑↑↑ν s) → μ = ν :=
  by sorry

The theorem `MeasureTheory.FiniteMeasure.eq_of_forall_toMeasure_apply_eq` states that for any type `Ω` with a `MeasurableSpace` instance and any two finite measures `μ` and `ν` on `Ω`, if for every measurable set `s`, the measure of `s` under `μ` equals the measure of `s` under `ν`, then `μ` must be equal to `ν`. In other words, two finite measures on a measurable space are considered equal if they assign the same measure to every measurable set within the space.

If two finite measures assign equal measures to every measurable set in a measurable space, then they are equal.


theorem Set.Nonempty.of_image :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Set.Nonempty (f '' s) → Set.Nonempty s := by sorry

The theorem `Set.Nonempty.of_image` states that for any types `α` and `β`, a function `f` from `α` to `β`, and a set `s` of type `α`, if the image set of `s` through `f` is nonempty, then the original set `s` is also nonempty. In other words, if there exists at least one element in the image of `s` under `f`, there must exist at least one element in `s` itself.

If `f` is a function from a nonempty set `α` to a set `β` and the image of a set `s subseteq α` under `f` is nonempty, then `s` is nonempty.


/-- Like `Finsupp.mapDomain_add`, but for the convolutive multiplication we define in this file  -/
theorem MonoidAlgebra.mapDomain_mul :
    ∀ {α : Type u_3} {β : Type u_4} {α₂ : Type u_5} [inst : Semiring β] [inst_1 : Mul α] [inst_2 : Mul α₂]
      {F : Type u_6} [inst_3 : FunLike F α α₂] [inst_4 : MulHomClass F α α₂] (f : F) (x y : MonoidAlgebra β α),
      MonoidAlgebra.mapDomain (⇑f) (x * y) = MonoidAlgebra.mapDomain (⇑f) x * MonoidAlgebra.mapDomain (⇑f) y :=
  by sorry

The theorem `MonoidAlgebra.mapDomain_mul` states that for any semiring `β`, multiplicative structures `α` and `α₂`, a function `f` from `α` to `α₂` that preserves multiplication, and two elements `x` and `y` from the monoid algebra over `β` generated by `α`, the operation of mapping the domain of the product of `x` and `y` using `f` is equivalent to the product of the domain mappings of `x` and `y` individually by `f`. In other words, it asserts that the `mapDomain` operation commutes with the convolution multiplication in the monoid algebra.

For any semiring β, multiplicative structures α and α₂, and a multiplicative function f from α to α₂, the mapDomain operation of the product of elements x and y in the monoid algebra over β, with respect to f, is equal to the product of the mapDomain mappings of x and y by f.


theorem Set.ordConnectedComponent_subset :
    ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {x : α}, Set.ordConnectedComponent s x ⊆ s := by sorry

This theorem states that for any given type `α` that has a linear order, any set `s` of type `α`, and any element `x` of type `α`, the order-connected component of `x` in `s` is a subset of `s`. In mathematical terms, if we consider a set `s` and a point `x` in a space with linear order, the set of all points `y` such that the interval from `x` to `y` is contained within `s` (this is the order-connected component of `x` in `s`) is always a subset of `s` itself.

For any type `α` with a linear order, any set `s` of elements from `α`, and any `x` in `s`, the order-connected component of `x` in `s` is a subset of `s`.


theorem AlgebraicGeometry.Scheme.OpenCover.ι_fromGlued :
    ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.OpenCover X) (x : 𝒰.J),
      CategoryTheory.CategoryStruct.comp
          (AlgebraicGeometry.Scheme.GlueData.ι (AlgebraicGeometry.Scheme.OpenCover.gluedCover 𝒰) x)
          (AlgebraicGeometry.Scheme.OpenCover.fromGlued 𝒰) =
        𝒰.map x :=
  by sorry

The theorem `AlgebraicGeometry.Scheme.OpenCover.ι_fromGlued` states that for any algebraic scheme `X` and any open cover `𝒰` of `X`, the composition of the immersion of `𝒰.J` into the glued scheme and the canonical morphism from the glued scheme to `X` is equal to the map of `𝒰.J` in the open cover `𝒰`. In other words, this theorem ensures the compatibility of local descriptions (given by `𝒰.map x`) with the global gluing construction, which is a crucial property in the theory of algebraic geometry.

The composition of the immersion of an open cover's joint open subset into the glued scheme and the canonical morphism from the glued scheme to the original algebraic scheme is equal to the map of the joint open subset in the open cover.


theorem Set.Finite.interior_biInter :
    ∀ {X : Type u} [inst : TopologicalSpace X] {ι : Type u_3} {s : Set ι},
      Set.Finite s → ∀ (f : ι → Set X), interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i) :=
  by sorry

This theorem, `Set.Finite.interior_biInter`, states that for any type `X` that is a topological space, any type `ι`, and any set `s` of type `ι`, if `s` is finite, then for any function `f` from `ι` to the set of `X`, the interior of the intersection of the sets `f i` for each `i` in `s` is equal to the intersection of the interiors of the sets `f i` for each `i` in `s`. In other words, if we have a finite index set and a function mapping each index to a set in a topological space, then the interior of the intersection of these sets can be found by first finding the interior of each individual set and then finding the intersection of these interiors.

For any topological space X, finite index set ι, and function f from ι to the powerset of X, the interior of ∩ (fi : i ∈ ι) equals ∧ (int (fi) : i ∈ ι).


theorem Valuation.mem_supp_iff :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : CommRing R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀]
      (v : Valuation R Γ₀) (x : R), x ∈ Valuation.supp v ↔ v x = 0 :=
  by sorry

The theorem `Valuation.mem_supp_iff` states that for any type `R` with a commutative ring structure, any type `Γ₀` with a structure of a linear ordered commutative monoid with zero, a valuation `v` from `R` to `Γ₀`, and an element `x` of `R`, `x` is in the support of the valuation `v` if and only if the valuation `v` of `x` is zero. The support of a valuation `v` is the ideal of `R` where `v` vanishes. In other words, this theorem connects the zero values of a valuation with the elements in its support.

For any commutative ring `R`, valuation `v` from `R` to a linear ordered commutative monoid `Γ₀`, and element `x` in `R`, `x` is in the support of `v` if and only if `v(x) = 0`.


theorem List.nodup_iff_nthLe_inj :
    ∀ {α : Type u} {l : List α},
      List.Nodup l ↔
        ∀ (i j : ℕ) (h₁ : i < List.length l) (h₂ : j < List.length l), List.nthLe l i h₁ = List.nthLe l j h₂ → i = j :=
  by sorry

The theorem `List.nodup_iff_nthLe_inj` states that for any list `l` of elements of an arbitrary type `α`, the condition of the list having no duplicate elements (`List.Nodup l`) is equivalent to the condition that, for any two indices `i` and `j` which are less than the length of the list (`i < List.length l` and `j < List.length l`), if the elements at index `i` and `j` are the same (`List.nthLe l i h₁ = List.nthLe l j h₂`), then `i` and `j` must be the same. In other words, no two distinct indices point to the same element in a list with no duplicates.

For any list `l` of distinct elements, if `i` and `j` are indices such that `0 <= i, j < List.length l` and `List.nthLe l i = List.nthLe l j`, then `i = j`.


theorem LinearIsometry.toLinearMap_injective :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
      [inst_5 : Module R₂ E₂], Function.Injective LinearIsometry.toLinearMap :=
  by sorry

This theorem states that for any two types `R` and `R₂` that are semirings, a ring homomorphism `σ₁₂` from `R` to `R₂`, two types `E` and `E₂` that are seminormed additive commutative groups and also modules over `R` and `R₂` respectively, the function `toLinearMap` that converts a `LinearIsometry` from `E` to `E₂` (preserving the linear structure and the distance) into a `LinearMap` (preserving only the linear structure) is injective. In other words, if two `LinearIsometry` objects are mapped to the same `LinearMap` by `toLinearMap`, then those two `LinearIsometry` objects were originally identical.

Given semirings R and R₂, ring homomorphisms σ₁₂ from R to R₂, seminormed additive commutative groups and R-module E, E₂ with a given LinearIsometry f : E ≅ E₂, if toLinearMap(f) = toLinearMap(g) for some LinearIsometry g : E ≅ E₂, then f = g.


theorem AddAction.isPeriodicPt_vadd_iff :
    ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] {m : M} {a : α} {n : ℕ},
      Function.IsPeriodicPt (fun x => m +ᵥ x) n a ↔ n • m +ᵥ a = a :=
  by sorry

This theorem states that for any type `α`, any add monoid `M`, any additive action of `M` on `α`, any element `m` of `M`, any element `a` of `α`, and any natural number `n`, a point `a` is a periodic point of the function `x => m +ᵥ x` with period `n` if and only if the scalar multiplication `n • m +ᵥ a` equals `a`. In other words, the point `a` returns to its original position after `n` applications of the function `x => m +ᵥ x` exactly when adding `m` scaled by `n` to `a` gives `a` back.

For any add monoid `M`, additive action on type `α`, element `m` in `M`, element `a` in `α`, and natural number `n`, the element `a` is a periodic point of the function `x => m + α x` with period `n` if and only if `n * m + α a = a`.


theorem one_div_neg_one_eq_neg_one :
    ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K], 1 / -1 = -1 := by sorry

This theorem states that in any division monoid `K` that also supports the distribution of negation over multiplication and addition, the division of 1 by -1 always equates to -1. A division monoid is a structure with a single binary operation that is associative and has an identity element, and every element has a multiplicative inverse. The distribution of negation means that negating a sum of two elements is the same as summing their negations.

In a division monoid with negation distribution, the multiplicative inverse of 1 is -1.


Setoid.ext

theorem Setoid.ext : ∀ {α : Sort u_3} {s t : Setoid α}, (∀ (a b : α), Setoid.r a b ↔ Setoid.r a b) → s = t := by sorry

The theorem `Setoid.ext` states that for any sort `α`, given two setoids `s` and `t` on `α`, if for every pair of elements `(a, b)` from `α`, the statement "a is related to b under setoid `s`" is equivalent to "a is related to b under setoid `t`" (i.e., `Setoid.r a b` is true under both setoids), then the two setoids `s` and `t` are identical. This theorem essentially provides a criterion for the equality of two setoids based on the equivalence of their respective relation conditions for all pairs of elements in the set.

If two setoids on a sort have equivalent relation conditions for all pairs of elements, then they are equal.


theorem Mathlib.Analysis.Calculus.TangentCone._auxLemma.11 :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [inst_1 : DenselyOrdered α], Set.Nonempty (Set.Ioo a b) = (a < b) :=
  by sorry

This theorem states that for any type `α` with a `Preorder` relation, and any two elements `a` and `b` of this type such that `α` is `DenselyOrdered`, the left-open right-open interval `(a, b)` is nonempty if and only if `a` is less than `b`. In other words, there exists at least one element `x` that strictly lies between `a` and `b` (`a < x < b`) if and only if `a < b`.

For any densely ordered type `α` with a `Preorder` relation, the interval `(a, b)` is nonempty if and only if `a` is strictly less than `b`.


CompactExhaustion.subset

theorem CompactExhaustion.subset :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X) ⦃m n : ℕ⦄, m ≤ n → K m ⊆ K n := by sorry

This theorem states that for any type `X` equipped with a topological space structure and any compact exhaustion `K` of `X`, if you have two natural numbers `m` and `n` such that `m` is less than or equal to `n`, then the `m`th compact subset of `K` is a subset of the `n`th compact subset of `K`. In other words, the compact subsets in a compact exhaustion of a topological space are nested, with each subset being contained within all subsequent subsets in the sequence.

For any compact exhaustion `K` of a topological space `X`, the `i`-th compact subset is contained in the `j`-th compact subset for all `i ≤ j`.


theorem Pell.yn_add :
    ∀ {a : ℕ} (a1 : 1 < a) (m n : ℕ), Pell.yn a1 (m + n) = Pell.xn a1 m * Pell.yn a1 n + Pell.yn a1 m * Pell.xn a1 n :=
  by sorry

The theorem `Pell.yn_add` states that for any natural number `a` greater than 1, and any natural numbers `m` and `n`, the `n`-th element of the Pell `y` sequence with parameter `a`, where `n` is the sum of `m` and `n`, is equal to the product of the `m`-th element of the Pell `x` sequence and the `n`-th element of the Pell `y` sequence, plus the product of the `m`-th element of the Pell `y` sequence and the `n`-th element of the Pell `x` sequence. In mathematical notation, this can be stated as: $y_{m+n} = x_m * y_n + y_m * x_n$ for $a > 1$, where $x_n$ and $y_n$ denote the `n`-th element of the Pell `x` and `y` sequences respectively.

For any natural number `a` > 1, the `n`-th element of the Pell `y` sequence with parameter `a` is equal to the sum of the product of the `m`-th element of the Pell `x` sequence and the `n`-th element of the Pell `y` sequence, and the product of the `m`-th element of the Pell `y` sequence and the `n`-th element of the Pell `x` sequence, where `n` is the sum of `m` and `n`. In mathematical notation, $y_{m+n} = x_m * y_n + y_m * x_n$.


theorem Mathlib.Topology.Filter._auxLemma.2 :
    ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) := by sorry

This theorem states that for any type `α` that is a preorder, and for any two elements `b` and `x` of this type, `x` belongs to the set `Set.Iic b` if and only if `x` is less than or equal to `b`. In other words, the set `Set.Iic b` is defined to be the set of all elements that are less than or equal to `b`.

For any preorder type `α` and elements `b` and `x` of `α`, `x` belongs to `Set.Iic b` if and only if `x ≤ b`.


theorem MvPolynomial.ringHom_ext :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A]
      {f g : MvPolynomial σ R →+* A},
      (∀ (r : R), f (MvPolynomial.C r) = g (MvPolynomial.C r)) →
        (∀ (i : σ), f (MvPolynomial.X i) = g (MvPolynomial.X i)) → f = g :=
  by sorry

The theorem `MvPolynomial.ringHom_ext` states that for any type `R` with a commutative semiring structure, any type `σ`, any type `A` with a semiring structure, and any two ring homomorphisms `f` and `g` from the multivariate polynomials over `R` and `σ` to `A`, if `f` and `g` coincide on the constant polynomials and on the degree `1` monomials, then `f` and `g` are identical. In other words, a ring homomorphism from a multivariate polynomial ring is uniquely determined by its values on the constants and on the degree `1` monomials.

Given commutative semirings R, type σ, semiring A, and ring homomorphisms f and g from the multivariate polynomials over R and σ to A, if f and g agree on constants and degree 1 monomials, then f = g.


theorem Set.iSup_iInf_of_monotone :
    ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Finite ι] [inst : Preorder ι'] [inst_1 : Nonempty ι']
      [inst_2 : IsDirected ι' fun x x_1 => x ≤ x_1] [inst_3 : Order.Frame α] {f : ι → ι' → α},
      (∀ (i : ι), Monotone (f i)) → ⨆ j, ⨅ i, f i j = ⨅ i, ⨆ j, f i j :=
  by sorry

The theorem `Set.iSup_iInf_of_monotone` states that for any types `ι`, `ι'`, and `α`, where `ι` is finite, `ι'` is nonempty and directed under the order `≤`, and `α` is a frame; given a function `f` from `ι` and `ι'` to `α` such that for every element `i` of `ι`, the function `f i` is monotone, then the supremum (over `j`) of the infimum (over `i`) of `f i j` equals the infimum (over `i`) of the supremum (over `j`) of `f i j`. This means the order of taking supremum and infimum does not change the result in this context.

For any finite `ι`, nonempty and directed `ι'`, and frame `α`, if `f : ι → ι' → α` is such that `f i` is monotone for all `i`, then `sup (i, inf (j, f i j)) = inf (i, sup (j, f i j))`.


theorem Nat.iSup_lt_succ :
    ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ),
      ⨆ k, ⨆ (_ : k < n + 1), u k = (⨆ k, ⨆ (_ : k < n), u k) ⊔ u n :=
  by sorry

For any type `α` that is a complete lattice, and any function `u` from the natural numbers to `α`, the least upper bound of the function `u` applied over all natural numbers `k` less than `n + 1` is equal to the join (i.e., maximum or union) of the least upper bound of `u` applied over all natural numbers less than `n` and `u` applied to `n`.

For any complete lattice type `α` and function `u` from natural numbers to `α`, the least upper bound of `u` over numbers less than `n + 1` equals the join of the least upper bound over numbers less than `n` and `u` applied to `n`.


theorem PFunctor.W.dest_mk : ∀ {P : PFunctor.{u}} (p : ↑P (PFunctor.W P)), PFunctor.W.dest (PFunctor.W.mk p) = p := by
  sorry

The theorem `PFunctor.W.dest_mk` states that for any polynomial functor `P`, and for any `p` which is a member of type `P` applied to the type `PFunctor.W P`, constructing a W-type from `p` using `PFunctor.W.mk` and then destructing it with `PFunctor.W.dest` yields `p` back. In other words, the destruction function `PFunctor.W.dest` is the left inverse of the construction function `PFunctor.W.mk` for W-types of a polynomial functor. This theorem ensures that W-type construction and destruction operations are reversible.

For any polynomial functor `P`, the functions `PFunctor.W.mk` and `PFunctor.W.dest` are mutually inverse, i.e., applying `PFunctor.W.dest` to a W-type constructed by `PFunctor.W.mk` from an element `p` in `P (PFunctor.W P)` yields `p` back.


/-- A closed ball in a product space is a product of closed balls. See also `closedBall_pi'`
for a version assuming `Nonempty β` instead of `0 ≤ r`.  -/
theorem closedBall_pi :
    ∀ {β : Type v} {π : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (π b)]
      (x : (b : β) → π b) {r : ℝ}, 0 ≤ r → Metric.closedBall x r = Set.pi Set.univ fun b => Metric.closedBall (x b) r :=
  by sorry

The theorem `closedBall_pi` states that for any type `β`, a function `π` mapping `β` to some type which has a pseudometric space structure, a finitely typed instance of `β`, and a function `x` mapping `β` to the pseudometric space, given a real number `r` greater than or equal to zero, the closed ball in this product space is equivalent to the set of functions (from set `β` to the pseudometric space) such that for each element in `β`, the function maps it into the closed ball in the pseudometric space with the same radius `r`. In mathematical terms, it can be expressed as: for a product of pseudometric spaces, the closed ball centered at a point `x` with radius `r` is the set of all points whose distance to `x` in each individual space does not exceed `r`.

The closed ball in a product of pseudometric spaces with respect to a point and radius is equivalent to the set of functions mapping each element to a closed ball in the corresponding space with the same radius.


theorem RelIso.symm_apply_apply :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (e : r ≃r s) (x : α),
      (RelIso.symm e) (e x) = x :=
  by sorry

The theorem `RelIso.symm_apply_apply` states that for any types `α` and `β`, any relations `r` and `s` on `α` and `β` respectively, any relation isomorphism `e` between `r` and `s`, and any element `x` of type `α`, applying the inverse (or symmetry) of the isomorphism `e` to the result of applying `e` to `x` yields back the original element `x`. In other words, the inverse operation of a relation isomorphism undoes the effect of the original operation.

For any relation isomorphisms between types and relations, application of the inverse isomorphism to the composition of the original isomorphism with an element maps the element back to its original value.


theorem Polynomial.coe_monomial :
    ∀ {R : Type u_2} [inst : CommSemiring R] (n : ℕ) (a : R),
      ↑((Polynomial.monomial n) a) = (PowerSeries.monomial R n) a :=
  by sorry

The theorem `Polynomial.coe_monomial` states that for any given commutative semiring `R`, a natural number `n` and an element `a` of `R`, the coercion of the `n`-th monomial with coefficient `a` in the polynomial ring over `R` to a formal power series over `R` equals the `n`-th monomial with coefficient `a` in the formal power series ring over `R`. Essentially, this theorem is saying that the monomial structure in the polynomial ring and the formal power series ring over `R` is preserved under the coercion from polynomials to power series.

For any commutative semiring R, the coercion of the n-th monomial with coefficient a in the polynomial ring over R to a formal power series over R equals the n-th monomial with coefficient a in the formal power series ring over R.


theorem nhds_cons :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (l : List α),
      nhds (a :: l) = Seq.seq (List.cons <$> nhds a) fun x => nhds l :=
  by sorry

This theorem, `nhds_cons`, states that for any type `α` equipped with a topology (denoted by `inst : TopologicalSpace α`) and any element `a` of type `α` and list `l` of type `List α`, the neighborhood filter of the cons list `(a :: l)` is equal to the sequence of the map of list cons function on the neighborhood filter of `a` and the neighborhood filter of `l`. In other words, it shows how the neighborhood filter of a cons list can be constructed from the neighborhood filters of its head and tail.

Given a topological space `α` and an element `a` in `α` with neighborhood filter `Nhds a`, and a list `l` of elements in `α` with neighborhood filter `Nhds l`, the neighborhood filter of the cons list `a :: l` is equal to `Nhds a ⊓ ∥map (λx ═> Nhds x) (Nhds l)∥`, where `⊓` denotes the meet operation in the lattice of filters on `α` and `∥map ...∥` denotes the sequential composition of the map function with `map` and the set of filters.


theorem FreeGroup.invRev_involutive : ∀ {α : Type u}, Function.Involutive FreeGroup.invRev := by sorry

The theorem `FreeGroup.invRev_involutive` states that for all types `α`, the function `FreeGroup.invRev` is involutive. In other words, applying `FreeGroup.invRev` twice to any list of pairs of elements from type `α` and boolean values will return the original list. This means that `FreeGroup.invRev` is its own inverse function.

The function `FreeGroup.invRev` on lists of pairs from type `α` and boolean values is self-inverse.


theorem SimplexCategory.eq_id_of_isIso :
    ∀ {x : SimplexCategory} (f : x ⟶ x) [inst : CategoryTheory.IsIso f], f = CategoryTheory.CategoryStruct.id x := by
  sorry

The theorem `SimplexCategory.eq_id_of_isIso` states that for all objects `x` in the SimplexCategory, if a morphism `f` from `x` to itself is an isomorphism (i.e., it has an inverse), then `f` is the identity morphism on `x`. In other words, any isomorphism from an object to itself in the SimplexCategory is the identity morphism. It asserts the uniqueness of identity in this category: no other morphism can have the properties of an identity morphism.

In the SimplexCategory, every isomorphism from an object to itself is the identity morphism.


theorem DirectSum.of_eq_of_gradedMonoid_eq :
    ∀ {ι : Type u_1} [inst : DecidableEq ι] {A : ι → Type u_2} [inst_1 : (i : ι) → AddCommMonoid (A i)] {i j : ι}
      {a : A i} {b : A j}, GradedMonoid.mk i a = GradedMonoid.mk j b → (DirectSum.of A i) a = (DirectSum.of A j) b :=
  by sorry

This theorem states that for any types `ι` and `A` where `ι` has a decidable equality and `A` is an index type for a collection of additive commutative monoids, if two elements `a` and `b` from types `A i` and `A j` respectively are such that their corresponding elements in the graded monoid, created via `GradedMonoid.mk`, are equal, then their images under the natural inclusion maps into the direct sum of the collection of monoids, created via `DirectSum.of`, are also equal.
In other words, if `GradedMonoid.mk i a = GradedMonoid.mk j b`, then `(DirectSum.of A i) a = (DirectSum.of A j) b`.

If `ι` is a type with decidable equality and `A` is an indexed collection of additive commutative monoids, then for all `i, j` and elements `a in A i` and `b in A j` with equal images in the graded monoid of `A`, their images under the natural inclusion maps in the direct sum of `A` are also equal: `(DirectSum.of A i) a = (DirectSum.of A j) b`.


theorem Polynomial.natDegree_eq_card_roots' :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] {p : Polynomial K} {i : K →+* L},
      Polynomial.Splits i p →
        Polynomial.natDegree (Polynomial.map i p) = Multiset.card (Polynomial.roots (Polynomial.map i p)) :=
  by sorry

This theorem states that for any commutative ring `K`, any field `L`, any polynomial `p` over `K`, and any ring homomorphism `i` from `K` to `L`, if the polynomial `p` splits via `i`, then the natural degree of the polynomial obtained by mapping `p` across `i` is equal to the cardinality of the multiset of roots of the mapped polynomial. In other words, if a polynomial can be factored such that all its irreducible factors have degree 1, then the natural degree of the polynomial in the field `L` is equal to the number of its roots in `L` including their multiplicities.

For any commutative ring `K`, field `L`, ring homomorphism `i` from `K` to `L`, and polynomial `p` over `K`, if `p` splits in `L` via `i` with all irreducible factors having degree 1, then the degree of the mapped polynomial equals the number of roots of `p` in `L` including multiplicities.


/-- The measurable space structures generated by independent pi-systems are independent.  -/
theorem ProbabilityTheory.kernel.iIndepSets.iIndep :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      (m : ι → MeasurableSpace Ω),
      (∀ (i : ι), m i ≤ _mΩ) →
        ∀ (π : ι → Set (Set Ω)),
          (∀ (n : ι), IsPiSystem (π n)) →
            (∀ (i : ι), m i = MeasurableSpace.generateFrom (π i)) →
              ProbabilityTheory.kernel.iIndepSets π κ μ → ProbabilityTheory.kernel.iIndep m κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.iIndepSets.iIndep` states that given a measurable space structure `_mα` on a type `α`, another measurable space structure `_mΩ` on a type `Ω`, a kernel function `κ` of type `ProbabilityTheory.kernel α Ω`, a measure `μ` on `α`, and a family of measurable space structures `m` indexed by `ι` such that each `m i` is a sub-measurable space of `_mΩ`, if for each `ι`-index `i`, there exists a set `π i` which is a π-system and the `m i` is the smallest measurable space containing the set `π i`, and if these π-systems are independent with respect to `κ` and `μ`, then the measurable space structures `m` are also independent with respect to `κ` and `μ`. In other words, if the π-systems that generate the measurable spaces are independent, then the generated measurable spaces themselves are also independent.

If for each index `i`, a π-system `π i` generates a sub-measurable space `m i` of a measurable space `_mΩ` such that `m i` is the smallest measurable space containing `π i` and the π-systems `π i` are independent, then the measurable spaces `m i` are independent with respect to a kernel function `κ` and a measure `μ`.


theorem quasiIsoAt_iff_isIso_homologyMap :
    ∀ {ι : Type u_2} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c}
      (f : K ⟶ L) (i : ι) [inst_2 : HomologicalComplex.HasHomology K i] [inst_3 : HomologicalComplex.HasHomology L i],
      QuasiIsoAt f i ↔ CategoryTheory.IsIso (HomologicalComplex.homologyMap f i) :=
  by sorry

This theorem, `quasiIsoAt_iff_isIso_homologyMap`, states that for any homological complexes `K` and `L` of objects in a category `C` (where `C` has zero morphisms and is indexed by some type `ι` in a complex shape `c`), and for any morphism `f` from `K` to `L` and index `i`, `f` is a quasi-isomorphism at index `i` if and only if the map arising from `f` on the homology at index `i` is an isomorphism. Here, the homology exists at index `i` for both `K` and `L`.

In other words, the theorem is about the relationship between a 'quasi-isomorphism at a specific index' and an 'isomorphism of the homology map at the same index'. They are equivalent concepts according to this theorem.

For homological complexes K and L in a zero-morphism category C indexed by ι, and a morphism f from K to L, f is a quasi-isomorphism at index i if and only if the map on i-th homologies induced by f is an isomorphism.


theorem WithTop.top_add : ∀ {α : Type u} [inst : Add α] (a : WithTop α), ⊤ + a = ⊤ := by sorry

The theorem `WithTop.top_add` states that for any type `α` that has an addition operation defined on it, when you add the special element `⊤` (representing a kind of "infinity") to any element `a` of the type `WithTop α` (which is `α` with an additional `⊤` element), the result is always `⊤`. This means that `⊤` acts as an absorbing element for the addition operation in the extended type `WithTop α`.

For any type `α` with an addition operation, in `WithTop α`, the element `⊤` absorbs additions, i.e., `a + ⊤ = ⊤` for all `a` in `α`.


/-- A version of `edist_le_Ico_sum_edist` with each intermediate distance replaced
with an upper estimate.  -/
theorem edist_le_Ico_sum_of_edist_le :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : ℕ → α} {m n : ℕ},
      m ≤ n →
        ∀ {d : ℕ → ENNReal},
          (∀ {k : ℕ}, m ≤ k → k < n → edist (f k) (f (k + 1)) ≤ d k) →
            edist (f m) (f n) ≤ Finset.sum (Finset.Ico m n) fun i => d i :=
  by sorry

This theorem, named `edist_le_Ico_sum_of_edist_le`, is a version of `edist_le_Ico_sum_edist` where each intermediate distance is replaced with an upper estimate. In more specific terms, it states that for any type `α` that forms a pseudometric space, and any function `f` from natural numbers to `α`, for any natural numbers `m` and `n` such that `m` is less than or equal to `n`, and any function `d` from natural numbers to the extended non-negative real numbers (ENNReal), if for all `k` (which is a natural number) between `m` and `n` the distance in the pseudometric space between `f(k)` and `f(k+1)` is less than or equal to `d(k)`, then the distance between `f(m)` and `f(n)` is less than or equal to the sum of the values of `d(i)` for each `i` in the finite integer interval from `m` to `n`.

For any pseudometric space (α, d), function f : ℕ → α, and function d' : ℕ → ∣∣Real.enn║∣∣, if for all i in the range from m to n, the distance d(i) between f(i) and f(i+1) is less than or equal to d'(i), then the distance from f(m) to f(n) is less than or equal to the sum of d'(i) for i from m to n.


/-- Shows that the integer parts of the continued fraction are at least one.  -/
theorem GeneralizedContinuedFraction.of_one_le_get?_part_denom :
    ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : LinearOrderedField K] [inst_1 : FloorRing K] {b : K},
      Stream'.Seq.get? (GeneralizedContinuedFraction.partialDenominators (GeneralizedContinuedFraction.of v)) n =
          some b →
        1 ≤ b :=
  by sorry

This theorem states that for any type `K` that has an order structure (a `LinearOrderedField`) and a `FloorRing` structure, any value `v` of type `K`, and any natural number `n`, if `b` is the `n`th element of the sequence of partial denominators of the generalized continued fraction representation of `v`, then `b` is greater than or equal to 1. In other words, the integer parts of the continued fraction representation of any number are always at least one.

For any number `v` in a LinearOrderedField with a FloorRing structure, the integer parts of its generalized continued fraction representation are greater than or equal to 1.


theorem Set.bot_eq_empty : ∀ {α : Type u}, ⊥ = ∅ := by sorry

This theorem states that for any type `α`, the bottom element (`⊥`) is equal to the empty set (`∅`). In other words, in the context of set theory, `⊥` is used to denote the smallest element in a set, which is the empty set. This holds true for any type `α`.

For any type `α`, the bottom element `⊥` is equivalent to the empty set `∅`.


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

The theorem `mem_lowerBounds_image2_of_mem_upperBounds` states that for all types `α`, `β`, `γ` with preorder relations, a binary function `f : α → β → γ`, and sets `s` of type `α` and `t` of type `β`, if `f` is antitone with respect to both its arguments, then for any elements `a` in the upper bounds of `s` and `b` in the upper bounds of `t`, the image of `f` applied to `a` and `b` is in the lower bounds of the image of the binary function `f` applied to sets `s` and `t`.

In simple words, if `f` reverses the order of its arguments and `a` and `b` are upper bounds of their respective sets, then `f(a, b)` is a lower bound of the set of all possible values of `f` when applied to elements of sets `s` and `t`.

If `f : α → β → γ` is an antitone function between preordered sets `(α, ≤α)` and `(β, ≤β)`, and `a ∈ ⨆ s` and `b ∈ ⨆ t`, then `f a b ∈ ⊓ (f '' s) ∩ (f '' t)`. (Here, `s ⊆ α`, `t ⊆ β`, `s''` denotes the image of `s` under `f`, and `⨆` and `⊓` represent the upper bounds and lower bounds of sets, respectively.)


theorem Polynomial.sum_zero_index :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : AddCommMonoid S] (f : ℕ → R → S),
      Polynomial.sum 0 f = 0 :=
  by sorry

The theorem `Polynomial.sum_zero_index` states that for any type `R` with a semiring structure, any type `S` with an additive commutative monoid structure, and any function `f` from pairs of natural numbers and `R` to `S`, the sum of the values of the function `f` applied to the coefficients of the zero polynomial is equal to zero.

For any semiring `R`, additive commutative monoid `S`, and function `f` from pairs of natural numbers and `R` to `S` representing polynomial coefficients, the sum of `f` applied to the coefficients of the zero polynomial is equal to the zero element of `S`.


theorem Rat.toNNRat_eq_zero : ∀ {q : ℚ}, Rat.toNNRat q = 0 ↔ q ≤ 0 := by sorry

This theorem states that for any rational number 'q', the function `Rat.toNNRat` that maps 'q' to a non-negative rational number returns 0 if and only if 'q' is less than or equal to 0. This means the conversion of 'q' to a non-negative rational number will yield 0 precisely when 'q' is not positive.

For any rational number q, Rat.toNNRat q = 0 if and only if q ≤ 0.


CochainComplex.HomComplex.Cocycle.ext

theorem CochainComplex.HomComplex.Cocycle.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G : CochainComplex C ℤ} {n : ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cocycle F G n), ↑z₁ = ↑z₂ → z₁ = z₂ :=
  by sorry

This theorem states that given a category `C` that is also preadditive, two cochain complexes `F` and `G` over integers, and an integer `n`, if two `n`-cocycles `z₁` and `z₂` in the homology complex of `F` and `G` are equal as elements of the underlying type (i.e., their coerced forms `↑z₁` and `↑z₂` are equal), then the original cocycles `z₁` and `z₂` themselves are also equal. This basically asserts that the embedding of cocycles into the larger type is injective, or in other words, no two distinct cocycles get identified under this embedding.

In a preadditive category `C` with integer-valued cohomology, equal underlying cohomology classes of degree `n` cocycles in complexes `F` and `G` imply equal cocycles.


theorem Set.support_indicator_subset :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {f : α → M}, Function.support (Set.indicator s f) ⊆ s :=
  by sorry

The theorem `Set.support_indicator_subset` asserts that for any type `α`, any type `M` with a zero element, any set `s` of elements of type `α`, and any function `f` from `α` to `M`, the support of the set indicator function of `s` and `f` is a subset of `s`. In other words, the set of all points `x` in `α` where the function `Set.indicator s f` does not equal zero, is contained within `s`. Here, `Set.indicator s f` is a function that gives the value `f(x)` for `x` in `s`, and zero otherwise.

For any set `s` in type `α` and any function `f` from `α` to a type `M` with a zero element, the set where `Set.indicator s f` is non-zero is contained in `s`.


theorem AddEquivClass.map_ne_zero_iff :
    ∀ {F : Type u_1} {M : Type u_12} {N : Type u_13} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : EquivLike F M N] [inst_3 : AddEquivClass F M N] (h : F) {x : M}, h x ≠ 0 ↔ x ≠ 0 :=
  by sorry

This theorem, `AddEquivClass.map_ne_zero_iff`, states that for all types `F`, `M`, and `N`, given `M` and `N` are additive zero classes, `F` is an equivalence relation between `M` and `N`, and `F` is an additive equivalence class between `M` and `N`, for any instance `h` of `F` and any `x` in `M`, `h x` is not equal to zero if and only if `x` is not equal to zero. Essentially, it says that under these conditions, mapping `x` through the equivalence `h` preserves the property of not being zero.

For all types `F`, `M`, and `N`, if `F` is an additive equivalence relation between additive zero classes `M` and `N`, then `x ∈ M` is not equal to zero if and only if `F x` is not equal to zero.


ContinuousAt.smul

theorem ContinuousAt.smul :
    ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : SMul M X] [inst_4 : ContinuousSMul M X] {f : Y → M} {g : Y → X} {b : Y},
      ContinuousAt f b → ContinuousAt g b → ContinuousAt (fun x => f x • g x) b :=
  by sorry

The theorem states that for any types `M`, `X`, and `Y` equipped with topological space structures, and assuming `M` and `X` also have a scalar multiplication structure, and this scalar multiplication is continuous, then if a function `f` from `Y` to `M` is continuous at a point `b`, and another function `g` from `Y` to `X` is also continuous at the same point, the function that maps `x` in `Y` to the scalar product of `f(x)` and `g(x)` is also continuous at the point `b`.

Given types `M` and `X` with topological spaces and scalar multiplication structures, and `Y` with scalar multiplication continuous in `M` and `X`, if `f : Y → M` and `g : Y → X` are continuous at a point `b` in `Y`, then the function `x ↦ f x ⋅ g x` from `Y` to `M` is continuous at `b`. (Here, "⋅" denotes scalar product.)


theorem Matroid.Basis.union_basis_union :
    ∀ {α : Type u_1} {M : Matroid α} {I X J Y : Set α},
      M.Basis I X → M.Basis J Y → M.Indep (I ∪ J) → M.Basis (I ∪ J) (X ∪ Y) :=
  by sorry

This theorem, named "union_basis_union", pertains to the context of Matroids in mathematics. It states that for any type `α`, and any `Matroid` named `M` of that type, if `I`,`X`,`J`, and `Y` are all sets of `α`, and if `I` and `X` form a basis of `M` (`M.Basis I X`), as well as `J` and `Y` (`M.Basis J Y`), and if `I union J` is independent (`M.Indep (I ∪ J)`), then `I union J` and `X union Y` also form a basis of `M` (`M.Basis (I ∪ J) (X ∪ Y)`). Thus, it provides a condition under which the union of two bases in a Matroid yields another valid basis.

If two sets are bases of a matroid and their union is independent, then their union is also a basis.


/-- A `DistribMulAction` that is continuous on a uniform group is uniformly continuous.
This can't be an instance due to it forming a loop with
`UniformContinuousConstSMul.to_continuousConstSMul`  -/
theorem uniformContinuousConstSMul_of_continuousConstSMul :
    ∀ (R : Type u) (M : Type v) [inst : Monoid R] [inst_1 : AddCommGroup M] [inst_2 : DistribMulAction R M]
      [inst_3 : UniformSpace M] [inst_4 : UniformAddGroup M] [inst_5 : ContinuousConstSMul R M],
      UniformContinuousConstSMul R M :=
  by sorry

This theorem states that for any types `R` and `M`, where `R` is a monoid, `M` is an additive commutative group, `M` is a uniform space and a uniform additive group, and `R` has a distributive multiplication action on `M` that is continuous, then the constant scalar multiplication of `R` on `M` is uniformly continuous. However, this cannot be an instance because it would form a loop with the theorem `UniformContinuousConstSMul.to_continuousConstSMul`.

If `R` is a continuous, distributive monoid action on an additive commutative group `M`, which is also a uniform space and a uniform additive group, then constant scalar multiplication by elements of `R` on `M` is uniformly continuous.


theorem tsub_add_tsub_cancel :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α}, b ≤ a → c ≤ b → a - b + (b - c) = a - c :=
  by sorry

This theorem, `tsub_add_tsub_cancel`, states that for any type `α` that has an additive commutative semigroup structure, a partial order, the ability to find an additive element satisfying a less than or equal to relation, follows covariant laws with respect to addition and order, and also supports subtraction operation that respects the order, the following holds: for any three elements `a`, `b`, and `c` of `α` such that `b` is less than or equal to `a` and `c` is less than or equal to `b`, the expression `a - b + (b - c)` is equal to `a - c`. This is a generalized property related to order and arithmetic operations, particularly subtraction and addition, in this mathematical structure.

For any additive commutative semigroup with order relation and subtraction operation, if `a` is greater than or equal to `b` and `b` is greater than or equal to `c`, then `a - b + (b - c) = a - c`.


/-- If `f` has derivative `f'` within `(x, +∞)` at `x`, then for any `r > ‖f'‖` the ratio
`(‖f z‖ - ‖f x‖) / (z - x)` is frequently less than `r` as `z → x+0`.
In other words, the limit inferior of this ratio as `z` tends to `x+0`
is less than or equal to `‖f'‖`.

See also

* `HasDerivWithinAt.limsup_norm_slope_le` for a stronger version using
  limit superior and any set `s`;
* `HasDerivWithinAt.liminf_right_norm_slope_le` for a stronger version using
  `‖f z - f xp‖` instead of `‖f z‖ - ‖f x‖`.  -/
theorem HasDerivWithinAt.liminf_right_slope_norm_le :
    ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {f' : E} {x r : ℝ},
      HasDerivWithinAt f f' (Set.Ici x) x →
        ‖f'‖ < r → ∃ᶠ (z : ℝ) in nhdsWithin x (Set.Ioi x), (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r :=
  by sorry

The theorem `HasDerivWithinAt.liminf_right_slope_norm_le` states that if a function `f` has a derivative `f'` at a point `x` within the interval extending from `x` to positive infinity, then for any real number `r` that is greater than the norm of `f'`, there frequently exists a point `z` within the interval that extends from `x` to just over `x` such that the ratio `(‖f z‖ - ‖f x‖) / (z - x)` is less than `r`. In other terms, the lower limit (or limit inferior) of this ratio as `z` approaches `x` from the right is less than or equal to the norm of `f'`. This theorem also refers to two stronger versions, one employing limit superior and any set `s`, and another using the difference of function values `‖f z - f xp‖` instead of the difference of norms `‖f z‖ - ‖f x‖`.

If a real-valued function `f` has a derivative `f'` at `x`, then for any `r` greater than the norm of `f'`, there exists `z` near `x` such that the ratio of the norm difference `|f z - f x|` to the distance `|z - x|` is less than `r`. (The lower right-hand limit of this ratio is less than or equal to the norm of `f'`.)


theorem List.sorted_ofFn_iff :
    ∀ {n : ℕ} {α : Type uu} {f : Fin n → α} {r : α → α → Prop},
      List.Sorted r (List.ofFn f) ↔ ((fun x x_1 => x < x_1) ⇒ r) f f :=
  by sorry

This theorem, `List.sorted_ofFn_iff`, states that for any natural number `n`, any type `α`, any function `f` mapping from the finite set of `n` elements to `α`, and any relation `r` on `α`, the list generated by applying `f` to each element in the finite set is sorted according to the relation `r` if and only if `r` holds whenever `f` is applied to any pair of distinct elements in the finite set. In other words, if `r` is a relational property between two elements in the list, and `f` is a function that maps from each element in a finite list to the new list, then the list is sorted according to `r` if `r` is true for every pair of elements in the new list.
This theorem bridges the concept of a function preserving a property through its mapping and the sortedness of the resulting list.

For any natural number `n`, type `α`, function `f` mapping a finite set of `n` elements to `α`, and relation `r` on `α`, `List.sorted (map f xs)` if and only if `r x y` for all distinct `x, y` in the finite set `xs`.


List.Subperm.subset

theorem List.Subperm.subset : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Subperm l₁ l₂ → l₁ ⊆ l₂ := by sorry

The theorem `List.Subperm.subset` states that for any type `α` and any two lists `l₁` and `l₂` of that type, if `l₁` is a sub-permutation of `l₂` (denoted as `l₁ <+~ l₂`), then all elements of `l₁` are also elements of `l₂`. In other words, `l₁` is a subset of `l₂` (denoted as `l₁ ⊆ l₂`). This theorem establishes a relationship between the sub-permutation and subset properties of two lists.

For any type `α` and lists `l₁` and `l₂` of that type, if `l₁` is a sub-permutation of `l₂` (`l₁ <+~ l₂`), then `l₁` is a subset of `l₂` (`l₁ ⊆ l₂`).


theorem CategoryTheory.Limits.limitIsoLimitCurryCompLim_hom_π_π :
    ∀ {J K : Type v} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.SmallCategory K] {C : Type u}
      [inst_2 : CategoryTheory.Category.{v, u} C] (G : CategoryTheory.Functor (J × K) C)
      [inst_3 : CategoryTheory.Limits.HasLimitsOfShape K C] [inst_4 : CategoryTheory.Limits.HasLimit G]
      [inst_5 :
        CategoryTheory.Limits.HasLimit
          (CategoryTheory.Functor.comp (CategoryTheory.curry.obj G) CategoryTheory.Limits.lim)]
      {j : J} {k : K},
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitIsoLimitCurryCompLim G).hom
          (CategoryTheory.CategoryStruct.comp
            (CategoryTheory.Limits.limit.π
              (CategoryTheory.Functor.comp (CategoryTheory.curry.obj G) CategoryTheory.Limits.lim) j)
            (CategoryTheory.Limits.limit.π ((CategoryTheory.curry.obj G).obj j) k)) =
        CategoryTheory.Limits.limit.π G (j, k) :=
  by sorry

This theorem states that for any two types `J` and `K`, which are small categories, and a type `C` which is a category, given a functor `G` from the product of `J` and `K` to `C`, if `C` has limits of shape `K` and the functor `G` and the composition of the curry of `G` with the limit have limits, then the composition of the homomorphism from the isomorphism between the limit and the curry composition limit of `G` with the composition of two projections (the first from the limit of the composition of the curry of `G` with the limit to an object `j` of `J`, the second from the object `j` of the curry of `G` to an object `k` of `K`) is equal to the projection from the limit of `G` to the pair `(j, k)`.

Given functors `G: J × K → C` from the product of small categories `J` and `K` to a category `C` with limits of shape `K`, if `C` has limits of shape `J × K` and the limit of `G` and the limit of the composition `G ∘ (π1 ∘ product.fst) ∘ limit` exist, then the composition of the homomorphism from the limit to `G` with the projections `π1` and `π2` equals the projection from the limit of `G` to `J × K`.


/-- If `m₁ s = op (m₂ s) (m₃ s)` for all `s`, then the same is true for `m₁.trim`, `m₂.trim`,
and `m₃ s`.  -/
theorem MeasureTheory.OuterMeasure.trim_binop :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {m₁ m₂ m₃ : MeasureTheory.OuterMeasure α}
      {op : ENNReal → ENNReal → ENNReal},
      (∀ (s : Set α), ↑m₁ s = op (↑m₂ s) (↑m₃ s)) →
        ∀ (s : Set α),
          ↑(MeasureTheory.OuterMeasure.trim m₁) s =
            op (↑(MeasureTheory.OuterMeasure.trim m₂) s) (↑(MeasureTheory.OuterMeasure.trim m₃) s) :=
  by sorry

The given theorem is about the operation on outer measures in measure theory. It states that if we have three outer measures `m₁`, `m₂`, and `m₃`, and an operation `op` on the extended nonnegative real numbers such that for every set `s`, the measure `m₁` of `s` equals the result of applying operation `op` to the measures `m₂` and `m₃` of `s`, then the same relationship holds when we consider the trimmed versions of these measures. In other words, if the measure of a set under `m₁` equals the result of some operation on the measures under `m₂` and `m₃`, this property will still hold true after trimming these measures.

If outer measures $m\_1$, $m\_2$, and $m\_3$ satisfy $m\_1(S) = \operatorop{op}(m\_2(S), m\_3(S))$ for all sets $S$, then $m\_{1\text{-}trim}(S) = \operatorop{op}(m\_{2\text{-}trim}(S), m\_{3\text{-}trim}(S))$ for all sets $S$.


theorem BoundedContinuousFunction.coe_nsmul :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : AddMonoid β]
      [inst_3 : LipschitzAdd β] (r : ℕ) (f : BoundedContinuousFunction α β), ⇑(r • f) = r • ⇑f :=
  by sorry

This theorem states that for any natural number `r` and any bounded continuous function `f` from a topological space `α` to a pseudo metric space `β` (where `β` also has an addition operation that is both a monoid operation and Lipschitz continuous), the function obtained by scaling `f` by `r` is the same as scaling the function `f` first and then applying it. Specifically, if you apply the scaled function to an input, it's the same as multiplying the output of the original function by `r`.

For any natural number `r` and a bounded continuous function `f` from a topological space `α` to a pseudo metric space `β` with a Lipschitz continuous addition operation, the function `r * f` equals `f * r` where `r * f(x) = r * f(x)` and `f * r(x) = f(rx)`.


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

This theorem states that, for every type `α` with a measurable space structure `m0` and any measure `μ` on that space, and any two sets of elements of `α`, `s` and `t`, if `s` is a subset of `t`, then the measure of `s` when restricted to `t` is equal to the original measure of `s`. In mathematical terms, given any measure `μ` and sets `s` and `t` with `s ⊆ t`, we have `μ.restrict(t)(s) = μ(s)`.

For every measurable space `(α, m0)` and measure `μ`, if `s ⊆ t` are sets in `α`, then `μ.restrict(t)(s) = μ(s)`.


theorem Array.append_nil : ∀ {α : Type u_1} (as : Array α), as ++ #[] = as := by sorry

This theorem states that for any type `α` and any array of this type `as`, appending an empty array (`#[]`) to `as` will result in `as` itself. In other words, adding nothing to the end of any array does not change the array. This is analogous to the mathematical property that adding zero to any number does not change the number.

For any type `α` and array `as : α array`, appending the empty array `#[]` to `as` results in the array `as` itself (i.e., `as ++ #[] = as`).


CategoryTheory.Presieve.singleton.mk

theorem CategoryTheory.Presieve.singleton.mk :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : Y ⟶ X},
      CategoryTheory.Presieve.singleton f f :=
  by sorry

The theorem `CategoryTheory.Presieve.singleton.mk` states that for any category `C` and any two objects `X` and `Y` in `C`, for any morphism `f` from `Y` to `X`, `f` is in the presieve generated by `f`. In other words, the morphism `f` is included in the singleton presieve of `f`. This makes sense because a singleton presieve, by definition, is the set that only contains the morphism used to generate it.

For any category C, morphism f : C.Obj X → C.Obj Y, and object X, Y in C, f ∈ {g | ∃ h : C.Morset.singleton h, C.Morset.mem (C.Morset.singleton h) f}.


/-- A finite dimensional space has zero `finrank` iff it is a subsingleton.
This is the `finrank` version of `rank_zero_iff`.  -/
theorem FiniteDimensional.finrank_zero_iff :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      [inst_4 : StrongRankCondition R] [inst_5 : Module.Finite R M] [inst_6 : NoZeroSMulDivisors R M],
      FiniteDimensional.finrank R M = 0 ↔ Subsingleton M :=
  by sorry

This theorem states that a finite-dimensional space over a ring `R` has a rank of zero if and only if it is a subsingleton. Here, a subsingleton is a set or type with at most one element. This theorem is the `finrank` version of `rank_zero_iff`, meaning it concerns the rank defined in the context of finite-dimensional spaces.

The theorem applies to a module `M` over a ring `R`, assuming that `R` is nontrivial (i.e., not a zero ring), satisfies the strong rank condition (which implies that submodules of free modules are free), has finite rank, and has no zero `s`-multiples or divisors. All these conditions are encapsulated in the assumptions `[inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R] [inst_4 : StrongRankCondition R] [inst_5 : Module.Finite R M] [inst_6 : NoZeroSMulDivisors R M]`.

A finite-dimensional module over a nontrivial ring with the strong rank condition, finite rank, and no zero multiples or divisors has rank zero if and only if it is a subsingleton.


theorem geom_sum_two :
    ∀ {α : Type u} [inst : Semiring α] {x : α}, (Finset.sum (Finset.range 2) fun i => x ^ i) = x + 1 := by sorry

The theorem `geom_sum_two` states that for any type `α` that has semiring structure and for any element `x` of `α`, the sum of `x` raised to each element in the set of natural numbers less than 2, which are 0 and 1, is equal to `x + 1`. In mathematical terms, it's stating that $x^{0} + x^{1} = x + 1$ for all `x` in a semiring.

For any semiring `α` and its element `x`, $x^0 + x^1 = x + 1$.


theorem Set.pi_univ_Iio_subset :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i) [inst_1 : Nonempty ι],
      (Set.pi Set.univ fun i => Set.Iio (x i)) ⊆ Set.Iio x :=
  by sorry

The theorem `Set.pi_univ_Iio_subset` states that for any type `ι`, any family of types `α` indexed by `ι`, any preorder structure on each `α i`, and any function `x` from `ι` to `α i` (i.e., an element of the dependent product type), if `ι` is nonempty, then the set of dependent functions that are strictly less than `x` at each index is a subset of the set of dependent functions that are strictly less than `x` in the sense of the product order. In other words, if every coordinate of a function is less than the corresponding coordinate of `x`, then the function itself is less than `x` in the preorder of functions.

For any nonempty type `ι`, family of types `α i` indexed by `ι`, preorder `≤_α i` on each `α i`, and function `x : ∏ i, α i` from `ι` to `α i`, the subset of dependent functions `g : ∏ i, α i` with `g i < x i` for all `i` is included in the subset of functions `h : ∏ i, α i` with `h < x` in the product order.


theorem QuadraticForm.polar_smul_left :
    ∀ {R : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (Q : QuadraticForm R M) (a : R) (x y : M),
      QuadraticForm.polar (⇑Q) (a • x) y = a * QuadraticForm.polar (⇑Q) x y :=
  by sorry

The theorem `QuadraticForm.polar_smul_left` states that for any commutative ring `R`, additively commutative group `M` and `M` being a module over `R`, for any quadratic form `Q` from `R` to `M`, any scalar factor `a` in `R`, and for any `x` and `y` in `M`, the polar form of `Q` evaluated at `a • x` and `y` is equal to `a` times the polar form of `Q` evaluated at `x` and `y`. This can be interpreted as the linearity property of the polar form of a quadratic form with respect to scalar multiplication on the left argument.

For any quadratic form Q over a commutative ring R and additively commutative group M, the polar form of Q is left-linearly homogeneous, i.e., Q(ax, y) = a * Q(x, y) for all a in R and x, y in M.


/-- **Alias** of the forward direction of `Asymptotics.isLittleO_norm_right`. -/
theorem Asymptotics.IsLittleO.of_norm_right :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
      {g' : α → F'} {l : Filter α}, (f =o[l] fun x => ‖g' x‖) → f =o[l] g' :=
  by sorry

This theorem is an alias of the forward direction of `Asymptotics.isLittleO_norm_right` in asymptotic analysis. It says that for any types `α`, `E`, and `F'`, where `E` has a `Norm` and `F'` is a `SeminormedAddCommGroup`, and for any functions `f : α → E` and `g' : α → F'` and any filter `l` on `α`, if `f` is little-o of the norm of `g'` at `l` (meaning that `f` grows no faster than the norm of `g'` as we approach the limit `l`), then `f` is also little-o of `g'` at `l`.

If `f : α → E` is little-o of the norm of `g' : α → F'` at a filter `l` on `α`, then `f` is also little-o of `g'` at `l`.


theorem SimpleGraph.Subgraph.connected_iff' :
    ∀ {V : Type u} {G : SimpleGraph V} {H : SimpleGraph.Subgraph G},
      SimpleGraph.Subgraph.Connected H ↔ SimpleGraph.Connected (SimpleGraph.Subgraph.coe H) :=
  by sorry

This theorem establishes a relationship between a subgraph being connected and the corresponding simple graph, constructed from the vertex set of the subgraph, being connected. Specifically, for any given type of vertices 'V', a simple graph 'G' on 'V', and a subgraph 'H' of 'G', the subgraph 'H' is connected if and only if the simple graph created from the vertex set of the subgraph 'H' is also connected. Here, 'connected' refers to the property of a graph where there exists a path between any two vertices in the graph.

A subgraph of a simple graph is connected if and only if the simple subgraph formed by its vertex set is connected.


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

This theorem, denoted as `Stream'.WSeq.ofList_cons`, establishes a property about weak sequences in the context of Stream' in Lean 4. For any type `α`, and any element `a` of type `α` and list `l` of elements of type `α`, it states that the weak sequence generated from the list obtained by prepending `a` to `l` (i.e., `a :: l`) is equal to the weak sequence obtained by invoking the `cons` operation on `a` and the weak sequence generated from `l`. In simpler terms, prepending an element to a list and converting it to a weak sequence is equivalent to prepending the same element to the weak sequence generated from the list.

For any type `α` and elements `a` and `x` of type `α`, the weak sequence obtained from the list `a :: xs` is equal to the weak sequence obtained from `xs` by prepending `a` using the `cons` operation.


theorem AddCircle.measurable_mk' : ∀ {a : ℝ}, Measurable QuotientAddGroup.mk := by sorry

The theorem `AddCircle.measurable_mk'` states that for all real numbers `a`, the function `QuotientAddGroup.mk` is measurable. In mathematical terms, the canonical map from an additive group `α` to the quotient `α ⧸ s` respects the property of measurability. That means, for any subset of the quotient space that is measurable, the preimage of this set under the canonical map is also measurable in the original additive group.

The canonical map from an additive group to its quotient by a subgroup preserves measurability of subsets.


theorem Finset.mem_univ_val : ∀ {α : Type u_1} [inst : Fintype α] (x : α), x ∈ Finset.univ.val := by sorry

This theorem states that for any type `α` that has a `Fintype` instance, every element `x` of type `α` belongs to the universal finite set of type `α`. In simpler terms, the theorem ensures that every element of a finite type is included in its corresponding universal finite set.

For any type `α` with a `Fintype` instance, every `x : α` is an element of the universal finite set of `α`.


/-- **Alias** of `le_compl_comm`. -/
theorem le_compl_iff_le_compl : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ bᶜ ↔ b ≤ aᶜ := by sorry

This theorem, `le_compl_iff_le_compl`, is an alias of the `le_compl_comm` theorem. It states that for any Type `α` that forms a Heyting algebra, and for any elements `a` and `b` of this type, `a` is less than or equal to the complement of `b` if and only if `b` is less than or equal to the complement of `a`. In other words, in a Heyting algebra, the order relationship between two elements is mirrored when comparing each element to the complement of the other.

In a Heyting algebra, for all elements a and b, a <= complement(b) if and only if b <= complement(a).