theorem eVariationOn.sum_le :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) {s : Set α}
      (n : ℕ) {u : ℕ → α},
      Monotone u →
        (∀ (i : ℕ), u i ∈ s) →
          (Finset.sum (Finset.range n) fun i => edist (f (u (i + 1))) (f (u i))) ≤ eVariationOn f s :=
  by sorry

The theorem `eVariationOn.sum_le` states that for any linear order `α`, any pseudo eMetric space `E`, any function `f` from `α` to `E`, any set `s` of `α`, any natural number `n`, and any monotone function `u` from natural numbers to `α` such that every `u i` is in `s`, the sum over the range of `n` of the extended distance between `f (u (i + 1))` and `f (u i)` is less than or equal to the eVariation of `f` on `s`. In other words, the sum of extended distances over an increasing sequence in the set is bounded by the eVariation of the function on the set. This is a property related to the variation of functions in mathematical analysis.

For any linear order α, pseudo metric space E, function f from α to E, set s of α, natural number n, and monotone function u from natural numbers to α with every ui in s, the sum of extended distances between f (ui+1) and f (ui) over the range of n is less than or equal to the eVariation of f on s.


/-- If a family is convex independent, so is any subfamily given by composition of an embedding into
index type with the original family.  -/
theorem ConvexIndependent.comp_embedding :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommGroup E]
      [inst_2 : Module 𝕜 E] {ι' : Type u_4} (f : ι' ↪ ι) {p : ι → E},
      ConvexIndependent 𝕜 p → ConvexIndependent 𝕜 (p ∘ ⇑f) :=
  by sorry

This theorem states that if we have a family of points that is convex independent in some vector space over an ordered semiring, then any subfamily obtained by composing an embedding function into the index type with the original family is also convex independent. In other words, a family of points is convex independent if every point only belongs to the convex hulls of sets containing it, and this property is preserved when considering subfamilies that are formed by subsets of the original index set.

If a family of points in a vector space over an ordered semiring is convex independent, then any subfamily obtained by applying an embedding function into the index type also is convex independent.


theorem Subalgebra.mem_star_iff :
    ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
      [inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (S : Subalgebra R A) (x : A),
      x ∈ star S ↔ star x ∈ S :=
  by sorry

This theorem states that for any commutative semiring `R`, star ring `R`, semiring `A`, algebra of `R` and `A`, star ring `A`, and a star module `R` and `A`, and given a subalgebra `S` of `R` and `A` and an element `x` in `A`, `x` is in the star of `S` if and only if the star of `x` is in `S`. Here, "star" refers to an operation in ring theory related to the conjugate of an element.

For any commutative semirings R and star rings R\*, A, semirings A, and star modules R and A, if S is a subalgebra of R and A, then an element x in A is in the star of S if and only if the star of x is in S.


theorem NonemptyInterval.coe_pure :
    ∀ {α : Type u_1} [inst : PartialOrder α] (a : α), ↑(NonemptyInterval.pure a) = {a} := by sorry

This theorem states that for any type `α` that has a partial order, the function `NonemptyInterval.pure a` returns a non-empty interval that only contains the single element `a`. This function effectively creates an interval from `a` to `a`. As a result, when this interval is converted back to a set (using the coercion `↑`), it yields the singleton set containing only `a`. In other words, the "pure" non-empty interval containing `a` is equivalent to the singleton set `{a}`.

For any type `α` with a partial order, the function `NonemptyInterval.pure a` is equivalent to the singleton set `{a}`.


Ideal.IsJacobson.out

theorem Ideal.IsJacobson.out :
    ∀ {R : Type u_3} [inst : CommRing R],
      Ideal.IsJacobson R → ∀ {I : Ideal R}, Ideal.IsRadical I → Ideal.jacobson I = I :=
  by sorry

This theorem states that in a commutative ring `R`, if `R` has the property of being a Jacobson ring (i.e., `Ideal.IsJacobson R`), then for any ideal `I` of `R` that is a radical ideal (i.e., `Ideal.IsRadical I`), the Jacobson radical of `I` is equal to `I` itself. In mathematical notation, this can be written as: if `R` is a Jacobson ring and `I` is a radical ideal in `R`, then `I = J(I)` where `J(I)` denotes the Jacobson radical of `I`.

In a commutative ring `R` with the property of being a Jacobson ring, a radical ideal `I` equals its Jacobson radical `J(I)`.


theorem List.rel_of_chain_cons :
    ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α}, List.Chain R a (b :: l) → R a b := by sorry

This theorem, `List.rel_of_chain_cons`, states that for any type `α`, a binary relation `R` on `α`, and any elements `a` and `b` of type `α`, if `a` has a relation `R` with every element of the list that starts with `b` (i.e., `b` followed by list `l`), then `a` has the relation `R` with `b`. In other words, if `a` is related to every element in the list `b :: l` through `R`, then `a` is directly related to `b` through the same relation `R`.

If for all `x` in a list `l`, `a` is related to `x` (via relation `R`), then `a` is related to the head `b` of the list (via relation `R`).


theorem IsOpen.mem_nhds_iff :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], IsOpen s → (s ∈ nhds x ↔ x ∈ s) := by sorry

This theorem states that for any type `X`, any element `x` of type `X`, and any set `s` of elements of type `X`, given a topological structure on `X`, if `s` is an open set, then `s` is a neighborhood of `x` (i.e., `s` belongs to the neighborhood filter of `x`) if and only if `x` belongs to `s`. In mathematical terms, for an open set `s` in a topological space, `s` is a neighborhood of an element `x` if and only if `x` is an element of `s`.

In a topological space, an open set is a neighborhood of an element if and only if that element is a member of the set.


theorem Relation.transGen_reflGen :
    ∀ {α : Type u_1} {r : α → α → Prop}, Relation.TransGen (Relation.ReflGen r) = Relation.ReflTransGen r := by sorry

This theorem states that for any type `α` and any binary relation `r` over `α`, the transitive closure of the reflexive closure of `r` is equal to the reflexive transitive closure of `r`. In mathematics, these are concepts related to how you can extend a relation - the reflexive closure adds all self-loops, the transitive closure links any two related items, while the reflexive transitive closure does both.

The reflexive closure and transitive closure of a binary relation are equal.


theorem div_zpow : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α) (n : ℤ), (a / b) ^ n = a ^ n / b ^ n := by
  sorry

This theorem states that for any type `α` which has a Division Commutative Monoid structure, and for any two elements `a` and `b` of this type, and any integer `n`, the nth power of the division of `a` and `b` is equal to the division of `a` to the power of `n` and `b` to the power of `n`. In mathematical terms, for any $\alpha$ which is a Division Commutative Monoid, $(a / b)^n = a^n / b^n$ for all $a$, $b$ in $\alpha$ and for all integers $n$.

For any Division Commutative Monoid `α`, `(a / b)^n = a^n / b^n` for all `a, b ∈ α` and `n ∈ ℤ`.


theorem Set.ordConnected_Ioo : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.OrdConnected (Set.Ioo a b) := by
  sorry

The theorem `Set.ordConnected_Ioo` states that for any type `α` that has a preorder relation, and any two elements `a` and `b` of this type, the open interval `(a, b)` (denoted as `Set.Ioo a b` in Lean) is order-connected. In terms of mathematics, this can be understood as: given any two points in the open interval `(a, b)`, all points between them (according to the preorder) are also in the interval.

For any type `α` with a preorder relation and any `a < b` in `α`, the open interval `(a, b)` consists only of elements between `a` and `b` according to the preorder.


theorem Set.ordConnected_Ioc : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.OrdConnected (Set.Ioc a b) := by
  sorry

This theorem states that for any type `α` that has a preorder structure, any left-open right-closed interval, denoted as `(a, b]` or `Set.Ioc a b` in Lean 4, is order-connected. In terms of mathematical language, an interval `(a, b]` in a preordered set is said to be order-connected if, for any two points `x` and `y` in `(a, b]` with `x ≤ y`, all points `z` in the set such that `x ≤ z ≤ y` are also in `(a, b]`.

In a preordered set, any left-open right-closed interval is order-connected, meaning all elements x, y in the interval with x ≤ y imply that every z in the interval between x and y also satisfies x ≤ z ≤ y.


theorem Mathlib.Data.Multiset.Powerset._auxLemma.16 : ∀ {α : Type u_1} {l : List α}, Multiset.Nodup ↑l = List.Nodup l :=
  by sorry

This theorem, `Mathlib.Data.Multiset.Powerset._auxLemma.16`, states that for every type `α` and for any list `l` of type `α`, the property of having no duplicates in the list's multiset representation (`Multiset.Nodup ↑l`) is the same as the property of the list itself having no duplicates (`List.Nodup l`). In other words, a list has no duplicate elements if and only if its corresponding multiset also has no duplicate elements.

For any type `α` and list `l` of type `α`, the multiset representation of `l` having no duplicates if and only if `l` itself has no duplicates. In Lean notation: `(Multiset.Nodup ↑l) ↔ List.Nodup l`.


theorem Array.filter_data :
    ∀ {α : Type u_1} (p : α → Bool) (l : Array α), (Array.filter p l 0).data = List.filter p l.data := by sorry

The theorem `Array.filter_data` states that for any type `α`, any function `p` from `α` to `Bool`, and any array `l` of elements of type `α`, the data of the result of filtering `l` using `p` starting from the 0th index is equal to the result of filtering the data of `l` using `p`. In other words, filtering an array using a certain function gives the same result as filtering the list representation of the array with the same function.

For any type `α`, function `p` from `α` to `Bool`, and array `l` of length `n` in `α`, `[ filter (i : nat) (x : α) (l : array α) : bool | i < n := p x ] |> Data = filter (i : nat) (x : α) (Data l) : list α | i < length (Data l) := p x`.


theorem AddSubmonoid.closure_union :
    ∀ {M : Type u_1} [inst : AddZeroClass M] (s t : Set M),
      AddSubmonoid.closure (s ∪ t) = AddSubmonoid.closure s ⊔ AddSubmonoid.closure t :=
  by sorry

This theorem, `AddSubmonoid.closure_union`, states that for any type `M` that has an addition and zero operation (captured by the `AddZeroClass` typeclass), and for any two sets `s` and `t` of this type `M`, the additive submonoid generated by the union of these two sets (`s ∪ t`) is equal to the supremum (the least upper bound or "join", denoted by `⊔`) of the additive submonoids generated by each of these sets separately (`s` and `t`). Essentially, it shows a distributive property of the closure operation over the union of sets in the context of additive submonoids.

The additive submonoid generated by the union of two sets is equal to the supremum of the additive submonoids generated by each set.


theorem Filter.disjoint_comap :
    ∀ {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β},
      Disjoint g₁ g₂ → Disjoint (Filter.comap m g₁) (Filter.comap m g₂) :=
  by sorry

This theorem asserts that if two filters `g₁` and `g₂` on a type `β` are disjoint (in the sense that their infimum is the bottom element in the lattice of filters), then the filters obtained by precomposing these filters with a function `m` from some other type `α` to `β` (i.e., the filters `Filter.comap m g₁` and `Filter.comap m g₂`) are also disjoint. This means that for any element in the filter obtained by the composition, if it is less than or equal to both `Filter.comap m g₁` and `Filter.comap m g₂`, it is less than or equal to the bottom element of the filter lattice.

If filters `g₁` and `g₂` on type `β` are disjoint, then the filters obtained by composing them with a function `m` from type `α` to `β` (`Filter.comap m g₁` and `Filter.comap m g₂`) are also disjoint, meaning their infimum is the bottom element in the lattice of filters.


theorem WithLp.prod_antilipschitzWith_equiv_aux :
    ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [hp : Fact (1 ≤ p)] [inst : PseudoEMetricSpace α]
      [inst_1 : PseudoEMetricSpace β], AntilipschitzWith (2 ^ (1 / p).toReal) ⇑(WithLp.equiv p (α × β)) :=
  by sorry

The theorem `WithLp.prod_antilipschitzWith_equiv_aux` states that for every extended nonnegative real number `p` such that `1 ≤ p`, and for every pair of types `α` and `β` that have pseudometric space structures, the canonical equivalence function between `WithLp p (α × β)` and `α × β` (which is given by `WithLp.equiv p (α × β)`) is Antilipschitz with constant `2^(1/p)`.

In more mathematical terms, an Antilipschitz condition ensures that the distances between points in the original space and their images under a map do not shrink too much. In this context, for any two points `x` and `y` in the space `WithLp p (α × β)`, the edistance between `x` and `y` is less than or equal to `2^(1/p)` times the edistance between their images under the equivalence function.

For every extended nonnegative real number `p` with `1 ≤ p`, the canonical equivalence function between `WithLp p (α × β)` and `α × β` is an Antilipschitz function with constant `2^(1/p)`.


theorem Real.contDiff_arsinh : ∀ {n : ℕ∞}, ContDiff ℝ n Real.arsinh := by sorry

The theorem `Real.contDiff_arsinh` declares that the inverse hyperbolic sine function (`arsinh`), which is defined on real numbers as `log (x + sqrt(1 + x^2))`, is continuously differentiable for all natural numbers `n`, including infinity. Continuous differentiability means that the function is smooth, i.e., it has continuous derivatives up to any order `n`.

The function `arsinh : ℝ → ℝ` defined as `log (x + sqrt(1 + x^2))` is continuously differentiable for all natural numbers `n`, including infinity.


theorem FreeMonoid.prodAux_eq : ∀ {M : Type u_4} [inst : Monoid M] (l : List M), FreeMonoid.prodAux l = List.prod l :=
  by sorry

The theorem `FreeMonoid.prodAux_eq` states that for any type `M` that forms a monoid, the function `FreeMonoid.prodAux` computes the same result as the function `List.prod` for any list `l` of elements from `M`. Essentially, it says that the product of elements in a list, calculated using `FreeMonoid.prodAux`, is identical to the product computed using `List.prod`. Both functions calculate the product by successively multiplying the elements of the list together, starting with the identity element for `FreeMonoid.prodAux` and the first element for `List.prod`.

For any monoid `M` and list `l` of elements from `M`, `FreeMonoid.prodAux l` equals `List.prod l`.


Substring.ValidFor.startPos

theorem Substring.ValidFor.startPos :
    ∀ {l m r : List Char} {s : Substring}, Substring.ValidFor l m r s → s.startPos = { byteIdx := String.utf8Len l } :=
  by sorry

This theorem, named `Substring.ValidFor.startPos`, states that for any lists of characters `l`, `m`, and `r`, and any `Substring` `s`, if `s` is valid for the concatenation of `l`, `m`, and `r`, then the starting position of the substring `s` is equal to the UTF-8 byte length of the list `l`. In other words, the start of the substring is positioned right after the list of characters `l` when `l`, `m`, and `r` are concatenated.

Given lists of characters `l`, `m`, and `r`, and a valid substring `s` of their concatenation, the starting position of `s` equals the length of `l` in UTF-8 bytes.


theorem mem_connectedComponentIn :
    ∀ {α : Type u} [inst : TopologicalSpace α] {x : α} {F : Set α}, x ∈ F → x ∈ connectedComponentIn F x := by sorry

This theorem states that for any type `α` equipped with a topological structure, a set `F` in `α`, and a point `x` in `α`, if `x` belongs to the set `F`, then `x` is an element of its connected component in `F`. In other words, given a topological space and a point in a set of that space, the point is part of the subset that forms the connected component it belongs to in the original set.

In a topological space, any point in a connected subset belongs to its connected component.


theorem Fin.castSucc_lt_succ : ∀ {n : ℕ} (i : Fin n), Fin.castSucc i < Fin.succ i := by sorry

The theorem `Fin.castSucc_lt_succ` states that for any natural number `n` and any element `i` of the type `Fin n` (which is a type representing the finite set of natural numbers less than `n`), the operation of embedding `i` into `Fin (n+1)` via `Fin.castSucc` will always result in a value that is less than the result of the operation `Fin.succ i` (which increments the value of `i` and confirms it's less than or equal to `n`). In other words, if you increment a number and then embed it in the set of natural numbers that are less than `n+1`, that will always be less than if you simply increment the number within the set of natural numbers that are less than `n`.

For any natural number `n` and `Fin n` element `i`, `Fin.castSucc i < Fin.succ i`.


theorem MeasureTheory.Measure.count_apply_finite :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (s : Set α) (hs : Set.Finite s),
      ↑↑MeasureTheory.Measure.count s = ↑(Set.Finite.toFinset hs).card :=
  by sorry

The theorem `MeasureTheory.Measure.count_apply_finite` states that for any set `s` of type `α`, in a measurable space where singletons are measurable, if `s` is finite then the counting measure of `s` is equal to the cardinality of the finite set represented by `s`. This simply means that the counting measure, which counts the number of elements in the set, will indeed return the actual number of elements in the finite set.

In a measurable space where singletons are measurable, the counting measure of a finite set equals its cardinality.


theorem MeasureTheory.SimpleFunc.setToSimpleFunc_congr :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      (T : Set α → E →L[ℝ] F),
      (∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0) →
        MeasureTheory.FinMeasAdditive μ T →
          ∀ {f g : MeasureTheory.SimpleFunc α E},
            MeasureTheory.Integrable (↑f) μ →
              ↑f =ᶠ[MeasureTheory.Measure.ae μ] ↑g →
                MeasureTheory.SimpleFunc.setToSimpleFunc T f = MeasureTheory.SimpleFunc.setToSimpleFunc T g :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.setToSimpleFunc_congr` states that given a measurable space `α`, a normed additively commutative group `E`, a normed additively commutative group `F`, a measure `μ` on `α`, and a function `T` from subsets of `α` to continuous linear real-valued maps from `E` to `F`, if `T` is zero on all measurable sets of measure zero and `T` is finitely additive on measurable sets with finite measure, then for any two simple (step) functions `f` and `g` from `α` to `E` that are integrable with respect to `μ`, if `f` and `g` are almost everywhere equal with respect to the measure `μ`, then the extension of `T` to simple functions applied to `f` equals the extension of `T` to simple functions applied to `g`.

If `T` is a finitely additive, measure-zero preserving continuous linear map from subsets of a measure space to the space of continuous linear maps between two normed additive commutative groups, and `f` and `g` are integrable simple functions that are almost everywhere equal, then `T(f) = T(g)`.


theorem iSup_le_iSup_of_subset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s t : Set β},
      s ⊆ t → ⨆ x ∈ s, f x ≤ ⨆ x ∈ t, f x :=
  by sorry

This theorem states that for any types `α` and `β`, with `α` being a complete lattice, and for any function `f` from `β` to `α`, along with any sets `s` and `t` of elements of type `β`, if `s` is a subset of `t`, then the supremum (greatest lower bound) of the images of `s` under `f` is less than or equal to the supremum of the images of `t` under `f`. In mathematical terms, if `s` is a subset of `t` then `sup_{x ∈ s} f(x) ≤ sup_{x ∈ t} f(x)`.

For any complete lattice `α`, function `f` from type `β` to `α`, and sets `s` and `t` of elements in `β` where `s` is a subset of `t`, the supremum of `f` over `s` is less than or equal to the supremum of `f` over `t`. Symbolically, `sup(f(x)|x ∈ s) ≤ sup(f(x)|x ∈ t)`.


DifferentiableAt.smul

theorem DifferentiableAt.smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {𝕜' : Type u_6} [inst_5 : NontriviallyNormedField 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜']
      [inst_7 : NormedSpace 𝕜' F] [inst_8 : IsScalarTower 𝕜 𝕜' F] {c : E → 𝕜'},
      DifferentiableAt 𝕜 c x → DifferentiableAt 𝕜 f x → DifferentiableAt 𝕜 (fun y => c y • f y) x :=
  by sorry

The theorem `DifferentiableAt.smul` states that for any types `𝕜`, `E`, `F`, and `𝕜'` where `𝕜` is a non-trivially normed field, `E` is a normed additive commutative group and is a normed space over `𝕜`, `F` is also a normed additive commutative group and a normed space over `𝕜` and `𝕜'`, and `𝕜'` is a non-trivially normed field with `𝕜` being a normed algebra over `𝕜'` and a scalar tower over `F`, if a function `f` from `E` to `F` is differentiable at a point `x` in `E`, and another function `c` from `E` to `𝕜'` is also differentiable at `x`, then the function defined by pointwise scalar multiplication of `c` and `f` (i.e., `(fun y => c y • f y)`) is also differentiable at `x`.

If `f: E → F` is differentiable at `x ∈ E` and `c: E → ℝ'` is differentiable at `x` in the normed spaces `E` over `ℝ` and `F` over `ℝ'`, then the pointwise multiplication `(c ∘ x) • f` is differentiable at `x`.


LE.ext

theorem LE.ext : ∀ {α : Type u} (x y : LE α), LE.le = LE.le → x = y := by sorry

This theorem states that for any type `α`, if we have two instances `x` and `y` of the less-or-equal relation (`LE`) on `α`, and if their less-equal functions (marked by `LE.le`) are the same, then `x` and `y` must also be the same. Essentially, it asserts that the less-equal relation on a certain type is uniquely determined by its less-equal function.

For any type `α` and instances `x` and `y` of the less-or-equal relation on `α` with equal less-equal functions `LE.le`, we have `x = y`.


theorem TensorProduct.map_id :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N],
      TensorProduct.map LinearMap.id LinearMap.id = LinearMap.id :=
  by sorry

This theorem, `TensorProduct.map_id`, states that for any commutative semiring `R` and any two types `M` and `N` that form additively commutative monoids and are modules over `R`, the tensor product of the identity linear map with itself is equal to the identity linear map. This is a property about the identity in the context of tensor products and linear maps, similar to the idea that multiplying any number by 1 leaves it unchanged.

For any commutative semiring `R`, and modules `M` and `N` over `R` that form additively commutative monoids, the identity linear map from `M` to itself, tensored with itself, is equal to the identity linear map from `M` to `M` and from `N` to itself, tensored with itself, in the tensor product `M ⊗ N` over `R`.


theorem Subgroup.map_top_of_surjective :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
      Function.Surjective ⇑f → Subgroup.map f ⊤ = ⊤ :=
  by sorry

The theorem `Subgroup.map_top_of_surjective` states that for every surjective monoid homomorphism `f` from a group `G` to another group `N`, the image of the entire group `G` (denoted by `⊤`) under the map `f` is the entire group `N`. In other words, if every element in group `N` is the image of some element in group `G` under the homomorphism `f`, then every element of `N` is in the image of `G` under `f`. This theorem is a property regarding surjective homomorphisms and subgroup mappings in group theory.

If `f` is a surjective group homomorphism from `G` to `N`, then `⊤(G) = N`.


theorem omegaLimit_subset_of_tendsto :
    ∀ {τ : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] (ϕ : τ → α → β) (s : Set α) {m : τ → τ}
      {f₁ f₂ : Filter τ}, Filter.Tendsto m f₁ f₂ → omegaLimit f₁ (fun t x => ϕ (m t) x) s ⊆ omegaLimit f₂ ϕ s :=
  by sorry

The theorem `omegaLimit_subset_of_tendsto` states that for any types `τ`, `α`, and `β` with `β` having a topological space structure, along with a function `ϕ : τ → α → β`, a set `s` of type `α`, a function `m : τ → τ`, and two filters `f₁` and `f₂` on `τ`, if `m` tends towards `f₂` with respect to filter `f₁` (denoted by `Filter.Tendsto m f₁ f₂`), then the ω-limit of set `s` under the function `(fun t x => ϕ (m t) x)` with respect to filter `f₁` is a subset of the ω-limit of set `s` under function `ϕ` with respect to filter `f₂`. In other words, if we transform the time scale of a dynamical system using a function that tends to a limit under a certain filter, the ω-limit set of the transformed system is contained in the ω-limit set of the original system under the limit filter.

If a function `ϕ : τ -> α -> β` maps the ω-limit of a set `s` in `α` under filter `f₁` to a subset of its ω-limit under filter `f₂`, when `m : τ -> τ` tends towards `f₂` with respect to filter `f₁`.


theorem AbsoluteValue.ne_zero_iff :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S) {x : R},
      abv x ≠ 0 ↔ x ≠ 0 :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, the absolute value function `abv` from `R` to `S` applied to a value `x` from `R` is not equal to zero if and only if `x` is not equal to zero. In other words, the absolute value of a number is non-zero exactly when the number itself is non-zero.

For all semirings R and ordered semirings S, the absolute value function from R to S satisfies |x| ≠ 0 if and only if x ≠ 0.


/-- $x^n-y^n = (x-y) \sum x^ky^{n-1-k}$ reformulated without `-` signs.  -/
theorem Commute.geom_sum₂_mul_add :
    ∀ {α : Type u} [inst : Semiring α] {x y : α},
      Commute x y →
        ∀ (n : ℕ), (Finset.sum (Finset.range n) fun i => (x + y) ^ i * y ^ (n - 1 - i)) * x + y ^ n = (x + y) ^ n :=
  by sorry

This is a theorem about the algebraic identity $x^n-y^n = (x-y) \sum x^ky^{n-1-k}$, specifically reformulated without the use of subtraction ("-") signs. It states that for any semiring `α`, given two elements `x` and `y` of `α` that commute (meaning that `x * y = y * x`), and for every natural number `n`, the sum (`Finset.sum`) of terms `(x + y) ^ i * y ^ (n - 1 - i)` for all `i` in the range less than `n` (i.e., `0, 1, 2, ..., n-1`), multiplied by `x`, and then added to `y^n`, equals `(x + y) ^ n`. This equation holds true under the condition that `x` and `y` commute in the semiring `α`.

For any commutative semiring `α` and elements `x, y` in `α`, the identity $(x+y)^n=\sum\_{i<n}x^iy^{n-1-i}\cdot x+y^n$ holds.


theorem Filter.map_inf :
    ∀ {α : Type u} {β : Type v} {f g : Filter α} {m : α → β},
      Function.Injective m → Filter.map m (f ⊓ g) = Filter.map m f ⊓ Filter.map m g :=
  by sorry

This theorem, named `Filter.map_inf`, states that for any types `α` and `β`, any two filters `f` and `g` on `α`, and any function `m` from `α` to `β` that is injective, the map of the intersection of `f` and `g` under `m` is equivalent to the intersection of the map of `f` under `m` and the map of `g` under `m`. In other words, if `m` is a function that doesn't map different elements to the same value (it's injective), then mapping the intersection of two filters through `m` is the same as intersecting the individual mappings of the two filters.

For injective functions `m` from type `α` to type `β`, the map of the intersection of filters `f` and `g` on `α` under `m` equals the intersection of the maps of `f` and `g` under `m`.


theorem UpperSemicontinuous.upperSemicontinuousWithinAt :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : Preorder β] {f : α → β},
      UpperSemicontinuous f → ∀ (s : Set α) (x : α), UpperSemicontinuousWithinAt f s x :=
  by sorry

This theorem states that for all types `α`, which have a topology, and `β`, which have a preorder, and for any function `f` from `α` to `β`, if `f` is UpperSemicontinuous, then for any set `s` of type `α` and any element `x` of `α`, `f` is also UpperSemicontinuousWithinAt `s` at `x`. In mathematical terms, the upper semicontinuity of a real-valued function in the entire space guarantees its upper semicontinuity at any point within any subset of that space.

For any type `α` with a topology and `β` with a preorder, if the function `f` from `α` to `β` is upper semicontinuous, then it is upper semicontinuous within `s` at every `x` in `α`.


theorem CategoryTheory.Limits.biprod.isoProd_hom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
      (CategoryTheory.Limits.biprod.isoProd X Y).hom =
        CategoryTheory.Limits.prod.lift CategoryTheory.Limits.biprod.fst CategoryTheory.Limits.biprod.snd :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.isoProd_hom` states that, in any category `C` with zero morphisms and binary biproducts, for any two objects `X` and `Y` in `C`, the morphism component of the isomorphism from the binary biproduct of `X` and `Y` to their binary product is given by lifting the pair of projections from the biproduct (i.e., the first and second projection morphisms). In other words, this theorem connects the concepts of binary biproduct and binary product in a category.

In any category with zero morphisms and binary biproducts, the morphism component of the isomorphism from the binary biproduct of two objects to their binary product is given by the pair of projections from the biproduct.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.7 :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      (v ∈ SimpleGraph.Walk.support p) = True :=
  by sorry

This theorem states that, for any type `V`, any simple graph `G` of type `V`, and any two vertices `u` and `v` of type `V`, if there exists a walk `p` from `u` to `v` in graph `G`, then vertex `v` is always included in the support list of walk `p`. The support of a walk is defined as the list of vertices it visits in order. Therefore, the theorem asserts that the terminal vertex of a walk is always a part of the vertices visited in the walk.

For any simple graph and any two vertices, if there is a walk connecting them, then the terminal vertex is in the support of that walk.


theorem MvPolynomial.sumToIter_C :
    ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (a : R),
      (MvPolynomial.sumToIter R S₁ S₂) (MvPolynomial.C a) = MvPolynomial.C (MvPolynomial.C a) :=
  by sorry

The theorem `MvPolynomial.sumToIter_C` establishes that for any commutative semiring `R` and any types `S₁` and `S₂`, and for any element `a` of `R`, when you apply `MvPolynomial.sumToIter` (a function that transforms a multivariable polynomial in a sum of two types `S₁` and `S₂`, to a multivariable polynomial in one of the types, with coefficients in multivariable polynomials in the other type) to the constant polynomial with value `a`, the result is the constant polynomial with its value being the constant polynomial of `a`. In other words, this theorem demonstrates that the `sumToIter` operation preserves the structure of constant polynomials in the input multivariable polynomial.

For any commutative semiring R and types S₁, S₂, and element a in R, the application of `MvPolynomial.sumToIter` to the constant polynomial of value a results in the constant polynomial of value a.


/-- **Equality case of the Rearrangement Inequality**: Pointwise scalar multiplication of `f` and
`g`, which antivary together, is unchanged by a permutation if and only if `f` and `g ∘ σ` antivary
together. Stated by permuting the entries of `g`.  -/
theorem AntivaryOn.sum_smul_eq_sum_smul_comp_perm_iff :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      AntivaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s →
          (((Finset.sum s fun i => f i • g (σ i)) = Finset.sum s fun i => f i • g i) ↔ AntivaryOn f (g ∘ ⇑σ) ↑s) :=
  by sorry

This theorem, often known as the "Equality case of the Rearrangement Inequality," states that for any types `ι`, `α`, `β` with `α` being a linearly ordered ring, `β` being a linearly ordered additive commutative group, and `ι` being permuted by a bijection `σ`, along with functions `f : ι → α` and `g : ι → β` that antivary on a finite set `s`, the pointwise scalar multiplication of `f` and `g` remains unchanged by this permutation if and only if `f` and `g ∘ σ` antivary together. This result is significant in ensuring the property of antivariance under permutations.

In other words, sum of scalar multiplication of `f i` and `g (σ i)` over all `i` in `s`, is equal to sum of scalar multiplication of `f i` and `g i` over all `i` in `s` if and only if `f` and the function obtained by composing `g` with `σ` antivary on `s`. Moreover, this theorem requires that the set of `i` for which `σ i` is not equal to `i` is a subset of `s`.

For functions `f : ι → α` and `g : ι → β` over linearly ordered rings `α` and additive commutative groups `β`, antivarying on a finite set `s`, pointwise scalar multiplication `∑ i in s (f i * g i)` equals `∑ i in s (f i * g (σ i))` if and only if `f` and `g ∘ σ` antivary on `s`, where `σ` is a bijection on `ι` and `s` is the set of indices where `σ` is not the identity.


theorem Finset.max_eq_sup_withBot :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α), Finset.max s = Finset.sup s WithBot.some := by sorry

This theorem states that for any finite set `s` of type `α`, where `α` is a type equipped with a linear order, the maximum of `s` is equal to the supremum of `s` with a function `WithBot.some` applied to each element. This `WithBot.some` function simply converts an element from `α` to `WithBot α`. In other words, the maximum element of a finite set in a linear order is the same as the supremum of the set when each element is lifted into an extended type that includes a "bottom" element.

For any finite set `s` in a linearly ordered type `α`, the maximum element is equal to the supremum of `s` when each element is lifted to `WithBot α`.


theorem List.foldrIdx_eq_foldr_enum :
    ∀ {α : Type u} {β : Type v} (f : ℕ → α → β → β) (b : β) (as : List α),
      List.foldrIdx f b as = List.foldr (Function.uncurry f) b (List.enum as) :=
  by sorry

This theorem states that for any list of elements of type `α`, initial value of type `β`, and function `f` that takes an index of type `ℕ`, an element of type `α`, and an accumulator of type `β`, and returns a new accumulator of type `β`, the `List.foldrIdx` function, which applies the function `f` to every element in the list from right to left along with its index, is equivalent to `List.foldr` function (which also applies a function to each element in the list from right to left but without the index) paired with the `Function.uncurry` function (which interprets `f` as a function on pairs of indices and elements) applied to the enumeration (`List.enum`) of the list that pairs up each element with its index. In other words, folding a list with a binary function and an initial accumulator, while passing the index of each element to the binary function, yields the same result as folding over the enumerated list (which turns each element into a pair of its index and value) with the uncurried binary function.

For any type `α`, initial value `β`, and function `f : ℕ × α → β → β`, the function `List.foldrIdx` applying `f` to a list `l` is equivalent to applying `Function.uncurry(List.foldr (λ x, λ _ acc => f _ x acc))` to the enumeration of `l`.


theorem le_tsub_iff_left :
    ∀ {α : 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 : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      a ≤ c → (b ≤ c - a ↔ a + b ≤ c) :=
  by sorry

This theorem, `le_tsub_iff_left`, states that for any type `α` that has the structure of an additive commutative semigroup, a partial order, satisfies the existence of addition from less than or equal to (`ExistsAddOfLE`), is a covariant class and contravariant class under a certain condition, and has subtraction operation and an ordered subtraction, if `a` is less than or equal to `c` then the statement `b` is less than or equal to `c - a` is equivalent to the statement `a + b` is less than or equal to `c`.

For any additive commutative semigroup with a partial order, existence of addition from less than or equal to, and ordered subtraction, if `a ≤ c` then `b ≤ c - a` if and only if `a + b ≤ c`.


theorem List.formPerm_cons_cons :
    ∀ {α : Type u_1} [inst : DecidableEq α] (x y : α) (l : List α),
      List.formPerm (x :: y :: l) = Equiv.swap x y * List.formPerm (y :: l) :=
  by sorry

The theorem `List.formPerm_cons_cons` states that for any type `α` with decidable equality and any two elements `x` and `y` of that type `α`, along with a list `l` of elements of the same type `α`, the permutation created by the function `List.formPerm` on a list formed by prepending `x` and `y` to `l` will be equal to the product of the permutation that swaps `x` and `y` and the permutation created by the function `List.formPerm` on the list formed by prepending `y` to `l`. In other words, adding an element to the start of a list and forming a permutation with `List.formPerm` is the same as swapping this element with the second one and then forming a permutation with `List.formPerm` on the new list.

For any type `α` with decidable equality, `List.formPerm (x :: y :: l) = List.formPerm y :: x :: List.formPerm l * List.swap x y`, where `::` denotes list concatenation, `*` denotes permutation multiplication, and `List.swap` is the permutation that swaps `x` and `y`.


/-- We can clear the denominators of a finite set of fractions.  -/
theorem IsLocalization.exist_integer_multiples_of_finset :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (s : Finset S),
      ∃ b, ∀ a ∈ s, IsLocalization.IsInteger R (↑b • a) :=
  by sorry

This theorem states that for any finite set of fractions in the localization `S` of a commutative semiring `R` with respect to a submonoid `M`, there exists an integer `b` in `R` such that when each fraction in the set is multiplied by `b`, the result is an integer in `R`. In other words, we can clear the denominators of a finite set of fractions in the localization.

Given a finite set of fractions in the localization of a commutative semiring with respect to a submonoid, there exists an integer in the semiring that makes all the fractions in the set have integer values when multiplied by it.


theorem midpoint_vsub_midpoint :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] [inst_4 : AddTorsor V P] (p₁ p₂ p₃ p₄ : P),
      midpoint R p₁ p₂ -ᵥ midpoint R p₃ p₄ = midpoint R (p₁ -ᵥ p₃) (p₂ -ᵥ p₄) :=
  by sorry

The theorem `midpoint_vsub_midpoint` states that for any ring `R`, an additive commutative group `V`, a module structure between `R` and `V`, an additive torsor `P` over `V`, and any four points `p₁, p₂, p₃, p₄` in `P`, the difference vector between the midpoint of `p₁` and `p₂` and the midpoint of `p₃` and `p₄` is equal to the midpoint of the difference vectors `p₁ -ᵥ p₃` and `p₂ -ᵥ p₄`. Essentially, this theorem captures a geometric property about midpoints and difference vectors in the context of affine spaces.

For any additive commutative group `V` with an `R`-module structure, an additive torsor `P` over `V`, and points `p₁, p₂, p₃, p₄` in `P`, the midpoint of `(p₁ + p₂) / 2` and `(p₃ + p₄) / 2` equals `(p₁ - p₃ + p₂ - p₄) / 2`.


theorem Multiset.gcd_dedup :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] [inst_2 : DecidableEq α]
      (s : Multiset α), Multiset.gcd (Multiset.dedup s) = Multiset.gcd s :=
  by sorry

This theorem, `Multiset.gcd_dedup`, states that for any type `α` which is a `CancelCommMonoidWithZero` (a commutative monoid with zero where multiplication with a nonzero element is cancellable), a `NormalizedGCDMonoid` (a commutative monoid with a notion of greatest common divisor and a normalization function), and has a decidable equality, the greatest common divisor (gcd) of a multiset `s` of elements of this type doesn't change if the duplicates are removed from `s` (using `Multiset.dedup`). In other words, the gcd of a multiset is equal to the gcd of the same multiset without duplicates.

For any commutative monoid with zero, cancellative multiplication, and decidable equality `α`, the greatest common divisor of a multiset in `α` is unchanged when duplicates are removed.


theorem inv_closedBall :
    ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x : E),
      (Metric.closedBall x δ)⁻¹ = Metric.closedBall x⁻¹ δ :=
  by sorry

The theorem `inv_closedBall` states that for any type `E` that is a semi-normed commutative group, any real number `δ`, and any element `x` of `E`, the inverse of the closed ball centered at `x` with radius `δ` is equal to the closed ball centered at the inverse of `x` with radius `δ`. In other words, if you take the set of all points whose distance from `x` is less than or equal to `δ`, and then take the inverse of all those points, you end up with the same set as if you had started with the inverse of `x` and taken the set of all points whose distance from the inverse of `x` is less than or equal to `δ`.

For any semi-normed commutative group `E` and real number `δ`, the inverse of the closed ball `{x : E | norm x ≤ δ} around `x` is equal to the closed ball `{y : E | norm (inv x) ≤ δ} around the additive inverse `inv x` of `x`.


theorem measurableSet_lt' :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : LinearOrder α] [inst_4 : OrderClosedTopology α] [inst : SecondCountableTopology α],
      MeasurableSet {p | p.1 < p.2} :=
  by sorry

The theorem `measurableSet_lt'` states that for any type `α` with an instantiated `TopologicalSpace`, `MeasurableSpace`, `OpensMeasurableSpace`, `LinearOrder`, `OrderClosedTopology`, and `SecondCountableTopology`, the set of all pairs `(p.1, p.2)` such that `p.1 < p.2` forms a measurable set. In other words, in a space satisfying these structures, we can measure the set of ordered pairs where the first element is less than the second.

In a topological space equipped with a measurable structure, a linear order, an order topology, and a second countable topology, the set of ordered pairs with the first element strictly less than the second is a measurable set.


theorem zpow_right_strictMono :
    ∀ {α : Type u_1} [inst : OrderedCommGroup α] {a : α}, 1 < a → StrictMono fun n => a ^ n := by sorry

The theorem `zpow_right_strictMono` states that for any ordered commutative group `α` and any element `a` of `α`, if `a` is greater than 1, then the function mapping any integer `n` to `a` raised to the power of `n` is strictly monotonic. In other words, if `a` is greater than 1 and `n < m` for any integers `n` and `m`, then `a^n` is less than `a^m`.

For any ordered commutative group `α` and `a` in `α` with `a > 1`, the function `n => a ^ n` is strictly increasing on integers `n`.


theorem Pi.continuous_postcomp' :
    ∀ {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {X : ι → Type u_8}
      [inst : (i : ι) → TopologicalSpace (X i)] {g : (i : ι) → π i → X i},
      (∀ (i : ι), Continuous (g i)) → Continuous fun f i => g i (f i) :=
  by sorry

This theorem states that given an indexed type `ι` and two families of types `π` and `X` indexed by `ι`, where each type in both families (`π` and `X`) has an associated topological space, and a family of functions `g` that maps each type in `π` to its corresponding type in `X`, if each function in the `g` family is continuous, then the composite function which applies `g` after `f` for each index `i` is also continuous. In mathematical terms, for each `i` in `ι`, if `g_i: π_i -> X_i` is continuous, then the function `(f -> g(f(i))) : (Πi, π_i) -> (Πi, X_i)` is also continuous.

If, for each index `i`, the function `g_i: π_i -> X_i` is continuous, then the function `(λf. g (f i)): ∏i. π_i -> ∏i. X_i` is continuous.


theorem SimpleGraph.Walk.isPath_def :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      SimpleGraph.Walk.IsPath p ↔ List.Nodup (SimpleGraph.Walk.support p) :=
  by sorry

The theorem `SimpleGraph.Walk.isPath_def` states that for any given simple graph `G` with vertices of type `V`, and for any walk `p` in the graph `G` from vertex `u` to vertex `v`, the walk `p` is a path if and only if the list of vertices visited in order (`SimpleGraph.Walk.support p`) has no duplicates (`List.Nodup`). In other words, a walk `p` is a path in a simple graph `G` precisely when it visits each vertex at most once.

A simple graph walk is a path if and only if the vertices visited in the order of the walk have no repetitions.


Submodule.FG.sup

theorem Submodule.FG.sup :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {N₁ N₂ : Submodule R M}, Submodule.FG N₁ → Submodule.FG N₂ → Submodule.FG (N₁ ⊔ N₂) :=
  by sorry

This theorem states that for any semiring `R` and any additive commutative monoid `M` that is also an `R`-module, given two submodules `N₁` and `N₂` of `M` that are finitely generated (i.e., each can be expressed as the span of a finite subset of `M`), their superset (denoted as `N₁ ⊔ N₂`) is also finitely generated. Essentially, this means that the union of two finitely generated submodules is itself finitely generated.

The union of two finitely generated submodules of an `R`-module `M` over a semiring `R` is itself a finitely generated submodule.


theorem Finset.sup_mono_fun :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f g : β → α},
      (∀ b ∈ s, f b ≤ g b) → Finset.sup s f ≤ Finset.sup s g :=
  by sorry

The theorem `Finset.sup_mono_fun` states that for all types `α` and `β`, where `α` is a semilattice sup and an order bot, and given a finite set `s` of type `β`, and two functions `f` and `g` from `β` to `α`, if every element `b` in the set `s` meets the condition that `f(b)` is less than or equal to `g(b)`, then the supremum of the set `s` under the function `f` is less than or equal to the supremum of the set `s` under the function `g`. In simple terms, if a function `f` is pointwise less than or equal to a function `g` for all elements in a set, then the maximum value of `f` over the set is less than or equal to the maximum value of `g` over the same set.

If `f` is pointwise less than or equal to `g` for all elements in a finite set `s`, then the supremum of `s` under `f` is less than or equal to the supremum of `s` under `g`.


theorem Mathlib.Topology.UniformSpace.UniformConvergence._auxLemma.6 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
      Filter.Tendsto f a (Filter.comap g c) = Filter.Tendsto (g ∘ f) a c :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, and for all functions `f` from `α` to `β`, `g` from `β` to `γ`, and for all filters `a` on `α` and `c` on `γ`, the function `f` tends to the inverse image filter of `g` with respect to `c` as `a` tends to infinity if and only if the composition function `g ∘ f` tends to `c` as `a` tends to infinity. In other words, it states that filtering through `f` and then mapping `g` onto the result is equivalent to composing `g` with `f` and then filtering the result. This codifies a key property of limits in topology and uniform spaces.

For all types `α`, `β`, `γ`, functions `f: α → β` and `g: β → γ`, and filters `a on α` and `c on γ`, the filter `f⁁⁃¹(c)` is the limit of `f⁁⁃(a)` if and only if `g ∘ f` tends to `c` as `a` tends to infinity.


theorem Ioc_mem_nhdsWithin_Iic' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a b : α},
      a < b → Set.Ioc a b ∈ nhdsWithin b (Set.Iic b) :=
  by sorry

This theorem states that for any two elements `a` and `b` of some type `α`, where `α` is endowed with a topological space structure, a linear order structure, and a closed-left-infinite-right-closed-interval (`ClosedIicTopology`) topology, if `a` is less than `b`, then the left-open right-closed interval from `a` to `b` (`Set.Ioc a b`) is an element of the "neighborhood within" filter of `b` in the right-closed left-infinite interval up to `b` (`nhdsWithin b (Set.Iic b)`).

In plain English, this means that if we have a space where we can talk about order and closeness, and we have two points `a` and `b` with `a` less than `b`, then the open interval from `a` to `b` is a "local" concept around `b` when considering all points less than or equal to `b`.

For any topological space `α` endowed with a linear order and a `ClosedIicTopology`, if `a` is less than `b` in the linear order, then `Set.Ioc a b` is an element of the neighborhood filter `nhdsWithin b (Set.Iic b)`.


theorem lowerBounds_upperClosure :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, lowerBounds ↑(upperClosure s) = lowerBounds s := by sorry

This theorem states that for any given set `s` of a certain type `α` that obeys a preorder (i.e., a binary relation that is reflexive and transitive), the set of lower bounds of the upper closure of `s` is equal to the set of lower bounds of `s` itself. In other words, the set of all elements that are less than or equal to all elements in the upper closure of `s` is the same as the set of all elements that are less than or equal to all elements in `s`.

For any set `s` of type `α` in a preorder, the set of lower bounds of `s` is equal to the set of lower bounds of its upper closure.


/-- `Finset.cons` version of `Finset.Iio_insert`.  -/
theorem Finset.Iic_eq_cons_Iio :
    ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : LocallyFiniteOrderBot α] (b : α),
      Finset.Iic b = Finset.cons b (Finset.Iio b) ⋯ :=
  by sorry

This theorem, `Finset.Iic_eq_cons_Iio`, states that for any type `α` with a partial order and where all elements are part of a locally finite order with a smallest element, and any element `b` of this type, the finset of all elements `x` such that `x` is less than or equal to `b` (`Finset.Iic b`) is equivalent to the set constructed by taking the finset of all elements `x` such that `x` is strictly less than `b` (`Finset.Iio b`), and adding `b` to it (`Finset.cons b`). This theorem essentially says that adding `b` to the set of all elements less than `b`, forms the set of all elements less than or equal to `b`.

For any type `α` with a partial order and a smallest element, the finset of elements less than or equal to `b` equals the finset of elements strictly less than `b` followed by `b`.


theorem MeasurableSpace.le_map_comap :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {g : β → α},
      m ≤ MeasurableSpace.map g (MeasurableSpace.comap g m) :=
  by sorry

The theorem `MeasurableSpace.le_map_comap` says that for any types `α` and `β`, for any measurable space `m` on `α`, and for any function `g` from `β` to `α`, the measurable space `m` is a sub-measurable-space of the forward image under `g` of the reverse image under `g` of `m`. Here, `MeasurableSpace.map g (MeasurableSpace.comap g m)` creates a measurable space where the measurable sets are those whose preimage under `g` is a measurable set in the measurable space created by the reverse image of `m` under `g`. The inequality `m ≤ MeasurableSpace.map g (MeasurableSpace.comap g m)` means that every set which is measurable in `m` is also measurable in `MeasurableSpace.map g (MeasurableSpace.comap g m)`.

For any measurable space `m` on type `α` and any function `g` from type `β` to `α`, the reverse image of `m` under `g` is a measurable sub-set of `α`, so the forward image of `m` under `g` is a measurable space and every measurable set in `m` is measurable in this forward image under `g`.


theorem MeasureTheory.VectorMeasure.trim_measurableSet_eq :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      {n : MeasurableSpace α} {v : MeasureTheory.VectorMeasure α M} (hle : m ≤ n) {i : Set α},
      MeasurableSet i → ↑(MeasureTheory.VectorMeasure.trim v hle) i = ↑v i :=
  by sorry

This theorem states that for any type `α`, given two measure spaces `m` and `n` on `α`, a vector measure `v` of `α` into a type `M` (which is an additive commutative monoid and has a topology), and a subset `i` of `α`, if `m` is less than or equal to `n` (in the sense of being a sub-σ-algebra), and if `i` is a measurable set (in the ambient measure space on `α`), then the restriction of the vector measure `v` onto the sub-σ-algebra `m` evaluated on `i` is equal to the original vector measure `v` evaluated on `i`. In mathematical terms, this theorem asserts that restricting a vector measure to a sub-σ-algebra does not change its values on measurable sets.

For any measure spaces `m ≤ n` on type `α`, any measurable subset `i` of `α`, and any additive commutative monoid-valued vector measure `v` on `α`, the restriction of `v` to `m` on `i` equals `v` on `i`.


theorem IsClosed.frontier_eq :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s → frontier s = s \ interior s := by sorry

The theorem `IsClosed.frontier_eq` states that for any type `X` with a `TopologicalSpace` instance, and for any set `s` of type `X`, if `s` is a closed set, then the frontier of `s` is equal to the set difference of `s` and the interior of `s`. Here, the frontier of a set is defined as the set of points between the closure and the interior of the set, and the interior of a set `s` is the largest open subset of `s`.

For any topological space `X` and closed set `s` in `X`, the frontier of `s` is equal to the set difference between `s` and its interior.


theorem Nat.eq_of_factorization_eq :
    ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → (∀ (p : ℕ), (Nat.factorization a) p = (Nat.factorization b) p) → a = b := by sorry

This theorem states that for any two non-zero natural numbers `a` and `b`, if the factorization of `a` and `b`, i.e., the mappings from their prime factors to their multiplicities, are the same for every prime number `p`, then `a` and `b` must be equal. In other words, two natural numbers are equal if and only if they have the same prime factorization, which is a mathematical manifestation of the fundamental theorem of arithmetic.

Two natural numbers are equal if and only if they have the same prime factorization.


theorem ContractingWith.efixedPoint_isFixedPt :
    ∀ {α : Type u_1} [inst : EMetricSpace α] [cs : CompleteSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f)
      {x : α} (hx : edist x (f x) ≠ ⊤), Function.IsFixedPt f (ContractingWith.efixedPoint f hf x hx) :=
  by sorry

The theorem `ContractingWith.efixedPoint_isFixedPt` states that for any type `α` which is a complete metric space, for any non-negative real number `K`, and any function `f` from `α` to `α`, if `f` is a contracting map with contraction constant `K`, and for any point `x` in `α` where the extended distance between `x` and `f(x)` is not infinite, the function `efixedPoint` applied to `f`, the proof that `f` is contracting, `x`, and the proof that the distance between `x` and `f(x)` is not infinite, is a fixed point of `f`. In other words, the unique fixed point of a contracting function in the complete metric space, which lies within any distance of a given point, is indeed a fixed point of the function.

If `α` is a complete metric space, `f: α → α` is a contracting map with constant `K`, and `x ∈ α` has finite distance to `f(x)`, then `efixedPoint f x` is a fixed point of `f`.


theorem Mathlib.Order.Filter.AtTopBot._auxLemma.26 :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedField α] {l : Filter β} {f : β → α} {r : α}
      [inst_1 : Filter.NeBot l],
      Filter.Tendsto (fun x => r * f x) l Filter.atTop =
        (0 < r ∧ Filter.Tendsto f l Filter.atTop ∨ r < 0 ∧ Filter.Tendsto f l Filter.atBot) :=
  by sorry

The theorem `Mathlib.Order.Filter.AtTopBot._auxLemma.26` states that for any types `α` and `β`, where `α` is a linearly ordered field, a filter `l` on `β`, a function `f` from `β` to `α`, and a real number `r`, if the filter `l` is not a bottom filter, then the function `f` multiplied by `r` tends towards infinity (`Filter.atTop`) as `l` tends towards infinity if and only if either `r` is positive and `f` tends towards infinity as `l` tends towards infinity, or `r` is negative and `f` tends towards negative infinity (`Filter.atBot`) as `l` tends towards infinity.

For a linearly ordered field `α`, a filter `l` on `β`, a function `f` from `β` to `α`, and a real number `r`, if `l` is not a bottom filter, then `f` multiplied by `r` tends towards infinity (`Filter.atTop`) if `r` is positive and `f` does, or tends towards negative infinity (`Filter.atBot`) if `r` is negative.


theorem Mathlib.Order.Filter.AtTopBot._auxLemma.23 :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommGroup β] {l : Filter α} {f : α → β},
      Filter.Tendsto f l Filter.atBot = Filter.Tendsto (fun x => -f x) l Filter.atTop :=
  by sorry

The theorem `Mathlib.Order.Filter.AtTopBot._auxLemma.23` states that for any types `α` and `β`, where `β` is an ordered additive commutative group, and given a filter `l` on type `α` and a function `f` from `α` to `β`, the function `f` tends towards negative infinity (`Filter.atBot`) along the filter `l` if and only if the function that sends `x` to `-f(x)` tends towards positive infinity (`Filter.atTop`) along the same filter `l`. In other words, reversing the direction of a function flips the direction it tends to infinity.

For any filter `l` on type `α`, function `f` from `α` to an ordered additive commutative group `β`, the function `f` tends towards negative infinity along `l` if and only if the function `-f` tends towards positive infinity along `l`.


theorem Mathlib.Order.Filter.AtTopBot._auxLemma.27 :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedField α] {l : Filter β} {f : β → α} {r : α}
      [inst_1 : Filter.NeBot l],
      Filter.Tendsto (fun x => r * f x) l Filter.atBot =
        (0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop) :=
  by sorry

This theorem states that for any types `α` and `β`, with `α` being a linear ordered field, any filter `l` on `β` that is not bottom (i.e., not empty), any function `f` from `β` to `α`, and any real number `r`, the function that multiplies `r` with the output of `f` tends to negative infinity along the filter `l` if and only if either `r` is positive and `f` itself tends to negative infinity along `l`, or `r` is negative and `f` tends to positive infinity along `l`. In other words, the sign of `r` determines whether `f` should tend to positive or negative infinity for `r * f` to tend to negative infinity.

For any linear ordered field `α`, filter `l` on type `β`, function `f` from `β` to `α`, and real number `r`, if `l` is non-empty and `r * f` tends to negative infinity along `l`, then either `r` is positive and `f` tends to negative infinity along `l`, or `r` is negative and `f` tends to positive infinity along `l`.


theorem Mathlib.Order.Filter.AtTopBot._auxLemma.18 :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : NoMaxOrder α] (x : α) (l : Filter β)
      [inst_2 : Filter.NeBot l], Filter.Tendsto (fun x_1 => x) l Filter.atTop = False :=
  by sorry

This theorem states that for all types `α` and `β` where `α` has a preorder structure and does not have a maximum element (`NoMaxOrder α`), and for every element `x` of type `α` and every non-bottom filter `l` of type `β` (`Filter.NeBot l`), the constant function from `β` to `α` that always returns `x` does not tend towards infinity (`Filter.atTop`) as the inputs tend towards any neighborhood under the filter `l`. In other words, there is no filter `l` under which the preimage of any neighborhood of infinity is a neighborhood of `x`.

For any type `α` with no maximum element and filter `l` over type `β`, the constant function from `β` to `α` does not tend towards infinity under filter `l`.


theorem Mathlib.Order.Filter.AtTopBot._auxLemma.16 :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommGroup β] {l : Filter α} {f : α → β},
      Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` is an ordered additive commutative group, and any filter `l` on `α` and function `f` mapping `α` to `β`, the function `-f` tends to `atTop` as `l` tends to infinity if and only if the function `f` tends to `atBot` as `l` tends to negative infinity. In mathematical terms, this is saying that $\lim_{x\to\infty}-f(x) = \lim_{x\to-\infty}f(x)$.

For functions from an arbitrary type to an ordered additive commutative group, the negation of the function converges to the top element as the filter approaches infinity if and only if the original function converges to the bottom element as the filter approaches negative infinity.


Inducing.secondCountableTopology

theorem Inducing.secondCountableTopology :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
      [inst_2 : SecondCountableTopology β], Inducing f → SecondCountableTopology α :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` and `β` both have a topological space structure, and there is a function `f` from `α` to `β`. If `β` has a second countable topology, and `f` induces the topology of `α` from `β`, then `α` also has a second countable topology. Here, a second countable topology is one where there is a countable basis, and a function `f` is said to induce a topology when the topology on `α` is the coarsest one for which `f` is continuous.

If `α` and `β` are topological spaces with `α` being second countable if and only if `β` is, and `f`: `α -> β` is a continuous function, then `α` has a second countable topology.


theorem Nat.one_lt_two_pow : ∀ {n : ℕ}, n ≠ 0 → 1 < 2 ^ n := by sorry

This theorem states that for all non-zero natural numbers `n`, 1 is less than 2 raised to the power of `n`. In other words, any power of 2 (where the exponent is a non-zero natural number) is always greater than 1.

For all non-zero natural numbers n, 2^n > 1.


theorem FiberPrebundle.mem_pretrivializationAt_source :
    ∀ {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      [inst_2 : (x : B) → TopologicalSpace (E x)] (a : FiberPrebundle F E) (b : B) (x : E b),
      { proj := b, snd := x } ∈ (a.pretrivializationAt b).source :=
  by sorry

This theorem states that for any given fiber prebundle `a` over a base space `B` with fiber `F` and total space `E`, a point `b` in `B`, and a point `x` in the fiber `E` over `b`, the pair consisting of `b` and `x`, denoted as `{ proj := b, snd := x }`, is always an element of the source set of the pretrivialization of `a` at `b`. Here, "pretrivialization" refers to an operation in the theory of fiber bundles that simplifies the structure of the bundle in a neighborhood of a given point.

For any fiber prebundle `a` over a base space `B` with fiber `F` and total space `E`, given a point `b` in `B` and a point `x` in the fiber `E` over `b`, the pair `{proj := b, snd := x}` is in the source set of the pretrivialization of `a` at `b`.


theorem AlgebraicGeometry.StructureSheaf.toOpen_res :
    ∀ (R : Type u) [inst : CommRing R] (U V : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
      (i : V ⟶ U),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.StructureSheaf.toOpen R U)
          ((AlgebraicGeometry.Spec.structureSheaf R).val.map i.op) =
        AlgebraicGeometry.StructureSheaf.toOpen R V :=
  by sorry

The theorem `AlgebraicGeometry.StructureSheaf.toOpen_res` states that for any type `R` that is a commutative ring, and any two open subsets `U` and `V` of the prime spectrum of `R` (seen as a topological space), if there is a morphism `i` from `V` to `U`, then the composition of the morphism `toOpen` from the structure sheaf of `R` at `U` and the map induced by `i` on the structure sheaf of `R` (seen as a presheaf of commutative rings) is equal to the morphism `toOpen` from the structure sheaf of `R` at `V`. This can be interpreted as a compatibility condition between the restriction of functions to open sets and the structure sheaf on the prime spectrum, in the context of algebraic geometry.

For any commutative ring `R`, if `i` is a morphism from an open subset `V` to another open subset `U` in the prime spectrum of `R`, then the restriction of the structure sheaf morphism `toOpen` from `U` to the composition of `i` with the structure sheaf morphism `toOpen` from `V` is the identity.


theorem List.indexOf_nthLe :
    ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α} (h : List.indexOf a l < List.length l),
      List.nthLe l (List.indexOf a l) h = a :=
  by sorry

This theorem states that for any given type `α` with decidable equality and any given list `l` of type `α`, if the index of an element `a` in `l` is less than the length of `l`, then the nth element of `l` at this index is `a`. In other words, if we obtain the index of an element `a` in `l` and it is a valid index (i.e., less than the length of `l`), then fetching the element at this index from `l` will give us `a` back.

For any decidably equal type `α` and list `l` of length `n` over `α`, if `i` is a valid index (i.e., `0 ≤ i < n`), then `l.get! i = a` where `a` is the element at index `i` in `l`.


theorem MeasureTheory.VectorMeasure.neg_le_neg_iff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : OrderedAddCommGroup M]
      [inst_2 : TopologicalAddGroup M] (v w : MeasureTheory.VectorMeasure α M) {i : Set α},
      MeasurableSet i →
        (MeasureTheory.VectorMeasure.restrict (-w) i ≤ MeasureTheory.VectorMeasure.restrict (-v) i ↔
          MeasureTheory.VectorMeasure.restrict v i ≤ MeasureTheory.VectorMeasure.restrict w i) :=
  by sorry

This theorem states that for any measurable space `α`, any topological space `M` which is also an ordered additive commutative group and a topological additive group, and any two vector measures `v` and `w` from `α` to `M`, as well as any set `i` in `α` that is measurable, the restriction of the negation of `w` to `i` is less than or equal to the restriction of the negation of `v` to `i` if and only if the restriction of `v` to `i` is less than or equal to the restriction of `w` to `i`.

In mathematical terms, it says that for all measurable set `i`, $(-w)|_i \leq (-v)|_i$ if and only if $v|_i \leq w|_i$, where $v|_i$ and $w|_i$ denote the restrictions of the vector measures `v` and `w` to the set `i`, respectively.

For any measurable sets `i` in a measurable space `α`, the negation of vector measure `w` restricted to `i` is less than or equal to the negation of vector measure `v` restricted to `i` if and only if `v` restricted to `i` is less than or equal to `w` restricted to `i`.


theorem Nat.fib_greatestFib_le : ∀ (n : ℕ), Nat.fib (Nat.greatestFib n) ≤ n := by sorry

The theorem `Nat.fib_greatestFib_le` states that for all natural numbers `n`, the Fibonacci number at the greatest index less than or equal to `n` is itself less than or equal to `n`. In other words, for any natural number `n`, if you find the largest index `k` such that the `k`-th Fibonacci number is less than or equal to `n`, then the `k`-th Fibonacci number is indeed less than or equal to `n`.

For all natural numbers n, the largest Fibonacci number less than or equal to n is less than or equal to n.


theorem strictMono_comp_ofDual_iff :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono (f ∘ ⇑OrderDual.ofDual) ↔ StrictAnti f :=
  by sorry

This theorem states that for any two types `α` and `β` that are preordered, and for any function `f` from `α` to `β`, the function `f` composed with the identity function `OrderDual.ofDual` is strictly monotone if and only if `f` itself is strictly antitone. In other words, a strictly increasing transformation of the dual order implies that the original function is strictly decreasing. The dual order is simply the original order with the direction of the inequalities reversed.

For any preordered types `α` and `β` and function `f` from `α` to `β`, `f` is strictly antitone if and only if `f ∘ OrderDual.ofDual` is strictly monotone.


theorem FractionalIdeal.mul_mem_mul :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {I J : FractionalIdeal S P} {i j : P}, i ∈ I → j ∈ J → i * j ∈ I * J :=
  by sorry

The theorem `FractionalIdeal.mul_mem_mul` states that for any commutative ring `R`, submonoid `S` of `R`, commutative ring `P`, algebra structure of `P` over `R`, and fractional ideals `I` and `J` of `P` over `R` with respect to `S`, if an element `i` is in `I` and another element `j` is in `J`, then the product `i * j` is in the product of the fractional ideals `I * J`. In mathematical terms, this means if $i \in I$ and $j \in J$, then $i*j \in I*J$ where $I$ and $J$ are fractional ideals of some ring.

If `I` and `J` are fractional ideals of a commutative ring `P` with respect to a submonoid `S` of `P`, then for all `i` in `I` and `j` in `J`, the product `i * j` is in the product `I * J`.


theorem Function.LeftInverse.preimage_preimage :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β} {g : β → α},
      Function.LeftInverse g f → ∀ (s : Set α), f ⁻¹' (g ⁻¹' s) = s :=
  by sorry

The theorem `Function.LeftInverse.preimage_preimage` states that for all types `α` and `β`, and for all functions `f` from `α` to `β` and `g` from `β` to `α`, if `g` is a left inverse to `f` (that is, applying `g` after `f` results in the identity function), then for any set `s` of elements of type `α`, the preimage of the preimage of `s` under `f` followed by `g` is equal to `s` itself. In other words, applying `f` and then `g` to the elements of `s` doesn't change the set `s`.

If `f: α → β` has a left inverse `g: β → α`, then for any subset `S ⊆ α`, we have `f''(g''(S)) = S`.


theorem Filter.map_sup :
    ∀ {α : Type u} {β : Type v} {f₁ f₂ : Filter α} {m : α → β},
      Filter.map m (f₁ ⊔ f₂) = Filter.map m f₁ ⊔ Filter.map m f₂ :=
  by sorry

This theorem states that for any two filters `f₁` and `f₂` on a type `α`, and for any function `m` from `α` to another type `β`, the forward map of the supremum (join) of the two filters under `m` is equal to the supremum of the forward maps of the two filters individually. In other words, the operation of taking the supremum commutes with the operation of taking the forward map in this context.

For filters `f₁` and `f₂` on type `α` and a function `m` from `α` to type `β`, `m⁁(sup f₁ f₂) = sup (m⁁f₁) (m⁁f₂)`.


theorem Asymptotics.IsBigOWith.right_le_sub_of_lt_one :
    ∀ {α : Type u_1} {E' : Type u_6} [inst : SeminormedAddCommGroup E'] {c : ℝ} {l : Filter α} {f₁ f₂ : α → E'},
      Asymptotics.IsBigOWith c l f₁ f₂ → c < 1 → Asymptotics.IsBigOWith (1 / (1 - c)) l f₂ fun x => f₂ x - f₁ x :=
  by sorry

The theorem `Asymptotics.IsBigOWith.right_le_sub_of_lt_one` states that for any types `α` and `E'`, where `E'` is a semi-normed additive commutative group, and any real number `c`, filter `l` on `α`, and functions `f₁` and `f₂` from `α` to `E'`, if `f₁` is Big-O of `f₂` with constant `c` at filter `l` (i.e., `f₁` is eventually bounded by `c * f₂` at `l`), and `c` is less than 1, then `f₂` is Big-O of `f₂ - f₁` with constant `1 / (1 - c)` at filter `l`. In other words, `f₂` is eventually bounded by `1 / (1 - c)` times `f₂ - f₁` at `l`. This theorem governs the interaction of Big-O notation with subtraction under certain conditions.

If `f₁` is Big-O of `f₂` with constant `c` at filter `l` and `0 < c < 1`, then `f₂` is Big-O of `f₂ - f₁` with constant `1 / (1 - c)` at filter `l`.


CategoryTheory.Functor.isZero

theorem CategoryTheory.Functor.isZero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
      (F : CategoryTheory.Functor C D),
      (∀ (X : C), CategoryTheory.Limits.IsZero (F.obj X)) → CategoryTheory.Limits.IsZero F :=
  by sorry

This theorem states that given two categories `C` and `D`, and a functor `F` from `C` to `D`, if for all objects `X` in `C`, `F.obj X` is a zero object in `D` (meaning it's both a terminal and initial object), then the functor `F` itself is considered a zero functor in the limit theory of categories. This is under the condition that `C` and `D` have respective category structures.

If for every object X in a category C, the image F.obj X under a functor F from C to D is a zero object in D, then F is a zero functor in the limit theory of categories C and D.


theorem HasFDerivAtFilter.const_add :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {L : Filter E},
      HasFDerivAtFilter f f' x L → ∀ (c : F), HasFDerivAtFilter (fun y => c + f y) f' x L :=
  by sorry

The theorem `HasFDerivAtFilter.const_add` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` for both `E` and `F`, if the function `f` from `E` to `F` has a Frechet derivative `f'` at a point `x` with respect to a filter `L`, then for any constant `c` in `F`, the function that adds `c` to `f(y)` for every `y` in `E` also has the same derivative `f'` at `x` with respect to the filter `L`.

In simpler terms, it states that the derivative of a function `f` is unaffected by adding a constant to the function, similar to the well-known property in calculus that the derivative of a function plus a constant is simply the derivative of the original function.

If a function `f` from a normed space `E` to another normed space `F` over a nontrivially normed field `𝕜` has a Frechet derivative `f'` at `x` with respect to a filter `L`, then the function `g(y) = f(y) + c` (for any constant `c` in `F`) also has derivative `f'` at `x` with respect to `L`.


theorem Mathlib.Data.Set.Function._auxLemma.25 :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {b : β}, Set.BijOn f {a} {b} = (f a = b) := by sorry

The theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, and any elements `a` from `α` and `b` from `β`, the function `f` is bijective from the set containing only `a` to the set containing only `b` if and only if `f(a)` equals `b`. In other words, a function `f` provides a bijective mapping from a singleton set `{a}` to another singleton set `{b}` precisely when the application of `f` to `a` yields `b`.

A function from type `α` to type `β` is a bijection from the singleton set `{a : α}` to the singleton set `{b : β}` if and only if `f a = b`.


theorem Complex.hasSum_sin' :
    ∀ (z : ℂ),
      HasSum (fun n => (z * Complex.I) ^ (2 * n + 1) / ↑(Nat.factorial (2 * n + 1)) / Complex.I) (Complex.sin z) :=
  by sorry

The theorem `Complex.hasSum_sin'` states that for any complex number `z`, the infinite series made by taking successive odd powers of `z * Complex.I`, each divided by the factorial of its power and the imaginary unit `Complex.I`, converges to the complex sine of `z`. In mathematical terms, it's saying that the sum of `((z * Complex.I) ^ (2 * n + 1) / (Nat.factorial (2 * n + 1)) / Complex.I)` for all `n` from `0` to `∞` equals `Complex.sin z`. This is a restatement of the well-known power series representation for the sine function in terms of complex numbers.

The theorem `Complex.hasSum_sin'` asserts that the infinite series of `((z * Complex.I) ^ (2 * n + 1) / (Nat.factorial (2 * n + 1)) / Complex.I)` for `n = 0, 1, 2, ...` converges to `Complex.sin z` for any complex number `z`.


theorem MeasureTheory.ae_withDensity_iff :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : α → Prop} {f : α → ENNReal},
      Measurable f → ((∀ᵐ (x : α) ∂μ.withDensity f, p x) ↔ ∀ᵐ (x : α) ∂μ, f x ≠ 0 → p x) :=
  by sorry

This theorem states that for any type `α`, measurable space `m0`, measure `μ`, proposition `p` and function `f` from `α` to the extended nonnegative reals, if `f` is measurable, then the property `p` holds almost everywhere (in the sense of measure `μ`) with respect to the measure obtained by applying `f` to `μ` (denoted `μ.withDensity f`), if and only if `p` holds almost everywhere with respect to `μ` whenever `f` is not zero. In other words, the set of points where `p` fails is of measure zero in `μ.withDensity f` if and only if the set of points where both `p` fails and `f` is not zero is of measure zero in `μ`.

For a measurable function $f : \alpha \to \mathbb{R}^+ \cup \{ \infty \}$ from a type $\alpha$ to the extended nonnegative reals and any measure $\mu$, proposition $p$, if $f$ is measurable and $\mu.withDensity(f) = \mu$ almost everywhere where $f$ is nonzero if and only if $p$ holds almost everywhere with respect to $\mu$, then $p$ holds almost everywhere with respect to $\mu.withDensity(f)$.


theorem Turing.PointedMap.map_pt :
    ∀ {Γ : Type u_1} {Γ' : Type u_2} [inst : Inhabited Γ] [inst_1 : Inhabited Γ'] (f : Turing.PointedMap Γ Γ'),
      f.f default = default :=
  by sorry

This theorem, `Turing.PointedMap.map_pt`, states that for all types 'Γ' and 'Γ'', assuming both types are inhabited (i.e., they contain at least one element), any pointed map 'f' from 'Γ' to 'Γ'' maps the default value of 'Γ' to the default value of 'Γ''. In other words, the pointed map preserves the default values between the two types.

For any inhabited types 'Γ' and 'Γ'' and a pointed map f from 'Γ' to 'Γ'' between them, the default value of 'Γ' maps to the default value of 'Γ'' under f.


theorem EReal.coe_ne_top : ∀ (x : ℝ), ↑x ≠ ⊤ := by sorry

This theorem states that for any real number `x`, the extended real number equivalent of `x` is not equal to positive infinity. Explicitly, this means that no matter what real number we choose, when we convert this real number into its extended real number form, it will never be equal to positive infinity.

For every real number x, its extended real number equivalent is not equal to positive infinity.


theorem Composition.ofFn_blocksFun : ∀ {n : ℕ} (c : Composition n), List.ofFn (Composition.blocksFun c) = c.blocks := by
  sorry

This theorem, `Composition.ofFn_blocksFun`, states that for any natural number `n` and any composition `c` of `n`, the list created by applying the function `Composition.blocksFun c` to each index of the composition (from 0 to `Composition.length c - 1`) is equal to the list of blocks in the composition `c`. In other words, it asserts that the function `Composition.blocksFun` retrieves the blocks of the composition when applied to each element of the finite set `Fin (Composition.length c)`, and the resulting list of these blocks is exactly the same as the original list of blocks in the composition.

For any composition `c` of length `n`, the list of blocks obtained by applying `Composition.blocksFun` to each index in `Fin n` equals the original list of blocks in `c`.


theorem Set.subsingleton_of_subsingleton : ∀ {α : Type u} [inst : Subsingleton α] {s : Set α}, Set.Subsingleton s := by
  sorry

The theorem `Set.subsingleton_of_subsingleton` states that for any type `α` that is a subsingleton, and for any set `s` of that type `α`, the set `s` is also a subsingleton. In other words, if a type `α` can have at most one instance (meaning it is a subsingleton), then any set of elements of type `α` can also have at most one element, thus making it a subsingleton set.

If `α` is a subsingleton type, then any set `s` of type `α` is also a subsingleton.


theorem Order.succ_le_succ_iff :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α} [inst_2 : NoMaxOrder α],
      Order.succ a ≤ Order.succ b ↔ a ≤ b :=
  by sorry

The theorem `Order.succ_le_succ_iff` states that for any type `α` that is a preorder and has a successor order with no maximum element, for any two elements `a` and `b` of this type, the successor of `a` is less than or equal to the successor of `b` if and only if `a` is less than or equal to `b`. In other words, in such a structure, the order of elements is preserved when taking successors.

For any preorder type `α` without a maximum element having a successor order, `a ≤ b` if and only if `succ a ≤ succ b`.


theorem Submonoid.mem_top : ∀ {M : Type u_1} [inst : MulOneClass M] (x : M), x ∈ ⊤ := by sorry

This theorem states that for any given type `M` (which is a multiplication class with a multiplicative identity), every element `x` of type `M` belongs to the top submonoid `⊤`. In the context of abstract algebra, a submonoid is a subset of a monoid that is closed under the monoid operation and contains the identity element of the monoid. The top submonoid `⊤` is the whole monoid itself, hence every element of the monoid belongs to it.

Every element of a multiplication class `M` with an identity belongs to the top submonoid `⊤` (equivalent to the monoid itself).


theorem Real.sin_eq_zero_iff : ∀ {x : ℝ}, Real.sin x = 0 ↔ ∃ n, ↑n * Real.pi = x := by sorry

This theorem states that for every real number 'x', the sine of 'x' equals to zero if and only if 'x' equals 'n' times pi, where 'n' is an integer. In mathematical terms, `sin(x) = 0` if and only if `x = nπ`, ∀ `n ∈ Z`, where 'Z' is the set of all integers.

The sine function equals zero if and only if the argument is an integer multiple of pi.


theorem MeasureTheory.snorm_mono :
    ∀ {α : Type u_1} {F : Type u_3} {G : Type u_4} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
      (∀ (x : α), ‖f x‖ ≤ ‖g x‖) → MeasureTheory.snorm f p μ ≤ MeasureTheory.snorm g p μ :=
  by sorry

This theorem, named `MeasureTheory.snorm_mono`, states the following: Given two types `α` and `F` and `G`, where `α` is a measurable space and `F` and `G` are normed additive commutative groups, if for every element `x` of type `α`, the norm of `f(x)` is less than or equal to the norm of `g(x)`, then the seminorm (or `ℒp` norm) of `f` is less than or equal to the seminorm of `g`. Here, `f` and `g` are functions from `α` to `F` and `G` respectively, `p` is an extended non-negative real number representing the `p` in `ℒp` norm, and `μ` is a measure on the measurable space `α`. This theorem basically demonstrates the monotonicity of the `ℒp` norm in the context of measure theory.

If `μ` is a measure on a measurable space `α` and `p ≥ 0` is an extended real number, given functions `f : α → F` and `g : α → G` with `F` and `G` normed additive commutative groups, if `∀x ∈ α, ||f(x)|| ≤ ||g(x)||`, then `||f||ₚ(μ) ≤ ||g||ₚ(μ)`, where `||.||ₚ(μ)` denotes the seminorm (or `ℒp` norm) with respect to the measure `μ`.


theorem Polynomial.leadingCoeff_mul_monic :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.Monic q → Polynomial.leadingCoeff (p * q) = Polynomial.leadingCoeff p :=
  by sorry

This theorem states that for any semiring `R` and any polynomials `p` and `q` in `R`, if `q` is monic (meaning its leading coefficient is 1), then the leading coefficient of the product `p * q` is the same as the leading coefficient of `p`. In other words, multiplying a polynomial by a monic polynomial does not change the leading coefficient of the original polynomial.

The leading coefficient of the product of a polynomial and a monic polynomial is equal to the leading coefficient of the original polynomial.


/-- Given a submartingale `f` and bounded stopping times `τ` and `π` such that `τ ≤ π`, the
expectation of `stoppedValue f τ` is less than or equal to the expectation of `stoppedValue f π`.
This is the forward direction of the optional stopping theorem.  -/
theorem MeasureTheory.Submartingale.expected_stoppedValue_mono :
    ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
      {f : ℕ → Ω → ℝ} {τ π : Ω → ℕ} [inst : MeasureTheory.SigmaFiniteFiltration μ 𝒢],
      MeasureTheory.Submartingale f 𝒢 μ →
        MeasureTheory.IsStoppingTime 𝒢 τ →
          MeasureTheory.IsStoppingTime 𝒢 π →
            τ ≤ π →
              ∀ {N : ℕ},
                (∀ (ω : Ω), π ω ≤ N) →
                  ∫ (x : Ω), MeasureTheory.stoppedValue f τ x ∂μ ≤ ∫ (x : Ω), MeasureTheory.stoppedValue f π x ∂μ :=
  by sorry

This theorem, known as the forward direction of the optional stopping theorem, states that for a given submartingale `f` and two bounded stopping times `τ` and `π` (where `τ` is less than or equal to `π`), the expected value of the function `f` stopped at time `τ` is less than or equal to the expected value of the function `f` stopped at time `π`. This result is valid for any natural number `N` such that `π ω` is less than or equal to `N` for all `ω`. The theorem is particularly significant in the context of stochastic processes and their related filtration systems.

For a submartingale `f` and bounded stopping times `τ` and `π` with `τ ≤ π` and `π ω ≤ N` for some natural number `N`, we have the inequality `E[f?_τ] ≤ E[f?_π]`.


theorem ContinuousLinearMap.le_of_opNorm_le :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
      (f : E →SL[σ₁₂] F) {c : ℝ}, ‖f‖ ≤ c → ∀ (x : E), ‖f x‖ ≤ c * ‖x‖ :=
  by sorry

This theorem, `ContinuousLinearMap.le_of_opNorm_le`, states that for any continuous linear map `f` from a normed space `E` over a nontrivially normed field `𝕜` to a normed space `F` over a nontrivially normed field `𝕜₂`, given a real number `c`, if the operator norm (or "opNorm") of `f` is less than or equal to `c`, then for any vector `x` in `E`, the norm of `f(x)` is less than or equal to `c` times the norm of `x`. This theorem essentially bounds the norm of the image of a vector under a continuous linear map in terms of the norm of the vector itself and a constant factor determined by the operator norm of the map.

For any continuous linear map between normed spaces and a real constant, if the operator norm of the map is less than or equal to the constant, then the norm of the image of any vector under the map is less than or equal to the constant times the norm of the vector.


theorem AffineIsometry.dist_map :
    ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
      [inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
      [inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
      [inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (f : P →ᵃⁱ[𝕜] P₂) (x y : P),
      dist (f x) (f y) = dist x y :=
  by sorry

This theorem states that for an affine isometry `f`, taken from the space `P` to the space `P₂` in a normed field `𝕜`, and for any two points `x` and `y` in `P`, the distance between the image points `f(x)` and `f(y)` in `P₂` is the same as the distance between `x` and `y` in `P`. This property characterizes an important aspect of affine isometries: they preserve distances.

For any affine isometry f from a normed field P to P₂, and for all x, y in P, the distance between f(x) and f(y) in P₂ equals the distance between x and y in P.


/-- For a function taking values in a second countable space, the set of points `x` for
which the image under `f` of `(x, ∞)` is separated above from `f x` is countable.  -/
theorem countable_image_lt_image_Ioi :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : LinearOrder β] (f : β → α) [inst : SecondCountableTopology α],
      Set.Countable {x | ∃ z, f x < z ∧ ∀ (y : β), x < y → z ≤ f y} :=
  by sorry

This theorem states that for a function `f` that maps elements from a type `β` to a type `α` (with `α` being a topological space with a second countable topology and a linear order that is also an order topology, and `β` a linear order), the set of points `x` in `β` for which the image of `(x, ∞)` under `f` is always equal to or greater than some value `z` that is greater than `f(x)` is a countable set. In other words, it's the set of points `x` in `β` where `f(x)` is strictly less than some `z`, and for all `y` greater than `x`, `f(y)` is always at least `z`.

For a function `f` from a linearly ordered type `β` to a second countable topological space `α` with a linear order that is also an order topology, the set of `x` in `β` such that for all `y > x`, `f(y)` is greater than or equal to `f(x) + z`, for some `z > f(x)`, is countable.


Embedding.metrizableSpace

/-- Given an embedding of a topological space into a metrizable space, the source space is also
metrizable.  -/
theorem Embedding.metrizableSpace :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace.MetrizableSpace Y] {f : X → Y}, Embedding f → TopologicalSpace.MetrizableSpace X :=
  by sorry

This theorem states that if you have a function that embeds a topological space 'X' into a metrizable space 'Y' (a space where you can define a metric or distance function), then the original topological space 'X' is also metrizable. In other words, if you can accurately and continuously map 'X' into 'Y' such that 'Y' can be measured with a metric, then 'X' can also be measured with a metric.

If a topological space X admits a continuous embedding into a metrizable space Y, then X is metrizable.


theorem Tropical.add_eq_left : ∀ {R : Type u} [inst : LinearOrder R] ⦃x y : Tropical R⦄, x ≤ y → x + y = x := by sorry

This theorem states that for any type `R` that has an instance of `LinearOrder` (a type of order that includes less and equal), and for any two elements `x` and `y` of the tropicalization of `R` (`Tropical R`), if `x` is less than or equal to `y`, then the sum of `x` and `y` is equal to `x`. In other words, in the tropicalized version of a type with a linear order, the sum of two elements is equal to the smallest of the two elements.

For any type `R` with a linear order and any elements `x, y` in the tropicalization of `R`, if `x ≤ y`, then `x + y = x`.


theorem AkraBazziRecurrence.isLittleO_smoothingFn_one : AkraBazziRecurrence.smoothingFn =o[Filter.atTop] fun x => 1 :=
  by sorry

This theorem, named `AkraBazziRecurrence.isLittleO_smoothingFn_one`, states that in the limit as x approaches infinity, the "smoothing function", which is defined as `1 / log(x)`, is little 'o' of the constant function `1`. This means that the smoothing function becomes insignificant relative to the constant function `1` as `x` tends to infinity. In mathematical terms, this is expressed as $\frac{1}{\log(x)} = o(1)$ as $x \rightarrow \infty$.

As x approaches infinity, the smoothing function 1 / log(x) is little 'o' of the constant function 1, i.e., 1 / log(x) = o(1).


theorem Subalgebra.finrank_eq_one_iff :
    ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Ring E] [inst_2 : Algebra F E] [inst_3 : Nontrivial E]
      {S : Subalgebra F E}, FiniteDimensional.finrank F ↥S = 1 ↔ S = ⊥ :=
  by sorry

This theorem states that for any field `F`, any ring `E` that has an algebra structure over `F`, and any nontrivial subalgebra `S` of `E`, the rank of `S` as a `F`-module being equal to 1 is equivalent to `S` being the bottom (i.e., zero) subalgebra. In other words, a subalgebra of a ring over a field has rank one if and only if it is the zero subalgebra. This is calculated in terms of the finiteness of the dimension of the module, which is a natural number defined as zero if the space has infinite rank.

A subalgebra of a ring over a field has rank 1 as an `F`-module if and only if it is the zero subalgebra.


theorem Bornology.IsVonNBounded.of_add_right :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : ContinuousSMul 𝕜 E] [inst_5 : ContinuousAdd E] {s t : Set E},
      Bornology.IsVonNBounded 𝕜 (s + t) → Set.Nonempty s → Bornology.IsVonNBounded 𝕜 t :=
  by sorry

The theorem `Bornology.IsVonNBounded.of_add_right` states that for any types `𝕜` and `E` with `𝕜` being a normed field, `E` being an additive commutative group, and a module over `𝕜`, if we have a continuous scalar multiplication and addition on `E`, then for any two sets `s` and `t` of type `E`, if the set `s + t` is von Neumann bounded and the set `s` is not empty, then the set `t` is also von Neumann bounded.

In other words, if `s` is a nonempty set and `s + t` is a von Neumann bounded set, then `t` must also be a von Neumann bounded set. Here, `s + t` is the set of all elements that can be written as the sum of an element from `s` and an element from `t`, and a set being von Neumann bounded means that every neighborhood of 0 absorbs that set.

If `𝕜` is a normed field, `E` is an additive commutative group and a `𝕜`-module, `s` is a nonempty set in `E`, and `s + t` is von Neumann bounded, then `t` is also von Neumann bounded.


/-- Cancel right multiplication in the modulus.

For cancelling right multiplication on both sides of the `≡`, see `nat.modeq.mul_right_cancel'`.  -/
theorem Nat.ModEq.of_mul_right : ∀ {n a b : ℕ} (m : ℕ), a ≡ b [MOD n * m] → a ≡ b [MOD n] := by sorry

This theorem, `Nat.ModEq.of_mul_right`, states that for any natural numbers `n`, `a`, `b`, and `m`, if `a` is congruent to `b` modulo `n * m`, then `a` is also congruent to `b` modulo `n`. This is essentially stating that right multiplication can be cancelled out in the modulus. For a theorem that cancels right multiplication on both sides of the congruence relation, refer to `nat.modeq.mul_right_cancel'`.

If `a` is congruent to `b` modulo `n * m`, then `a` is congruent to `b` modulo `n`.


theorem Nat.range_nth_of_infinite : ∀ {p : ℕ → Prop}, Set.Infinite (setOf p) → Set.range (Nat.nth p) = setOf p := by
  sorry

The theorem `Nat.range_nth_of_infinite` states that for any predicate `p` on natural numbers, if the set of natural numbers satisfying `p` is infinite, then the range of the function that maps each natural number to the corresponding `n`-th natural number satisfying `p` is exactly the set of all natural numbers satisfying `p`. In other words, if there are infinitely many natural numbers satisfying `p`, then every such natural number is the `n`-th satisfying `p` for some `n`.

If a predicate `p` on natural numbers has an infinite number of solutions, then the function mapping each natural number to the `n`-th solution of `p` is a surjection from the set of natural numbers.


theorem Decidable.exists_ne : ∀ {α : Type u_1} [inst : Nontrivial α] [inst : DecidableEq α] (x : α), ∃ y, y ≠ x := by
  sorry

This theorem, `Decidable.exists_ne`, asserts that for any type `α` that is nontrivial (i.e., has at least two distinct elements) and has decidable equality (meaning, given any two elements of `α`, it is decidable whether or not they are equal), if we have an element `x` of `α`, there exists another element `y` in `α` which is not equal to `x`. In essence, this theorem guarantees that in such a type `α`, for any given element, there is always another distinct element.

For any nontrivial type `α` with decidable equality, there exists a distinct element in `α` for every given element.


theorem Matrix.updateColumn_apply :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n]
      {j' : n}, Matrix.updateColumn M j c i j' = if j' = j then c i else M i j' :=
  by sorry

The theorem `Matrix.updateColumn_apply` states that for any types `m` and `n`, any type `α` which has decidable equality, any matrix `M` with entries in `α` and indexed by `m` and `n`, any elements `i` of type `m` and `j` and `j'` of type `n`, and any function `c` from `m` to `α`, the entry at position `(i, j')` of the matrix obtained by updating the column `j` of `M` with the values provided by `c` is `c i` if `j'` is equal to `j`, and is the original entry `M i j'` otherwise. This theorem provides a precise specification for the behavior of the `Matrix.updateColumn` function.

For any matrix `M` with decidable equality entries, updating column `j` of `M` with values `c(i)` results in a matrix where the entry at position `(i, j')` is `c(i)` if `j' = j` and the original entry `M(i, j')` otherwise.


theorem MeasureTheory.AEEqFun.instNeg.proof_1 :
    ∀ {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : AddGroup γ] [inst_2 : TopologicalAddGroup γ],
      Continuous fun a => -a :=
  by sorry

This theorem states that for any type `γ`, if `γ` is a topological space, an additive group, and a topological additive group, then the function that takes an element `a` from `γ` and returns its additive inverse `-a` is a continuous function. In mathematical terms, for all `a` in `γ`, the function `f(a) = -a` is continuous. This means that for any sequence of elements in `γ` converging to `a`, their additive inverses also converge to `-a`.

If `γ` is a topological space, an additive group, then the additive inverse function `a ↔- a` is a continuous function on `γ`.