theorem List.mem_replicate : ∀ {α : Type u_1} {a b : α} {n : ℕ}, b ∈ List.replicate n a ↔ n ≠ 0 ∧ b = a := by sorry

This theorem states that for any type `α`, any elements `a` and `b` of type `α`, and any natural number `n`, the element `b` is a member of the list obtained by replicating `a` `n` times if and only if `n` is not zero and `b` equals `a`. In other words, `b` is in the list containing `n` copies of `a` exactly when `n` is not zero and `b` is same as `a`.

For any type `α`, any natural number `n`, and any elements `a` and `b` of type `α`, `b` is an element of the list of length `n+1` consisting of `a` repeated `n` times if and only if `n` is nonzero and `b = a`.


theorem iteratedFDeriv_zero_fun :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ},
      (iteratedFDeriv 𝕜 n fun x => 0) = 0 :=
  by sorry

This theorem states that for any nontrivial normed field `𝕜`, normed add commutative group `E`, normed space of `𝕜` and `E`, another normed add commutative group `F`, another normed space of `𝕜` and `F`, and a natural number `n`, the `n`-th iterated Frechet derivative of the zero function (i.e., a function that always returns zero) is also zero. This is essentially saying that if you take any number of derivatives of a constant zero function, you'll always get zero, regardless of the spaces and fields involved.

The `n`-th Frechet derivative of the zero function is zero for any normed field, normed add commutative group, and natural number.


Eq.subset'

/-- **Alias** of `subset_of_eq`. -/
theorem Eq.subset' :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1], a = b → a ⊆ b := by sorry

This theorem, which is an alias of `subset_of_eq`, states that for any type `α` that has a subset operation and a reflexivity relation defined on it, if `a` and `b` are elements of `α` and `a` is equal to `b`, then `a` is a subset of `b`.

For all types `α` with defined subset and equality relations, if `a` and `b` are elements of `α` with `a = b`, then `a ⊆ b`.


Sum.inr.inj

theorem Sum.inr.inj : ∀ {α : Type u} {β : Type v} {val val_1 : β}, Sum.inr val = Sum.inr val_1 → val = val_1 := by sorry

This theorem, `Sum.inr.inj`, states that for any types `α` and `β`, and for any two values `val` and `val_1` of type `β`, if `Sum.inr val` is equal to `Sum.inr val_1`, then `val` is equal to `val_1`. In other words, the `inr` function of the `Sum` type is injective (or one-to-one), meaning that equal outputs can only come from equal inputs.

For all types α and β, the injective function `inr : β -> Sum β α` holds that `inr a = inr a'` implies `a = a'`.


theorem exists_int_lt : ∀ {α : Type u_1} [inst : StrictOrderedRing α] [inst_1 : Archimedean α] (x : α), ∃ n, ↑n < x :=
  by sorry

This theorem, `exists_int_lt`, states that for any type `α` that is a strictly ordered ring and also Archimedean, for any element `x` of that type, there exists an integer `n` such that `n` is less than `x`. In other words, in any Archimedean strictly ordered ring, given any element, we can always find an integer that is less than that element.

In any Archimedean strictly ordered ring, every element has a strictly positive integer lower bound.


theorem Real.cauchy_add : ∀ (a b : ℝ), (a + b).cauchy = a.cauchy + b.cauchy := by sorry

This theorem states that for any two real numbers 'a' and 'b', the Cauchy sequence of the sum of 'a' and 'b' is equal to the sum of the Cauchy sequences of 'a' and 'b'. In other words, the operation of adding two real numbers commutes with the operation of taking their Cauchy sequences.

For any real numbers a and b, the Cauchy sequences of a and b add componentwise to form the Cauchy sequence of a + b.


theorem LocallyFinite.point_finite :
    ∀ {ι : Type u_1} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X},
      LocallyFinite f → ∀ (x : X), Set.Finite {b | x ∈ f b} :=
  by sorry

The theorem `LocallyFinite.point_finite` states that for any type `ι`, any type `X` equipped with a topological structure, and any function `f` from `ι` to the set of `X`, if `f` is locally finite - meaning that for every point `x` in `X`, there exists a neighborhood of `x` which intersects only finitely many sets in the family `f` - then for every point `x` in `X`, the set of `b` in `ι` such that `x` belongs to `f b` is finite. In other words, each point in the space `X` belongs to only finitely many sets in the locally finite family `f`.

If `f` is a locally finite family of sets over a topological space `X` (i.e., for every point `x` in `X`, there exists a neighborhood of `x` intersecting only finitely many sets in `f`), then for every point `x` in `X`, the set of indices `b` for which `x` belongs to `f(b)` is finite.


theorem exists_int_gt : ∀ {α : Type u_1} [inst : StrictOrderedRing α] [inst_1 : Archimedean α] (x : α), ∃ n, x < ↑n :=
  by sorry

This theorem, named `exists_int_gt`, states that for any type `α` that forms a strictly ordered ring and is Archimedean, given any element `x` of that type, there exists an integer `n` such that `x` is less than `n`. In other words, in any Archimedean strictly ordered ring, any given element is exceeded by some integer.

In any Archimedean strictly ordered ring, every element is surpassed by some integer.


theorem PrimeSpectrum.isClosed_singleton_iff_isMaximal :
    ∀ {R : Type u} [inst : CommSemiring R] (x : PrimeSpectrum R), IsClosed {x} ↔ Ideal.IsMaximal x.asIdeal := by sorry

This theorem states that for any given ring `R`, which is a commutative semiring, and a point `x` in the prime spectrum of `R`, the set containing only `x` is closed if and only if `x` is a maximal ideal in the ring `R`. In other words, the closure of a single point in the prime spectrum of a ring corresponds to maximal ideals of the ring.

A point in the prime spectrum of a commutative semiring is a closed set if and only if it is a maximal ideal.


theorem UniformSpace.Completion.uniformContinuous_map :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {f : α → β},
      UniformContinuous (UniformSpace.Completion.map f) :=
  by sorry

The theorem `UniformSpace.Completion.uniformContinuous_map` states that for any two types `α` and `β` equipped with a uniform space structure, and for any function `f` from `α` to `β`, the completion map of `f` (represented as `UniformSpace.Completion.map f`) is uniformly continuous. In other words, if `x` and `y` are sufficiently close points in the completion of `α`, then their images under the `f` completion map in the completion of `β` are also close, regardless of the specific locations of `x` and `y` in the completion of `α`.

Given uniform spaces (α, dα) and (β, dβ), and a uniformly continuous function f : α → β, the completion map UniformSpace.Completion.map f is uniformly continuous from the completion of (α, dα) to the completion of (β, dβ).


theorem List.mem_insert_iff :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a b : α} {l : List α},
      a ∈ List.insert b l ↔ a = b ∨ a ∈ l :=
  by sorry

This theorem, `List.mem_insert_iff`, states that for any type `α` with an equality test (BEq) and a lawful equality test (LawfulBEq), and given any elements `a` and `b` of type `α` and a list `l` of elements of type `α`, an element `a` is a member of the list obtained by inserting `b` into `l` if and only if `a` is equal to `b` or `a` is already a member of `l`. This theorem encapsulates the principle that inserting an element into a list without duplication either leaves the membership of other elements unchanged, or adds the new element to the set of members.

For any type `α` with equality (=) and lawful equality test (LawfulBEq), and any list `l` of elements of type `α` and elements `a` and `b` of `α`, `a` is in the list obtained by inserting `b` into `l` if and only if `a = b` or `a` is already in `l`.


theorem Finsupp.comapDomain_apply :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α → β) (l : β →₀ M)
      (hf : Set.InjOn f (f ⁻¹' ↑l.support)) (a : α), (Finsupp.comapDomain f l hf) a = l (f a) :=
  by sorry

The theorem `Finsupp.comapDomain_apply` states that for any types `α`, `β`, and `M` (with `M` being a type with a zero element), given a function `f` from `α` to `β`, a finitely supported function `l` from `β` to `M`, a proof `hf` that `f` is injective on the preimage of the support of `l`, and any element `a` of `α`, the value of `Finsupp.comapDomain f l hf` at `a` is equal to `l` of `f(a)`. In other words, when you apply the finitely supported function derived from `l` and `f` to an element `a`, it's equivalent to applying `l` to the image of `a` under `f`.

For injective functions `f: α → β` and finitely supported functions `l: β → M`, `Finsupp.comapDomain f l hf(a) = l (f a)` for all `a ∈ α`.


theorem List.chain'_append :
    ∀ {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α},
      List.Chain' R (l₁ ++ l₂) ↔
        List.Chain' R l₁ ∧ List.Chain' R l₂ ∧ ∀ x ∈ List.getLast? l₁, ∀ y ∈ List.head? l₂, R x y :=
  by sorry

This theorem, `List.chain'_append`, states that for all types `α` and for all relations `R` of type `α → α → Prop`, and given two lists `l₁` and `l₂` of type `α`, the relation `R` forms a chain across the concatenation of `l₁` and `l₂` if and only if `R` forms a chain across `l₁`, forms a chain across `l₂`, and for all elements `x` in the last position of `l₁` and all elements `y` in the first position of `l₂`, `R x y` holds true. In other words, a relation forms a chain over the concatenation of two lists if it forms a chain over each list separately and also links the last element of the first list to the first element of the second list.

For all types `α` and relations `R` on `α`, `R` is a chain over the concatenation of lists `l₁` and `l₂` if and only if `R` is a chain on `l₁`, `R` is a chain on `l₂`, and `R` relates the last element of `l₁` to the first element of `l₂`.


theorem rank_finsupp :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] [inst_4 : Module.Free R M] (ι : Type w),
      Module.rank R (ι →₀ M) = Cardinal.lift.{v, w} (Cardinal.mk ι) * Cardinal.lift.{w, v} (Module.rank R M) :=
  by sorry

This theorem, `rank_finsupp`, states that for any type `R` representing a ring, any type `M` representing a module over `R`, and any type `ι`, under the conditions that `R` has the strong rank condition and `M` is a free module over `R`, the rank of the free module over `R` with basis type `ι →₀ M` is equal to the product of the cardinality of `ι` lifted to the maximum of the universes of `ι` and `M`, and the rank of `M` lifted to the maximum of the universes of `M` and `ι`. In other words, if $\text{Card}(\text{Type})$ denotes the cardinality of a type and $\text{rank}_R(M)$ denotes the rank of a module $M$ over a ring $R$, then the theorem states:

$$\text{rank}_R(\iota \rightarrow₀ M) = \text{Card}_{\text{lift}}(\iota) \times \text{Card}_{\text{lift}}(\text{rank}_R(M))$$

where the subscript 'lift' indicates that the cardinalities are lifted to the appropriate universe level.

The rank of a free module over a ring with the strong rank condition is equal to the product of the cardinality of its basis, lifted to the maximum universe level, and the rank of the module, also lifted to the maximum universe level.


theorem Complex.sin_arg : ∀ (x : ℂ), Real.sin (Complex.arg x) = x.im / Complex.abs x := by sorry

The theorem `Complex.sin_arg` states that for every complex number `x`, the sine of the argument of `x` is equal to the imaginary part of `x` divided by the absolute value of `x`. In mathematical terms, this could be written as $\sin(\arg(x)) = \frac{Im(x)}{|x|}$ for all complex numbers `x`. This relationship is fundamental in the polar form representation of complex numbers.

The sine of the argument of a complex number equals the imaginary part divided by its absolute value: $\sin(\arg(x)) = \frac{Im(x)}{|x|}$.


theorem Ordinal.succ_ne_zero : ∀ (o : Ordinal.{u_3}), Order.succ o ≠ 0 := by sorry

The theorem `Ordinal.succ_ne_zero` states that for any ordinal `o`, the successor of `o` is not equal to zero. In other words, in the context of ordinals, which represent well orders, the next ordinal after any given ordinal is always non-zero. This is true regardless of the specific ordering or type of the ordinal.


/-- Note: this lemma is specifically about `Fintype.ofSubsingleton`. For a statement about
arbitrary `Fintype` instances, use either `Fintype.card_le_one_iff_subsingleton` or
`Fintype.card_unique`.  -/
theorem Fintype.card_ofSubsingleton : ∀ {α : Type u_1} (a : α) [inst : Subsingleton α], Fintype.card α = 1 := by sorry

This theorem, `Fintype.card_ofSubsingleton`, states that for any type `α` and an element `a` of that type, if `α` is a subsingleton (i.e., it has at most one distinct element), then the cardinality of `α` is 1. In other words, the number of elements in a subsingleton type is always 1. Note that this theorem is particular to `Fintype.ofSubsingleton`, and for arbitrary `Fintype` instances, one should use `Fintype.card_le_one_iff_subsingleton` or `Fintype.card_unique` instead.

If `α` is a subsingleton type, then the cardinality of `α` is 1.


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.1 :
    ∀ {α : Type u_2} {x y : α}, Equiv.Perm.SameCycle 1 x y = (x = y) := by sorry

This theorem states that for any type 'α' and any two elements 'x' and 'y' of this type, 'x' and 'y' are in the same cycle of the identity permutation if and only if 'x' equals 'y'. In the context of group theory and permutations, the identity permutation does not change any elements, thus two elements are in the same cycle of the identity permutation only when they are the same.

For any type 'α' and any two elements 'x' and 'y' of type 'α', 'x' and 'y' are in the same cycle of the identity permutation if and only if 'x' equals 'y'. In other words, the identity permutation has only the identity element as its fixed points.


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.2 :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, Equiv.Perm.SameCycle f⁻¹ x y = Equiv.Perm.SameCycle f x y := by sorry

This theorem states that for any type `α`, any permutation `f` on `α`, and any two elements `x` and `y` of `α`, `x` and `y` are in the same cycle of the inverse permutation `f⁻¹` if and only if they are in the same cycle of the permutation `f`. In other words, being in the same cycle is an invariant property under taking the inverse of a permutation.

For any permutation `f` on type `α`, elements `x` and `y` are in the same cycle of `f` if and only if they are in the same cycle of `f⁻¹`.


theorem CategoryTheory.GradedObject.ι_descMapObj :
    ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C]
      (X : CategoryTheory.GradedObject I C) (p : I → J) [inst_1 : CategoryTheory.GradedObject.HasMap X p] {A : C}
      {j : J} (φ : (i : I) → p i = j → (X i ⟶ A)) (i : I) (hi : p i = j),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapObj X p i j hi)
          (CategoryTheory.GradedObject.descMapObj X p φ) =
        φ i hi :=
  by sorry

The theorem `CategoryTheory.GradedObject.ι_descMapObj` states that for any types `I`, `J`, and `C` where `C` is a category, any graded object `X` of type `I` in category `C`, any function `p` from `I` to `J`, and given that `X` has a map `p`, for any object `A` in `C` and any `j` in `J`, if we have a family of morphisms `φ` from each `i` in `I` (where `p i` equals `j`) to `A`, then the composition of the morphism from `X i` to the coproduct of all `X i` such that `p i = j` and the morphism from this coproduct to `A` (which is constructed using the family `φ`), is equal to `φ i`, for any `i` in `I` where `p i = j`. In other words, this theorem captures a property of commuting diagrams in the category, where the direct morphism from one object to another is the same as the composite of two morphisms via an intermediary object.

For any graded object X in a category C, function p from I to J, and object A in C, if for all i in I with p(i) = j, there are morphisms φi from X i to A, then the composition of the morphism from the coproduct of {X i | p(i) = j} to A constructed from φi and the morphism from X i to this coproduct is equal to φi for all i.


Set.OrdConnected.convex

theorem Set.OrdConnected.convex :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : LinearOrderedAddCommMonoid E]
      [inst_2 : Module 𝕜 E] [inst_3 : OrderedSMul 𝕜 E] {s : Set E}, Set.OrdConnected s → Convex 𝕜 s :=
  by sorry

The theorem `Set.OrdConnected.convex` states that for any type `𝕜` which forms an ordered semiring and another type `E` that is a linearly ordered additive commutative monoid with a `𝕜`-module structure and ordered scalar multiplication, if a set `s` of type `E` is ordinally connected, then `s` is also convex over the type `𝕜`. In other words, if `s` is such that for any two points in `s`, all points between them (in the order defined by `E`) are also in `s`, then for any two points in `s`, all points on the line segment between them (in the vector space structure defined by `𝕜` and `E`) are also in `s`.

If `s` is an ordinally connected subset of an additive commutative monoid `E` endowed with a `𝕜`-module structure and ordered scalar multiplication, then `s` is convex in the vector space structure defined by `𝕜` and `E`.


/-- This rather trivial consequence of `iInter_subset`is convenient with `apply`, and has `i`
explicit for this purpose.  -/
theorem Set.iInter_subset_of_subset :
    ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α} (i : ι), s i ⊆ t → ⋂ i, s i ⊆ t := by sorry

This theorem, `Set.iInter_subset_of_subset`, states that for any type `α`, index type `ι`, function `s` mapping from `ι` to a set of `α`, and a set `t` of `α`, if a specific set `s i` (for some `i` of type `ι`) is a subset of `t`, then the intersection over all `s i` (denoted by `⋂ i, s i`) is also a subset of `t`. In simpler terms, if a specific set from a collection of sets is contained within another set, then the intersection of all sets in that collection is also contained within the latter set.

If for all i in ι, si ⊆ t, then ⋂ i, si ⊆ t. (In other words, if every si is a subset of t, then the intersection of all si is a subset of t.)


theorem map_coe_Ioi_atBot :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] (a : α), Filter.map Subtype.val Filter.atBot = nhdsWithin a (Set.Ioi a) :=
  by sorry

This theorem, `map_coe_Ioi_atBot`, states that for any type `α` that has a topological space structure, a linear order, order topology, and is densely ordered, for any element `a` of `α`, the filter obtained by mapping the `atBot` filter (representing the concept of going to negative infinity) of subtypes of `α` via the function `Subtype.val` (which extracts the element from the subtype) is equal to the neighborhood within the open interval `(a, +∞)` of `a`. In simpler terms, it states that mapping the "going to negative infinity" concept from subtypes to the actual elements results in the concept of "limiting towards `a` from values greater than `a`".

For any densely ordered topological space `(α, ≤, τ)` with a topology `τ` induced by the order, the map of the `atBot` filter of subtypes to elements via `Subtype.val` equals the filter of neighborhoods of `a` in the open interval `(a, ∞)`.


Continuous.star

theorem Continuous.star :
    ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [inst_1 : Star R] [inst_2 : ContinuousStar R]
      [inst_3 : TopologicalSpace α] {f : α → R}, Continuous f → Continuous fun x => star (f x) :=
  by sorry

This theorem states that for any types `α` and `R`, where `R` is a topological space, a "star" type (an operation which takes an element and returns its "star" element), and has a continuous "star" operation, and `α` is also a topological space, if `f` is a continuous function from `α` to `R`, then the function that takes `x` in `α` and maps it to the "star" of `f(x)` in `R` is also continuous.

If `α` and `R` are topological spaces, `f` is a continuous function from `α` to `R`, and `α` has a continuous star operation, then the function that maps `x` in `α` to the star of `f(x)` in `R` is continuous.


theorem Subgroup.normal_le_normalCore :
    ∀ {G : Type u_1} [inst : Group G] {H N : Subgroup G} [hN : Subgroup.Normal N], N ≤ Subgroup.normalCore H ↔ N ≤ H :=
  by sorry

This theorem states that for any group `G`, and any subgroups `H` and `N` of `G`, where `N` is a normal subgroup, `N` is a subset of the normal core of `H` if and only if `N` is a subset of `H`. The normal core of a subgroup `H` is the largest normal subgroup of `G` that is contained in `H`. Therefore, this theorem essentially says that a normal subgroup `N` can only be part of the normal core of `H` if it is also part of `H` itself.

For any group `G`, a normal subgroup `N` of `G` is contained in the normal core of a subgroup `H` of `G` if and only if `N` is a subset of `H`.


theorem dist_le_tsum_of_dist_le_of_tendsto :
    ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {f : ℕ → α} (d : ℕ → ℝ),
      (∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n) →
        Summable d →
          ∀ {a : α}, Filter.Tendsto f Filter.atTop (nhds a) → ∀ (n : ℕ), dist (f n) a ≤ ∑' (m : ℕ), d (n + m) :=
  by sorry

The theorem `dist_le_tsum_of_dist_le_of_tendsto` states that for any sequence of elements in a pseudometric space (represented as a function `f` from natural numbers to the elements of the space), and a sequence of real numbers `d`, if the distance between each consecutive pair of elements in the sequence `f` is less than or equal to the corresponding number in the sequence `d` and `d` is summable, then for any limit point `a` of the sequence `f` (that is, the sequence `f` tends to `a` as it goes to infinity), the distance from `f n` to `a` is less than or equal to the sum of the tail of sequence `d` starting from `n`. In mathematical terms, we have this inequality for all `n`: `dist (f n) a ≤ ∑' (m : ℕ), d (n + m)`.

Given a sequence `(f : ℕ → X)` in a pseudometric space `(X, d)` and a summable sequence `(d : ℕ → ℝ)` of distances such that `d (n + m) ≥ dist (f (n + m), f n)` for all `n, m ∈ ℕ`, then for any limit point `a` of `f`, we have `dist (f n, a) ≤ ∑' m ∈ ℕ, d (n + m)`.


theorem Int.modEq_zero_iff_dvd : ∀ {n a : ℤ}, a ≡ 0 [ZMOD n] ↔ n ∣ a := by sorry

This theorem states that for any two integers `n` and `a`, `a` is congruent to `0` modulo `n` if and only if `n` divides `a`. In other words, if there's an integer `k` so that `n * k = a`, then the remainder of `a` divided by `n` is `0`, and vice versa. This is a fundamental property in number theory that establishes a direct link between the divisibility of two integers and their congruence relation in modular arithmetic.

A natural number `n` divides an integer `a` if and only if `a` is congruent to `0` modulo `n`.


theorem Set.Icc.coe_one : ∀ {α : Type u_1} [inst : OrderedSemiring α], ↑1 = 1 := by sorry

This theorem states that for any type `α` which has an ordered semiring structure, the set interval closure of 1 (denoted as `↑1`) is equal to 1. In other words, in any ordered semiring, the singleton set containing 1 can be identified with 1 itself.

In any ordered semiring, the set interval closure of 1 equals 1.


theorem inf_inf_distrib_left : ∀ {α : Type u} [inst : SemilatticeInf α] (a b c : α), a ⊓ (b ⊓ c) = a ⊓ b ⊓ (a ⊓ c) := by
  sorry

This theorem states that for any type `α` that forms a semilattice under an infimum operation (`⊓`), the operation distributes over itself when it's applied from the left. In other words, for any three elements `a`, `b`, and `c` of `α`, the infimum of `a` and the infimum of `b` and `c` (`a ⊓ (b ⊓ c)`) equals the infimum of `a` and `b`, and the infimum of `a` and `c` (`a ⊓ b ⊓ (a ⊓ c)`). This is a property of the infimum operation in a semilattice.

In a semilattice, the infimum of any two elements is commutative and associative with respect to infimum. That is, for all elements `a, b, c`, `(a ⊓ b) = (b ⊓ a)` and `(a ⊓ b) ⊓ (a ⊓ c) = a ⊓ (b ⊓ c)`.


theorem CategoryTheory.Pretriangulated.comp_hom₁ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      {X Y Z : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).hom₁ = CategoryTheory.CategoryStruct.comp f.hom₁ g.hom₁ :=
  by sorry

The theorem `CategoryTheory.Pretriangulated.comp_hom₁` states that for any category `C` with a shift, given three objects `X`, `Y`, and `Z` in the pretriangulated triangle of `C`, and morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the composite of `f` and `g` via `CategoryTheory.CategoryStruct.comp` (denoted `f ≫ g`), when projected to its first component (denoted as `.hom₁`) is the same as the composite of the first components of `f` and `g`. In other words, the operation of taking the first component of a morphism commutes with the composition of morphisms.

For any pretriangulated category `C` with a shift, the composition of morphisms `f: X ⟶ Y` and `g: Y ⟶ Z` in `C` agrees with the composition of their first components when composing morphisms in `C` and taking the first component of the resulting morphism. In other words, `(f ≫ g).hom₁ = f.hom₁ ≫ g.hom₁`.


theorem CategoryTheory.Pretriangulated.comp_hom₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      {X Y Z : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).hom₂ = CategoryTheory.CategoryStruct.comp f.hom₂ g.hom₂ :=
  by sorry

This theorem, `CategoryTheory.Pretriangulated.comp_hom₂`, says that for any category `C` with a shift and any three pretriangulated triangles `X`, `Y`, and `Z` in `C`, given morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the `hom₂` component of the composition of `f` and `g` is equal to the composition of the `hom₂` components of `f` and `g`. In other words, within the context of pretriangulated categories, composition of morphisms preserves the `hom₂` component.

For any pretriangulated category with a shift, the `hom₂` component of the composition of two morphisms between pretriangulated triangles is equal to the composition of their `hom₂` components.


theorem CategoryTheory.Pretriangulated.comp_hom₃ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      {X Y Z : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).hom₃ = CategoryTheory.CategoryStruct.comp f.hom₃ g.hom₃ :=
  by sorry

The theorem `CategoryTheory.Pretriangulated.comp_hom₃` states that for any type `C` that is a category with a shift, and any `X`, `Y`, and `Z` that are pretriangulated triangles in the category `C`, given morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the third homomorphism of the composition of `f` and `g` is equal to the composition of the third homomorphisms of `f` and `g`. In other words, it guarantees the compatibility of the composition operation with the third homomorphism in the context of pretriangulated categories.

For any pretriangulated categories `C` with a shift, and pretriangulated triangles `X → Y → Z` in `C`, the composition of third homomorphisms of morphisms `X → Y` and `Y → Z` equals the third homomorphism of their composition.


Basis.injective

theorem Basis.injective :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (b : Basis ι R M) [inst_3 : Nontrivial R], Function.Injective ⇑b :=
  by sorry

The theorem `Basis.injective` states that for any Type `ι`, a semiring `R`, and an additive commutative monoid `M` that is also an `R`-module, if `b` is a basis of the `R`-module `M`, and `R` is nontrivial (meaning it contains at least two distinct elements), then the function defined by applying `b` is injective. In other words, if `b` is a basis of `M` and we have two elements from type `ι` such that applying `b` to both of them gives the same result, then these two elements must be equal. This is a key property of bases in module theory, reflecting that different elements of the basis are mapped to linearly independent vectors in the module.

If `β` is a basis of the `R`-module `M` over a nontrivial semiring `R`, then the function `x ↦ ∑ (b : β) (x b)` is injective.


theorem Mathlib.Data.PEquiv._auxLemma.4 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem, `Mathlib.Data.PEquiv._auxLemma.4`, asserts that for any type `α` and any two elements `a` and `b` of that type, the statement that `a` equals `b` is equivalent to the statement that `b` equals `a`. This is a fundamental property of equality, known as symmetry, which states that if `a` is equal to `b`, then `b` is also equal to `a`.

For all types `α` and elements `a, b` of `α`, `a = b` if and only if `b = a`.


theorem Set.univ_eq_empty_iff : ∀ {α : Type u}, Set.univ = ∅ ↔ IsEmpty α := by sorry

This theorem states that for any type `α`, the universal set of `α` is equivalent to an empty set if and only if `α` is an empty type. Here, the universal set of `α` is the set that contains all elements of the type `α`. The term `IsEmpty α` indicates that the type `α` has no elements, i.e., it's an 'empty type'. So, essentially, this theorem establishes a connection between a type being empty and its universal set being an empty set.

For any type `α`, the universal set of `α` is equal to the empty set if and only if `α` is an empty type.


theorem MvPowerSeries.coeff_C_mul :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R),
      (MvPowerSeries.coeff R n) ((MvPowerSeries.C σ R) a * φ) = a * (MvPowerSeries.coeff R n) φ :=
  by sorry

The theorem `MvPowerSeries.coeff_C_mul` states that, for any semiring `R`, any index set `σ`, any multivariate formal power series `φ` over `R` indexed by `σ`, any coefficient `a` in `R`, and any `n` in the power multi-set of `σ`, the `n`-th coefficient of the product of the constant multivariate formal power series defined by `a` and `φ` is equal to `a` times the `n`-th coefficient of `φ`. This means that, in the context of multivariate formal power series, multiplication by a constant behaves as expected with respect to coefficients.

For any semiring R, multivariate formal power series φ over R indexed by σ, coefficient a in R, and index n in the power multi-set of σ, the (n)-th coefficient of the product of the constant series a and φ is equal to a times the (n)-th coefficient of φ.


theorem Set.neg_subset : ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s t : Set α}, -s ⊆ t ↔ s ⊆ -t := by sorry

This theorem, `Set.neg_subset`, states that for any type `α` equipped with an `InvolutiveNeg` operation (that is, a negation operation which satisfies `neg (neg x) = x`), and for any two sets `s` and `t` of type `α`, the negation of set `s` is a subset of set `t` if and only if set `s` is a subset of the negation of set `t`. Here, the negation of a set `s` is defined as the set of all negated elements of `s`, and the subset relation `⊆` is defined in its usual sense: a set `s` is a subset of a set `t` if every element of `s` is also an element of `t`.

For sets `s` and `t` of an type `α` equipped with an `InvolutiveNeg` operation, `s ⊆ t` if and only if `neg t ⊆ neg s`.


theorem MeasureTheory.lintegral_eq_iSup_eapprox_lintegral :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      Measurable f →
        ∫⁻ (a : α), f a ∂μ = ⨆ n, MeasureTheory.SimpleFunc.lintegral (MeasureTheory.SimpleFunc.eapprox f n) μ :=
  by sorry

This theorem, `MeasureTheory.lintegral_eq_iSup_eapprox_lintegral`, states that for any measurable space `α`, a measure `μ` on `α`, and a measurable function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), the Lebesgue integral of `f` with respect to `μ` is equal to the supremum over all natural numbers `n` of the integral of the `n`-th approximation of `f` by simple functions. In other words, the Lebesgue integral of any measurable function can be approximated by the integral of a sequence of simple functions.

For any measurable space `α`, measure `μ` on `α`, and measurable function `f` from `α` to the extended nonnegative real numbers, the Lebesgue integral of `f` with respect to `μ` equals the supremum of the integrals of `n`-th approximations of `f` by simple functions, where the approximations are taken over all natural numbers `n`.


theorem Commute.mul_zpow :
    ∀ {α : Type u_1} [inst : DivisionMonoid α] {a b : α}, Commute a b → ∀ (i : ℤ), (a * b) ^ i = a ^ i * b ^ i := by
  sorry

This theorem states that for any type `α` that is a division monoid, given any two elements `a` and `b` of type `α` that commute (meaning `a * b = b * a`), and an integer `i`, the `i`th integer power of the product `a * b` is equal to the product of the `i`th integer powers of `a` and `b`. In other words, `(a * b) ^ i = a ^ i * b ^ i` for all `a`, `b` that commute and all integers `i`. This shows the distribution of exponentiation over multiplication for commuting elements in a division monoid.

For any commuting elements `a` and `b` in a division monoid `α`, and any integer `i`, the `i`th power of their product equals the product of their `i`th powers: `(a * b) ^ i = a ^ i * b ^ i`.


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

This theorem states that for any types `α` and `β`, given a topological space, a preorder, and an order-closed topology on `α`, two functions `f` and `g` from `β` to `α`, a filter `b` on `β`, and two elements `a₁` and `a₂` of `α`, if the filter `b` is not bottom, the limit of `f` at `b` is a neighborhood of `a₁`, the limit of `g` at `b` is a neighborhood of `a₂`, and for all `x` in `β`, `f(x)` is less than or equal to `g(x)`, then `a₁` is less than or equal to `a₂`. In other words, if `f` and `g` are functions such that `f(x)` is always less than or equal to `g(x)` for all `x` and both `f` and `g` tend to limits `a₁` and `a₂` at the same filter `b`, then the limit `a₁` of `f` is less than or equal to the limit `a₂` of `g`.

If `f` and `g` are functions from a preordered set `β` to an order-closed topological space `α`, with `f(x) ≤ g(x)` for all `x`, and `a₁` and `a₂` are the limits of `f` and `g`, respectively, at a non-bottom filter `b`, then `a₁ ≤ a₂`.


theorem Real.volume_Icc_pi :
    ∀ {ι : Type u_1} [inst : Fintype ι] {a b : ι → ℝ},
      ↑↑MeasureTheory.volume (Set.Icc a b) = Finset.prod Finset.univ fun i => ENNReal.ofReal (b i - a i) :=
  by sorry

This theorem, `Real.volume_Icc_pi`, states that for every finite type ι, and for any two functions `a` and `b` that map from this type to the set of real numbers, the measure (or "volume") of the closed interval from `a` to `b` in the real line (as given by `Set.Icc a b`) is equal to the product, over all elements of the universe of the type ι, of the nonnegative part of the difference between the value of `b` and `a` at each element (as given by `ENNReal.ofReal (b i - a i)`). In simpler terms, it calculates the "volume" of a multidimensional box, where the box's dimensions are specified by the differences between the values of `b` and `a` at each point in ι.

The volume of a closed real interval with endpoints given by functions mapping from a type ι to the real numbers is equal to the product of the nonnegative differences between the function values at each index in ι.


/-- **Alias** of the reverse direction of `ENNReal.ofReal_eq_zero`. -/
theorem ENNReal.ofReal_of_nonpos : ∀ {p : ℝ}, p ≤ 0 → ENNReal.ofReal p = 0 := by sorry

This theorem, named `ENNReal.ofReal_of_nonpos`, states that for any real number `p`, if `p` is less than or equal to zero, then the function `ENNReal.ofReal` applied to `p` will return zero. In mathematical terms, for all real numbers `p`, if `p ≤ 0` then `ENNReal.ofReal(p) = 0`. This theorem is the reverse direction of the theorem `ENNReal.ofReal_eq_zero`.

For all real numbers `p`, if `p <= 0`, then `ENNReal.ofReal(p) = 0`.


theorem Decidable.not_and_iff_or_not_not : ∀ {a b : Prop} [inst : Decidable a], ¬(a ∧ b) ↔ ¬a ∨ ¬b := by sorry

This theorem, `Decidable.not_and_iff_or_not_not`, states the relationship between logical negation, conjunction, and disjunction properties for any given propositions `a` and `b`. Specifically, it declares that not both `a` and `b` being true is equivalent to either `a` is not true or `b` is not true. This is applicable when `a` is a decidable proposition. The theorem codifies a basic law of logic, known as De Morgan's laws.

The theorem `Decidable.not_and_iff_or_not` in Lean 4 states that for any decidable propositions `a` and `b`, `~(a ∧ b)` is equivalent to `(~a) ∨ (~b)`.


theorem Finsupp.mapDomain_add :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {v₁ v₂ : α →₀ M} {f : α → β},
      Finsupp.mapDomain f (v₁ + v₂) = Finsupp.mapDomain f v₁ + Finsupp.mapDomain f v₂ :=
  by sorry

The theorem `Finsupp.mapDomain_add` asserts that for any two finitely supported functions `v₁` and `v₂` from a type `α` to a type `M` (under the structure of an additive commutative monoid), and a function `f` from `α` to `β`, the operation of mapping the domain of the sum of `v₁` and `v₂` through `f` is equivalent to the sum of the operations of mapping the domain of `v₁` and `v₂` separately through `f`. In mathematical terms, it captures the property that the mapDomain function distributes over the addition of finitely supported functions.

For any additive commutative monoids M and types α and β, given finitely supported functions v₁, v₂ from α to M and a function f from α to β, the map of the domain of v₁ + v₂ along f is equal to the map of the domains of v₁ and v₂ along f added pointwise.


Algebra.FinitePresentation.quotient

/-- The quotient of a finitely presented algebra by a finitely generated ideal is finitely
presented.  -/
theorem Algebra.FinitePresentation.quotient :
    ∀ {R : Type w₁} {A : Type w₂} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {I : Ideal A},
      Ideal.FG I → Algebra.FinitePresentation R A → Algebra.FinitePresentation R (A ⧸ I) :=
  by sorry

The theorem `Algebra.FinitePresentation.quotient` states that for any commutative ring `R` and any commutative ring `A` with an algebra structure over `R`, and any ideal `I` of `A`, if `I` is a finitely generated ideal and `A` is a finitely presented `R`-algebra, then the quotient ring `A/I` is also a finitely presented `R`-algebra. It says that the property of being finitely presented is preserved when taking quotients by finitely generated ideals.

If `R` is a commutative ring, `A` is a commutative `R`-algebra that is finitely presented, and `I` is a finitely generated ideal of `A`, then `A/I` is also a finitely presented `R`-algebra.


theorem max_le_add_of_nonneg :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : AddZeroClass α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      0 ≤ a → 0 ≤ b → max a b ≤ a + b :=
  by sorry

The theorem `max_le_add_of_nonneg` states that for any type `α` equipped with a linear order, the structure of an additive zero class, and the property that addition is covariant in both arguments, if `a` and `b` are elements of `α` and both are nonnegative (i.e., greater than or equal to zero), then the maximum of `a` and `b` is less than or equal to the sum of `a` and `b`. In mathematical symbols, it states that if `0 ≤ a` and `0 ≤ b`, then `max(a, b) ≤ a + b`.

For any type with a linear order, additive zero, and covariant addition, if `a` and `b` are nonnegative elements, then `max(a, b) ≤ a + b`.


theorem Set.range_restrictPreimage :
    ∀ {α : Type u_1} {β : Type u_2} (t : Set β) (f : α → β),
      Set.range (Set.restrictPreimage t f) = Subtype.val ⁻¹' Set.range f :=
  by sorry

This theorem states that for any types `α` and `β`, for any set `t` of type `β`, and for any function `f` from `α` to `β`, the range of the restriction of `f` onto the preimage of `t` is equal to the preimage under the `val` function (that retrieves the underlying element from a subtype) of the range of `f`. In simpler terms, this theorem is about the connection between the range of a function restricted to a subset of its domain (in particular, the preimage of another set) and the range of the original function.

For any functions \(f : \alpha \to \beta\), sets \(t \subseteq \beta\), and preimage \(s = \exists x : \beta. x \in t \land f(x) \in \operatorname{range}(f)\), \(\operatorname{range}(f|_s) = \operatorname{image}(\operatorname{val}|_{\operatorname{range}(f)}) \cap t\).


theorem Mathlib.Data.Set.Finite._auxLemma.28 : ∀ {α : Type u} (a : α), Set.Finite {a} = True := by sorry

The theorem `Mathlib.Data.Set.Finite._auxLemma.28` states that for all types `α` and any element `a` of type `α`, the set containing only the element `a` is finite. This is trivially true as the set contains exactly one element, hence there exists a natural number `n` (in this case, `n` is 1) and an equivalence between the set `{a}` and the finite set `Fin n`, satisfying the definition of a finite set.

The set consisting of a single element is finite.


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

The theorem `Set.iUnion_subtype` states that for any type `α` and `β`, and any property `p` of `α` and a function `s` that maps elements of `α` satisfying `p` to sets of `β`, the union over all `x` of the sets `s` of `x` is equal to the union over all `x`, and for those `x` that satisfy the property `p`, of the sets `s` of `x` with the property `p`. In other words, this theorem expresses the equality of two different ways of forming a union of sets, one in which the sets are indexed by elements satisfying a certain property, and another where the sets are indexed by elements directly, but the union is only taken over elements that satisfy the property.

For any type `α`, property `p` of `α`, and function `s : α → Set β`, the union of `{x : α | p x} Map s = (⋃x : α. p x) s x`.


theorem Nat.eq_zero_of_add_eq_zero : ∀ {n m : ℕ}, n + m = 0 → n = 0 ∧ m = 0 := by sorry

This theorem states that for all natural numbers `n` and `m`, if the sum of `n` and `m` equals zero, then both `n` and `m` must be zero. This is because there are no natural numbers (which include zero and all positive integers) that you can add together to give a negative number, so the only way for two natural numbers to add to zero is if they are both zero.

If two natural numbers `n` and `m` have the property that `n + m = 0`, then both `n` and `m` are equal to zero.


theorem Mathlib.Data.Set.Finite._auxLemma.15 :
    ∀ {α : Type u} {s : Set α} {h : Set.Finite s}, (Set.Finite.toFinset h = ∅) = (s = ∅) := by sorry

This theorem states that for any given type `α` and any set `s` of that type, if the set `s` is finite (denoted by `h : Set.Finite s`), then the finiteness of the set `s` being converted to a finite set (using the `Set.Finite.toFinset` function) equals the empty set if and only if the set `s` itself equals the empty set. In other words, the conversion of a finite set to a finite set results in an empty set if and only if the original set was empty.

For any type `α` and finite set `s` of that type, `Set.Finite.toFinset s = {} <> s` if and only if `s = {}`.


SimpleGraph.IsNClique.mono

theorem SimpleGraph.IsNClique.mono :
    ∀ {α : Type u_1} {G H : SimpleGraph α} {n : ℕ} {s : Finset α},
      G ≤ H → SimpleGraph.IsNClique G n s → SimpleGraph.IsNClique H n s :=
  by sorry

This theorem states that for any two simple graphs `G` and `H` of type `α`, a natural number `n`, and a finite set `s` of type `α`, if `G` is a subgraph of `H` (`G ≤ H`) and `s` is an `n`-clique in `G` (`SimpleGraph.IsNClique G n s`), then `s` is also an `n`-clique in `H` (`SimpleGraph.IsNClique H n s`). In other words, an `n`-clique in a subgraph remains an `n`-clique in the supergraph.

If `G` is a subgraph of `H` and `s` is an `n`-clique in `G`, then `s` is an `n`-clique in `H`.


HasFPowerSeriesAt.hasFDerivAt

theorem HasFPowerSeriesAt.hasFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {p : FormalMultilinearSeries 𝕜 E F} {f : E → F} {x : E},
      HasFPowerSeriesAt f p x → HasFDerivAt f ((continuousMultilinearCurryFin1 𝕜 E F) (p 1)) x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and a function `f` mapping `E` to `F`, if `f` has a formal power series expansion at a point `x` in `E`, then `f` also has a derivative at `x`. The derivative is the continuous linear map given by applying the continuous multilinear curry function to the first term of the power series, effectively obtaining the linear term of the power series as the derivative.

If `f` is a function from a normed additive commutative group `E` to another normed additive commutative group `F` over a non-trivially normed field, and `f` has a formal power series expansion at a point `x` in `E`, then `f` has a derivative at `x` given by the continuous linear map that is the application of the multilinear curry function to the first term of `f`'s power series.


theorem Function.LinearMap.exact_iff :
    ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} {R : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P},
      Function.Exact ⇑f ⇑g ↔ LinearMap.ker g = LinearMap.range f :=
  by sorry

This theorem states that for any three types `M`, `N`, and `P` and a type `R` with a commutative semiring structure, and given additive commutative monoid structures on `M`, `N`, and `P`, as well as `R`-module structures on `M`, `N`, and `P`, for any linear maps `f` from `M` to `N` and `g` from `N` to `P`, the maps `f` and `g` form an exact pair if and only if the kernel of `g` is equal to the range of `f`. Here, an exact pair of maps means that for any element `y` from `N`, `g` of `y` equals to zero if and only if `y` is in the image of `f`.

Given commutative semirings R, types M, N, P with additive commutative monoid and R-module structures, maps f : M -> N and g : N -> P are exact pairs if and only if the kernel of g equals the range of f.


theorem Commute.add_right :
    ∀ {R : Type x} [inst : Distrib R] {a b c : R}, Commute a b → Commute a c → Commute a (b + c) := by sorry

This theorem states that for any type `R` that has a distributive property (denoted by `[inst : Distrib R]`), if two elements `a` and `b` commute, and `a` and `c` also commute, then `a` commutes with the sum of `b` and `c`. In other words, if `a * b = b * a` and `a * c = c * a`, then `a * (b + c) = (b + c) * a`. This is a property that is closely related to the distributivity of multiplication over addition in the given type `R`.

If `R` is a distributive type with elements `a`, `b`, and `c` such that `a` commutes with both `b` and `c`, then `a` commutes with their sum, `b + c`. That is, `a * (b + c) = (b + c) * a`.


theorem CategoryTheory.Idempotents.KaroubiKaroubi.idem_f :
    ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
      (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C)),
      CategoryTheory.CategoryStruct.comp P.p.f P.p.f = P.p.f :=
  by sorry

This theorem is a statement in category theory. It states that for any category `C` and any idempotent `P` in the category of idempotents of `C`, the composition of the morphism `P.p.f` with itself (written `P.p.f ≫ P.p.f` in category theory) is equal to `P.p.f`. In other words, the morphism `P.p.f` is idempotent in its category.

For any idempotent `P` in a category `C`, the morphism `P.p.f` is idempotent, i.e., `P.p.f ≫ P.p.f = P.p.f`.


/-- The closed thickening is a closed set.  -/
theorem Metric.isClosed_cthickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} {E : Set α}, IsClosed (Metric.cthickening δ E) := by sorry

This theorem states that in any pseudo emetric space, the closed δ-thickening of a subset is a closed set. To elaborate, given a subset E of some type α, where α boasts a pseudo emetric space structure, and a real number δ, the "closed δ-thickening" of E is always a closed set. Here, the "closed δ-thickening" of E, denoted as `Metric.cthickening δ E`, refers to the collection of points in α that are at an infimum (or minimum) distance of at most δ from the subset E.

In any pseudo metric space, the closed δ-thickening of a subset is a closed set. That is, `Metric.cthickening δ E` is a closed subset of the space for any subset `E` and real number `δ`.


theorem List.get?_len_le : ∀ {α : Type u_1} {l : List α} {n : ℕ}, List.length l ≤ n → List.get? l n = none := by sorry

This theorem states that for any type `α`, any list `l` of type `α`, and any natural number `n`, if the length of the list `l` is less than or equal to `n`, then the `n`th element of list `l` does not exist. In essence, you can't retrieve an element `n` positions into the list if `n` is not less than the length of the list. This result is also consistent with the zero-indexing convention in most programming languages, including Lean 4.

For any type `α`, list `l` of length `m` in `α`, and natural number `n` with `n > m`, the `n`th element of `l` does not exist.


theorem rank_pos_iff_nontrivial :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      [inst_4 : NoZeroSMulDivisors R M], 0 < Module.rank R M ↔ Nontrivial M :=
  by sorry

This theorem states that for a given ring `R` and an additive commutative group `M`, which is also a module over `R`, the rank of the module `M` is greater than 0 if and only if `M` is nontrivial, given that `R` is nontrivial and there are no zero scalar multiplicative divisors in `R` and `M`. In mathematical terms, it means that the dimension of a vector space (which is equivalent to the rank of a module in this context) is positive if and only if that vector space is nontrivial (i.e., it contains more than just the zero vector).

The rank of a nontrivial additive commutative group `M` over a nontrivial ring `R` without zero scalar multiplicative divisors is positive.


theorem CategoryTheory.ShortComplex.p_fromOpcycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.pOpcycles S)
          (CategoryTheory.ShortComplex.fromOpcycles S) =
        S.g :=
  by sorry

The theorem `CategoryTheory.ShortComplex.p_fromOpcycles` states that for any Category `C` that has zero morphisms, and any Short Complex `S` in that Category that has right homology, the composition of the projection `S.X₂ ⟶ S.opcycles` (represented as `CategoryTheory.ShortComplex.pOpcycles S`) and the morphism `fromOpcycles S` is equal to the morphism `S.g`. In other words, in the context of category theory, this theorem demonstrates that certain morphisms in a short complex satisfy a specific compositional relationship.

For any Short Complex `S` in a Category with zero morphisms having right homology, `CategoryTheory.ShortComplex.pOpcycles S` composing with `fromOpcycles S` equals `S.g`.


theorem MeasureTheory.StronglyMeasurable.ennnorm :
    ∀ {α : Type u_1} {x : MeasurableSpace α} {β : Type u_5} [inst : SeminormedAddCommGroup β] {f : α → β},
      MeasureTheory.StronglyMeasurable f → Measurable fun a => ↑‖f a‖₊ :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.ennnorm` states that for any type `α` with a `MeasurableSpace` structure, any type `β` with a `SeminormedAddCommGroup` structure, and any function `f` from `α` to `β`, if `f` is strongly measurable (that is, it is the limit of simple functions), then the function that maps each element `a` in `α` to the seminorm of `f(a)` is also measurable. In other words, the seminorm function preserves measurability when applied to a strongly measurable function.

If `f` is a strongly measurable function from a measurable space `(α, Σ)` to a seminormed additive commutative group `(β, ∥.∥)`, then the function `x ↦ ∥f(x)∥` is measurable.


/-- If a function admits a finite power series expansion `p` on an open ball `B (x, r)`, then
it is continuously polynomial at every point of this ball.  -/
theorem HasFiniteFPowerSeriesOnBall.cPolynomialAt_of_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {r : ENNReal} {n : ℕ} {x y : E},
      HasFiniteFPowerSeriesOnBall f p x n r → y ∈ EMetric.ball x r → CPolynomialAt 𝕜 f y :=
  by sorry

This theorem states that if a function `f` from type `E` to `F` admits a finite power series expansion `p` on an open ball centered at `x` with radius `r` in a non-trivially normed field `𝕜`, then the function `f` is continuously polynomial at every point `y` within this ball. In other words, if a function can be represented by a finite power series within a certain region in the domain, it behaves as a polynomial function at each point in this region.

If a function `f` from type `E` to `F` admits a finite power series expansion on an open ball centered at `x` in a non-trivially normed field `𝕜`, then `f` is continuously polynomial on this ball.


theorem Mathlib.CategoryTheory.Iso._auxLemma.10 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f]
      {g h : Z ⟶ X}, (CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) :=
  by sorry

This theorem states that in any category `C`, for any objects `X`, `Y`, `Z` in `C`, and a monomorphism `f` from `X` to `Y`, if `g` and `h` are morphisms from `Z` to `X`, then the composition of `g` and `f` is equal to the composition of `h` and `f` if and only if `g` is equal to `h`. The condition of `f` being a monomorphism, in category theory, means that `f` is left-cancellable, i.e., for any pair of morphisms `g` and `h`, if the composition of `g` and `f` equals the composition of `h` and `f`, then `g` must equal `h`.

In any category, if a morphism is a monomorphism and given objects X, Y, Z with morphisms g and h from Z to X, then g = h if and only if the composition of g and f equals the composition of h and f.


theorem PrimeSpectrum.mem_vanishingIdeal :
    ∀ {R : Type u} [inst : CommSemiring R] (t : Set (PrimeSpectrum R)) (f : R),
      f ∈ PrimeSpectrum.vanishingIdeal t ↔ ∀ x ∈ t, f ∈ x.asIdeal :=
  by sorry

This theorem states that for any commutative semiring `R`, a set `t` of prime spectra of `R`, and an element `f` of `R`, `f` is a member of the vanishing ideal of `t` if and only if for every prime spectrum `x` in `t`, `f` is an element of the ideal associated with `x`. In simpler terms, it provides a criterion for an element to belong to the vanishing ideal of a set of prime spectra: it must belong to the ideal of each prime spectrum in the set.

For any commutative semiring R, an element f of R belongs to the vanishing ideal of a set T of its prime spectra if and only if it is contained in the ideal associated with each prime spectrum x in T.


theorem TopologicalSpace.IsTopologicalBasis.nhds_hasBasis :
    ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
      TopologicalSpace.IsTopologicalBasis b → ∀ {a : α}, Filter.HasBasis (nhds a) (fun t => t ∈ b ∧ a ∈ t) fun t => t :=
  by sorry

This theorem states that for any type 'α' with a topology 't' and a set 'b' of subsets of 'α' which forms a topological basis, then for any element 'a' of 'α', the neighborhood filter of 'a' has a filter basis given by the set of those elements of 'b' which not only contain 'a' but are also themselves present in 'b'. In other words, it's ensuring that the neighborhood of any point in a topological space can be generated by sets from a topological basis that contain the given point.

For any topological space ('α', 't'), and topological basis 'b' of 'α', the neighborhood filter of any point 'a' in 'α' has 'b' as a filter basis, i.e., the neighborhood filter of 'a' is the smallest filter containing all sets in 'b' that include 'a'.


theorem DFinsupp.toMultiset_toDFinsupp :
    ∀ {α : Type u_1} [inst : DecidableEq α] (f : Π₀ (x : α), ℕ), Multiset.toDFinsupp (DFinsupp.toMultiset f) = f := by
  sorry

This theorem states that for any type `α` that has decidable equality, given a function `f` mapping each element in `α` to a natural number (as a direct sum), the operation of first converting `f` to a multiset using `DFinsupp.toMultiset` and then back to a function using `Multiset.toDFinsupp` is the identity operation on `f`. In other words, going from a direct sum to a multiset and back leaves the original direct sum function `f` unchanged.

For any type `α` with decidable equality, the function `DFinsupp.toMultiset ∘ DFinsupp.fromMultiset` is the identity on functions from `α` to the natural numbers as direct sums.


theorem Mathlib.Order.Hom.Basic._auxLemma.12 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β) {a b : α},
      (f a < f b) = (a < b) :=
  by sorry

This theorem, named `Mathlib.Order.Hom.Basic._auxLemma.12`, asserts that for any two types `α` and `β` that are both preordered, and given an order-embedding function `f` from `α` to `β`, and any two elements `a` and `b` of `α`, the inequality `f(a) < f(b)` holds if and only if `a < b` holds. This theorem essentially says that the order-embedding function `f` preserves the strict less-than order of the elements from `α`.

For any preordered types `α` and `β`, and order-embedding `f` from `α` to `β`, if `a < b` in `α`, then `f(a) < f(b)` in `β`.


theorem Filter.Tendsto.div_atTop :
    ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜]
      [inst_2 : OrderTopology 𝕜] {l : Filter α} {f g : α → 𝕜} {a : 𝕜},
      Filter.Tendsto f l (nhds a) → Filter.Tendsto g l Filter.atTop → Filter.Tendsto (fun x => f x / g x) l (nhds 0) :=
  by sorry

This theorem states that for any types `𝕜` and `α`, where `𝕜` is a linearly ordered field with a topological structure and an order topology, and `α` is an arbitrary type with a filter `l` and two functions `f` and `g` from `α` to `𝕜`. If the function `f` tends toward a value `a` in the neighborhood filter at `a` as we approach any point in the filter `l`, and the function `g` tends to infinity (represented by `Filter.atTop`) as we approach any point in the filter `l`, then the function that sends each point `x` in `α` to the ratio `f(x)/g(x)` tends towards 0 in the neighborhood filter at `0` as we approach any point in the filter `l`. This theorem essentially provides a condition under which the quotient of two functions tends to 0.

If `𝕜` is a linearly ordered field with a topology and `α` is a type with filter `l`, given functions `f : α → 𝕜` converging to `a` in `l` and `g : α → 𝕜` approaching infinity in `l`, then the ratio function `x ↦ f(x) / g(x)` converges to 0 in the neighborhood filter at 0 as we approach any point in `l`.


theorem PiLp.nnnorm_eq_of_L2 :
    ∀ {ι : Type u_2} [inst : Fintype ι] {β : ι → Type u_5} [inst_1 : (i : ι) → SeminormedAddCommGroup (β i)]
      (x : PiLp 2 β), ‖x‖₊ = NNReal.sqrt (Finset.sum Finset.univ fun i => ‖x i‖₊ ^ 2) :=
  by sorry

This theorem states that for any type `ι` which is a finite type, and any function `β : ι → Type` such that for each `i : ι` the type `β i` forms a seminormed additively commutative group, the non-negative norm of a function `x` of type `PiLp 2 β` (which is a family of types equipped with a pseudo-metric space structure, where each type is a copy of a certain Pi type endowed with an `L^2` distance) is equal to the square root of the sum over all elements in `ι` of the square of the non-negative norm of `x i`. In mathematical notation, this would be represented as ‖x‖₊ = √(∑_{i ∈ ι} ‖x i‖₊²).

For any finite type `ι` and function `β : ι → Type` where each `β i` forms a seminormed additively commutative group, the `L^2` norm of a function `x : PiLp 2 β` equals the square root of the sum of the squares of the non-negative norms of `x i` over all `i ∈ ι`.


theorem isClosed_iff_clusterPt :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X],
      IsClosed s ↔ ∀ (a : X), ClusterPt a (Filter.principal s) → a ∈ s :=
  by sorry

This theorem states that for any type `X` and a set `s` of `X` under a certain topological space, the set `s` is closed if and only if for every point `a` in `X`, if `a` is a cluster point of the principal filter of `s`, then `a` belongs to `s`. In other words, a set is closed when all of its cluster points, with respect to the principal filter of the set, are contained within the set itself.

A set `s` under a topological space is closed if and only if every cluster point of `s` with respect to its principal filter belongs to `s`.


theorem monotone_Iio : ∀ {α : Type u_1} [inst : Preorder α], Monotone Set.Iio := by sorry

The theorem `monotone_Iio` states that for any type `α` that has a preorder (a binary relation that is both reflexive and transitive), the function `Set.Iio` is monotone. In other words, if we have two elements `a` and `b` of type `α` such that `a` is less than or equal to `b`, then the left-infinite right-open interval ending at `a` is a subset of the left-infinite right-open interval ending at `b`. This can be written in mathematical notation as: for all `a` and `b` in `α`, if `a ≤ b` then `{x | x < a} ⊆ {x | x < b}`.

For any type `α` with a preorder, the function `Set.Iio` maps smaller elements to smaller sets: `{x | x < a} ⊆ {x | x < b}` when `a ≤ b`.


theorem Set.sUnion_insert : ∀ {α : Type u_1} (s : Set α) (T : Set (Set α)), ⋃₀ insert s T = s ∪ ⋃₀ T := by sorry

This theorem, `Set.sUnion_insert`, states that for any type `α` and any set `s` of type `α`, and another set `T` of sets of type `α`, the union over the set obtained by inserting `s` into `T` is equivalent to the union of `s` and the union over `T`. In terms of set theory, it is equivalent to saying: the union over all the sets in the collection where one additional set `s` is inserted, is the same as the union of that set `s` with the union over the original collection of sets. This theorem is analogous in structure to a fundamental property of unions in set theory.

For any type `α` and set `s` of type `α`, and any set `T` of sets of type `α`, the set `s ∪ (⋃ t ∈ T : t)` equals `s ∪ (⋃ t ∈ T : t)`.


theorem monotone_Iic : ∀ {α : Type u_1} [inst : Preorder α], Monotone Set.Iic := by sorry

The theorem `monotone_Iic` states that for any type `α` with a preorder structure, the function `Set.Iic` is monotone. In other words, if `a ≤ b` for some `a` and `b` of type `α`, then the set of all elements less than or equal to `a` is a subset of the set of all elements that are less than or equal to `b`. This is the mathematical way of saying that the interval "up to `a`" is contained in the interval "up to `b`" when `a` is less than or equal to `b`.

For any preordered type `α`, the set inclusion `Set.Iic a ⊆ Set.Iic b` holds when `a ≤ b`.


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

**Lagrange's Theorem**: For any additive group `α` that has a finite number of elements, and for any additive subgroup `s` of `α` that also has a finite number of elements, the size of the subgroup `s` (denoted as `Fintype.card ↥s`) is a divisor of the size of the group `α` (denoted as `Fintype.card α`). In other words, the number of elements in the group is an integer multiple of the number of elements in the subgroup.

For any finite additive group `α` and its finite subgroup `s`, the order of `s` divides the order of `α`.


theorem Subgroup.range_mem_leftTransversals :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {f : G ⧸ H → G},
      (∀ (q : G ⧸ H), ↑(f q) = q) → Set.range f ∈ Subgroup.leftTransversals ↑H :=
  by sorry

This theorem states that for any group `G` and subgroup `H` of `G`, and for any function `f` from the quotient group `G ⧸ H` to `G` (where `G ⧸ H` is the set of all left cosets of `H` in `G`), if the function `f` maps each element of `G ⧸ H` to a representative of that element in `G` (i.e., for all `q` in `G ⧸ H`, the coset of `f(q)` is `q`), then the range of `f` is a left complement of `H` in `G`.

In simpler terms, the theorem ensures that if we choose one representative from each coset of `H` in `G`, the set of all such representatives forms a left complement of `H` in `G`. A left complement of `H` in `G` is a subset of `G` such that every element of `G` can be uniquely written as the product of an element from the subset and an element from `H`.

If `f` is a function from the quotient group `G ⧸ H` to `G` such that for all `q` in `G �agi H`, the coset of `f(q)` is `q`, then the range of `f` is a left complement of `H` in `G`.


theorem Ordinal.nat_lt_card : ∀ {o : Ordinal.{u_3}} {n : ℕ}, ↑n < Ordinal.card o ↔ ↑n < o := by sorry

The theorem `Ordinal.nat_lt_card` states that for any ordinal `o` and natural number `n`, the cardinality of the ordinal `n` is less than the cardinal of the ordinal `o` if and only if the ordinal `n` is less than the ordinal `o`. Essentially, it shows that the inequality relationship between two natural numbers, when lifted to the level of their corresponding ordinals, corresponds directly to the inequality relationship between their cardinalities.

For any ordinal numbers `o` and `n`, `n < o` if and only if the cardinality of `n` is less than the cardinality of `o`.


theorem isUnit_of_mul_isUnit_right : ∀ {M : Type u_1} [inst : CommMonoid M] {x y : M}, IsUnit (x * y) → IsUnit y := by
  sorry

This theorem states that for any type `M` that is a commutative monoid (which implies that the operation of the monoid is commutative), if an element `y` of `M` is such that the product of `y` and any other element `x` in `M` is a unit (i.e., it has a two-sided inverse), then `y` itself must also be a unit. In other words, if the product of `x` and `y` is an element that possesses an inverse, then `y` must also possess an inverse.

If `M` is a commutative monoid and `y` in `M` has a two-sided inverse for every `x` in `M`, then `y` is a unit in `M`.


variationOnFromTo.add

theorem variationOnFromTo.add :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] {f : α → E} {s : Set α},
      LocallyBoundedVariationOn f s →
        ∀ {a b c : α},
          a ∈ s → b ∈ s → c ∈ s → variationOnFromTo f s a b + variationOnFromTo f s b c = variationOnFromTo f s a c :=
  by sorry

This theorem states that for any function `f` of type `α → E`, where `α` has a linear order and `E` is a pseudo-emetric space, and any set `s` of type `α`, if the function `f` has locally bounded variation on the set `s`, then for any three elements `a`, `b`, `c` of the set `s`, the sum of the variation of `f` on the interval from `a` to `b` and the variation of `f` on the interval from `b` to `c` equals the variation of `f` on the interval from `a` to `c`. In mathematical terms, the theorem asserts that if `f` has locally bounded variation on `s`, then for all `a`, `b`, `c` in `s`, `V_f(a, b) + V_f(b, c) = V_f(a, c)`, where `V_f(a, b)` denotes the variation of `f` from `a` to `b`.

Given a function `f` of type `α → E` on a linearly ordered set `α` with locally bounded variation, the sum of the variations of `f` between any three consecutive elements equals the variation between the first and the last. In other words, for all `a`, `b`, `c` in `α`, `V_f(a, b) + V_f(b, c) = V_f(a, c)`.


/-- If a function `f` with a densely ordered codomain is monotone on a right neighborhood of `a` and
the closure of the image of this neighborhood under `f` is a right neighborhood of `f a`, then `f`
is continuous at `a` from the right.  -/
theorem continuousWithinAt_right_of_monotoneOn_of_closure_image_mem_nhdsWithin :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : LinearOrder β] [inst_4 : TopologicalSpace β] [inst_5 : OrderTopology β] [inst_6 : DenselyOrdered β]
      {f : α → β} {s : Set α} {a : α},
      MonotoneOn f s →
        s ∈ nhdsWithin a (Set.Ici a) →
          closure (f '' s) ∈ nhdsWithin (f a) (Set.Ici (f a)) → ContinuousWithinAt f (Set.Ici a) a :=
  by sorry

This theorem states that if we have a function `f` from type `α` to type `β`, where `β` is densely ordered, and this function is monotone on a subset `s` of `α` that lies in the right neighborhood of a point `a` in `α`, then under certain conditions `f` is continuous at `a` from the right. The specific conditions are: the closure of the image of this subset `s` under `f` is itself a right neighborhood of the image of `a` under `f`. In mathematical terms, this theorem deals with the continuity of monotone functions on right neighborhoods using closure of function images and dense orders.

If `f` is a monotone function from a dense order `α` to a dense order `β`, and the closure of `f`'s image of a right neighborhood of `a` in `α` contains `f(a)` as an interior point, then `f` is continuous at `a` from the right.


theorem Mathlib.Data.Rat.Cast.CharZero._auxLemma.3 :
    ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α] (m n : ℚ), ↑m + ↑n = ↑(m + n) := by sorry

This theorem takes a type `α`, which is a division ring and has characteristic zero, along with two rational numbers `m` and `n`. It states that the sum of the casted values of `m` and `n` to the type `α` is equal to the casted value of the sum of `m` and `n` to the type `α`. In other words, the process of casting from rationals to type `α` preserves the addition operation. This can be expressed mathematically as: if `m` and `n` are rational numbers and `α` is a type with certain properties, then `↑m + ↑n = ↑(m + n)`.

If `α` is a division ring of characteristic zero, then for all rational numbers `m` and `n`, `↑(m + n) = ↑m + ↑n`, where `↑` denotes casting from rationals to type `α`.


theorem WithZero.zero_le : ∀ {α : Type u_1} [inst : Preorder α] (a : WithZero α), 0 ≤ a := by sorry

The theorem `WithZero.zero_le` states that for any type `α` which has a defined `Preorder` (a mathematical structure that captures the intuitive notion of an ordering that is "less than", "equal to", or "greater than"), when we add an extra element `0` to this type to create `WithZero α`, the new element `0` is less than or equal to any other element `a` in `WithZero α`. In other words, `0` is the least element in the `WithZero α` structure for all possible values of `α` that have a `Preorder` structure.

For any type `α` with a `Preorder`, the zero element `0` in `WithZero α` is less than or equal to any element `a` in `WithZero α`.


theorem Mathlib.Topology.Separation._auxLemma.5 : ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the statement that `a` and `b` and `c` are all true is equivalent to the statement that `b` and `a` and `c` are all true. In other words, the order in which we consider the conjunction of propositions does not matter.

The theorem asserts that for any propositions `a`, `b`, and `c`, the conjunctions `a ∧ b ∧ c` and `b ∧ a ∧ c` are logically equivalent.


theorem Complex.sin_two_mul : ∀ (x : ℂ), Complex.sin (2 * x) = 2 * Complex.sin x * Complex.cos x := by sorry

The theorem `Complex.sin_two_mul` states that for all complex numbers `x`, the sine of `2x` is equal to `2` times the sine of `x` times the cosine of `x`. This is the complex number version of the double-angle formula in trigonometry, which in mathematical notation is expressed as $\sin(2x) = 2 \sin(x) \cos(x)$.

The complex sine function satisfies the double-angle identity: $\sin(2x) = 2\sin(x)\cos(x)$.


theorem Mathlib.Topology.Separation._auxLemma.2 :
    ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (b ∧ ∃ x, p x) = ∃ x, b ∧ p x := by sorry

This theorem, named `Mathlib.Topology.Separation._auxLemma.2`, states that for any type `α`, any predicate `p` on `α`, and any proposition `b`, the conjunction of `b` and the existence of an element of `α` satisfying `p` is logically equivalent to the existence of an element of `α` such that `b` and `p` both hold for that element. In other words, it's stating that the proposition `b` can be distributed inside the existential quantifier.

For any type `α`, proposition `b`, and predicate `p` on `α`, the statements `∃x : α, p x ∧ b` and `∃x : α, p x ∧ b holds` are logically equivalent.


theorem IsOpen.exterior_eq : ∀ {α : Type u_3} [inst : TopologicalSpace α] {s : Set α}, IsOpen s → exterior s = s := by
  sorry

This theorem states that for any set `s` in a topological space `α`, if `s` is an open set, then the exterior of `s` is equal to `s` itself. In other words, for all open sets in a topological space, the intersection of all their neighborhoods (which is the definition of the exterior of a set) is the set itself. This theorem highlights a key property of open sets in a topological space.

In a topological space, the exterior of an open set is equal to the set itself.


theorem Set.Ioc_union_left :
    ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a ≤ b → Set.Ioc a b ∪ {a} = Set.Icc a b := by sorry

This theorem states that for any partially ordered type `α` and any two elements `a` and `b` of `α` where `a` is less than or equal to `b`, the union of the left-open right-closed interval from `a` to `b` (`Set.Ioc a b`) and the singleton set containing `a` is equal to the left-closed right-closed interval from `a` to `b` (`Set.Icc a b`). In other words, if we add the left endpoint `a` to the interval `(a, b]`, we get the interval `[a, b]`.

For any partially ordered type `α` and elements `a` and `b` in `α` with `a ≤ b`, `Set.Ioc a b ∪ {a} = Set.Icc a b`.


theorem IsCoprime.prod_right :
    ∀ {R : Type u} {I : Type v} [inst : CommSemiring R] {x : R} {s : I → R} {t : Finset I},
      (∀ i ∈ t, IsCoprime x (s i)) → IsCoprime x (Finset.prod t fun i => s i) :=
  by sorry

The theorem `IsCoprime.prod_right` states that for any given type `R` with a commutative semiring structure, a type `I`, an element `x` of type `R`, a function `s` from `I` to `R`, and a finite set `t` of elements of type `I`, if for every element `i` in `t`, `x` and `s i` are coprime (that is, there exist elements `a` and `b` such that `a * x + b * s i = 1`), then `x` is also coprime with the product of `s i` as `i` ranges over the elements of `t` (denoted as ∏ `i` in `t`, `s i`). In other words, if a number is coprime with all elements of a set, it is also coprime with the product of the elements of the set.

If `x` is coprime to every `s i` in the finite set `t`, then `x` is coprime to the product of `s i` as `i` ranges over `t`.


theorem Cardinal.mul_aleph0_eq : ∀ {a : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → a * Cardinal.aleph0 = a := by sorry

The theorem `Cardinal.mul_aleph0_eq` states that for any cardinal number 'a', if aleph zero (the smallest infinite cardinal, represented by the cardinality of the set of natural numbers) is less than or equal to 'a', then the product of 'a' and aleph zero is equal to 'a'. This property mirrors the behavior of infinity in the real numbers, where multiplying infinity by any finite or infinite number still results in infinity.

For any cardinal number 'a', if |Nat| ≤ 'a' then 'a' * |Nat| = 'a', where |Nat| denotes the cardinality of the natural numbers and |A| denotes the cardinality of set A.


Asymptotics.IsBigOWith.mul

theorem Asymptotics.IsBigOWith.mul :
    ∀ {α : Type u_1} {R : Type u_13} {𝕜 : Type u_15} [inst : SeminormedRing R] [inst_1 : NormedDivisionRing 𝕜]
      {l : Filter α} {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} {c₁ c₂ : ℝ},
      Asymptotics.IsBigOWith c₁ l f₁ g₁ →
        Asymptotics.IsBigOWith c₂ l f₂ g₂ →
          Asymptotics.IsBigOWith (c₁ * c₂) l (fun x => f₁ x * f₂ x) fun x => g₁ x * g₂ x :=
  by sorry

The theorem `Asymptotics.IsBigOWith.mul` states that for any two pairs of functions `(f₁, g₁)` and `(f₂, g₂)` over a type `α`, if `f₁` is "big O with constant `c₁`" of `g₁` with respect to a filter `l`, and `f₂` is "big O with constant `c₂`" of `g₂` with respect to the same filter `l`, then the function that maps `x` to the product `f₁(x) * f₂(x)` is "big O with constant `c₁ * c₂`" of the function that maps `x` to the product `g₁(x) * g₂(x)`, again with respect to the filter `l`. In other words, if each of the functions `f₁` and `f₂` grows no faster than their corresponding `g₁` and `g₂`, respectively, then the same is true for their products, with the new constant being the product of the original constants.

If functions `f₁(x)` is big O of `g₁(x)` with constant `c₁` and `f₂(x)` is big O of `g₂(x)` with constant `c₂` with respect to filter `l`, then `f₁(x) * f₂(x)` is big O of `g₁(x) * g₂(x)` with constant `c₁ * c₂` with respect to `l`.


Monoid.ext

theorem Monoid.ext : ∀ {M : Type u} ⦃m₁ m₂ : Monoid M⦄, HMul.hMul = HMul.hMul → m₁ = m₂ := by sorry

The theorem `Monoid.ext` states that for any type `M`, if there are two monoid instances `m₁` and `m₂` on `M` such that their multiplication operations `HMul.hMul` (which computes the product of two elements) are equal, then the two monoid instances `m₁` and `m₂` are indeed the same. Essentially, this theorem is saying that the multiplication operation determines a monoid structure.

If two monoid structures on a type have equal multiplication operations, then they are equal.


theorem Filter.const_boundedAtFilter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] (l : Filter α) (c : β),
      Filter.BoundedAtFilter l (Function.const α c) :=
  by sorry

This theorem states that for any type `α` and any normed field `β`, for any filter `l` on `α` and any constant `c` from `β`, the constant function (which always returns `c`, regardless of the input) is bounded at the filter `l`. In other words, the rate of growth of a constant function is always bounded when evaluated at any filter.

For any type `α`, normed field `β`, filter `l` on `α`, and constant `c` from `β`, the constant function from `α` to `β` that maps every element to `c` is bounded at `l`.


theorem Set.smul_set_subset_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s t : Set β} {a : α}, a • s ⊆ t ↔ ∀ ⦃b : β⦄, b ∈ s → a • b ∈ t :=
  by sorry

The theorem `Set.smul_set_subset_iff` states that for any types `α` and `β` with a scalar multiplication operation (`SMul α β`), given sets `s` and `t` of type `β` and a scalar `a` of type `α`, the scalar multiplication of the set `s` by `a` is a subset of `t` if and only if for every element `b` in `s`, the result of scalar multiplying `b` by `a` is in `t`. This basically means that if we multiply each element of `s` by `a` and all these results are also elements of `t`, then the set formed by multiplying all elements of `s` by `a` is a subset of `t`.

For sets $s$ and $t$ of type $\beta$ and a scalar $a$ of type $\alpha$ in a type with scalar multiplication, $a \cdot s \subseteq t$ if and only if for all $b \in s$, $a \cdot b \in t$.


theorem Mathlib.Data.Finset.Sups._auxLemma.19 :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] [inst_2 : OrderBot α]
      [inst_3 : DecidableRel Disjoint] {s t : Finset α} {c : α},
      (c ∈ Finset.disjSups s t) = ∃ a ∈ s, ∃ b ∈ t, Disjoint a b ∧ a ⊔ b = c :=
  by sorry

The theorem `Mathlib.Data.Finset.Sups._auxLemma.19` states that for any type `α` with decidable equality, a semilattice structure, an order bot structure and a decidable relation of disjointness, given two finsets `s` and `t` and an element `c` of type `α`, `c` is in the finset of elements obtained by taking the supremum of disjoint elements from `s` and `t` (denoted as `Finset.disjSups s t`) if and only if there exist elements `a` and `b` in `s` and `t` respectively, such that `a` and `b` are disjoint and `c` is the supremum of `a` and `b`.

In other words, an element `c` belongs to the finset of supremums of disjoint pairs from `s` and `t` if and only if `c` is the supremum of some disjoint pair from `s` and `t`.

For finsets `s` and `t` over a type `α` with decidable equality, semilattice and order bot structures, and a decidable disjointness relation, an element `c` is in the finset of suprema of disjoint pairs from `s` and `t` if and only if there exist disjoint elements `a` in `s` and `b` in `t` such that `c = a ⨝ b`. (Here, `⨝` denotes the supremum in the semilattice.)


theorem MvPolynomial.rename_eq :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] (f : σ → τ) (p : MvPolynomial σ R),
      (MvPolynomial.rename f) p = Finsupp.mapDomain (Finsupp.mapDomain f) p :=
  by sorry

The theorem `MvPolynomial.rename_eq` states that for any commutative semiring `R` and any function `f` from type `σ` to type `τ`, the renaming of all variables in a multivariate polynomial `p` of type `σ` with coefficients in `R` via the function `f` is equivalent to mapping the domain of `p` twice with the function `f`. Here, `MvPolynomial.rename f p` is renaming all variables in `p` according to `f` and `Finsupp.mapDomain (Finsupp.mapDomain f) p` is applying the function `f` to the domain of `p` twice.

For any commutative semiring R and function f from type σ to type τ, renaming variables in a multivariate polynomial p of type σ with coefficients in R via f is equivalent to applying f to the domain of p twice.


theorem ENNReal.toNNReal_eq_toNNReal_iff' : ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ ⊤ → (x.toNNReal = y.toNNReal ↔ x = y) := by
  sorry

This theorem states that for any two extended nonnegative real numbers `x` and `y`, as long as neither `x` nor `y` are equal to positive infinity, `x.toNNReal` being equal to `y.toNNReal` is equivalent to `x` being equal to `y`. In other words, if two extended nonnegative real numbers are not infinity, then their conversion to nonnegative real numbers will maintain their equality.

For extended nonnegative real numbers `x` and `y`, if `x` and `y` are finite, then `x = y` if and only if `x.toNNReal = y.toNNReal`.


theorem CochainComplex.HomComplex.Cocycle.mem_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G : CochainComplex C ℤ} (n m : ℤ),
      n + 1 = m →
        ∀ (z : CochainComplex.HomComplex.Cochain F G n),
          z ∈ CochainComplex.HomComplex.cocycle F G n ↔ CochainComplex.HomComplex.δ n m z = 0 :=
  by sorry

This theorem states that for any category `C` with zero morphisms and any two cochain complexes `F` and `G` over `C`, if we take integers `n` and `m` such that `n + 1 = m`, a cochain `z` of degree `n` from `F` to `G` is a member of the subgroup of cocycles of degree `n` (from `F` to `G`) if and only if the image of `z` under the coboundary map `δ` at degrees `n` and `m` is zero. In other words, a cochain is a cocycle if it is mapped to zero in the cohomology complex.

A cochain of degree n in a cochain complex over a category with zero morphisms is a cocycle if and only if its coboundary at degrees n and n+1 is zero.


ContDiffOn.prod

/-- The cartesian product of `C^n` functions on domains is `C^n`.  -/
theorem ContDiffOn.prod :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ∞} {s : Set E} {f : E → F} {g : E → G},
      ContDiffOn 𝕜 n f s → ContDiffOn 𝕜 n g s → ContDiffOn 𝕜 n (fun x => (f x, g x)) s :=
  by sorry

The theorem `ContDiffOn.prod` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E`, `F`, `G` with `E` being a normed space over `𝕜`, `F` and `G` being normed spaces over `𝕜`, and for any set `s` of elements of type `E`, functions `f` and `g` from `E` to `F` and `G` respectively, if both `f` and `g` are `C^n` differentiable on `s`, then the function mapping `x` to the pair `(f(x), g(x))` is also `C^n` differentiable on `s`. In other words, the cartesian product of `C^n` differentiable functions is also `C^n` differentiable. The `C^n` notation is used to denote n-times continuously differentiable functions.

If `f` and `g` are `C^n` differentiable functions from a non-trivially normed vector space to their respective normed spaces, then the function mapping `x` to the pair `(f(x), g(x))` is also `C^n` differentiable.


theorem PEquiv.eq_some_iff :
    ∀ {α : Type u} {β : Type v} (f : α ≃. β) {a : α} {b : β}, (PEquiv.symm f) b = some a ↔ f a = some b := by sorry

This theorem states that for any partial equivalence `f` between two types `α` and `β`, and for any elements `a` of type `α` and `b` of type `β`, the partial equivalence `f` maps `a` to `some b` if and only if the inverse of `f` maps `b` to `some a`. In other words, an element `a` is in the domain of the partial function `f` with image `b` if and only if `b` is in the domain of the inverse partial function with image `a`.

For any partial equivalence relation `R` on types `α` and `β`, `a ��:`α` R b ↔ b ∋ a. (Here, `∋` denotes the existence quantifier, and `∉` its negation, meaning "there exists" and "there does not exist" respectively.) In other words, `a` is related to `b` by `R` if and only if `b` is related to `a` by the inverse relation.


ConvexBody.nonempty

theorem ConvexBody.nonempty :
    ∀ {V : Type u_1} [inst : TopologicalSpace V] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V] (K : ConvexBody V),
      Set.Nonempty ↑K :=
  by sorry

This theorem states that for any type `V` which is equipped with a topological space structure, an additive commutative group structure, and a real number module structure, every convex body `K` in `V` is non-empty. In other words, there exists at least one element in `V` that is a member of the convex body `K`.  This theorem works regardless of the specifics of the type `V` as long as the appropriate structures are defined.

Every convex body in a topological vector space is non-empty.


SetTheory.PGame.Equiv.trans

theorem SetTheory.PGame.Equiv.trans : ∀ {x y z : SetTheory.PGame}, x ≈ y → y ≈ z → x ≈ z := by sorry

This theorem states that the equivalence relation on the type of games, denoted by `≈`, is transitive. In other words, for any three games `x`, `y`, and `z` in set theory, if game `x` is equivalent to game `y` and game `y` is equivalent to game `z`, then game `x` is also equivalent to game `z`. This is a fundamental property of equivalence relations in mathematics.

If `x ≈ y` and `y ≈ z` then `x ≈ z` for the equivalence relation `≈` on the type of games.


theorem circleMap_mem_sphere' : ∀ (c : ℂ) (R θ : ℝ), circleMap c R θ ∈ Metric.sphere c |R| := by sorry

This theorem states that for any complex number `c`, and any real numbers `R` and `θ`, the output of the function `circleMap` with inputs `c`, `R`, and `θ`, is a member of the sphere centered at `c` with radius `|R|`. In other words, the exponential map, which maps the real number `θ` to the complex number `c + Re^{θi}`, produces a point on the complex plane that lies on the circle with center `c` and radius `|R|`.

For any complex number `c` and real numbers `R` and `θ`, the point `c + R * exp iθ` lies on the circle centered at `c` with radius `|R|` in the complex plane.


theorem Submodule.top_orthogonal_eq_bot :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
      ⊤ᗮ = ⊥ :=
  by sorry

This theorem states that for any type `𝕜` (representing a scalar) and any type `E` (representing a vector space), given that `𝕜` forms a commutative ring (denoted by `RCLike 𝕜`), `E` forms a normed add commutative group, and `E` forms an inner product space over `𝕜`, the orthogonal complement of the entire space (`⊤ᗮ`) is the zero subspace (`⊥`). In the language of linear algebra, this means that the space orthogonal to the entire vector space is just the zero vector.

If `𝕜` is a commutative ring, `E` a normed add commutative group and an inner product space over `𝕜`, then the orthogonal complement of `E` is the zero subspace.


theorem Matroid.basis_iff :
    ∀ {α : Type u_1} {M : Matroid α} {X I : Set α},
      autoParam (X ⊆ M.E) _auto✝ →
        (M.Basis I X ↔ M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J) :=
  by sorry

The theorem `Matroid.basis_iff` states that for any type `α` and a matroid `M` on that type, as well as for any two sets `X` and `I` of that type, given that `X` is a subset of the ground set of `M` (assumed automatically), a set `I` is a basis of `X` in `M` if and only if `I` is independent in `M`, `I` is a subset of `X`, and for any other set `J` which is independent and a subset of `X`, if `I` is also a subset of `J`, then `I` and `J` must be the same set. In short, a basis is an independent set within `X` that cannot be further expanded by any other independent set within `X`.

A set is a basis of a matroid if and only if it is an independent subset that is not a proper subset of any other independent subset.


Antitone.comp

theorem Antitone.comp :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {g : β → γ}
      {f : α → β}, Antitone g → Antitone f → Monotone (g ∘ f) :=
  by sorry

This theorem states that if we have two types `α`, `β`, and `γ` which have the `Preorder` property (i.e., they support operations of comparison like less than or equal to), then for any two functions `f : α → β` and `g : β → γ`, if `f` is antitone (meaning that for any two elements in `α`, if the first is less than or equal to the second, then the result of applying `f` to the second is less than or equal to the result of applying `f` to the first) and `g` is also antitone, then the composition of `g` and `f` (i.e., `g ∘ f`) is monotone (meaning that for any two elements in `α`, if the first is less than or equal to the second, then the result of applying `g ∘ f` to the first is less than or equal to the result of applying `g ∘ f` to the second).

If `α`, `β`, and `γ` are preordered types, and `f : α → β` and `g : β → γ` are antitone functions, then `g ∘ f` is a monotone function.


theorem Multiset.coe_replicate : ∀ {α : Type u_1} (n : ℕ) (a : α), ↑(List.replicate n a) = Multiset.replicate n a := by
  sorry

The theorem `Multiset.coe_replicate` states that for any type `α`, any natural number `n`, and any element `a` of type `α`, converting a list that is generated by replicating `a` `n` times to a multiset results in the same multiset as directly replicating `a` `n` times in a multiset. In other words, the list replication followed by conversion to multiset is the same as multiset replication.

For any type `α`, natural number `n`, and element `a` of type `α`, the multiset obtained from replicating `a` `n` times in a list and then converting to a multiset equals the multiset obtained by directly replicating `a` `n` times in a multiset.


theorem Polynomial.mul_divByMonic_eq_iff_isRoot :
    ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R},
      (Polynomial.X - Polynomial.C a) * (p /ₘ (Polynomial.X - Polynomial.C a)) = p ↔ Polynomial.IsRoot p a :=
  by sorry

This theorem states that for any commutative ring `R`, any element `a` of `R`, and any polynomial `p` over `R`, the polynomial `p` is equal to the product of `(Polynomial.X - Polynomial.C a)` and the result of dividing `p` by `(Polynomial.X - Polynomial.C a)` if and only if `a` is a root of the polynomial `p`. In terms of mathematics, this is saying that for a polynomial $p(x)$ and a number $a$, $p(x) = (x-a)q(x)$ if and only if $p(a) = 0$, where $q(x)$ is the quotient when $p(x)$ is divided by $(x-a)$.

A polynomial `p` over a commutative ring `R` has a root `a` in `R` if and only if `p` equals the product of `(X - Polynomial.C a)` and the quotient of `p` by `(X - Polynomial.C a)`, where `X` is an indeterminate over `R`.


theorem Primrec.option_some : ∀ {α : Type u_1} [inst : Primcodable α], Primrec some := by sorry

The theorem `Primrec.option_some` states that for any type `α` that is Primcodable, the function `some`, which wraps a given value in an Option, is primitive recursive. In other words, the function `some` can be computed by a sequence of basic operations, loops, and conditionals, when both its input (of type `α`) and output (of type `Option α`) are encoded as natural numbers.

The function `some : α → Option α` is primitive recursive for any type `α` that is Primcodable.


theorem Set.iInter_and :
    ∀ {α : Type u_1} {p q : Prop} (s : p ∧ q → Set α), ⋂ (h : p ∧ q), s h = ⋂ (hp : p), ⋂ (hq : q), s ⋯ := by sorry

This theorem states that for any type `α` and given two propositions `p` and `q`, and a set `s` which depends on the conjunction of `p` and `q`, the intersection over `s` for every instance where both `p` and `q` hold true is the same as the nested intersection over `s` where `p` holds true and then for every instance where `q` holds true. In mathematical terms, it's saying that the intersection over a set that depends on the conjunction of two conditions is equivalent to taking the intersection twice, first for each condition separately.

For any set `s` and propositions `p` and `q`, the intersection of `s` over instances where `p` and `q` hold true equals the intersection of `s` where `p` holds true and then the intersection of the result with where `q` holds true.


theorem specializes_iff_forall_open :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x ⤳ y ↔ ∀ (s : Set X), IsOpen s → y ∈ s → x ∈ s := by sorry

This theorem, named `specializes_iff_forall_open`, states that for any topological space `X` and for any two points `x` and `y` in `X`, the condition `x` specializes to `y` is equivalent to the property that for all sets `s` in `X`, if `s` is an open set and `y` is an element of `s`, then `x` is also an element of `s`. In simpler terms, a point `x` specializes to another point `y` if and only if `x` belongs to every open set that `y` belongs to.

A point x specializes to another point y if and only if for every open set s containing y, x belongs to s.


/-- See also `Module.Finite.exists_fin'`.  -/
theorem Module.Finite.exists_fin :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Module.Finite R M], ∃ n s, Submodule.span R (Set.range s) = ⊤ :=
  by sorry

The theorem `Module.Finite.exists_fin` states that for any semiring `R` and any additively commutative monoid `M` that is also a module over `R` and is finite, there exists an integer `n` and a function `s` such that the submodule spanned by the range of `s` is the entire module. In other words, it's possible to generate the whole module by taking linear combinations of a finite set of vectors, where these vectors are the images of the function `s`.

For any finite, additively commutative `R`-module `M`, there exists an integer `n` and a function `s : Fin n → M` such that the span of `s` is equal to `M`.


theorem Computation.Results.len_unique :
    ∀ {α : Type u} {s : Computation α} {a b : α} {m n : ℕ},
      Computation.Results s a m → Computation.Results s b n → m = n :=
  by sorry

The theorem `Computation.Results.len_unique` asserts that for any computation `s` of a certain type `α`, and any two results `a` and `b` of the same type, if the computation `s` terminates with result `a` after `m` steps, and with result `b` after `n` steps, then `m` and `n` must be equal. This theorem essentially states that the number of steps required for a computation to terminate is unique.

For any computation `s` of type `α`, if `s` terminates after `m` steps to result `a` and after `n` steps to result `b`, then `m = n`.


theorem subsingleton_iff_bot_eq_top :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α], ⊥ = ⊤ ↔ Subsingleton α := by sorry

This theorem states that for any type `α` with a partial order and a bounded order, the bottom element `⊥` is equal to the top element `⊤` if and only if `α` is a subsingleton. In the context of order theory, a subsingleton is a set with at most one element, so `α` being a subsingleton would mean it cannot have distinct `⊥` and `⊤`.

For a type `α` equipped with a partial order and a bottom element `⊥`, `⊥` equals the top element `⊤` if and only if `α` is a subsingleton (i.e., has at most one element).


theorem UniformSpace.Completion.inner_coe :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (a b : E), ⟪↑E a, ↑E b⟫_𝕜 = ⟪a, b⟫_𝕜 :=
  by sorry

This theorem, `UniformSpace.Completion.inner_coe`, states that for any types `𝕜` and `E`, where `𝕜` is a ring and `E` is a normed-additive-commutative-group with an inner product space over `𝕜`, the inner product of the completion of `E` with respect to `𝕜` of any two elements `a` and `b` of `E` is the same as the inner product of `a` and `b` in the original inner product space `E` over `𝕜`. In simpler terms, taking the completion of an inner product space doesn't change the inner products of the original elements.

For any normed-additive-commutative `ℝ`-module `E` over a ring `ℝ` with an inner product and completion `ℱ`, the inner product of `ℱ` of any two elements from `E` is equal to their inner product in `E`.