theorem Set.image_subset_image_iff :
    ∀ {α : Type u_1} {β : Type u_2} {s t : Set α} {f : α → β}, Function.Injective f → (f '' s ⊆ f '' t ↔ s ⊆ t) := by
  sorry

This theorem states that for any two sets `s` and `t` of elements of type `α`, and any function `f` from `α` to `β`, if `f` is injective (meaning that it never maps different inputs to the same output), then the image of `s` under `f` is a subset of the image of `t` under `f` if and only if `s` is a subset of `t`. Here, the image of a set under a function is the set of all outputs of that function when applied to elements of the set. Thus, this theorem relates the subset relation on the original sets with the subset relation on their images under an injective function.

If `f` is an injective function from type `α` to type `β`, then `s ⊆ t` implies `f(s) ⊆ f(t)` and conversely.


theorem Cardinal.aleph0_le_continuum : Cardinal.aleph0 ≤ Cardinal.continuum := by sorry

The theorem `Cardinal.aleph0_le_continuum` states that the cardinality of the set of natural numbers, denoted as `ℵ₀` (or 'aleph null'), is less than or equal to the cardinality of the continuum. The cardinality of the continuum, denoted as 'Cardinal.continuum' in Lean 4, is defined as the power set of the set of natural numbers, or 2 raised to the power of `ℵ₀`. This theorem reflects the mathematical concept that there are at least as many real numbers (which form the continuum) as there are natural numbers.

The cardinality of the set of natural numbers is less than or equal to the cardinality of the continuum.


theorem Int.ediv_neg : ∀ (a b : ℤ), a / -b = -(a / b) := by sorry

This theorem states that for any two integers `a` and `b`, the floor division of `a` by `-b` is equal to the negation of the floor division of `a` by `b`. In other words, dividing an integer by a negative integer is the same as negating the result of dividing that integer by the positive counterpart of the negative integer. This is the standard behavior in mathematics where division by a negative number results in a negative quotient.

For all integers `a` and `b`, `floor a (-b) = neg (floor a b)`.


theorem MeasureTheory.lintegral_zero :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}, ∫⁻ (x : α), 0 ∂μ = 0 := by sorry

This theorem states that for any type `α`, any measurable space `m` on `α`, and any measure `μ` on this measurable space, the Lebesgue integral (notated as `∫⁻`) of the constant zero function over the measure `μ` is zero. In other words, the integral of zero over any space, under any measure, is always zero.

For any measurable space `(α, m)` and measure `μ` on `α`, the Lebesgue integral of the constant zero function over `μ` is equal to zero.


theorem hasDerivAt_id : ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜), HasDerivAt id 1 x := by sorry

This theorem states that the derivative of the identity function, `id`, is always `1` for any point `x` in a nontrivial normed field `𝕜`. Here, the identity function `id` is a function that returns its input unchanged. In mathematical terms, if `𝕜` is a field equipped with a norm (a function defining a notion of distance), where there exists at least one non-zero element, then the derivative of the identity function at any point `x` in `𝕜` is `1`. This result is a fundamental property in calculus.

The derivative of the identity function in a nontrivial normed field is equal to 1 for all points in the field.


theorem Int.mul_one : ∀ (a : ℤ), a * 1 = a := by sorry

This theorem states that for every integer `a`, the product of `a` and 1 is `a`. In mathematical terms, this theorem represents the multiplicative identity property in the set of integers, which says that any number multiplied by 1 remains the same.

For all integers a, a * 1 = a. (This statement asserts that the multiplicative identity 1 holds for integers.)


theorem MeasureTheory.Lp.mem_Lp_iff_memℒp :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f : α →ₘ[μ] E}, f ∈ MeasureTheory.Lp E p μ ↔ MeasureTheory.Memℒp (↑f) p μ :=
  by sorry

This theorem establishes an equivalence relationship between two key concepts in measure theory. For any measure space `α`, type `E`, measurable space `m0`, extended nonnegative real number `p`, measure `μ`, and function `f` from `α` to `E` that is integrable with respect to `μ`, the function `f` belongs to the Lp space with respect to `E`, `p`, and `μ` if and only if `f` satisfies the Memℒp property. The Memℒp property signifies that `f` is almost everywhere strongly measurable and the integral of the p-th power of its norm with respect to `μ` is finite (when `p < ∞`) or the essential supremum of `f` is finite (when `p = ∞`).

For any measurable function `f` from a measure space to a normed vector space with finite p-th moment, with respect to a given measure, `f` belongs to the Lp space if and only if it satisfies the Memℒp property.


theorem Finset.length_sort :
    ∀ {α : Type u_1} (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r] [inst_2 : IsAntisymm α r]
      [inst_3 : IsTotal α r] {s : Finset α}, List.length (Finset.sort r s) = s.card :=
  by sorry

The theorem `Finset.length_sort` states that for any type `α`, and any relation `r` on `α` which is decidable, transitive, antisymmetric, and total, the length of the list obtained by sorting a finite set `s` of `α` elements according to `r` is equal to the cardinality of the set `s`. In other words, sorting the elements of the set `s` into a list does not change the number of elements.

For any type `α` and decidable, transitive, antisymmetric, and total relation `r` on `α`, the length of the list obtained by sorting a finite set of `α` elements according to `r` equals the cardinality of the set.


theorem Finset.inter_subset_right : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ ∩ s₂ ⊆ s₂ := by sorry

The theorem `Finset.inter_subset_right` states that for any type `α` with a decidable equality relation, for any two finite sets (or `Finset`s) `s₁` and `s₂` of type `α`, the intersection of `s₁` and `s₂` (denoted by `s₁ ∩ s₂`) is a subset of `s₂`. This theorem asserts one of the fundamental properties of set intersection in the context of finite sets.

For any type `α` with decidable equality and for any finite sets `s₁` and `s₂` of type `α`, `s₁ ∩ s₂` is a subset of `s₂`.


Function.Injective.hasLeftInverse

theorem Function.Injective.hasLeftInverse :
    ∀ {α : Sort u_1} {β : Sort u_2} [inst : Nonempty α] {f : α → β}, Function.Injective f → Function.HasLeftInverse f :=
  by sorry

The theorem `Function.Injective.hasLeftInverse` states that for every function `f` from a nonempty type `α` to any type `β`, if `f` is injective (meaning that identical outputs imply identical inputs), then `f` has a left inverse. In mathematical terms, this left inverse is a function that, when composed with `f` from the left, results in the identity function on `α`.

If `f: α → β` is injective, then there exists a function `g: β → α` such that `f ∘ g = idα`.


theorem AbsoluteValue.add_le :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S)
      (x y : R), abv (x + y) ≤ abv x + abv y :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, and given an absolute value function `abv` from `R` to `S`, the absolute value of the sum of two elements `x` and `y` in `R` is less than or equal to the sum of the absolute values of `x` and `y`. This is a formal statement of the triangle inequality for absolute values in the context of semirings.

For any semirings R and S with an ordered semiring structure on S, and an absolute value function from R to S, |x + y| ≤ |x| + |y| holds for all x, y in R. (Triangle inequality for absolute values in semirings)


theorem Filter.map_neBot_iff :
    ∀ {α : Type u} {β : Type v} (f : α → β) {F : Filter α}, Filter.NeBot (Filter.map f F) ↔ Filter.NeBot F := by sorry

The theorem `Filter.map_neBot_iff` states that for any types `α` and `β`, a function `f` from `α` to `β`, and a filter `F` on `α`, the forward image filter `Filter.map f F` under the function `f` is non-trivial (i.e., doesn't contain only the empty set) if and only if the original filter `F` is non-trivial. This means that the non-triviality of a filter is preserved under the operation of taking forward images.

For any functions f between types α and β and filters F on α, the filter obtained by applying the function f to the elements of F (Filter.map f F) is non-empty if and only if the original filter F is non-empty.


theorem TopologicalSpace.exists_countable_dense :
    ∀ (α : Type u) [t : TopologicalSpace α] [inst : TopologicalSpace.SeparableSpace α],
      ∃ s, Set.Countable s ∧ Dense s :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure and with the property that it is a separable space, there exists a set `s` that is both countable and dense in the topological space. In mathematical terms, this means that we can always find a countable set such that every point in the space belongs to the closure of this set. This theorem is a key result in topology, as it ensures the existence of a dense countable subset in any separable topological space.

In any separable topological space, there exists a countable dense subset.


theorem Finset.eq_empty_of_forall_not_mem : ∀ {α : Type u_1} {s : Finset α}, (∀ (x : α), x ∉ s) → s = ∅ := by sorry

This theorem states that for any type `α` and any finite set `s` of `α`, if every element of type `α` is not in `s`, then `s` must be the empty set. In other words, if no elements of a particular type belong to a certain finite set, then the finite set is necessarily empty.

If a finite set of type `α` contains no elements of type `α`, then the set is empty.


theorem ENNReal.toReal_pos_iff : ∀ {a : ENNReal}, 0 < a.toReal ↔ 0 < a ∧ a < ⊤ := by sorry

This theorem states that for any extended nonnegative real number `a`, `a`'s real number value is greater than zero if and only if `a` is greater than zero and `a` is less than positive infinity. In other words, an extended nonnegative real number `a` has a positive real counterpart if and only if it itself is positive and finite. This theorem bridges the relationship between the positivity in the space of extended nonnegative real numbers and the space of real numbers.

An extended nonnegative real number `a` has a positive real value if and only if `a` is positive and finite.


theorem neg_eq_iff_add_eq_zero : ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, -a = b ↔ a + b = 0 := by sorry

This theorem, `neg_eq_iff_add_eq_zero`, states that for any type `G` that is an additive group, and for any elements `a` and `b` of `G`, the negation of `a` equals `b` if and only if the sum of `a` and `b` is zero. In simpler terms: in any additive group, the negative of a number is another number if adding the original number to the other number yields zero.

In an additive group, for all elements `a` and `b`, `-a = b` if and only if `a + b = 0`.


CochainComplex.next

theorem CochainComplex.next :
    ∀ (α : Type u_2) [inst : AddRightCancelSemigroup α] [inst_1 : One α] (i : α),
      ComplexShape.next (ComplexShape.up α) i = i + 1 :=
  by sorry

This theorem, `CochainComplex.next`, states that for any type `α` which has an `AddRightCancelSemigroup` and `One` structure, and for any element `i` of type `α`, the `next` operation of the `ComplexShape.up` on `i` will always yield `i + 1`. In simpler terms, when we move to the 'next' element in the cochain complex structure, we are essentially incrementing the current index by one.

For any type `α` with an `AddRightCancelSemigroup` and `One` structure, the operation `next (ComplexShape.up i)` equals `i + One`.


theorem GaloisInsertion.l_sup_u :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β],
      GaloisInsertion l u → ∀ (a b : β), l (u a ⊔ u b) = a ⊔ b :=
  by sorry

This theorem states that for any two types `α` and `β`, a pair of functions `l : α → β` and `u : β → α`, and instances of semilattice structure (which means binary operation that is associative, commutative, idempotent, and has an order relation) on `α` and `β`, if `l` and `u` form a Galois insertion (a special relationship between `l` and `u` such that for all `a` in `α` and `b` in `β`, `l a ≤ b` iff `a ≤ u b`), then for any two elements `a` and `b` in `β`, the function `l` applied to the sup (the least upper bound operation, here denoted by `⊔`) of `u a` and `u b` is equal to the sup of `a` and `b`.

For any semilattices `α` and `β` with a Galois connection between functions `l : α → β` and `u : β → α`, the sup of `l (a ⊔ b)` equals `l a ⊔ l b` for all elements `a, b` in `α`.


theorem Set.smul_mem_smul_set_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {s : Set β} {a : α} {x : β},
      a • x ∈ a • s ↔ x ∈ s :=
  by sorry

This theorem states that for any type `α` that forms a group, and any type `β` that has a multiplication action by `α`, if we have a set `s` of elements of type `β`, an element `a` from group `α`, and an element `x` from type `β`, then `x` is in `s` if and only if the result of `a` acting on `x` (denoted by `a • x`) is in the set resulting from `a` acting on every element of `s` (denoted by `a • s`). This theorem essentially captures the invariance of set membership under the action of a group.

For any set `s` of elements from a group action `α` on type `β`, an element `x` is in `s` if and only if `a • x` is in `a • s` for all `a` in `α`.


theorem le_or_gt : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), a ≤ b ∨ a > b := by sorry

This theorem, `le_or_gt`, states that for all types `α` that have a linear ordering (`LinearOrder`), for any two elements `a` and `b` of that type, either `a` is less than or equal to `b` (`a ≤ b`) or `a` is greater than `b` (`a > b`). In other words, for any given pair of elements in a linearly ordered set, one of them is always either less than or equal to, or greater than the other.

For all linearly ordered types `α` and elements `a` and `b` of type `α`, either `a ≤ b` or `a > b`.


theorem MvPolynomial.vars_def :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq σ] (p : MvPolynomial σ R),
      MvPolynomial.vars p = Multiset.toFinset (MvPolynomial.degrees p) :=
  by sorry

This theorem states that for any multivariate polynomial `p` over a commutative semiring `R` with variables indexed by `σ`, the set of variables appearing in `p` is exactly the set obtained by removing duplicates from the multiset of maximal degrees of each variable in `p`. This assumes that equality between variables is decidable. In mathematical terms, if we denote by `vars(p)` the set of variables in `p` and `degrees(p)` the multiset of maximal degrees of each variable in `p`, then `vars(p)` is equal to the set obtained from `degrees(p)` by deleting duplicates.

For any multivariate polynomial `p` over a commutative semiring `R` with decidable variable equality, the set of variables in `p` equals the multiset of maximal degrees of each variable in `p`, without duplicates.


theorem Set.set_smul_subset_set_smul_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A B : Set β} {a : α},
      a • A ⊆ a • B ↔ A ⊆ B :=
  by sorry

This theorem states that for any two sets `A` and `B` of elements of some type `β` and any element `a` of type `α`, where `α` is a group and `β` is a set on which `α` acts multiplicatively, the scaled set `a • A` is a subset of the scaled set `a • B` if and only if `A` is a subset of `B`. In mathematical terms, given a group `α`, a set `β` with a group action defined by multiplication, and two subsets `A`, `B` of `β`, the condition `a • A ⊆ a • B` holds true if and only if `A ⊆ B`. Here `a • A` denotes the set of all elements obtained by scaling elements of `A` by `a`, and `a • B` is defined similarly.

For any group action of a multiplicative group α on a set β, and subsets A, B of β, the condition a • A ⊆ a • B holds if and only if A ⊆ B.


theorem sdiff_idem : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, (a \ b) \ b = a \ b := by sorry

This theorem states that for any type `α` that forms a `GeneralizedCoheytingAlgebra`, and for any two elements `a` and `b` of `α`, the operation of subtracting `b` from `a` two times in a row is equivalent to just subtracting `b` from `a` once. In other words, `(a \ b) \ b = a \ b`. This is a property of the subtraction operation in a `GeneralizedCoheytingAlgebra`.

In a Generalized Cohen algebra, for all elements `a` and `b`, the repeated subtraction `(a \ b) \ b` equals the single subtraction `a \ b`.


theorem Measurable.add_const :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Add M] {m : MeasurableSpace α} {f : α → M}
      [inst_2 : MeasurableAdd M], Measurable f → ∀ (c : M), Measurable fun x => f x + c :=
  by sorry

This theorem states that if `f` is a measurable function from a measurable space `α` to another measurable space `M` that has a defined addition operation, then for any constant `c` from `M`, the function which maps each element `x` in `α` to the sum of `f(x)` and `c` is also measurable. In other words, adding a constant to the values of a measurable function from a space with a defined addition operation does not prevent the resultant function from being measurable.

If `f` is a measurable function from a measurable space `α` to an Abelian group `M`, then the function `x ↦ f(x) + c` is measurable for any constant `c` in `M`.


theorem nontrivial_iff_exists_ne : ∀ {α : Type u_1} (x : α), Nontrivial α ↔ ∃ y, y ≠ x := by sorry

This theorem states that for any type `α` and any element `x` of that type, `α` is nontrivial if and only if there exists an element `y` in `α` which is not equal to `x`. In other words, a type is considered nontrivial when there's at least one instance of that type that's distinct from a given instance.

A type `α` is nontrivial if and only if it has at least two distinct elements.


theorem Nat.Primrec.casesOn1 : ∀ {f : ℕ → ℕ} (m : ℕ), Nat.Primrec f → Nat.Primrec fun x => Nat.casesOn x m f := by sorry

The theorem `Nat.Primrec.casesOn1` states that for any function `f` from natural numbers to natural numbers and any natural number `m`, if `f` is primitive recursive, then the function that applies `Nat.casesOn` to its argument `x` with the parameters `m` and `f` is also primitive recursive. In other words, given a primitive recursive function `f` and a natural number `m`, the function that returns `m` if its input is zero and applies `f` if its input is a successor is also primitive recursive.

If `f` is a primitive recursive function, then the function `x => if hx = 0 then m else f (succ x)` is also primitive recursive, for any natural numbers `m` and `x`. (Here, `h` denotes the predicate `Nat.pred_eq_zero` and `succ` denotes the successor function.)


theorem isMax_top : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α], IsMax ⊤ := by sorry

The theorem `isMax_top` states that for any given type `α` equipped with a preorder (a binary relation that is reflexive and transitive) and an order top (a greatest element), the top element `⊤` (the greatest element of `α`) is a maximal element. In the context of this theorem, a maximal element is defined as an element `a` such that for any other element `b`, if `a` is less than or equal to `b`, then `b` is less than or equal to `a` - in other words, no element is strictly greater than `a`.

For any type `α` with a preorder and an order top element `⊤`, the top element is a maximal element with no strictly greater elements.


theorem Set.image2_inter_union_subset_union :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t t' : Set β},
      Set.image2 f (s ∩ s') (t ∪ t') ⊆ Set.image2 f s t ∪ Set.image2 f s' t' :=
  by sorry

This theorem states that for any types α, β, γ, any binary function `f` from α and β to γ, and any sets `s`, `s'` of α and `t`, `t'` of β, the image of the function `f` over the intersection of `s` and `s'` and the union of `t` and `t'` is a subset of the union of the image of `f` over `s` and `t` and the image of `f` over `s'` and `t'`. In mathematical terms, for any sets $s, s' \subseteq \alpha$, $t, t' \subseteq \beta$, and function $f: \alpha \times \beta \mapsto \gamma$, it is true that $f[(s \cap s') \times (t \cup t')] \subseteq f[s \times t] \cup f[s' \times t']$.

For any sets $s, s' \subseteq \alpha$, $t, t' \subseteq \beta$, and function $f: \alpha \times \beta \rightarrow \gamma$, $f[(s \cap s') \times (t \cup t')] \subseteq f[s \times t] \cup f[s' \times t']$.


theorem Primrec₂.right :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec₂ fun x b => b := by sorry

The theorem `Primrec₂.right` states that for any two types `α` and `β` that have a primitive recursive encoding (`Primcodable`), the second projection function (which takes a pair `(x, b)` and returns `b`) is a binary primitive recursive function. In other words, the function that retrieves the second component of a pair is primitive recursive.

The second projection function on pairs of primitive recursively encodable types is a primitive recursive function.


theorem ENNReal.continuous_coe : Continuous ENNReal.ofNNReal := by sorry

This theorem asserts that the function `ENNReal.ofNNReal` is continuous. In more mathematical terms, it says that the function which coerces (or converts) a non-negative real number (represented by `NNReal`) to a non-negative extended real number (represented by `ENNReal`) is a continuous function. Here, "continuous" means that for any sequence of non-negative real numbers, the sequence of their images under this function will converge to the image of the limit of the original sequence. This ensures that no "gaps" or "jumps" appear when we map these numbers from `NNReal` to `ENNReal`.

The function `ENNReal.ofNNReal` is a continuous mapping from the non-negative real numbers to the non-negative extended real numbers.


theorem OmegaCompletePartialOrder.ContinuousHom.continuous :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β] (F : α →𝒄 β)
      (C : OmegaCompletePartialOrder.Chain α),
      F (OmegaCompletePartialOrder.ωSup C) =
        OmegaCompletePartialOrder.ωSup (OmegaCompletePartialOrder.Chain.map C ↑F) :=
  by sorry

This theorem is about the continuity of homomorphisms in the context of omega complete partial orders. It states that for all types `α` and `β`, which are both omega complete partial orders, and for a continuous homomorphism `F` from `α` to `β`, and a chain `C` in `α`, the application of `F` to the supremum of the chain `C` is equal to the supremum of the chain obtained by mapping `C` through `F`. In simpler terms, it asserts that continuous homomorphisms preserve the order-theoretic supremum of increasing sequences, which is a key property of continuity in the context of omega complete partial orders.

For any omega complete partial orders `α` and `β`, and a continuous homomorphism `F` from `α` to `β`, if `C` is a chain in `α`, then `F(sup C) = sup (F '' C)`.


theorem List.eq_replicate :
    ∀ {α : Type u_1} {a : α} {n : ℕ} {l : List α}, l = List.replicate n a ↔ List.length l = n ∧ ∀ b ∈ l, b = a := by
  sorry

The theorem `List.eq_replicate` states that for any type `α`, element `a` of type `α`, natural number `n`, and list `l` of type `α`, `l` equals `n` replicates of `a` if and only if the length of `l` equals `n` and every element `b` in `l` equals `a`. In other words, a list is equivalent to a list containing `n` repeated instances of an element `a` if the list has `n` elements and each of these elements is equal to `a`.

For any type `α`, natural number `n`, element `a` of type `α`, and list `l` of length `n` over `α`, `l` is equal to the list obtained by replicating `a n` times if and only if every element of `l` is equal to `a`.


theorem HahnSeries.isWF_support :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R),
      Set.IsWF (HahnSeries.support x) :=
  by sorry

The theorem `HahnSeries.isWF_support` states that for all Hahn series (denoted by `x`), of a type `Γ` with a partial order and a type `R` with zero, the support of the Hahn series is well-founded. In other words, the set of indices in `Γ` whose coefficients in the Hahn series are non-zero (i.e., the support of the Hahn series) has a well-founded order using the `<` operation. Here, a set being well-founded means there are no infinite descending sequences.

The support of a Hahn series over a well-ordered index set with respect to the partial order is a well-founded set.


theorem Finset.prod_nonneg :
    ∀ {ι : Type u_1} {R : Type u_8} [inst : CommMonoidWithZero R] [inst_1 : PartialOrder R] [inst_2 : ZeroLEOneClass R]
      [inst_3 : PosMulMono R] {f : ι → R} {s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → 0 ≤ Finset.prod s fun i => f i :=
  by sorry

The theorem `Finset.prod_nonneg` asserts that for any type `ι`, any commutative monoid `R` with zero that also has partial order and satisfies the `ZeroLEOneClass` and `PosMulMono` properties, any function `f` from `ι` to `R`, and any finite set `s` of type `ι`, if every element `i` of `s` satisfies `0 ≤ f i`, then the product of `f i` over all `i` in `s` is also nonnegative, i.e., `0 ≤ Finset.prod s fun i => f i`. Essentially, it states that the product of nonnegative numbers on a given finite set is also nonnegative.

If `R` is a commutative monoid with zero, partial order, and `ZeroLEOneClass` and `PosMulMono` properties, and `f : ι -> R` maps a finite set `s` of nonnegative elements `i` in `ι`, then the product `Finset.prod s fun i => f i` is nonnegative.


theorem Polynomial.natDegree_eq_zero_iff_degree_le_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.natDegree p = 0 ↔ Polynomial.degree p ≤ 0 := by
  sorry

This theorem states that for any type `R` that is a semiring and for any polynomial `p` over `R`, the natural degree of `p` is zero if and only if the degree of `p` is less than or equal to zero. The natural degree of a polynomial is the largest exponent of 'X' that appears in the polynomial, with the special case that the natural degree of the zero polynomial is zero. The degree of a polynomial is similar, but it returns a bottom type (`⊥`) for the zero polynomial, meaning it's undefined or not applicable. This theorem connects these two definitions.

For any semiring `R` and polynomial `p` over `R`, the natural degree and degree of `p` are equal when `p` is not the zero polynomial.


theorem mul_le_mul_right :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : MulPosMono α]
      [inst_4 : MulPosReflectLE α], 0 < a → (b * a ≤ c * a ↔ b ≤ c) :=
  by sorry

The theorem `mul_le_mul_right` states that for any type `α` that supports multiplication and zero, and has a preorder structure, and satisfies the properties of multiplication positivity monotonicity and multiplication positivity reflectivity, if `a` is a positive element of `α`, then the product of `b` and `a` is less than or equal to the product of `c` and `a` if and only if `b` is less than or equal to `c`. This theorem is basically saying that multiplying by a positive value on the right preserves the order of elements.

For any type `α` with multiplication, zero, preorder structure, and multiplication positivity monotonicity and reflectivity properties, if `a` is positive and `b ≤ c`, then `b * a ≤ c * a`.


theorem List.nil_append : ∀ {α : Type u} (as : List α), [] ++ as = as := by sorry

This theorem states that for any type `α` and for any list `as` of type `α`, appending an empty list `[]` at the front of the list `as` results in the original list `as`. In mathematical terms, for all `α` and `as`, `[] ++ as = as`. This is essentially the property of the identity element in the operation of list concatenation.

For all types `α` and lists `as` of type `α`, appending the empty list `[]` to the front of `as` results in the original list `as`, i.e., `[] ++ as = as`.


Int.ModEq.symm

theorem Int.ModEq.symm : ∀ {n a b : ℤ}, a ≡ b [ZMOD n] → b ≡ a [ZMOD n] := by sorry

This theorem, `Int.ModEq.symm`, states that for all integers `n`, `a`, and `b`, if `a` is congruent to `b` modulo `n`, then `b` is also congruent to `a` modulo `n`. In mathematical terms, if `a ≡ b (mod n)`, then `b ≡ a (mod n)`. This is the symmetry property of congruence mod `n`.

For all integers `n`, `a`, and `b`, if `a` is congruent to `b` modulo `n`, then `b` is congruent to `a` modulo `n` (i.e., `a ≡ b (mod n)` implies `b ≡ a (mod n)`).


theorem Function.IsPeriodicPt.minimalPeriod_le :
    ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ},
      0 < n → Function.IsPeriodicPt f n x → Function.minimalPeriod f x ≤ n :=
  by sorry

The theorem `Function.IsPeriodicPt.minimalPeriod_le` states that for any type `α`, function `f` from `α` to `α`, point `x` of type `α`, and natural number `n`, if `n` is greater than 0 and `x` is a periodic point of `f` with period `n`, then the minimal period of `x` under `f` is less than or equal to `n`. This essentially means that the smallest number of iterations of `f` needed to return to `x` can't be more than the defined period `n` of `x` under `f`, assuming `n` is not zero.

For any function f from type α to α, point x of type α, and natural number n greater than 0, if x is a periodic point of f with period n, then the minimal period of x under f is less than or equal to n.


Submodule.IsOrtho.symm

theorem Submodule.IsOrtho.symm :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {U V : Submodule 𝕜 E}, U ⟂ V → V ⟂ U :=
  by sorry

This theorem, "Submodule.IsOrtho.symm", states that for any two submodules `U` and `V` of an inner product space `E` over a ring `𝕜`, if `U` is orthogonal to `V`, then `V` is also orthogonal to `U`. In other words, the orthogonality relation between submodules is symmetric.

If submodules U and V of an inner product space E over a ring are orthogonal to each other, then V is orthogonal to U.


/-- `∏ i in Nat.divisors n, cyclotomic i R = X ^ n - 1`.  -/
theorem Polynomial.prod_cyclotomic_eq_X_pow_sub_one :
    ∀ {n : ℕ},
      0 < n →
        ∀ (R : Type u_1) [inst : CommRing R],
          (Finset.prod (Nat.divisors n) fun i => Polynomial.cyclotomic i R) = Polynomial.X ^ n - 1 :=
  by sorry

The theorem `Polynomial.prod_cyclotomic_eq_X_pow_sub_one` asserts that for every positive natural number `n` and for any commutative ring `R`, the product of the `n`-th cyclotomic polynomials with coefficients in `R`, where the product is taken over the divisors of `n`, is equal to the polynomial `X` raised to the power `n` minus `1`. In mathematical terms, this can be written as $\prod_{i \in \text{divisors}(n)} \text{cyclotomic}(i, R) = X^n - 1$. This is a fundamental result in algebraic number theory.

The product of the `n`-th cyclotomic polynomials with coefficients in a commutative ring `R`, taken over the divisors of `n`, equals `X` raised to the power of `n` minus `1` in `R[X]`.


theorem Commute.one_left : ∀ {M : Type u_2} [inst : MulOneClass M] (a : M), Commute 1 a := by sorry

This theorem, `Commute.one_left`, states that for any type `M` that has a multiplication and one identity operation (captured by `MulOneClass M`), the number 1 commutes with any element `a` of type `M`. In other words, in the context of multiplication, multiplying 1 with any element `a` (`1 * a`) is the same as multiplying `a` with 1 (`a * 1`).

For any type `M` with multiplication and identity operation, 1 and any element `a` in `M` commute in multiplication: `1 * a = a * 1`.


theorem Set.univ_prod : ∀ {α : Type u_1} {β : Type u_2} {t : Set β}, Set.univ ×ˢ t = Prod.snd ⁻¹' t := by sorry

The theorem `Set.univ_prod` states that for any types `α` and `β`, and any set `t` of elements of type `β`, the Cartesian product of the universal set of type `α` and set `t` is equivalent to the preimage of set `t` under the function `Prod.snd`. In simpler terms, it means that the set of all pairs (from `α` and `t`) is the same as the set of all second elements from `t`.

The Cartesian product of the universal set of type `α` and a set `t` of type `β` is equal to the image of `t` under the second projection `Prod.snd`.


Set.Subsingleton.anti

theorem Set.Subsingleton.anti : ∀ {α : Type u} {s t : Set α}, Set.Subsingleton t → s ⊆ t → Set.Subsingleton s := by
  sorry

The theorem `Set.Subsingleton.anti` states that for any type `α` and any two sets `s` and `t` of type `α`, if `t` is a `Subsingleton` (meaning that `t` contains at most one element) and `s` is a subset of `t`, then `s` is also a `Subsingleton`. In other words, any subset of a set that contains at most one element must also contain at most one element.

If `t` is a subsingleton set and `s` is a subset of `t`, then `s` is also a subsingleton.


theorem compl_sup : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ := by sorry

This theorem states that for any Heyting algebra (a kind of lattice-based mathematical structure) and for any two elements `a` and `b` of that algebra, the complement of the supremum (join, or least upper bound) of `a` and `b` is equal to the infimum (meet, or greatest lower bound) of the complements of `a` and `b`. Symbolically, this can be written as: `(a ∪ b)' = a' ∩ b'`.

For any Heyting algebra, the complement of the join (supremum) of two elements is equal to the meet (infimum) of their complements: `(a ∪ b)' = a' ∩ b'`.


theorem Set.countable_singleton : ∀ {α : Type u} (a : α), Set.Countable {a} := by sorry

The theorem `Set.countable_singleton` states that for any type `α` and any element `a` of type `α`, the set containing only `a` is countable. In other words, there exists an injective function from the set `{a}` to the set of natural numbers `ℕ`. This implies that single-element sets, or singletons, are always countable regardless of what that single element is.

For any type `α` and any element `a` of type `α`, the singleton set `{a}` is countable.


MeasureTheory.AEStronglyMeasurable.smul

theorem MeasureTheory.AEStronglyMeasurable.smul :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {𝕜 : Type u_5} [inst_1 : TopologicalSpace 𝕜] [inst_2 : SMul 𝕜 β] [inst_3 : ContinuousSMul 𝕜 β] {f : α → 𝕜}
      {g : α → β},
      MeasureTheory.AEStronglyMeasurable f μ →
        MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.AEStronglyMeasurable (fun x => f x • g x) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.smul` states that if we have a measure space `m` over a type `α`, a measure `μ` on this space, a topological space `β`, a type `𝕜` that also has a topological space structure, a scalar multiplication operation on `𝕜` and `β`, and this scalar multiplication operation is continuous, then given two functions `f : α → 𝕜` and `g : α → β` that are almost everywhere strongly measurable with respect to measure `μ`, their scalar multiplication (i.e., the function `(fun x => f x • g x) : α → β` which takes an element `x` from `α` and maps it to the scalar multiplication of `f(x)` and `g(x)`) is also almost everywhere strongly measurable with respect to the same measure `μ`.

If `m` is a measure space, `μ` is a measure on `α`, `β` is a topological space, `𝕜` is a topological vector space over the real or complex numbers, `f : α → 𝕜` and `g : α → β` are almost everywhere strongly measurable, and scalar multiplication on `𝕜` is continuous, then the scalar multiplication of `f` and `g`, i.e., `(fun x => f x • g x) : α → β`, is also almost everywhere strongly measurable with respect to `μ`.


theorem Finset.image_image₂_distrib :
    ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7}
      [inst : DecidableEq α'] [inst_1 : DecidableEq β'] [inst_2 : DecidableEq γ] [inst_3 : DecidableEq δ]
      {f : α → β → γ} {s : Finset α} {t : Finset β} {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'},
      (∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)) →
        Finset.image g (Finset.image₂ f s t) = Finset.image₂ f' (Finset.image g₁ s) (Finset.image g₂ t) :=
  by sorry

This theorem, `Finset.image_image₂_distrib`, states that for all types `α`, `α'`, `β`, `β'`, `γ`, and `δ`, given that `α'`, `β'`, `γ`, and `δ` have decidable equality. If `f` is a binary function from `α` and `β` to `γ`, `s` is a finite set of type `α`, `t` is a finite set of type `β`, `g` is a function from `γ` to `δ`, `f'` is a binary function from `α'` and `β'` to `δ`, `g₁` is a function from `α` to `α'` and `g₂` is a function from `β` to `β'`. If for all `a` in `α` and `b` in `β`, the function `g` of `f(a,b)` is equal to `f'(g₁(a), g₂(b))`, then the image of `g` on the image of `f` over the product set of `s` and `t` is equal to the image of `f'` over the product set of the image of `g₁` on `s` and the image of `g₂` on `t`.

In mathematical terms, it states that the function application and the image operations can be exchanged under certain conditions. This is a distributive property of images of functions over finite sets.

If `f: α × β → γ`, `g: γ → δ` are functions, `s ⊆ α` and `t ⊆ β` are finite sets, `g₁: α → α'`, `g₂: β → β'` are functions such that `g(f(a, b)) = f'(g₁(a), g₂(b))` for all `a ∈ α` and `b ∈ β`, then `g(∏ i in s, f(a\_i, b\_i)) = ∏ j in g₁[s], f'(g₁(a\_j), g₂(b\_j))` and `g(∏ i in s, f(a\_i, b\_i)) = ∏ j in g₂[t], f'(g₁(a\_j), g₂(b\_j))`.


theorem Set.mem_union : ∀ {α : Type u} (x : α) (a b : Set α), x ∈ a ∪ b ↔ x ∈ a ∨ x ∈ b := by sorry

The theorem `Set.mem_union` states that for any type `α`, an element `x` of type `α`, and two sets `a` and `b` of type `α`, `x` is a member of the union of `a` and `b` if and only if `x` is a member of `a` or `x` is a member of `b`. This corresponds to the standard mathematical definition of union of sets: an element belongs to the union of two sets if it belongs to at least one of the sets.

For any type `α` and sets `a` and `b` of type `α`, `x ∈ a ∪ b` if and only if `x ∈ a` or `x ∈ b`.


IsCompact.union

theorem IsCompact.union :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsCompact t → IsCompact (s ∪ t) := by sorry

This theorem states that if we have two sets, `s` and `t`, in a topological space `X`, and both `s` and `t` are compact, then their union is also compact. In mathematical terms, if `s` and `t` are subsets of a topological space `X` such that for any nontrivial filter `f` that contains `s` or `t`, there exists an element in `s` or `t` such that every set of `f` meets every neighborhood of that element, then the same property holds for the union of `s` and `t`.

If `s` and `t` are compact subsets of a topological space `X`, then their union `s ∪ t` is also compact.


theorem Int.gcd_dvd_right : ∀ {a b : ℤ}, ↑(Int.gcd a b) ∣ b := by sorry

This theorem states that for any two integers `a` and `b`, the greatest common divisor (GCD) of `a` and `b` (calculated as a nonnegative integer) is a divisor of `b`. In other words, `b` is a multiple of the GCD of `a` and `b`. Here, `∣` is the "divides" relation in integer arithmetic, so `↑(Int.gcd a b) ∣ b` means that `b` divided by the GCD of `a` and `b` yields an integer.

For any integers `a` and `b`, the greatest common divisor `d` of `a` and `b` satisfies `d ∣ b`.


theorem Set.compl_iUnion₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} (s : (i : ι) → κ i → Set α),
      (⋃ i, ⋃ j, s i j)ᶜ = ⋂ i, ⋂ j, (s i j)ᶜ :=
  by sorry

This theorem states that for any type `α` and two index types `ι` and `κ`, given a function `s` that generates a set of elements of type `α` for each pair of indices `(i, j)` where `i` is of type `ι` and `j` is of type `κ(i)`, the complement (i.e., set of elements not contained in the set) of the union over all `i` and `j` of the sets `s i j` is equal to the intersection over all `i` and `j` of the complements of the sets `s i j`. This theorem is a generalization of De Morgan's laws to infinite unions and intersections. In mathematical notation, it can be written as $(\bigcup_{i, j} s(i, j))^c = \bigcap_{i, j} s(i, j)^c$.

The complement of the union of all sets indexed by pairs of types `ι` and `κ(ι)` from a function `s` is equal to the intersection of the complements of those sets. In mathematical notation: $(⋃_{i:\_} ⋃_{j:\kappa(i)} s(i, j))^c = ⋂_{i:\_} ∣_{j:\kappa(i)} s(i, j)^c$.


Nat.strongInductionOn

theorem Nat.strongInductionOn {motive : ℕ → Sort u} (n : ℕ) :
    ((n : ℕ) → ((m : ℕ) → m < n → motive m) → motive n) → motive n := by sorry

The theorem `Nat.strongInductionOn` is a version of mathematical induction for natural numbers, but stronger. Given a natural number `n` and a motive (a property or predicate) that applies to natural numbers, if for every natural number `n`, assuming the motive holds for all natural numbers less than `n` allows us to prove that the motive holds for `n`, then we can conclude that the motive holds for the original `n`. This kind of induction is called strong because it allows assuming the property for all `m` less than `n`, not just for `n-1` as in the ordinary mathematical induction.

If a property holds for all natural numbers less than `n` implies it holds for natural number `n` (stronger induction hypothesis), then the property holds for `n` (Nat.strongInductionOn).


theorem div_mul_div_comm :
    ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c d : α), a / b * (c / d) = a * c / (b * d) := by sorry

This theorem states that, for any type `α` that has a commutative division operation (i.e. a division in which the order of operands does not affect the result), and for any four elements `a`, `b`, `c`, and `d` of this type, the formula `(a / b) * (c / d) = (a * c) / (b * d)` holds true. In basic terms, it says that multiplication of two fractions (division expressions) is the same as multiplying the numerators (the top of the fractions) together and the denominators (the bottom of the fractions) together.

For types `α` with commutative division, `(a / b) * (c / d) = (a * c) / (b * d)` for all `a, b, c, d ∈ α`.


Convex.inter

theorem Convex.inter :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      {s t : Set E}, Convex 𝕜 s → Convex 𝕜 t → Convex 𝕜 (s ∩ t) :=
  by sorry

This theorem states that for any type 𝕜 with an ordered semiring structure, and any type E with an additive commutative monoid structure and a scalar multiplication by elements of 𝕜, if s and t are sets of elements of E and both are convex in the sense defined above (i.e., for any point x in the set, the set is star-convex with respect to x), then their intersection is also a convex set. In other words, the intersection of two convex sets is also convex.

Given types 𝕜 with an ordered semiring structure and E with an additive commutative monoid structure and scalar multiplication by elements of 𝕜, if s and t are convex subsets of E, then their intersection is also a convex subset.


theorem Mathlib.Order.LocallyFinite._auxLemma.3 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      (x ∈ Finset.Ioc a b) = (a < x ∧ x ≤ b) :=
  by sorry

This theorem states that for any type `α` with a preorder structure and that is a locally finite order, and for any elements `a`, `b`, and `x` of type `α`, `x` is in the interval `(a, b]`, represented as a finite set `Finset.Ioc a b`, if and only if `a` is less than `x` and `x` is less than or equal to `b`. In other words, `x` belongs to the set of elements greater than `a` and less than or equal to `b`.

For any locally finite preorder type `α` and elements `a`, `b` of `α`, `x` belongs to the interval `(a, b]` if and only if `a < x <= b`.


theorem max_assoc : ∀ {α : Type u} [inst : LinearOrder α] (a b c : α), max (max a b) c = max a (max b c) := by sorry

This theorem, `max_assoc`, states that for any type `α` that has a linear order, the maximum of three elements `a`, `b`, and `c` is associative. In other words, taking the maximum of `a` and `b` first, and then the maximum with `c`, is the same as taking the maximum of `b` and `c` first, and then the maximum with `a`. This can be mathematically expressed as: max(max(a, b), c) = max(a, max(b, c)).

For all types `α` with a linear order, the association holds: max(max(a, b), c) = max(a, max(b, c)).


theorem Multiset.sum_add :
    ∀ {α : Type u_2} [inst : AddCommMonoid α] (s t : Multiset α),
      Multiset.sum (s + t) = Multiset.sum s + Multiset.sum t :=
  by sorry

This theorem states that for any type `α` that has an additive commutative monoid structure, and for any two multisets `s` and `t` of this type, the sum of the multiset obtained by adding `s` and `t` is equal to the sum of `s` plus the sum of `t`. In other words, it asserts the distributive property of sum over the addition of multisets.

For any additive commutative monoid type `α`, the sum of the multiset obtained by adding two multisets `s` and `t` of type `α` is equal to the multiset obtained by adding their individual sums.


theorem Set.Finite.encard_lt_top : ∀ {α : Type u_1} {s : Set α}, Set.Finite s → Set.encard s < ⊤ := by sorry

This theorem states that for any set `s` of a certain type `α`, if that set is finite (as defined by the `Set.Finite` function), then the cardinality of the set (as computed by the `Set.encard` function) is strictly less than positive infinity (`⊤`). In other words, the size of any finite set is a finite number.

For any finite set `s` of type `α` in Lean, the cardinality of `s` (as computed by `Set.encard`) is a finite natural number less than infinity (`⊤`).


theorem CategoryTheory.ShortComplex.comp_τ₂ :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁₂ : S₁ ⟶ S₂) (φ₂₃ : S₂ ⟶ S₃),
      (CategoryTheory.CategoryStruct.comp φ₁₂ φ₂₃).τ₂ = CategoryTheory.CategoryStruct.comp φ₁₂.τ₂ φ₂₃.τ₂ :=
  by sorry

The theorem `CategoryTheory.ShortComplex.comp_τ₂` states that for a category `C` (of a certain type `u_1`) with zero morphisms and for any three short complexes `S₁`, `S₂`, and `S₃` in `C`, the composition of two morphisms `φ₁₂` (from `S₁` to `S₂`) and `φ₂₃` (from `S₂` to `S₃`) has its second homological component (`τ₂`) equal to the composition of the second homological components of `φ₁₂` and `φ₂₃` individually. In other words, (φ₁₂ ∘ φ₂₃).τ₂ = φ₁₂.τ₂ ∘ φ₂₃.τ₂, where "∘" denotes the composition of morphisms.

For any three short complexes `S₁`, `S₂`, and `S₃` in a category `C` with zero morphisms, the second homological component of their composition is equal to the composition of their second homological components: (φ₁₂ ∘ φ₂₃).τ₂ = φ₁₂.τ₂ ∘ φ₂₃.τ₂.


theorem CategoryTheory.ShortComplex.comp_τ₃ :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁₂ : S₁ ⟶ S₂) (φ₂₃ : S₂ ⟶ S₃),
      (CategoryTheory.CategoryStruct.comp φ₁₂ φ₂₃).τ₃ = CategoryTheory.CategoryStruct.comp φ₁₂.τ₃ φ₂₃.τ₃ :=
  by sorry

The theorem `CategoryTheory.ShortComplex.comp_τ₃` states that for any category `C` that has zero morphisms, and for any three short complexes `S₁`, `S₂`, and `S₃` in this category, the τ₃-component of the composition of two morphisms φ₁₂ from `S₁` to `S₂` and φ₂₃ from `S₂` to `S₃`, denoted `(CategoryTheory.CategoryStruct.comp φ₁₂ φ₂₃).τ₃`, is equal to the composition of the τ₃-components of the two morphisms, denoted `CategoryTheory.CategoryStruct.comp φ₁₂.τ₃ φ₂₃.τ₃`. In other words, the τ₃-component of the composition of two morphisms is the composition of the τ₃-components of the two morphisms.

For any category with zero morphisms, the τ₃-component of the composition of two short complex morphisms is equal to the composition of their τ₃-components.


theorem Ideal.pow_le_pow_right :
    ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R} {m n : ℕ}, m ≤ n → I ^ n ≤ I ^ m := by sorry

The theorem `Ideal.pow_le_pow_right` states that for any commutative semiring `R`, any ideal `I` of `R`, and any natural numbers `m` and `n`, if `m` is less than or equal to `n`, then the `n`-th power of `I` is a subset of or equal to the `m`-th power of `I`. This is to say, if we multiply the elements of the ideal `I` by themselves `n` times and `m` times respectively, where `m` is less than or equal to `n`, then every element produced in the `n`-th power operation is guaranteed to be in the result of the `m`-th power operation.

For any commutative semiring R, ideal I, and natural numbers m ≤ n, the m-th power of I is included in the n-th power of I.


theorem Mathlib.Order.WithBot._auxLemma.26 : ∀ {α : Type u_1} {a : α}, (↑a = ⊤) = False := by sorry

This theorem, `Mathlib.Order.WithBot._auxLemma.26`, states that for any type `α` and any element `a` of that type, the proposition that this element `a` (when coerced) equals to the top element `⊤` (also known as "infinity" in the context of orders), is always false. In other words, any specific element of a type cannot be equal to the top element when we are working in the lattice of with-bottom elements.

For any type `α` and its element `a`, `a` does not equal the top element `⊤` in the lattice of with-bottom elements.


theorem CochainComplex.HomComplex.Cochain.ofHoms_v :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G : CochainComplex C ℤ} (ψ : (p : ℤ) → F.X p ⟶ G.X p) (p : ℤ),
      (CochainComplex.HomComplex.Cochain.ofHoms ψ).v p p ⋯ = ψ p :=
  by sorry

The theorem `CochainComplex.HomComplex.Cochain.ofHoms_v` states that for any Category `C` with Preadditive structure, and for any two Cochain Complexes `F` and `G` on `C` indexed by integers, given a family of morphisms `ψ` from the `p`th object of `F` to the `p`th object of `G` where `p` is an integer, the value of the `v` method on the `p`-degree cochain constructed from `ψ` is equal to the original morphism `ψ p`. This provides a method for constructing cochains in the homology complex of two cochain complexes.

For any two cochain complexes F and G over a preadditive category C, and a family of morphisms ψ between their p-th objects, the p-degree cochain constructed from ψ in the hom complex of Hom(F, G) is equal to ψ itself.


FreeGroup.reduce.red

/-- The first theorem that characterises the function `reduce`: a word reduces to its maximal
reduction.  -/
theorem FreeGroup.reduce.red :
    ∀ {α : Type u} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.Red L (FreeGroup.reduce L) := by sorry

The theorem `FreeGroup.reduce.red` states that, for an arbitrary type `α` with decidable equality and any list `L` of pairs of elements from `α` and Boolean values, the reflexive-transitive closure of the `FreeGroup.Red.Step` relation (i.e., `FreeGroup.Red`) holds between `L` and its maximal reduction (i.e., `FreeGroup.reduce L`). Essentially, this means that any word can be reduced to its maximal reduction using the `FreeGroup.Red` relation.

For any type `α` with decidable equality and list `L` of pairs of elements from `α` and Boolean values, the reflexive-transitive closure of the `FreeGroup.Red.Step` relation equals the reduction of `L` in the free group.


theorem Set.image2_iUnion_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_4} (f : α → β → γ) (s : ι → Set α) (t : Set β),
      Set.image2 f (⋃ i, s i) t = ⋃ i, Set.image2 f (s i) t :=
  by sorry

The theorem `Set.image2_iUnion_left` states that for all types α, β, and γ, and all types ι (which can be thought of as an index set), given a binary function `f` from α and β to γ, a function `s` from ι to the set of α, and a set `t` of β, the image under `f` of the union over all `i` of `s i` and `t` is equal to the union over all `i` of the image under `f` of `s i` and `t`. In simple words, applying a function to the union of sets is the same as taking the union of the function applied to each set, essentially proving a property similar to the distributivity of function application over set union for the left side of the function.

For all types α, β, γ, index set ι, function f : α × β → γ, set s : ι → α, and set t : Set β, the image of the union of sets s i and t under f is equal to the union of the images of sets si and t under f.


theorem Nat.choose_succ_succ :
    ∀ (n k : ℕ), Nat.choose (Nat.succ n) (Nat.succ k) = Nat.choose n k + Nat.choose n (Nat.succ k) := by sorry

The theorem `Nat.choose_succ_succ` is about binomial coefficients (commonly denoted by "n choose k") in combinatorics. It states that for all natural numbers `n` and `k`, the binomial coefficient of `n+1` choose `k+1` is equal to the sum of the binomial coefficient of `n` choose `k` and the binomial coefficient of `n` choose `k+1`. In other words, this theorem is a formalization of the Pascal's Rule, which is a fundamental property of binomial coefficients used in combinatorial mathematics. The theorem may be written in LaTeX mathematics as: $\binom{n+1}{k+1} = \binom{n}{k} + \binom{n}{k+1}$.

The theorem `Nat.choose_succ_succ` in Lean 4 states that for all natural numbers `n` and `k`, the binomial coefficient of `n+1` choose `k+1` equals the sum of the binomial coefficients of `n` choose `k` and `n` choose `k+1`. In mathematical notation, $\binom{n+1}{k+1} = \binom{n}{k} + \binom{n}{k+1}$.


AList.ext

theorem AList.ext : ∀ {α : Type u} {β : α → Type v} {s t : AList β}, s.entries = t.entries → s = t := by sorry

This is a theorem about associative lists (ALists) in the Lean 4 theorem prover. It states that for any type `α` and a type function `β` that depends on `α`, given two associative lists `s` and `t` with the type of keys determined by `α` and the type of values determined by `β`, if the entries of `s` and `t` are equal (that is, they have the same key-value pairs in the same order), then the associative lists `s` and `t` themselves are equal. This is a fundamental property of data structures like associative lists, which essentially states that two associative lists are equal if they have the same content.

If two associative lists of type `α × β` have equal entries, then they are equal as lists.


theorem Computation.get_mem :
    ∀ {α : Type u} (s : Computation α) [h : Computation.Terminates s], Computation.get s ∈ s := by sorry

The theorem `Computation.get_mem` states that for any type `α` and any computation `s` of type `Computation α` that terminates (denoted by `Computation.Terminates s`), the result of the computation (obtained by `Computation.get s`) is a member of `s`. In other words, the computed value of any terminating computation is an element of the set defined by that computation.

For any terminating computation `s : Computation α` in Lean 4, the result `Computation.get s` is an element of the set defined by `s` (i.e., `Computation.get s ∈ {x | Computation.apply s x}`).


theorem MeasurableSet.univ_pi :
    ∀ {δ : Type u_4} {π : δ → Type u_6} [inst : (a : δ) → MeasurableSpace (π a)] [inst_1 : Countable δ]
      {t : (i : δ) → Set (π i)}, (∀ (i : δ), MeasurableSet (t i)) → MeasurableSet (Set.pi Set.univ t) :=
  by sorry

The theorem `MeasurableSet.univ_pi` asserts that for any type `δ`, any function `π` from `δ` to another type, given that each `π a` has a measurable space structure and `δ` is countable, if we have a family of sets `t` indexed by `δ`, then if every set `t i` is measurable, the set of dependent functions from the universal set of `δ` to each `t i` is also measurable. This result is important in the theory of measure spaces and integration, especially when dealing with products of measurable spaces.

If `δ` is a countable type, `π: δ → Type`, and each `π a` has a measurable space structure, then the dependent family `{t i := t (π i)}` of measurable sets indexed by `δ` implies that the family `{f: δ → t i | i ∈ δ}` of functions from `δ` to each `t i` is measurable.


theorem MeasureTheory.Memℒp.coeFn_toLp :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f : α → E} (hf : MeasureTheory.Memℒp f p μ),
      ↑↑(MeasureTheory.Memℒp.toLp f hf) =ᶠ[MeasureTheory.Measure.ae μ] f :=
  by sorry

This theorem states that for any function `f` from `α` to `E` and for any measure `μ` on the measurable space `α`, if the function `f` satisfies the property `Memℒp` (which means the function is almost everywhere (ae) strongly measurable and its Lp norm is finite), then the function representation in Lp space obtained by `Memℒp.toLp` is almost everywhere equal to the original function `f`. In mathematical terms, it means if `f:α→E` is in `Lp` space (denoted by `Memℒp f p μ`), then `f` is almost everywhere equal to the function represented in `Lp` space (denoted by `MeasureTheory.Memℒp.toLp f hf`). Here, "almost everywhere" refers to the set of points where a property holds except for a set of measure zero, defined by `MeasureTheory.Measure.ae μ`.

If a function `f: α → E` is almost everywhere (ae) strongly measurable with finite Lp norm, then `f` is a.e. equal to its representation in the Lp space obtained by `Memℒp.toLp`.


theorem EReal.coe_lt_coe_iff : ∀ {x y : ℝ}, ↑x < ↑y ↔ x < y := by sorry

This theorem states that for any two real numbers `x` and `y`, the statement that the embedding of `x` is less than the embedding of `y` is equivalent to the statement that `x` is less than `y`. In other words, it describes the relationship between the order of real numbers and their corresponding elements in the extended real number system. The embeddings referred to here are the natural mappings from the set of real numbers to the set of extended real numbers.

The theorem asserts that for real numbers x and y, x < y if and only if x.__le__(y) holds in the extended real numbers.


theorem monotone_smul_left_of_nonneg :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulMono α β], 0 ≤ a → Monotone fun x => a • x :=
  by sorry

The theorem `monotone_smul_left_of_nonneg` states that for any types `α` and `β`, given an element `a` of type `α`, and given that `α` and `β` are preordered, `α` has a zero, and `α` and `β` have a positively monotone scalar multiplication operation, if `a` is non-negative (i.e., `0 ≤ a`), then the function that maps `x` to the scalar multiplication of `a` and `x` (i.e., `a • x`) is monotone. In other words, if `a` is non-negative, increasing `x` will not decrease `a • x`.

If `α` is a preordered type with a zero, `β` is another type, `a : α` is non-negative, and `α` and `β` have a positively monotone scalar multiplication, then the function `x => a • x` is monotone on `α`.


theorem FreeMonoid.hom_eq :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Monoid M] ⦃f g : FreeMonoid α →* M⦄,
      (∀ (x : α), f (FreeMonoid.of x) = g (FreeMonoid.of x)) → f = g :=
  by sorry

The theorem `FreeMonoid.hom_eq` states that for any type `α` and any type `M` that has a monoid structure, if `f` and `g` are two monoid homomorphisms from the free monoid over `α` to `M` such that they map any singleton list generated from an element of `α` to the same element in `M`, then the two homomorphisms `f` and `g` are equal. In other words, any two monoid homomorphisms from the free monoid over a set `α` to another monoid `M` are determined uniquely by their action on the elements of `α`.

Given a type `α` and a monoid `M`, any two monoid homomorphisms from the free monoid over `α` to `M` that agree on singleton lists are equal.


theorem RingHom.map_det :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type w}
      [inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), f (Matrix.det M) = Matrix.det ((RingHom.mapMatrix f) M) :=
  by sorry

The theorem `RingHom.map_det` states that for any types `n`, `R`, and `S` where `n` has decidable equality and is a finite type, `R` and `S` are commutative rings, any ring homomorphism `f` from `R` to `S`, and any matrix `M` with elements in `R` and indices in `n`, the determinant of the matrix `M` after applying the ring homomorphism `f` to each of its elements is equal to the result of applying `f` to the determinant of `M`. In other words, the mapping of the determinant of a matrix under a ring homomorphism is equal to the determinant of the matrix obtained by mapping each element of the original matrix under the same ring homomorphism. This is expressed mathematically as `f(det(M)) = det(f(M))` where `f` is the ring homomorphism and `M` is the matrix.

The determinant of a matrix under a ring homomorphism is equal to the ring homomorphism's application to the determinant of the original matrix. In other words, `f(det(M)) = det(f(M))` for any commutative rings `R` and `S`, finite type `n` with decidable equality, and ring homomorphism `f` from `R` to `S`.


theorem Polynomial.degree_X_pow :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : Nontrivial R] (n : ℕ), Polynomial.degree (Polynomial.X ^ n) = ↑n := by
  sorry

The theorem `Polynomial.degree_X_pow` states that for any semiring `R` (a type of algebraic structure) that is not trivial (i.e., containing at least two distinct elements), and for any natural number `n`, the degree of the polynomial obtained by raising the polynomial variable `X` to the power of `n` is equal to `n`. In mathematical terms, this is saying that the degree of the polynomial `X^n` is `n`.

For any semiring R with at least two elements and natural number n, the degree of the polynomial X^n is n.


theorem Set.add_mem_add : ∀ {α : Type u_2} [inst : Add α] {s t : Set α} {a b : α}, a ∈ s → b ∈ t → a + b ∈ s + t := by
  sorry

The theorem `Set.add_mem_add` states that for any type `α` that has an addition operation, given two sets `s` and `t` of elements of type `α`, and any two elements `a` and `b` such that `a` is in `s` and `b` is in `t`, then the sum `a + b` is in the sum set `s + t`. This essentially formalizes the intuitive idea that the sum of two elements, one from each of two sets, is in the set of all sums of elements from the two sets.

For any type `α` with addition and sets `s` and `t` of its elements, if `a` is in `s` and `b` is in `t`, then `a + b` is in `s + t`.


theorem MeasureTheory.Measure.finiteAt_nhds :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} [inst : TopologicalSpace α] (μ : MeasureTheory.Measure α)
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] (x : α), MeasureTheory.Measure.FiniteAtFilter μ (nhds x) :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` and a topological space instance on `α`, for any measure `μ` (which is a locally finite measure) and for any element `x` of `α`, the measure `μ` is finite at the neighborhood filter of `x`. In other words, there exists some neighborhood of `x` where the measure `μ` is finite. Note that a neighborhood of `x` is a set containing an open set around `x` and a measure is considered finite at a filter if it's finite at some set within the filter.

For any measurable space, topological space instance, locally finite measure, and element in the space, there exists a finite measure value at some open neighborhood of that element.


theorem inv_eq_iff_eq_inv : ∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, a⁻¹ = b ↔ a = b⁻¹ := by sorry

This theorem states that for any type `G` that has an involutive inverse (involutive in this context means applying the operation twice yields the original element), and for any two elements `a` and `b` of `G`, the inverse of `a` is equal to `b` if and only if `a` is equal to the inverse of `b`. The `InvolutiveInv G` constraint ensures that `G` has an operation that can be applied twice to get back the original element, such as negation in the integers or complex conjugation in the complex numbers. This theorem essentially captures the symmetry in the action of the inversion operation.

For any type `G` with an involutive operation and elements `a` and `b`, `a` and `b` have inverses of each other if and only if `a` is the inverse of `b` and `b` is the inverse of `a`.


theorem and_and_and_comm : ∀ {a b c d : Prop}, (a ∧ b) ∧ c ∧ d ↔ (a ∧ c) ∧ b ∧ d := by sorry

This theorem states that for any four propositions `a`, `b`, `c`, and `d`, the logical conjunctions of these propositions are commutative under a specific pattern. That is, having `a` and `b` together, and `c` and `d` separately, is equivalent to having `a` and `c` together, and `b` and `d` separately. In other words, $(a \land b) \land c \land d$ is logically equivalent to $(a \land c) \land b \land d$.

The theorem asserts the commutativity of logical conjunction for four propositions, that is, $(a \land b) \land c \land d \equiv (a \land c) \land b \land d$.


theorem Finset.sdiff_subset : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), s \ t ⊆ s := by sorry

The theorem `Finset.sdiff_subset` states that for any type `α` with decidable equality, and any two finite sets `s` and `t` of type `α`, the set difference `s \ t` is a subset of `s`. In other words, all elements of the set `s` minus the set `t` (notated as `s \ t`) originally belong to `s`.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, `s \ t` is a subset of `s`.


theorem Nat.descFactorial_eq_factorial_mul_choose :
    ∀ (n k : ℕ), Nat.descFactorial n k = Nat.factorial k * Nat.choose n k := by sorry

The theorem `Nat.descFactorial_eq_factorial_mul_choose` states that for any two natural numbers `n` and `k`, the descending factorial of `n` taken `k` at a time is equal to the product of the factorial of `k` and the binomial coefficient of `n` choose `k`. In mathematical terms, it expresses the equality `n.descFactorial k = k! * (n choose k)`. This theorem is a relationship between factorials, binomial coefficients, and descending factorials in combinatorial mathematics.

For any natural numbers `n` and `k`, the descending factorial of `n` taken `k` at a time equals the product of the factorial of `k` and the binomial coefficient of `n` choose `k`: `n.descFactorial k = k! * (n choose k)`.


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

This theorem states that, for any two types `α` and `β` equipped with uniform spaces and any function `f` from `α` to `β` that is uniformly continuous, then for any element `a` of `α`, the completion of the map `f` at the completion of `a` is equal to the completion of `f(a)`. In other words, if we first apply the function `f` to an element and then complete it, it is the same as if we first complete the element and then apply the completed function.

For any uniformly continuous function `f` from complete uniform space `α` to complete uniform space `β`, the completion of `f` at a point `a` in `α` is equal to the completion of `f(a)` in `β`.


theorem Nat.lt_of_sub_eq_succ : ∀ {m n l : ℕ}, m - n = Nat.succ l → n < m := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `l`, if the difference between `m` and `n` equals the successor (or `l + 1`) of `l`, it follows that `n` is less than `m`. In other words, if `m - n` gives a positive result (the successor of some natural number `l`), then `m` must be greater than `n`.

If `m` and `n` are natural numbers such that `m = l + 1 + n`, then `m > n`.


IsAddUnit.add

theorem IsAddUnit.add :
    ∀ {M : Type u_1} [inst : AddMonoid M] {a b : M}, IsAddUnit a → IsAddUnit b → IsAddUnit (a + b) := by sorry

The theorem `IsAddUnit.add` states that for any type `M` that is an instance of `AddMonoid`, if `a` and `b` are elements of `M` and both `a` and `b` are `AddUnit` elements (i.e., they have a two-sided additive inverse), then the sum of `a` and `b` is also an `AddUnit`. In other words, the sum of two elements, each having a two-sided additive inverse, also has a two-sided additive inverse.

If `a` and `b` are elements of an additive monoid `M` with two-sided additive inverses, then `a + b` also has a two-sided additive inverse.


/-- **Alias** of the reverse direction of `Polynomial.natDegree_le_iff_degree_le`. -/
theorem Polynomial.natDegree_le_of_degree_le :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      Polynomial.degree p ≤ ↑n → Polynomial.natDegree p ≤ n :=
  by sorry

The theorem `Polynomial.natDegree_le_of_degree_le` states that for any semiring `R`, polynomial `p` of type `R`, and natural number `n`, if the degree of `p` (the highest power of `X` appearing in `p`) is less than or equal to `n`, then the natural degree of `p` (which is the forced degree of `p` to natural numbers, with the degree of a zero polynomial defined as 0) is also less than or equal to `n`. Essentially, this theorem provides the condition under which the natural degree of a polynomial is less than or equal to a given natural number, based on its degree.

For any semiring `R`, polynomial `p` of degree `d` over `R`, and natural number `n`, if `d` ≤ `n`, then the natural degree of `p` is also less than or equal to `n`.


theorem finsum_eq_sum_of_support_subset :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) {s : Finset α},
      Function.support f ⊆ ↑s → (finsum fun i => f i) = Finset.sum s fun i => f i :=
  by sorry

This theorem states that for any type `α` and `M` where `M` is an additive commutative monoid, and any function `f` from `α` to `M`, if the support of the function `f` is a subset of the elements in the finset `s`, then the sum of `f x` for all `x` in the support of `f` (denoted by `finsum`) is equal to the sum of `f x` for all `x` in the finset `s` (denoted by `Finset.sum`). Here, the support of a function is the set of points where the function is non-zero.

For any additive commutative monoid M, type α, and function f from α to M with finite support contained in a finset s, the sum of f x over the support equals the sum of f x over s.


theorem Function.Injective.image_injective :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β}, Function.Injective f → Function.Injective (Set.image f) := by sorry

This theorem states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is injective, then the function that maps a set `s` of type `α` to the image of `s` under `f` is also injective. In mathematical terms, if `f : α → β` is an injective function, then the function `g: Set α → Set β` defined by `g(s) = f '' s` is also injective.

If `f : α → β` is an injective function, then the function `g : Set α → Set β` defined by `g(s) = {x │ ∃ (a ∈ s). f(a) = x}` is also injective. (Note: This statement assumes the set theoretic interpretation of Lean types and functions.)


theorem Complex.exp_neg : ∀ (x : ℂ), Complex.exp (-x) = (Complex.exp x)⁻¹ := by sorry

This theorem states that for all complex numbers `x`, the complex exponential of the negation of `x` is equal to the multiplicative inverse of the complex exponential of `x`. In other words, `Complex.exp (-x) = 1/(Complex.exp x)`. This mirrors the familiar property from real numbers that the exponential function of a negative input is the reciprocal of the exponential function with the same but positive input.

The complex exponential function is its own multiplicative inverse for the negated argument: `Complex.exp (-x) = 1 / (Complex.exp x)`.


theorem Set.inter_union_diff : ∀ {α : Type u} (s t : Set α), s ∩ t ∪ s \ t = s := by sorry

The theorem `Set.inter_union_diff` states that for any type `α` and any sets `s` and `t` of type `α`, the union of the intersection of `s` and `t` and the difference of `s` and `t` is equal to `s`. In other words, if we take the common elements of `s` and `t` (i.e., `s ∩ t`), and unite them with the elements that are in `s` but not in `t` (i.e., `s \ t`), we get back the set `s`. This is expressed in terms of set operations, and is a restatement of a standard identity in set theory.

The theorem `Set.inter_union_diff` asserts that for any set `α` and sets `s` and `t` in `α`, `s = (s ∩ t) ∪ (s \ t)`.


theorem Nat.dvd_mul_right : ∀ (a b : ℕ), a ∣ a * b := by sorry

This theorem states that for any two natural numbers `a` and `b`, `a` is a divisor of the product `a * b`. In mathematical terms, this is the principle that any number `a` divides its own multiplication with any other number `b`.

For all natural numbers a and b, a divides the product a * b.


theorem Ordnode.dual_dual : ∀ {α : Type u_1} (t : Ordnode α), Ordnode.dual (Ordnode.dual t) = t := by sorry

This theorem, `Ordnode.dual_dual`, states that for any type `α` and any value `t` of type `Ordnode α`, applying the `Ordnode.dual` function twice to `t` returns `t` itself. In other words, the `Ordnode.dual` function is its own inverse when applied twice.

For any type `α` and any `Ordnode α` value `t`, applying the `Ordnode.dual` function twice to `t` results in `t`. That is, `Ordnode.dual (Ordnode.dual t) = t`.


theorem mem_closure_iff_nhds_basis :
    ∀ {X : Type u} {ι : Sort w} {x : X} {t : Set X} [inst : TopologicalSpace X] {p : ι → Prop} {s : ι → Set X},
      Filter.HasBasis (nhds x) p s → (x ∈ closure t ↔ ∀ (i : ι), p i → ∃ y ∈ t, y ∈ s i) :=
  by sorry

This theorem, `mem_closure_iff_nhds_basis`, states that for any topological space `X`, an indexing type `ι`, a point `x` in `X`, and a set `t` of `X`, given a basis `{s i | p i}` for the neighborhood filter at `x`, then `x` is a member of the closure of `t` if and only if for all `i` in `ι` such that `p i` is true, there exists an element `y` in `t` that is also in `s i`. Here, the basis of a filter is a system of sets that can be used to generate the entire filter, and the closure of a set `t` is the smallest closed set that contains `t`. Essentially, the theorem establishes a condition for when a point is in the closure of a set, in terms of the basis sets of the point's neighborhood filter.

For any topological space X, point x in X, set t, and basis {si : p i} for the neighborhood filter at x, x is in the closure of t if and only if for all i, if p i then there exists y in t with y in si.


theorem lt_add_iff_pos_right :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α},
      a < a + b ↔ 0 < b :=
  by sorry

This theorem states that for any type `α` that forms an additive monoid and has a less-than (`<`) relation, and for any values `a` and `b` of type `α`, `a` is less than `a + b` if and only if `0` is less than `b`. The less-than relation is assumed to behave coherently with addition (meaning it respects the order of addition), as expressed by the `CovariantClass` and `ContravariantClass` instances.

For any additive monoid type `α` with a covariant and contravariant order relation `<`, we have `a < a + b` if and only if `0 < b`.


theorem eq_false_of_decide : ∀ {p : Prop} {x : Decidable p}, decide p = false → p = False := by sorry

This theorem states that for all propositions `p` and any instance `x` of `p` being decidable, if the decision procedure `decide p` returns `false`, then the proposition `p` is equivalent to `False`. It essentially indicates that if a decidable proposition is determined to be false, then the proposition itself is false. This is used in the context where the truth value of a proposition can be algorithmically determined.

If a decidable proposition `p` returns `false` when applied to an instance `x`, then `p` is equivalent to `False`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.65 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) := by sorry

This theorem states that for any type `α` with decidable equality, and for any multisets `s` and `t` of type `α` and any element `a` of type `α`, the statement "`a` is in the union of `s` and `t`" is equivalent to the statement "`a` is in `s` or `a` is in `t`". Here, a multiset is a set with duplicate elements allowed, and the union of two multisets `s` and `t` is a multiset that contains all the elements from `s` and `t`, including duplicates.

For any type `α` with decidable equality, and for any multisets `s` and `t` of type `α` and any element `a` of type `α`, `a` is in the union of `s` and `t` if and only if `a` is in `s` or `a` is in `t`.


theorem Finset.sum_le_card_nsmul :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] (s : Finset ι) (f : ι → N) (n : N),
      (∀ x ∈ s, f x ≤ n) → Finset.sum s f ≤ s.card • n :=
  by sorry

This theorem, `Finset.sum_le_card_nsmul`, states that for any type `ι`, type `N` that is an ordered commutative monoid, a finite set `s` of type `ι`, a function `f` from `ι` to `N`, and a value `n` of type `N`, if for all elements `x` in the set `s` the value of the function `f` at `x` is less than or equal to `n`, then the sum of the function `f` over all elements in the set `s` is less than or equal to the cardinality of the set `s` times `n`. Here the `•` operator represents scalar multiplication, meaning the multiplication of the integer cardinality of the set `s` with the element `n` of the monoid `N`.

For any finite set $s$ of type $\ι$, ordered commutative monoid $N$, function $f : \ι \to N$, and value $n \in N$, if $f(x) \le n$ for all $x \in s$, then $\sum_{x \in s} f(x) \le |s| \cdot n$.


theorem CategoryTheory.Functor.mapIso_refl :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
      (F : CategoryTheory.Functor C D) (X : C),
      F.mapIso (CategoryTheory.Iso.refl X) = CategoryTheory.Iso.refl (F.obj X) :=
  by sorry

This theorem states that for any category `C` and `D`, and any functor `F` from `C` to `D`, the mapping of the identity isomorphism on an object `X` of `C` under the functor `F` is equal to the identity isomorphism on the image of `X` under the functor `F`. More formally, for any object `X` in `C`, `F.mapIso` applied to the identity isomorphism on `X` will yield the identity isomorphism on `F.obj X`. This exhibits that functors preserve identity isomorphisms.

For any functor F from category C to category D and any object X in C, the image under F of the identity isomorphism on X is equal to the identity isomorphism on F(X).


theorem Finsupp.sum_zero_index :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] {h : α → M → N},
      Finsupp.sum 0 h = 0 :=
  by sorry

The theorem `Finsupp.sum_zero_index` states that for any types `α`, `M`, and `N` where `M` has an instance of `Zero` and `N` is an additive commutative monoid, and any function `h` from `α` and `M` to `N`, the sum of `h a (f a)` over the support of the zero function (`f = 0`) is zero. This is equivalent to stating that the sum of the function `h` over an empty set of inputs (since the support of the zero function is empty) is zero.

For any additive commutative monoid N with zero element, function h from type α x M to N, and zero function f on α, the sum of h (a, x) over the support of f (where a is an element of α) is zero.


theorem iInf_apply :
    ∀ {α : Type u_9} {β : α → Type u_10} {ι : Sort u_11} [inst : (i : α) → InfSet (β i)] {f : ι → (a : α) → β a}
      {a : α}, iInf (fun i => f i) a = ⨅ i, f i a :=
  by sorry

This theorem states that for any indexing type `ι`, any type `α`, and a dependent type `β` based on `α`, given a function `f` from `ι` to `α` that maps each index to a value of type `β`, and some `a` of type `α`, applying the indexed infimum function `iInf` to `f` at `a` is equivalent to taking the infimum over all the values of `f i a` for each index `i`. In other words, it formalizes the concept of the infimum of a set of dependent values indexed by `ι`.

For any indexing type `ι`, type `α`, dependent type `β`, function `f` from `ι` to `α` to `β`, and `a` of type `α`, `iInf (f) a = inf { f i a | i : ι }`.


theorem Real.exp_lt_exp : ∀ {x y : ℝ}, Real.exp x < Real.exp y ↔ x < y := by sorry

This theorem states that for any two real numbers `x` and `y`, the exponential of `x` is less than the exponential of `y` if and only if `x` is less than `y`. In other words, the Real exponential function is strictly increasing. In mathematical terms, it says that for all $x, y \in \mathbb{R}$, $e^{x} < e^{y}$ if and only if $x < y$.

The real exponential function is strictly increasing, that is, for all $x, y \in \mathbb{R}$, $x < y$ if and only if $e^x < e^y$.


theorem Fin.snoc_castSucc :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α (Fin.castSucc i)) (i : Fin n),
      Fin.snoc p x (Fin.castSucc i) = p i :=
  by sorry

This theorem states that for any natural number `n` and any dependent type `α : Fin (n + 1) → Type u`, given an object `x` of type `α (Fin.last n)` (i.e., `x` is an element of the type indexed by the last element of `Fin (n+1)`), a function `p : (i : Fin n) → α (Fin.castSucc i)` (i.e., `p` maps each element of `Fin n` after being embedded into `Fin (n+1)` to an object of the corresponding type in `α`), and an element `i` of `Fin n`, applying `Fin.snoc` to `p`, `x`, and the embedded element `Fin.castSucc i` results in the same value as applying `p` to `i`. In essence, this theorem proves a property of the `Fin.snoc` operation which adds an element at the end of an `n`-tuple, showing that it behaves as expected when applied to an element that isn't the additional end element.

For any natural number `n` and dependent type `α : Fin (n + 1) → Type u`, given an element `x : α (Fin.last n)`, a function `p : Fin n → α (Fin.castSucc i)`, and `i : Fin n`, `Fin.snoc p x (Fin.castSucc i) = p i`.


theorem CircleDeg1Lift.commute_add_int : ∀ (f : CircleDeg1Lift) (n : ℤ), Function.Commute ⇑f fun x => x + ↑n := by sorry

The theorem `CircleDeg1Lift.commute_add_int` states that for any `CircleDeg1Lift` function `f` and any integer `n`, the function `f` commutes with the function that adds `n` to its input. In other words, applying `f` and then adding `n` is the same as first adding `n` and then applying `f` for all inputs, expressed mathematically as `f(x + n) = f(x) + n` for all `x`.

For all `CircleDeg1Lift` functions `f` and integers `n`, `f(x + n) = f(x) + n` for all `x`.


/-- Group homomorphisms preserve integer power.  -/
theorem MonoidHom.map_zpow :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : DivisionMonoid β] (f : α →* β) (g : α) (n : ℤ),
      f (g ^ n) = f g ^ n :=
  by sorry

The theorem `MonoidHom.map_zpow` states that for any group homomorphism `f` from a group `α` to a division monoid `β`, and any element `g` in `α` and any integer `n`, the mapping of the `n`-th power of `g` under `f` is the same as the `n`-th power of the mapping of `g` under `f`. In other words, the power operation for `g` in the domain group `α` is preserved under the homomorphism `f` when mapped to the codomain `β`.

For any group homomorphism from a group to a division monoid and any group element and integer, the image of the element's `n`-th power under the homomorphism is equal to the `n`-th power of the image of the element.


theorem Multiset.mem_coe : ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ ↑l ↔ a ∈ l := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any list `l` of type `α`, `a` is a member of the multiset corresponding to `l` if and only if `a` is a member of `l`. In other words, an element is in the multiset created from a list if and only if it is in the original list. The ↑ operator is used in Lean to denote the coercion of a list into a multiset.

For any type `α` and list `l` of elements `α`, the multiset `↑l` contains an element `a` if and only if `a` is in `l`.


theorem Rat.cast_lt : ∀ {K : Type u_5} [inst : LinearOrderedField K] {m n : ℚ}, ↑m < ↑n ↔ m < n := by sorry

This theorem states that for any linear ordered field `K` and any two rational numbers `m` and `n`, the cast of `m` to `K` is less than the cast of `n` to `K` if and only if `m` is less than `n`. In other words, the inequality relationship between `m` and `n` is preserved when they are both cast to elements of the field `K`.

For any linear ordered field `K`, the cast of rational number `m` to `K` is less than the cast of rational number `n` to `K` if and only if `m` is less than `n`.


theorem monotone_mul_left_of_nonneg :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a : α}, 0 ≤ a → Monotone fun x => a * x := by sorry

The theorem `monotone_mul_left_of_nonneg` states that for any type `α` that has an ordered semiring structure, for any element `a` of type `α` which is nonnegative (i.e., `0 ≤ a`), the function which multiplies `a` to the left is monotone. In other words, if `a` is a nonnegative number in an ordered semiring, then for any two elements `b` and `c` of the semiring, if `b ≤ c` then `a * b ≤ a * c`.

For any non-negative element `a` in an ordered semiring `α`, the multiplication-by-`a` function is monotone, that is, `a * b ≤ a * c` for all `b ≤ c` in `α`.


theorem lt_of_smul_lt_smul_right :
    ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero β] [inst_4 : SMulPosReflectLT α β], a₁ • b < a₂ • b → 0 ≤ b → a₁ < a₂ :=
  by sorry

This theorem, `lt_of_smul_lt_smul_right`, asserts that for any types `α` and `β`, given any two elements `a₁` and `a₂` of type `α` and an element `b` of type `β`, if type `α` can be scaled by type `β` (indicated by `SMul α β`) and both `α` and `β` are preordered (i.e., have a specified order property), if `b` is nonnegative, and if the multiplication of `α` and `β` reflects the order property (indicated by `SMulPosReflectLT α β`), then if `a₁ • b` is less than `a₂ • b`, it implies `a₁` is less than `a₂`. In other words, the theorem ensures that the order is maintained when scaling by a nonnegative factor.

If `α` and `β` are preordered types with `α` scalable by `β` and `SMul PosReflectsLT` holds, then `a₁ < a₂` implies `a₁ * b < a₂ * b` for all nonnegative `b` in `β`.


theorem Pi.nnnorm_def :
    ∀ {ι : Type u_4} {π : ι → Type u_9} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedAddGroup (π i)]
      (f : (i : ι) → π i), ‖f‖₊ = Finset.sup Finset.univ fun b => ‖f b‖₊ :=
  by sorry

The theorem `Pi.nnnorm_def` states that for any finite type `ι` (denoted as `Fintype ι`) and a function `f` that maps each element of `ι` to a seminormed add group `π i`, the nonnegative norm (denoted as `‖f‖₊`) of the function `f` is equal to the supremum (`Finset.sup`) of the nonnegative norms of the function `f` evaluated at each element in the universal finite set of type `Finset α` (denoted as `Finset.univ`). In mathematical terms, this could be written as: for all `f` from `ι` to `π i`, we have `‖f‖₊ = sup {‖f b‖₊ : b ∈ ι}`.

The nonnegative norm of a function from a finite type to a seminormed add group is equal to the supremum of the nonnegative norms of the function evaluated at each element in the universal finite set.


theorem sub_sub_sub_cancel_right : ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a - c - (b - c) = a - b := by sorry

This theorem states that for all types `G` that form an additive group, for any three elements `a`, `b`, and `c` in this group, the expression `a - c - (b - c)` simplifies to `a - b`. In mathematical notation, for all $a, b, c \in G$, where $G$ is an additive group, we have that $a - c - (b - c) = a - b$.

For all additive groups G and elements a, b, c in G, the expression a - c - (b - c) equals a - b.


theorem Monotone.leftLim_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f → ∀ {x y : α}, x ≤ y → Function.leftLim f x ≤ f y :=
  by sorry

The theorem `Monotone.leftLim_le` states that for all types `α` and `β`, given that `α` is a linear order, `β` is a conditionally complete linear order, `β` is a topological space, and `β` has an order topology, then for any function `f` from `α` to `β`, if `f` is monotone, i.e.,  `f` preserves the order (`a ≤ b` implies `f a ≤ f b`), then for all `x` and `y` in `α`, if `x` is less than or equal to `y`, the left limit of the function `f` at `x` is less than or equal to the function `f` at `y`. In other words, the left limit of a monotone function at a point does not exceed the function's value at any greater point.

For any monotonic function from a linearly ordered type to a conditionally complete linear order topology, the left limit at a point is less than or equal to the function value at any greater point.


theorem map_ofNat :
    ∀ {R : Type u_3} {S : Type u_4} {F : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
      [inst_2 : FunLike F R S] [inst_3 : RingHomClass F R S] (f : F) (n : ℕ) [inst_4 : Nat.AtLeastTwo n],
      f (OfNat.ofNat n) = OfNat.ofNat n :=
  by sorry

This theorem, `map_ofNat`, states that for any types `R`, `S`, and `F`, if `R` and `S` are both non-associative semirings, `F` has an injective function-like coercion to functions from `R` to `S`, `F` is a ring homomorphism from `R` to `S`, `f` is a term of type `F`, and `n` is a natural number such that `n` is at least two, then applying `f` to the result of the function `OfNat.ofNat` applied to `n` gives the same result as applying `OfNat.ofNat` to `n` directly. Essentially, this means that the homomorphism `f` preserves the behaviour of the `OfNat.ofNat` function for natural numbers greater than or equal to two.

For any non-associative semirings R, S, and a ring homomorphism F from R to S with injective function-like coercion, if F(OfNat.ofNat n) = OfNat.ofNat m for some natural numbers n and m with n >= 2, then n = m.


theorem ne_top_of_lt : ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] {a b : α}, a < b → a ≠ ⊤ := by sorry

This theorem states that for any given type `α` that has a `Preorder` and `OrderTop` structure (meaning it can be ordered and has a "top" or greatest element), if `a` and `b` are elements of `α` such that `a` is strictly less than `b`, then `a` cannot be the top element of `α`. This is intuitive because if `a` were the top element, there could not exist another element `b` which is greater than `a`.

For any type `α` with a `Preorder` and `OrderTop` structure, if `a` is strictly less than `b` in `α`, then `a` cannot be the top element of `α`.


theorem MeasureTheory.snorm_exponent_zero :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
      {f : α → F}, MeasureTheory.snorm f 0 μ = 0 :=
  by sorry

This theorem states that for any measurable space `α`, any type `F` that forms a normed add commutative group, any measure `μ` on `α`, and any function `f` from `α` to `F`, the `ℒp` seminorm (`MeasureTheory.snorm`) of `f` with exponent `0` and with respect to the measure `μ` is always equal to `0`.

For any measurable space `α`, any normed add commutative group `F`, any measure `μ` on `α`, and any `μ`-measurable function `f` from `α` to `F`, the `ℒp` seminorm of `f` with `p = 0` is equal to 0.


theorem IsOpen.measure_pos :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X)
      [inst_1 : MeasureTheory.Measure.IsOpenPosMeasure μ] {U : Set X}, IsOpen U → Set.Nonempty U → 0 < ↑↑μ U :=
  by sorry

The theorem `IsOpen.measure_pos` states that for any topological space `X` with a measurable space structure and a measure `μ` that satisfies the property of being an open positive measure, if `U` is an open and nonempty subset of `X`, then the measure of `U` is strictly positive. In other words, it asserts that any nonempty open set in a topological space, when measured with an open positive measure, has a positive measure.

If X is a topological space with a measurable structure and μ is an open positive measure, then the measure of any nonempty open subset of X is strictly positive.


theorem AlgHom.comp_apply :
    ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
      [inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
      (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) (p : A), (AlgHom.comp φ₁ φ₂) p = φ₁ (φ₂ p) :=
  by sorry

The theorem `AlgHom.comp_apply` states that for any commutative semiring `R` and semirings `A`, `B`, and `C` with `R`-algebra structures, given two algebra homomorphisms `φ₁` from `B` to `C` and `φ₂` from `A` to `B`, and an element `p` of `A`, the result of applying the composition of `φ₁` and `φ₂` to `p` is the same as applying `φ₁` to the result of applying `φ₂` to `p`. This expresses the property that the composition of algebra homomorphisms is associative, aligning with the intuition from function composition in general.

For commutative semirings `R`, `A`, `B`, `C` with `R`-algebra structures, and algebra homomorphisms `φ₁: B → C` and `φ₂: A → B`, `φ₁ ∘ φ₂ (p) = φ₁ (φ₂ (p))` for all `p` in `A`.


theorem decide_not : ∀ {p : Prop} {h : Decidable p}, (decide ¬p) = !decide p := by sorry

This is a theorem about propositions and decision procedures in Lean. It states that for any given proposition `p` and a decision procedure `h` for `p`, the decision for the negation of `p` (`¬p`) is equivalent to the negation of the decision for `p`. This means that if `p` is decided to be true, then `¬p` is decided to be false, and vice versa.

For any proposition `p` and decision procedure `h`, if `h(p)` holds then `h(¬p)` does not hold, and conversely.


theorem Set.subset_set_smul_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A B : Set β} {a : α},
      A ⊆ a • B ↔ a⁻¹ • A ⊆ B :=
  by sorry

This theorem is about subsets and scalar multiplication in the context of sets and groups. Given a set `A` and `B` of elements of some type `β` which has a group action defined by a group `α`, and an element `a` of group `α`, the theorem states that `A` is a subset of the scalar multiplication of `a` and `B` if and only if the scalar multiplication of the inverse of `a` and `A` is a subset of `B`. Here, the 'scalar multiplication' denotes the action of the group `α` on the set `β`.

For sets `A` and `B` of elements of type `β` with a group action by `α`, and an element `a` in `α`, the sets `A` and `a⁻¹(B)` are equal if and only if `A` is a subset of `a · B` (scalar multiplication).


theorem Finset.coe_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑(Finset.erase s a) = ↑s \ {a} := by sorry

This theorem states that for any type `α` with decidable equality and any element `a` of type `α` and a finite set `s` of type `α`, the operation of erasing `a` from `s` in the context of finite sets (`Finset.erase s a`) corresponds to the set difference operation in the context of set theory (`↑s \ {a}`). In other words, erasing `a` from `s` in the context of finite sets produces a new set that contains all elements of the original set `s` except for `a`, which is what the set difference operation does.

For any finite type `α` with decidable equality and any `a : α` and finite set `s : Finset α`, `Finset.erase s a` equals the set difference `↑s \ {a}`.


/-- A set is contained in its `spanPoints`.  -/
theorem subset_spanPoints :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (s : Set P), s ⊆ spanPoints k s :=
  by sorry

The theorem `subset_spanPoints` states that for any set of points `s` in an affine space `P` over a ring `k` with associated vector space `V`, the set `s` is always a subset of its span points. In other words, every point in `s` can be represented as a combination of a point and a vector, where the point is in `s` and the vector is in the vector span of `s`.

For any set of points `s` in an affine space `P` over a ring `k`, the span of `s` contains `s`.


theorem List.getLast_cons :
    ∀ {α : Type u} {a : α} {l : List α} (h : l ≠ []), List.getLast (a :: l) ⋯ = List.getLast l h := by sorry

The `List.getLast_cons` theorem states that for any type `α`, any element `a` of type `α`, and any list `l` of type `α` that is not empty, the last element of the list formed by prepending `a` to `l` is the same as the last element of `l`. In other words, adding an element to the beginning of a non-empty list does not change what the last element of the list is.

For any type `α` and non-empty list `l` of type `α`, appending an element `a` to the front of `l` does not change the last element of the list. In symbols, `last (a :: l) = last l`.


theorem Fin.coe_fin_one : ∀ (a : Fin 1), ↑a = 0 := by sorry

This theorem states that for any element `a` of the type `Fin 1`, the coersion of `a` to its corresponding natural number is always 0. In other words, any element of `Fin 1` maps to the natural number 0 when coersed. This is because `Fin 1` has only one element, 0, in its set.

For any element `a` in `Fin 1`, its coercion to the natural numbers is the constant 0. (Or equivalently, the unique element of `Fin 1` is mapped to the natural number 0 during coercion.)


HasSum.add

theorem HasSum.add :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α} {a b : α}
      [inst_2 : ContinuousAdd α], HasSum f a → HasSum g b → HasSum (fun b => f b + g b) (a + b) :=
  by sorry

This theorem, `HasSum.add`, states that for all types `α` and `β`, where `α` is an additive commutative monoid and a topological space, and `α` also has the property of continuous addition, if there are two functions `f` and `g` from `β` to `α` such that `f` has a sum `a` and `g` has a sum `b`, then the function that maps each element of `β` to the sum of its images under `f` and `g` has a sum of `a + b`. In other words, the sum of the sums of two functions is equal to the sum of the function that is their pointwise sum.

For additive commutative monoid and topological space types `α` endowed with continuous addition, if functions `f` and `g` from type `β` to `α` have sums `a` and `b` respectively, then the function `h` defined by `h x = f x + g x` has sum `a + b`.