theorem top_sup_eq : ∀ {α : Type u} [inst : SemilatticeSup α] [inst_1 : OrderTop α] (a : α), ⊤ ⊔ a = ⊤ := by sorry

The theorem `top_sup_eq` states that for any type `α` that is both a semilattice under a supremum operation (`⊔`) and has a top element (`⊤`), the supremum of the top element and any element `a` of type `α` is always the top element. In other words, for any element `a` in such a structure, `⊤ ⊔ a = ⊤`. This theorem captures the property of the top element in a semilattice, which is that it is at least as great as every other element in the structure.

For any semilattice `α` with top element `⊤`, `⊤ ⊔ a = ⊤` for all `a ∈ α`.


theorem Multiset.cons_add : ∀ {α : Type u_1} (a : α) (s t : Multiset α), a ::ₘ s + t = a ::ₘ (s + t) := by sorry

The theorem `Multiset.cons_add` asserts that for all types `α`, for any element `a` of type `α`, and for any two multisets `s` and `t` of type `α`, the operation of prepending `a` to the multiset `s` and then adding the multiset `t` is equivalent to the operation of prepending `a` to the sum of `s` and `t`. In other words, the operations of prepending and adding multisets are associative, symbolically represented as `(a ::ₘ s) + t = a ::ₘ (s + t)`.

For all types `α` and multisets `s` and `t` of type `α`, prepending an element `a` to the sum of `s` and `t` is equivalent to first prepending `a` to `s` and then adding `t`, i.e., `(a :: s) + t = a :: (s + t)`.


theorem instCoeTCHeytingHom.proof_3 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : HeytingAlgebra α]
      [inst_2 : HeytingAlgebra β] [inst_3 : HeytingHomClass F α β] (f : F), f ⊥ = ⊥ :=
  by sorry

This theorem states that for any types `F`, `α`, and `β`, given a term `f` of type `F`, if `F` can be injected into a function from `α` to `β` (`FunLike F α β`), `α` and `β` are both Heyting algebras, and `F` forms a homomorphism from `α` to `β` (`HeytingHomClass F α β`), then the image of the bottom element (`⊥`) of the Heyting algebra `α` under `f` is the bottom element of the Heyting algebra `β`. In other words, the function `f` preserves the bottom element when mapping from one Heyting algebra to another.

If `F` is a homomorphism from the Heyting algebras `α` and `β`, `FunLike F α β`, and `⊥` is the bottom element of `α`, then `f ⊥ = ⊥` in `β`.


theorem instCoeTCHeytingHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : HeytingAlgebra α]
      [inst_2 : HeytingAlgebra β] [inst_3 : HeytingHomClass F α β] (f : F) (a b : α), f (a ⊓ b) = f a ⊓ f b :=
  by sorry

This theorem, `instCoeTCHeytingHom.proof_2`, is a property of a Heyting algebra homomorphism. Specifically, it states that for any types `F`, `α`, and `β`, if `F` is a type that can be injected into a function space from `α` to `β` (expressed by the `FunLike F α β` instance), `α` and `β` are Heyting algebras (expressed by the `HeytingAlgebra α` and `HeytingAlgebra β` instances), and `F` is a class of homomorphisms from `α` to `β` (expressed by the `HeytingHomClass F α β` instance), then for any function `f` of type `F` and any elements `a` and `b` of `α`, the image of the infimum (greatest lower bound) of `a` and `b` under `f` is the infimum of the images of `a` and `b` under `f`. In mathematical notation, this is saying that \(f(a \land b) = f(a) \land f(b)\), where \(\land\) denotes the infimum operation in a Heyting algebra.

Given a Heyting algebra homomorphism `f` between Heyting algebras `α` and `β` over a common type `F`, the image of the infimum of two elements under `f` equals the infimum of their images: `f(a ∧ b) = f(a) ∧ f(b)` for all `a, b ∈ α`.


theorem instCoeTCHeytingHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : HeytingAlgebra α]
      [inst_2 : HeytingAlgebra β] [inst_3 : HeytingHomClass F α β] (f : F) (a b : α), f (a ⊔ b) = f a ⊔ f b :=
  by sorry

This theorem states that for all types `F`, `α`, and `β`, if `F` is a function-like type from `α` to `β`, `α` and `β` are Heyting algebras, and `F` is a Heyting homomorphism class, then for any function `f` of type `F` and any elements `a` and `b` of type `α`, the function `f` preserves the join operation. In other words, applying `f` to the join of `a` and `b` (`a ⊔ b`) gives the same result as joining `f(a)` and `f(b)`. This property is a fundamental characteristic of homomorphisms in lattice theory.

For any function-like type `F` from Heyting algebras `α` and `β`, if `F` is a Heyting homomorphism class, then for all elements `a` and `b` in `α`, `F(a ⊔ b) = F(a) ⊔ F(b)`.


Nat.Prime.factorization

/-- The only prime factor of prime `p` is `p` itself, with multiplicity `1`  -/
theorem Nat.Prime.factorization : ∀ {p : ℕ}, Nat.Prime p → Nat.factorization p = fun₀ | p => 1 := by sorry

This theorem states that for any prime number `p`, the factorization of `p` only includes `p` itself with a multiplicity of `1`. In other words, in the prime factorization of a prime number, the prime number appears once and only once. This is consistent with the definition of a prime number, which has exactly two distinct natural number divisors: `1` and itself.

A prime number `p` has a prime factorization that consists only of `p` with multiplicity 1.


theorem eq_bot_mono : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, a ≤ b → b = ⊥ → a = ⊥ :=
  by sorry

This theorem, `eq_bot_mono`, states that for any given type `α` which has a partial order and a least element (denoted by ⊥), if `a` and `b` are elements of `α` such that `a` is less than or equal to `b`, and `b` is the least element (⊥), then `a` must also be the least element (⊥). In other words, in a partially ordered set with a bottom element, if `a` is not greater than `b` and `b` is the least possible value, `a` must be that least value as well.

In a partially ordered set with a bottom element, if an element is less than or equal to the bottom element, then it is the bottom element itself.


theorem nhdsWithin_singleton : ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α), nhdsWithin a {a} = pure a := by
  sorry

The theorem `nhdsWithin_singleton` states that for any type `α` equipped with a topological space structure and for any element `a` of `α`, the neighborhood within the singleton set `{a}` of `a` is equal to `pure a`. In other words, the filter that captures the notion of "being close to `a` within `{a}`" in `α` is just the filter that isolates `a` itself.

For any topological space `(α, τ)`, the neighborhood filter of `a` in the singleton set `{a} ⊆ α` equals the principal filter generated by `a`, i.e., `{U ∈ τ | a ∈ U} = ∇{a}`.


PUnit.ext

theorem PUnit.ext : ∀ (x y : PUnit.{u_1}), x = y := by sorry

This theorem, `PUnit.ext`, states that for any two elements `x` and `y` of type `PUnit` in any universe `u_1`, `x` is equal to `y`. In other words, all elements of `PUnit` are equal to each other. This makes sense because `PUnit` is a type with only one element, typically denoted by `*`.

For any `x, y : PUnit`, `x = y` holds in any universe `u_1`. (All elements of `PUnit` are equal.)


theorem Real.Angle.coe_neg : ∀ (x : ℝ), ↑(-x) = -↑x := by sorry

This theorem states that for all real numbers `x`, the angle of the negative of `x` is equal to the negative of the angle of `x`. Here, `↑` denotes the function that maps real numbers to angles. Essentially, this theorem captures the idea that negating a real number and then converting it to an angle is the same as first converting the real number to an angle and then negating it.

For all real numbers x, the angle of the negative x is equal to the negative of the angle of x. (or equivalently, the angle of -x = -angle x)


theorem Nat.choose_mul_factorial_mul_factorial :
    ∀ {n k : ℕ}, k ≤ n → Nat.choose n k * Nat.factorial k * Nat.factorial (n - k) = Nat.factorial n := by sorry

The theorem `Nat.choose_mul_factorial_mul_factorial` states that for any natural numbers `n` and `k` where `k` is less than or equal to `n`, the product of the binomial coefficient of `n` choose `k`, the factorial of `k`, and the factorial of `n - k` is equal to the factorial of `n`. In mathematical notation, this theorem can be expressed as: $\binom{n}{k} * k! * (n-k)! = n!$ for $k \leq n$.

For any natural numbers $n$ and $k$ with $k \leq n$, $\binom{n}{k} \cdot k! \cdot (n-k)! = n!$.


theorem ENNReal.div_eq_inv_mul : ∀ {a b : ENNReal}, a / b = b⁻¹ * a := by sorry

This theorem states that for all extended nonnegative real numbers `a` and `b`, the division of `a` by `b` is equivalent to the multiplication of the inverse of `b` and `a`. In mathematical terms, for any `a, b ∈ [0, ∞]`, the equation `a / b = b⁻¹ * a` holds true. This theorem expresses a fundamental property of division, namely that it can be represented as multiplication by the reciprocal.

For all extended nonnegative real numbers `a` and `b`, `a / b = b⁻¹ * a`.


theorem ENNReal.toNNReal_coe : ∀ {r : NNReal}, (↑r).toNNReal = r := by sorry

The theorem `ENNReal.toNNReal_coe` states that for any nonnegative real number `r` (represented by `NNReal`), when `r` is explicitly cast (using `↑` operation) to an extended nonnegative real number and then mapped back to a nonnegative real number using `.toNNReal` operation, it remains the same `r`. In other words, the process of casting a nonnegative real number to an extended nonnegative real number and then back to a nonnegative real number is identity-preserving, confirming the consistency between these two types.

For any non-negative real number `r`, the conversion `↑r`.toNNReal equals `r`.


theorem LieSubalgebra.subset_lieSpan :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {s : Set L},
      s ⊆ ↑(LieSubalgebra.lieSpan R L s) :=
  by sorry

This theorem states that for any commutative ring `R`, any Lie ring `L` with a Lie algebra structure over `R`, and any set `s` of elements from `L`, the set `s` is a subset of the Lie subalgebra generated by `s`. In other words, every element of `s` belongs to the Lie subalgebra spanned by `s`. This is a foundational property of generated subalgebras in the context of Lie algebras.

For any commutative ring `R`, any Lie ring `L` over `R`, and any set `s` of elements from `L`, `s` is contained in the Lie subalgebra of `L` generated by `s`.


IsPreconnected.subsingleton

theorem IsPreconnected.subsingleton :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : TotallyDisconnectedSpace α] {s : Set α},
      IsPreconnected s → Set.Subsingleton s :=
  by sorry

The theorem `IsPreconnected.subsingleton` states that for any type `α` that has a structure of a topological space and is a totally disconnected space, and for any set `s` of type `α`, if `s` is preconnected, then `s` is a subsingleton. In other words, if a set in a totally disconnected topological space is preconnected (meaning there is no non-trivial open partition of it), then it must contain at most one element, which is the definition of being a subsingleton.

In a totally disconnected topological space, a preconnected subset is a subsingleton.


theorem Finset.mem_cons :
    ∀ {α : Type u_1} {s : Finset α} {a b : α} {h : a ∉ s}, b ∈ Finset.cons a s h ↔ b = a ∨ b ∈ s := by sorry

The theorem `Finset.mem_cons` states that for any type α, any finite set `s` of type α, and any two elements `a` and `b` of type α where `a` is not in `s`, the element `b` is in the finite set resulting from consing `a` onto `s` (`Finset.cons a s h`) if and only if `b` is equal to `a` or `b` is in `s`. In other words, an element `b` is in the set created from adding `a` to `s` exactly when `b` is either equal to `a` or already in `s`.

For any type α and finite set s of type α, the element b is in the set s \cup {a}, where a is not in s, if and only if b is equal to a or is in s.


theorem Disjoint.inter_eq : ∀ {α : Type u} {s t : Set α}, Disjoint s t → s ∩ t = ∅ := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of type `α`, if the two sets are disjoint (i.e., their infimum is the bottom element of the given lattice), then the intersection of `s` and `t` is the empty set. In other words, if `s` and `t` have no elements in common (they are disjoint), then the set obtained by taking all the elements that belong to both `s` and `t` (the intersection of `s` and `t`) is an empty set. This is a formalization of the well-known mathematical fact about sets in set theory.

If two sets `s` and `t` of type `α` have no common elements (are disjoint), then their intersection `s ∩ t` is the empty set.


theorem Set.dual_Icc :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α},
      Set.Icc (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Icc b a :=
  by sorry

The theorem `Set.dual_Icc` states that for any type `α` with a preorder, and any two elements `a` and `b` of `α`, the closed interval from `a` to `b` in the dual order is the same as the preimage of the closed interval from `b` to `a` under the function `OrderDual.ofDual`. In other words, it asserts the duality between intervals in a preordered set and its dual.

For any preordered type `α` and elements `a` and `b` in `α`, the dual interval `[OrderDual.ofDual b, OrderDual.ofDual a]` is equal to the closed interval `[a, b]` in the original order.


theorem Set.mem_diff : ∀ {α : Type u} {s t : Set α} (x : α), x ∈ s \ t ↔ x ∈ s ∧ x ∉ t := by sorry

The theorem `Set.mem_diff` states that for any type `α`, and any two sets `s` and `t` of type `α`, an element `x` of type `α` belongs to the difference of `s` and `t` (denoted `s \ t`) if and only if `x` belongs to `s` and `x` does not belong to `t`. Here, the difference of two sets `s` and `t` is the set of elements that are in `s` but not in `t`.

For any type `α` and sets `s` and `t` of type `α`, an element `x` belongs to `s \ t` if and only if `x` is in `s` but not in `t`.


theorem Function.update_injective :
    ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] (f : (a : α) → β a) (a' : α),
      Function.Injective (Function.update f a') :=
  by sorry

The theorem `Function.update_injective` states that, for any type `α` with decidable equality and any dependent type `β` over `α`, and any function `f : α → β a`, and any element `a' : α`, the function update operation `Function.update f a'` is injective. In other words, if you update the value of the function `f` at some point `a'`, then this new function will not map different inputs to the same output. If two inputs produce the same output, then they were the same input initially. This holds under the condition that the equality of elements in `α` is decidable.

Given a type `α` with decidable equality, and a function `f : α → β` from `α` to another type `β`, the updated function `Function.update f a'` is a injection (one-to-one function) for any `a' : α`.


theorem sub_div : ∀ {K : Type u_3} [inst : DivisionRing K] (a b c : K), (a - b) / c = a / c - b / c := by sorry

This theorem states that for any division ring `K` and any three elements `a`, `b`, and `c` of `K`, the operation of subtracting `b` from `a` and then dividing by `c` is equivalent to first dividing `a` and `b` by `c` separately and then subtracting the results. In LaTeX mathematics terms, it can be shown as:  for all `a`, `b`, `c` in `K`, `(a - b) / c = a / c - b / c`.

For any division ring `K` and elements `a`, `b`, `c` in `K`, the expression `(a - b) / c` is equivalent to `(a / c) - (b / c)`.


theorem Nat.dvd_of_mod_eq_zero : ∀ {m n : ℕ}, n % m = 0 → m ∣ n := by sorry

This theorem, `Nat.dvd_of_mod_eq_zero`, states that for all natural numbers `m` and `n`, if the remainder of `n` divided by `m` (`n % m`) is zero, then `m` divides `n` (`m ∣ n`). In other words, if `n` is divisible by `m` without leaving a remainder, then `m` is a divisor of `n`. This is a basic property of divisibility in the domain of natural numbers.

If `n` is congruent to 0 modulo `m`, then `m` divides `n`. (In mathematical notation: `m ∣ n <-> n % m = 0`)


theorem HahnSeries.order_of_ne :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero Γ] {x : HahnSeries Γ R}
      (hx : x ≠ 0), HahnSeries.order x = Set.IsWF.min ⋯ ⋯ :=
  by sorry

The theorem `HahnSeries.order_of_ne` states that for any Hahn series `x` of type `HahnSeries Γ R` where `Γ` is a type with a partial order, `R` is a type with a zero element, and `x` is not equal to zero, the order of `x` is equal to the minimum element of a certain well-founded set. Here, the order of a Hahn series is defined as the minimal element of `Γ` at which the series has a nonzero coefficient, and the `Set.IsWF.min` function returns a minimal element of a nonempty well-founded set.

The order of a nonzero Hahn series `x` over a type `Γ` with a partial order and `R` with a zero element is equal to the minimum element in `Γ` where `x` has a nonzero coefficient.


theorem List.Perm.nodup_iff : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Perm l₁ l₂ → (List.Nodup l₁ ↔ List.Nodup l₂) := by
  sorry

The theorem `List.Perm.nodup_iff` states that for any two lists `l₁` and `l₂` of a certain type `α`, if `l₁` is a permutation of `l₂`, then `l₁` has no duplicates if and only if `l₂` has no duplicates. In other words, the property of a list having no duplicates is preserved under permutations.

For lists `l₁` and `l₂` of type `α`, if `l₁` is a permutation of `l₂`, then `l₁` has no duplicates if and only if `l₂` has no duplicates.


IsTop.isMax

theorem IsTop.isMax : ∀ {α : Type u_1} [inst : LE α] {a : α}, IsTop a → IsMax a := by sorry

This theorem states that for any type `α` equipped with a pre-order relation (denoted `LE α`), if an element `a` of `α` is a top element (as defined by the predicate `IsTop a`), then `a` is also a maximal element (`IsMax a`). In other words, if an element `a` is greater than or equal to any other element in the set, then there is no other element in the set which is strictly greater than `a`.

For any type `α` with a pre-order relation `LE α`, if `a` is a top element (`IsTop a`), then `a` is maximal (`IsMax a`) in the sense that there is no `x` with `a < x` in `α`.


/-- The coequalizer morphism in any colimit cocone is an epimorphism.  -/
theorem CategoryTheory.Limits.epi_of_isColimit_cofork :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      {c : CategoryTheory.Limits.Cofork f g},
      CategoryTheory.Limits.IsColimit c → CategoryTheory.Epi (CategoryTheory.Limits.Cofork.π c) :=
  by sorry

The theorem `CategoryTheory.Limits.epi_of_isColimit_cofork` states that in any category `C`, for any two morphisms `f` and `g` from `X` to `Y`, if `c` is a cofork on `f` and `g`, and `c` is a colimit, then the coequalizer morphism of the cofork `c` is an epimorphism. Here, epimorphism is a categorical concept equivalent to surjectivity in the category of sets. In other words, if we have a situation where any morphism `f` and `g` are coequalized at a specific cofork `c`, which is a colimit, then the coequalizer morphism of this cofork will always be an epimorphism, i.e., every element in the codomain is the image of some element in the domain.

In a category C, if morphisms f and g have cofork c as their coequalizer and c is a colimit, then the coequalizer morphism of c is an epimorphism.


theorem List.foldr_cons :
    ∀ {α : Type u_1} {a : α} {α_1 : Type u_2} {f : α → α_1 → α_1} {b : α_1} (l : List α),
      List.foldr f b (a :: l) = f a (List.foldr f b l) :=
  by sorry

The theorem `List.foldr_cons` states that for any types `α` and `α_1`, any function `f` of type `α → α_1 → α_1`, any value `b` of type `α_1`, and any list `l` of type `List α`, the operation of folding `f` over the list formed by prepending an element `a` of type `α` to the list `l` (expressed as `a :: l`), starting with the initial value `b`, is equivalent to applying `f` to `a` and the result of folding `f` over the list `l` starting with the same initial value `b`. In other words, the fold operation distributes over the `cons` operation in the list.

For any types `α` and `α_1`, any function `f : α → α_1 → α_1`, any value `b : α_1`, and any list `l : List α`, the operation of folding `f` over the list `a :: l` starting with `b` is equal to applying `f` to `a` and the result of folding `f` over `l` starting with `b`.


theorem ge_of_tendsto :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIciTopology α]
      {f : β → α} {a b : α} {x : Filter β} [inst_3 : Filter.NeBot x],
      Filter.Tendsto f x (nhds a) → (∀ᶠ (c : β) in x, b ≤ f c) → b ≤ a :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is endowed with a topological space structure, a preorder structure, and a topology that is closed on the interval `[a, +∞)`, given a function `f` from `β` to `α`, and given two elements `a` and `b` of type `α` and a filter `x` of type `β`, such that the filter `x` is not bottom (i.e., it is not the filter that contains every set), if the function `f` tends to the neighborhood filter of `a` along the filter `x` (meaning that for every neighborhood of `a`, the preimage of that neighborhood under `f` is eventually in `x`), and if eventually every element of the codomain of `f` in the filter `x` is greater than or equal to `b`, then `b` is less than or equal to `a`. In simpler terms, if values of `f` get arbitrarily close to `a` and are eventually all at least `b`, then `b` is at most `a`.

If a function from a filter on a preordered topological space to another preordered topological space tends to a point and eventually maps every element in the filter to a value greater than or equal to another point, then the second point is less than or equal to the first.


theorem eq_of_div_eq_one : ∀ {α : Type u_1} [inst : DivisionMonoid α] {a b : α}, a / b = 1 → a = b := by sorry

This theorem, `eq_of_div_eq_one`, states that for any type `α` with a division monoid structure, if the division of two elements `a` and `b` of that type equals 1, then `a` is equal to `b`. In other words, if `a / b = 1` then `a = b`. This is a general principle in division-based algebraic structures, reflecting the fact that 1 is the identity element for multiplication.

If `α` is a type with a division monoid structure and `a / b = 1`, then `a = b`.


/-- The closure of the interval `(a, +∞)` is the closed interval `[a, +∞)`.  -/
theorem closure_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] (a : α) [inst_4 : NoMaxOrder α], closure (Set.Ioi a) = Set.Ici a :=
  by sorry

The theorem `closure_Ioi` states that for any type `α` that is a topological space, a linear order, has order topology, is densely ordered, and has no maximum element, the closure of the interval `(a, +∞)` is the closed interval `[a, +∞)`. In mathematical terms, it means that the smallest closed set containing all elements greater than `a` is the set of all elements greater than or equal to `a`. This is valid in a context where the order is compatible with the topology (i.e., it has an order topology) and every two elements have another one strictly between them (i.e., the order is densely ordered), and there is no maximum element in the set.

In a densely ordered, topological space without a maximum element and with an order topology, the closure of the open interval (a, +∞) equals the closed interval [a, +∞).


/-- Express `dist` in terms of `nndist` -/
theorem dist_nndist : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), dist x y = ↑(nndist x y) := by sorry

This theorem, `dist_nndist`, states that for any given pseudometric space `α`, and any two elements `x` and `y` in this space, the `dist` function between `x` and `y` is equivalent to the non-negative real number (`↑`) representation of the `nndist` (non-negative distance) function between `x` and `y`. This theorem essentially relates the traditional distance measure in a pseudometric space to its non-negative counterpart.

For any pseudometric space, the distance between two elements is equivalent to the non-negative representation of their nested neighborhood distance.


Finsupp.induction

theorem Finsupp.induction :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] {p : (α →₀ M) → Prop} (f : α →₀ M),
      p 0 → (∀ (a : α) (b : M) (f : α →₀ M), a ∉ f.support → b ≠ 0 → p f → p ((fun₀ | a => b) + f)) → p f :=
  by sorry

This theorem, `Finsupp.induction`, states that for any type `α`, any type `M` that is an instance of the `AddZeroClass`, and any property `p` of functions from `α` to `M`, if `p` holds for the zero function and `p` holds for any function `f` plus a function that is zero everywhere except possibly at a single point `a` with value `b`, where `a` is not in the support of `f` and `b` is not zero, then `p` holds for any such function `f`. This is an induction principle for functions with finite support.

If `α` is a type, `M` is an AddZeroClass, `p` is a property of functions from `α` to `M`, and `p` holds for the zero function and for any function `f` with finite support such that `p` holds for `f` and the function zero everywhere except possibly at a point `a` not in the support of `f` with value `b` not equal to zero, then `p` holds for `f`.


theorem Real.hasDerivAt_cos : ∀ (x : ℝ), HasDerivAt Real.cos (-Real.sin x) x := by sorry

This theorem states that for any real number `x`, the function `Real.cos` (the cosine function on the real numbers) has a derivative at the point `x`, and the derivative is `-Real.sin x` (the negation of the sine of `x`). In other words, the derivative of the cosine function at any point is the negative of the sine function at that same point, which is consistent with calculus theory.

The derivative of the cosine function on the real numbers is equal to the negative of the sine function.


theorem FreeGroup.Red.cons_cons :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {p : α × Bool}, FreeGroup.Red L₁ L₂ → FreeGroup.Red (p :: L₁) (p :: L₂) :=
  by sorry

The theorem `FreeGroup.Red.cons_cons` states that for any type `α` and any pair `p` of type `α × Bool`, if there is a reflexive-transitive closure of the `Red.Step` relation (denoted by `FreeGroup.Red`) from list `L₁` to list `L₂`, then there is also a reflexive-transitive closure of the `Red.Step` relation from the list formed by consing `p` onto `L₁` to the list formed by consing `p` onto `L₂`. This essentially means that if `L₁` can be transformed into `L₂` by a series of steps, then the same series of steps can transform `p :: L₁` into `p :: L₂`.

If `FreeGroup.Red` connects lists `L₁` and `L₂`, then it also connects the lists `[p] :: L₁` and `[p] :: L₂` for any pair `p` of type `α × Bool`.


theorem map_comap_subtype_coe :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {s : Set α},
      MeasurableSet s →
        ∀ (μ : MeasureTheory.Measure α),
          MeasureTheory.Measure.map Subtype.val (MeasureTheory.Measure.comap Subtype.val μ) = μ.restrict s :=
  by sorry

This theorem, `map_comap_subtype_coe`, states that for any type `α` with a given measurable space `m0`, and any set `s` of type `α` that is a measurable set, for any measure `μ` on `α`, the measure of the image of `s` under the function `Subtype.val` when the preimage of `μ` under `Subtype.val` is taken, is equal to the restriction of the measure `μ` to the set `s`. In mathematical terms, given a measurable space, a measurable set within that space, and a measure on that space, the measure of the image of the set under the map `Subtype.val` is the same as the measure of the set itself restricted to the set.

Given a measurable space $(X, \Sigma,\mu)$, a measurable set $S \in \Sigma$, and the subtype $t : S \hookrightarrow X$, the measure $\mu(t(\cdot))$ is equal to the restriction of $\mu$ to $S$, denoted $\mu\vert_S$.


theorem Finset.subset_biUnion_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} [inst : DecidableEq β] (u : α → Finset β) {x : α},
      x ∈ s → u x ⊆ Finset.biUnion s u :=
  by sorry

The theorem `Finset.subset_biUnion_of_mem` asserts that for any types `α` and `β`, given a finset `s` of type `α`, a function `u` mapping elements of `α` to finsets of `β`, and any element `x` of `α`, if `x` is an element of `s`, then the finset `u(x)` is a subset of the biUnion of `s` and `u`, where the biUnion of `s` and `u` is defined as the union of `u(a)` for all `a` in `s`. This theorem assumes that equality for type `β` is decidable.

For any types `α` and `β`, if `s` is a finset of `α`, `u` maps elements of `α` to finsets of `β`, and `x` is an element of `s`, then `u(x)` is a subset of the union of `s` and the image of `u`: `u(x) ⊆ s ∪ {a ∣ a ∈ s} → u a`.


theorem hasSum_geometric_of_lt_one : ∀ {r : ℝ}, 0 ≤ r → r < 1 → HasSum (fun n => r ^ n) (1 - r)⁻¹ := by sorry

This theorem states that if `r` is a real number such that `r` is greater than or equal to zero and less than one, then the sum of the infinite geometric series `r^n` (where `n` is a non-negative integer) is equal to `(1 - r)⁻¹`, which is the multiplicative inverse of `1 - r`.

In mathematical terms, this theorem asserts the well-known result that the sum of an infinite geometric series `r + r^2 + r^3 + ...` with a common ratio `r` between 0 and 1 (exclusive) is given by `1/(1 - r)`.

The sum of an infinite geometric series with common ratio `r` in the open interval (0, 1) is equal to the multiplicative inverse of `1 - r`.


theorem NormedAddGroupHom.opNorm_nonneg :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂), 0 ≤ ‖f‖ :=
  by sorry

This theorem states that for any normed additive commutative group `V₁` and `V₂`, the operator norm of a normed group homomorphism `f` from `V₁` to `V₂` is non-negative, i.e., `0 ≤ ‖f‖`. The norm of `f` here represents a measure of its "size" or "length", and this theorem asserts that such a measure cannot be negative.

The norm of a normed group homomorphism is non-negative.


theorem singletons_open_iff_discrete :
    ∀ {X : Type u_2} [inst : TopologicalSpace X], (∀ (a : X), IsOpen {a}) ↔ DiscreteTopology X := by sorry

This theorem states that for every type `X` equipped with a certain topological space structure, the condition that every singleton set `{a}` is open in this topological space is equivalent to the topology being a discrete topology. In other words, in any topological space, if every single-element set is an open set, then that topology is a discrete topology, and vice versa.

In a topological space, the topology is discrete if and only if every singleton set is open.


theorem Nat.binaryRec_zero :
    ∀ {C : ℕ → Sort u} (z : C 0) (f : (b : Bool) → (n : ℕ) → C n → C (Nat.bit b n)), Nat.binaryRec z f 0 = z := by sorry

The theorem `Nat.binaryRec_zero` states that for any type function `C` from natural numbers to some arbitrary sort `u`, and for any inputs `z` of type `C 0` and `f` of type `(b : Bool) → (n : ℕ) → C n → C (Nat.bit b n)`, the result of applying the binary recursion function `Nat.binaryRec` to `z`, `f`, and `0` is equal to `z`. Essentially, this is saying that the base case of this binary recursion, when the input natural number is zero, is exactly the value `z`.

For any function `C : ℕ → Sort u` and values `z : C 0` and `f : ∀ (b : Bool), ℕ → C → C`, `Nat.binaryRec z f 0 = z`.


theorem Cardinal.mk_ne_zero_iff : ∀ {α : Type u}, Cardinal.mk α ≠ 0 ↔ Nonempty α := by sorry

The theorem `Cardinal.mk_ne_zero_iff` establishes a bi-conditional relationship between a type `α` having a non-zero cardinality and the type `α` being nonempty. In other words, it states that for any type `α`, the cardinality of `α` is not zero if and only if `α` is nonempty. This theorem is a key aspect of cardinality theory in set theory, determining the link between cardinality and the existence of elements in a particular type.

A type has a non-zero cardinality if and only if it is nonempty.


theorem DFinsupp.coe_le_coe :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → LE (α i)]
      {f g : Π₀ (i : ι), α i}, ⇑f ≤ ⇑g ↔ f ≤ g :=
  by sorry

This theorem states that for any types `ι` and `α` (where `α` is a function of `ι`), given a zero instance for `α i` and a less-than-or-equal-to (≤) instance for `α i` for each `i` in `ι`, the function application of a direct sum function `f` is less than or equal to the function application of another direct sum function `g` if and only if `f` is less than or equal to `g`.

Here, `f` and `g` are represented as `Π₀ (i : ι), α i`, which means they are direct sum functions over the index set `ι` with values in the type `α i`. The direct sum is a generalization of the sum concept, where the sum of a family of elements is only dependent on a finite number of them.

For any types `ι` and `α`, given zero and ≤ instances for `α i` (for all `i` in `ι`), the direct sum functions `Π₀ (i : ι), α i` `f` and `g` satisfy `f ≤ g` if and only if `∀i, f i ≤ g i`.


theorem MeasureTheory.snorm_eq_snorm' :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F],
      p ≠ 0 → p ≠ ⊤ → ∀ {f : α → F}, MeasureTheory.snorm f p μ = MeasureTheory.snorm' f p.toReal μ :=
  by sorry

This theorem states that for any measure space `α`, any extended nonnegative real number `p` that is neither `0` nor `∞`, any measure `μ`, and any function `f` from `α` to a normed additive commutative group `F`, the `ℒp` seminorm of `f` with respect to `p` and `μ` is equal to the integral of the `ℒq` seminorm of `f` raised to the power `q` and then to the power of `1/q`. In mathematical terms, for `0 < p < ∞`, we have `(∫ ‖f a‖^p ∂μ) ^ (1/p) = (∫ ‖f a‖^q ∂μ) ^ (1/q)`.

For any measure space, measurable function, and finite p > 0, the ℒp and ℒq integrals of the absolute value of the function, with respect to a given measure, are related by the equation (∫ |f(a)|^p dμ)^(1/p) = (∫ |f(a)|^q dμ)^(1/q), where 1/p + 1/q = 1.


theorem PartialEquiv.map_target :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {x : β},
      x ∈ e.target → ↑(PartialEquiv.symm e) x ∈ e.source :=
  by sorry

The theorem `PartialEquiv.map_target` states that for any types `α` and `β`, and any partial equivalence `e` from `α` to `β`, if an element `x` of type `β` is in the target set of `e`, then the image of `x` under the inverse of `e` (`PartialEquiv.symm e`) belongs to the source set of `e`. In other words, this theorem ensures that the inverse function of a partial equivalence correctly maps elements from its target set back to its source set.

For any partial equivalence `e` from `α` to `β`, if `x ∈ β` is in the target set of `e`, then `e.symm.apply x ∈ α` belongs to the source set of `e`.


theorem Complex.slitPlane_ne_zero : ∀ {z : ℂ}, z ∈ Complex.slitPlane → z ≠ 0 := by sorry

This theorem states that for any complex number `z`, if `z` belongs to the slit plane (which is defined as the complex plane with the closed negative real axis removed, i.e., all complex numbers whose real part is greater than 0 or whose imaginary part is not equal to 0), then `z` cannot be equal to 0. In other words, the origin (0,0) is not included in the slit plane.

The complex number `0` is not an element of the slit complex plane.


theorem GaloisCoinsertion.u_iSup_l :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : CompleteLattice α] [inst_1 : CompleteLattice β],
      GaloisCoinsertion l u → ∀ {ι : Sort x} (f : ι → α), u (⨆ i, l (f i)) = ⨆ i, f i :=
  by sorry

This theorem states that, for any types `α` and `β`, functions `l : α → β` and `u : β → α`, and for any complete lattices over `α` and `β`, if there exists a Galois coinsertion between `l` and `u`, then for any function `f` indexed by some sort `ι`, the function `u` applied to the supremum (expressed by `⨆`) over `i` of `l` applied to `f i` equals the supremum over `i` of `f i`. In other words, the coinsertion property allows us to move the `u` function outside of the supremum.

Given functions `l : α → β`, `u : β → α` between complete lattices `α` and `β`, if there exists a Galois coinsertion between `l` and `u`, then for any function `f : ι → α`, we have `u (⨆ i, l i (f i)) = ⨆ i, f i`.


theorem IsOpenMap.preimage_closure_eq_closure_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → Continuous f → ∀ (s : Set Y), f ⁻¹' closure s = closure (f ⁻¹' s) :=
  by sorry

This theorem states that, for any types `X` and `Y` and any function `f` from `X` to `Y`, given that `X` and `Y` are topological spaces, if `f` is an open map and continuous, then for any set `s` of type `Y`, the preimage of the closure of `s` under `f` is equal to the closure of the preimage of `s` under `f`. In mathematical terms, if $f : X \rightarrow Y$ is an open and continuous function between two topological spaces, then for any subset $s$ of $Y$, we have $f^{-1}(cl(s)) = cl(f^{-1}(s))$, where $cl(s)$ denotes the closure of the set $s$.

For any open and continuous function $f$ between topological spaces $X$ and $Y$, the preimages of closed sets under $f$ are equal: $f^{-1}(cl(s)) = cl(f^{-1}(s))$.


theorem PartialEquiv.trans_assoc :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : PartialEquiv α β) (e' : PartialEquiv β γ)
      (e'' : PartialEquiv γ δ),
      PartialEquiv.trans (PartialEquiv.trans e e') e'' = PartialEquiv.trans e (PartialEquiv.trans e' e'') :=
  by sorry

The theorem `PartialEquiv.trans_assoc` asserts the associativity of the operation `PartialEquiv.trans` across four arbitrary types `α`, `β`, `γ`, and `δ`. More specifically, for any three partial equivalences `e : PartialEquiv α β`, `e' : PartialEquiv β γ`, and `e'' : PartialEquiv γ δ`, the operation of composing these equivalences is associative. That is, first composing `e` and `e'`, and then composing the result with `e''`, yields the same result as first composing `e'` and `e''` and then composing `e` with the result.

For any partial equivalences $e : \alpha \leftrightarrows \beta$, $e' : \beta \leftrightarrows \gamma$, and $e'' : \gamma \leftrightarrows \delta$, the composition $e' \circ e \circ e''$ is equal to $e \circ (e' \circ e'')$.


theorem CategoryTheory.IsIso.eq_comp_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : Z ⟶ Y} {g : Z ⟶ X},
      g = CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) ↔ CategoryTheory.CategoryStruct.comp g α = f :=
  by sorry

The theorem `CategoryTheory.IsIso.eq_comp_inv` states that for any category `C` and objects `X`, `Y`, and `Z` within this category, given a morphism `α` from `X` to `Y` which is an isomorphism, and morphisms `f` from `Z` to `Y` and `g` from `Z` to `X`, then `g` is equal to the composition of `f` and the inverse of `α` if and only if the composition of `g` and `α` is equal to `f`. This theorem is a fundamental result in category theory expressing the interchangeability of a morphism with its inverse in a composition.

For any category C and objects X, Y, and Z, if α : X ↔ Y is an isomorphism and f : Z → Y and g : Z → X are morphisms such that g ∘ α = f and α ∘ g = id\_Y, then g = f ∘ α^(-1).


theorem Finmap.insert_toFinmap :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (b : β a) (s : AList β),
      Finmap.insert a b (AList.toFinmap s) = AList.toFinmap (AList.insert a b s) :=
  by sorry

The theorem `Finmap.insert_toFinmap` states that for any types `α` and `β` such that `β` is a type function of `α`, and for any instance of decidable equality on `α`, any key `a` of type `α`, any value `b` of type `β a`, and any association list `s` of type `AList β`, the operation of inserting the key-value pair `(a, b)` into the finite map resulting from converting the association list `s` to a finite map is equivalent to the operation of converting the association list obtained from inserting the key-value pair `(a, b)` into `s` to a finite map. In other words, the process of inserting a key-value pair into an association list and then converting it to a finite map is the same as first converting the association list to a finite map and then inserting the key-value pair.

For any type functions `β` of type `α`, and given a decidable equality on `α`, inserting a key-value pair `(a, b)` into the finite map constructed from an association list `s` is equivalent to constructing the finite map from the association list obtained by inserting `(a, b)` into `s`.


theorem nonZeroDivisors.ne_zero :
    ∀ {M : Type u_2} [inst : MonoidWithZero M] [inst_1 : Nontrivial M] {x : M}, x ∈ nonZeroDivisors M → x ≠ 0 := by
  sorry

This theorem states that for any type `M` that forms a `MonoidWithZero` (which is a monoid with an additional zero element) and is `Nontrivial` (meaning it has at least two distinct elements), any element `x` of `M` that belongs to the submonoid of non-zero-divisors (an element is a non-zero-divisor if when it multiplies any other element results in zero, then that other element must be zero) is not equal to zero.

In a MonoidWithZero `M` with at least two distinct elements, every non-zero non-zero-divisor belongs to `M\backslash {0}`.


Int.ModEq.rfl

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

This theorem states that for all integers `n` and `a`, `a` is congruent to `a` modulo `n`. In mathematical terms, this means that the remainder of the division of `a` by `n` is the same as the remainder of the division of `a` by `n`, which is always true.

For all integers `n` and `a`, `a` is congruent to `a` modulo `n`. (In other words, `a` `≡` `a` (mod `n`) always holds.)


theorem Submodule.mem_iSup_of_mem :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
      {b : M} {p : ι → Submodule R M} (i : ι), b ∈ p i → b ∈ ⨆ i, p i :=
  by sorry

This theorem states that for any semiring `R`, an additively commutative monoid `M`, and a module `M` over `R`, given an index type `ι` and a function `p` from `ι` to submodules of `M`, if an element `b` of `M` is in the image of `p` at index `i`, then `b` belongs to the supremum of the images of `p` over all indices. In simpler terms, if an element is in a particular submodule, it is also in the supremum of all the submodules.

For any semiring `R`, additively commutative monoid `M`, and `R`-module `M`, if `p` is a function from an index type `ι` to submodules of `M` such that `b ∈ p i` for some index `i`, then `b ∈ ⨆ (j : ι) p j`.


theorem WithTop.add_right_cancel_iff :
    ∀ {α : Type u} [inst : Add α] {a b c : WithTop α} [inst_1 : IsRightCancelAdd α], a ≠ ⊤ → (b + a = c + a ↔ b = c) :=
  by sorry

This theorem, `WithTop.add_right_cancel_iff`, states that for any type `α` with an addition (`Add α`) operation, and for any three elements `a`, `b`, `c` of the type `WithTop α` (which is the type `α` with a special element `⊤` attached), the following holds: if `a` is not equal to `⊤` and the type `α` has the right-cancellation property with respect to addition (`IsRightCancelAdd α`), then the equality `b + a = c + a` implies `b = c`, and conversely, `b = c` implies `b + a = c + a`. In other words, one can cancel `a` from both sides of an equation if `a` is not the special `⊤` element and the addition operation is right-cancellable.

If `α` is a type with an addition operation and `WithTop α` has right-cancellation for addition, then for all `a, b, c ∈ WithTop α` with `a ≠ ⊤`, `a` being the special element in `WithTop α`, the equations `b + a = c + a` and `b = c` are equivalent.


theorem NumberField.InfinitePlace.isReal_iff :
    ∀ {K : Type u_2} [inst : Field K] {w : NumberField.InfinitePlace K},
      NumberField.InfinitePlace.IsReal w ↔
        NumberField.ComplexEmbedding.IsReal (NumberField.InfinitePlace.embedding w) :=
  by sorry

This theorem states that, for any given field `K` and an infinite place `w` of that field, `w` is real if and only if the embedding of `w` into the complex numbers is real. In other words, an infinite place of a number field is considered real if its associated complex embedding is fixed by complex conjugation.

An infinite place `w` of a field `K` is real if and only if its complex embedding into the complex numbers is self-conjugate.


theorem List.count_eq_zero_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {l : List α}, a ∉ l → List.count a l = 0 := by sorry

This theorem states that for any type `α` that has a decidable equality, any element `a` of type `α` and any list `l` of elements of type `α`, if the element `a` is not an element of the list `l`, then the count of `a` in `l` is zero. In other words, if `a` is not in `l`, `a` occurs zero times in `l`.

For any decidably equal type `α` and list `l` of elements from `α`, if `a` is not an element of `l`, then the count of `a` in `l` equals zero.


/-- **Alias** of the forward direction of `Set.pairwise_iff_of_refl`. -/
theorem Set.Pairwise.of_refl :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} [inst : IsRefl α r],
      Set.Pairwise s r → ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → r a b :=
  by sorry

This theorem, named `Set.Pairwise.of_refl`, states that for any type `α` and a reflexive relation `r` on `α`, if `r` holds pairwise for all distinct elements in a set `s` of type `α`, then `r` holds for all elements in `s`, not just the distinct ones. In more formal terms, given a set `s` of elements of type `α` and a reflexive relation `r` on `α`, if ∀ `x`, `y` ∈ `s` such that `x` ≠ `y`, `r x y` holds, then ∀ `a`, `b` ∈ `s`, `r a b` also holds. Here, a reflexive relation is one for which every element is related to itself.

If a reflexive relation holds pairwise between all distinct elements of a set, then it holds for all elements in the set.


theorem Real.rpow_neg_one : ∀ (x : ℝ), x ^ (-1) = x⁻¹ := by sorry

This theorem states that for any real number `x`, raising `x` to the power of `-1` is equivalent to the multiplicative inverse of `x` (denoted as `x⁻¹`). In other words, for any real number, the operation of taking the power of `-1` is the same as taking the reciprocal. This is a standard result in real number arithmetic.

For any real number x, x^(-1) = 1/x (or x^(-1) is the multiplicative inverse of x).


theorem Set.image_image2 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {s : Set α} {t : Set β} (f : α → β → γ) (g : γ → δ),
      g '' Set.image2 f s t = Set.image2 (fun a b => g (f a b)) s t :=
  by sorry

This theorem states that for any types `α`, `β`, `γ`, and `δ`, any sets `s` of type `α` and `t` of type `β`, any binary function `f` from `α` and `β` to `γ`, and any function `g` from `γ` to `δ`, the image under `g` of the image under `f` of `s` and `t` is equal to the image under the function that first applies `f` and then applies `g` of `s` and `t`. In other words, it asserts that the operation of taking images of sets under functions respects the composition of functions, which is a fundamental property in set theory and functional analysis.

For any sets $s$ of type $\alpha$, $t$ of type $\beta$, binary function $f$ from $\alpha$ and $\beta$ to $\gamma$, and function $g$ from $\gamma$ to $\delta$, the image of $s$ and $t$ under $g \circ f$ is equal to the image of $s$ under $f$ and then $t$ under $g$.


theorem Codisjoint.mono_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b c : α},
      b ≤ c → Codisjoint a b → Codisjoint a c :=
  by sorry

The theorem `Codisjoint.mono_right` states that in a partial order structure with a top element, if we have three elements `a`, `b`, and `c`, and `b` is less than or equal to `c`, then if `a` and `b` are codisjoint, it implies that `a` and `c` are also codisjoint. In other words, the property of being codisjoint is monotonic with respect to the second argument.

If `a`, `b`, and `c` are elements of a partial order with a top element, `b` is less than or equal to `c`, and `a` and `b` are codisjoint, then `a` and `c` are also codisjoint.


theorem Asymptotics.isBigOWith_of_le :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      (l : Filter α), (∀ (x : α), ‖f x‖ ≤ ‖g x‖) → Asymptotics.IsBigOWith 1 l f g :=
  by sorry

This theorem, `Asymptotics.isBigOWith_of_le`, states that for all types `α`, `E`, and `F`, given two functions `f` and `g` from `α` to `E` and `F` respectively, and a filter `l` on `α`, if the norm of `f(x)` is less than or equal to the norm of `g(x)` for all `x` in `α`, then `f` is Big `O` of `g` with a constant of `1` at filter `l`. In other words, in the asymptotic analysis of the two functions `f` and `g`, if the absolute value of `f(x)` is always less than or equal to the absolute value of `g(x)`, then `f` grows no faster than `g`, up to a constant factor of `1`.

If for all `x` in `α`, the norm of `f(x)` is less than or equal to the norm of `g(x)`, then `f` is Big O of `g` with a constant of `1` at filter `l`. In other words, `|f(x)| ≤ |g(x)|` implies `f = O(g)` up to a constant factor of `1`.


theorem Dioph.reindex_dioph :
    ∀ {α : Type u} (β : Type u) {S : Set (α → ℕ)} (f : α → β), Dioph S → Dioph {v | v ∘ f ∈ S} := by sorry

The theorem `Dioph.reindex_dioph` states that for any types `α` and `β`, and for any set `S` of functions from `α` to natural numbers, if `S` is Diophantine, then the set of functions `v` from `β` to natural numbers such that `(v ∘ f)` is in `S` is also Diophantine. Here, `f` is a function from `α` to `β`, and `v ∘ f` represents the function composition of `v` and `f`. This theorem essentially proves that the Diophantine property is preserved under re-indexing.

If `S` is a Diophantine set of functions from `α` to natural numbers, then the set of functions `v` from `β` to natural numbers such that `(v ∘ f)` is in `S` for some function `f` from `α` to `β`, is also Diophantine.


theorem MeasureTheory.withDensity_one :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.withDensity 1 = μ := by sorry

This theorem states that for any type `α`, any measurable space `α` is equipped with `m0`, and any measure `μ` of type `MeasureTheory.Measure α`, applying the `withDensity` function to `μ` with the constant function `1` returns `μ` itself. Essentially, the measure with density 1 is the same as the original measure, in the context of Measure Theory.

For any measurable space `(α, Σ)` and measure `μ : MeasureTheory.Measure α`, `μ` equals `withDensity 1 μ`.


theorem sup_compl_eq_top : ∀ {α : Type u} {x : α} [inst : BooleanAlgebra α], x ⊔ xᶜ = ⊤ := by sorry

This theorem states that for any type `α` that has a Boolean algebra structure, the supremum (also known as the join or least upper bound) of any element `x` and its complement `xᶜ` is the top element `⊤`. In other words, in any Boolean algebra, the "or" operation (`⊔`) applied to an element and its negation always results in the truth value "true" or `⊤`.

In any Boolean algebra, the supremum of an element and its complement is the top element.


theorem MeasureTheory.Measure.add_right_inj :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ ν₁ ν₂ : MeasureTheory.Measure α) [inst : MeasureTheory.SigmaFinite μ],
      μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂ :=
  by sorry

This theorem states that for any type 'α', given a measurable space 'm0' over 'α', and three measures 'μ', 'ν₁' and 'ν₂' on this space, if 'μ' is a sigma-finite measure, then the equality of the sum of 'μ' and 'ν₁' with the sum of 'μ' and 'ν₂' implies the equality of 'ν₁' and 'ν₂'. In other words, if two sums of measures are equal, and one measure in both sums is the same and sigma-finite, then the other measures in the sums must be equal.

If 'μ' is a sigma-finite measure on measurable space '(α, m0)', and 'ν₁' and 'ν₂' are measures on '(α, m0)', then 'ν₁ = ν₂' given 'μ + ν₁ = μ + ν₂'.


theorem Set.image2_iInter_subset_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

This theorem states that for every types `α`, `β`, `γ` and a sort `ι`; for a function `f` from `α` to `β` to `γ`; for a family of sets `s` indexed by `ι` of type `α`; and for a set `t` of type `β`, the image under `f` of the intersection of all sets `s i` with set `t` is a subset of the intersection of the image under `f` of each `s i` with set `t`. In mathematical terms, it asserts that $f((\bigcap_{i} s_i) \times t) \subseteq \bigcap_{i} f(s_i \times t)$.

For every functions $f: \alpha \to \beta \to \gamma$, sets $s\_i:\_ \to \alpha$ indexed by $ι$, and sets $t:\beta$, we have $f(\bigcap\_{i} (s\_i \times t)) \subseteq \bigcap\_{i} (f(s\_i \times t))$.


theorem MeasureTheory.Measure.IicSnd_apply :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (r : ℝ) {s : Set α},
      MeasurableSet s → ↑↑(MeasureTheory.Measure.IicSnd ρ r) s = ↑↑ρ (s ×ˢ Set.Iic r) :=
  by sorry

The theorem `MeasureTheory.Measure.IicSnd_apply` states that for any measurable space `α`, any measure `ρ` on the product space `α × ℝ`, any real number `r`, and any set `s` in `α` that is measurable, the measure of `s` under `IicSnd ρ r` is equal to the measure of the cartesian product of `s` and the interval from negative infinity up to `r` under `ρ`. Here, `Set.Iic r` represents the interval of all real numbers less than or equal to `r`, and `s ×ˢ Set.Iic r` is the cartesian product of `s` and this interval. This theorem connects the measure of a set in the original measurable space with the measure of a related set in the product space.

For any measurable space `α`, measure `ρ` on `α × ℝ`, measurable set `s` in `α`, and real number `r`, the measure of `s` under `IicSnd ρ r` equals the measure of `s ×ˢ Set.Iic r` under `ρ`.


theorem MvPolynomial.map_injective :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁),
      Function.Injective ⇑f → Function.Injective ⇑(MvPolynomial.map f) :=
  by sorry

The theorem `MvPolynomial.map_injective` states that for any types `R`, `S₁`, and `σ`, where `R` and `S₁` are commutative semirings, and for any ring homomorphism `f` from `R` to `S₁`, if `f` is injective (i.e., if for any `a₁` and `a₂` in `R`, `f(a₁) = f(a₂)` implies `a₁ = a₂`), then the function that maps a multivariate polynomial over `R` to a multivariate polynomial over `S₁` using `f` is also injective. In other words, the injectivity of `f` guarantees the injectivity of the mapping operation for multivariate polynomials.

Given commutative semirings R and S₁, and a ring homomorphism f from R to S₁ that is injective, the mapping of multivariate polynomials over R to multivariate polynomials over S₁ using f is also injective.


/-- `Fintype.sum_bijective` is a variant of `Finset.sum_bij` that accepts
`Function.Bijective`.

See `Function.Bijective.sum_comp` for a version without `h`.  -/
theorem Fintype.sum_bijective :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid α]
      (e : ι → κ),
      Function.Bijective e →
        ∀ (f : ι → α) (g : κ → α),
          (∀ (x : ι), f x = g (e x)) → (Finset.sum Finset.univ fun x => f x) = Finset.sum Finset.univ fun x => g x :=
  by sorry

The theorem `Fintype.sum_bijective` states that for any two types `ι` and `κ` that have a finite number of elements (i.e., they are both instances of `Fintype`), and for any type `α` that is an instance of `AddCommMonoid` (meaning it behaves like a set of numbers with addition defined), if there is a bijective function `e` from `ι` to `κ`, then for any two functions `f : ι → α` and `g : κ → α` such that `f x` equals `g (e x)` for all `x` in `ι`, the sum of `f x` over all elements `x` in the universal finite set of type `ι` equals the sum of `g x` over all elements `x` in the universal finite set of type `κ`. Essentially, it says that if we re-label the elements of the finite set and apply the respective function, the sum remains the same.

For any finite types `ι` and `κ` and functions `f : ι → α` and `g : κ → α` such that there exists a bijective function `e : ι ≃ κ` with `f x = g (e x)` for all `x`, the sum of `f x` over `ι` equals the sum of `g x` over `κ`.


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

The theorem `Set.indicator_eq_self` states that for any type α, any type M with a zero element, any set s of elements of type α, and any function f from α to M, the indicator function for the set s and function f is equal to the function f itself if and only if the support of the function f is a subset of the set s. Here, the support of a function is the set of all points where the function does not output zero, and the indicator function for a set s and a function f outputs the application of the function to an input if the input is in the set and zero otherwise.

The indicator function of a set with respect to a function equals the function itself if and only if the function's support is contained in the set.


theorem List.perm_ext_iff_of_nodup :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Nodup l₁ → List.Nodup l₂ → (List.Perm l₁ l₂ ↔ ∀ (a : α), a ∈ l₁ ↔ a ∈ l₂) :=
  by sorry

This theorem, `List.perm_ext_iff_of_nodup`, states that for any two lists `l₁` and `l₂` of a certain type `α`, if both `l₁` and `l₂` do not contain any duplicate elements (i.e., `List.Nodup l₁` and `List.Nodup l₂` are true), then `l₁` is a permutation of `l₂` if and only if any element `a` of type `α` is in `l₁` if and only if `a` is in `l₂`. In other words, two lists without duplicates are permutations of each other if they contain exactly the same elements.

For lists `l₁` and `l₂` of type `α` without duplicate elements, `l₁` is a permutation of `l₂` if and only if they have the same elements.


theorem Subgroup.index_top : ∀ {G : Type u_1} [inst : Group G], Subgroup.index ⊤ = 1 := by sorry

This theorem states that for any given Type `G` that forms a Group, the index of the top (or universal) subgroup is always equal to 1. In mathematical terms, if `G` is a group, then the index of the top subgroup (which contains all elements of the group) is 1. This is because the top subgroup is essentially the whole group itself, and the index of a group to itself is defined as 1.

The index of a group to itself is equal to 1. (For any group G, |G| := |{x : G | x = 0}| = 1)


theorem isPeriodicPt_add_iff_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddMonoid G] {n : ℕ} (x : G), Function.IsPeriodicPt (fun x_1 => x + x_1) n 0 ↔ n • x = 0 :=
  by sorry

The theorem `isPeriodicPt_add_iff_nsmul_eq_zero` states that for any type `G` which has an `AddMonoid` structure, and any natural number `n` and element `x` of type `G`, the function defined as `λ x_1 => x + x_1` is periodic at `0` with period `n` if and only if the `n`-fold addition of `x` (denoted by `n • x`) equals `0`. This theorem draws a connection between the periodicity of the function and the repetitive addition of an element in an additive monoid.

For any additive monoid (G, +) and natural number n, an element x in G is periodic with period n under the addition operation if and only if n * x = 0.


theorem UniformContinuous.prod_map :
    ∀ {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} [inst : UniformSpace α] [inst_1 : UniformSpace β]
      [inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] {f : α → γ} {g : β → δ},
      UniformContinuous f → UniformContinuous g → UniformContinuous (Prod.map f g) :=
  by sorry

The theorem `UniformContinuous.prod_map` states that for any four types `α`, `β`, `γ`, `δ` each equipped with a uniform space structure, and any two functions `f : α → γ` and `g : β → δ`, if `f` and `g` are uniformly continuous, then the function `Prod.map f g`, which applies `f` and `g` to the components of a pair respectively, is also uniformly continuous. In mathematical terms, this means that if for any points `x` and `y` in `α` and `β` respectively, `f` and `g` bring `x` and `y` close together as `x` and `y` get close, then the same is true when `f` and `g` are applied to pairs of points in `α × β`.

If `f : α → γ` and `g : β → δ` are uniformly continuous functions between uniform spaces, then the function `Prod.map f g : α × β → γ × δ` is also uniformly continuous.


theorem List.foldl_map :
    ∀ {β₁ : Type u_1} {β₂ : Type u_2} {α : Type u_3} (f : β₁ → β₂) (g : α → β₂ → α) (l : List β₁) (init : α),
      List.foldl g init (List.map f l) = List.foldl (fun x y => g x (f y)) init l :=
  by sorry

The theorem `List.foldl_map` states that for all types `β₁`, `β₂`, and `α`, a function `f` from `β₁` to `β₂`, a function `g` from `α` and `β₂` to `α`, a list `l` of type `β₁`, and an initial value `init` of type `α`, the process of first mapping the function `f` over the list `l` and then folding the list from the left using the function `g` and initial value `init` is equivalent to folding the list from the left using a function that applies `f` to the second argument of `g`, with the same initial value.

In other words, the order of the map and fold operations can be swapped without changing the result, as long as the function used in the fold operation is adjusted accordingly. This can be stated more formally as:
\[ \text{foldl}\ g\ \text{init}\ (\text{map}\ f\ l) = \text{foldl}\ (\lambda x, y.\ g\ x\ (f\ y))\ \text{init}\ l \]

The theorem asserts that for any type `α`, functions `f : β₁ -> β₂` and `g : α -> β₂ -> α`, lists `l : β₁` and initial value `init : α`, the left fold-map operation `foldl g init (map f l)` is equivalent to the left fold operation `foldl (λ x, y => g x (f y)) init l`.


/-- A monotone function on an upwards-directed type is directed.  -/
theorem directed_of_isDirected_le :
    ∀ {α : Type u} {β : Type v} [inst : LE α] [inst_1 : IsDirected α fun x x_1 => x ≤ x_1] {f : α → β}
      {r : β → β → Prop}, (∀ ⦃i j : α⦄, i ≤ j → r (f i) (f j)) → Directed r f :=
  by sorry

The theorem `directed_of_isDirected_le` states that for any types `α` and `β`, given `α` has a `≤` relation that makes it upwards-directed, and a monotone function `f` from `α` to `β`, and a relation `r` on `β`, if it holds that for any `i` and `j` in `α` where `i ≤ j` it implies that `r(f(i), f(j))`, then the function `f` is directed with respect to the relation `r`. In other words, given any pair `x` and `y` in the domain of `f`, there is an element `z` such that both `f(x)` and `f(y)` are related to `f(z)` under the relation `r`.

If `α` is upwards-directed with respect to `≤`, and `f: α → β` is a monotone function such that `r(f(i), f(j))` holds for all `i ≤ j` in `α`, then `f` is a directed function with respect to `r`.


theorem Filter.prod_principal_principal :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β},
      Filter.principal s ×ˢ Filter.principal t = Filter.principal (s ×ˢ t) :=
  by sorry

This theorem states that for any two types `α` and `β`, and any two sets `s` of type `α` and `t` of type `β`, the product of the principal filters of `s` and `t` is equal to the principal filter of the product of `s` and `t`. In mathematical terms, given sets `s ⊆ α` and `t ⊆ β`, the principal filter generated by the Cartesian product `s × t` is the same as the Cartesian product of the principal filters generated by `s` and `t` respectively.

The principal filters of sets `s ⊆ α` and `t ⊆ β` have the same elements as the principal filter generated by the Cartesian product `s × t`.


/-- The complex sine function is everywhere differentiable, with the derivative `cos x`.  -/
theorem Complex.hasDerivAt_sin : ∀ (x : ℂ), HasDerivAt Complex.sin (Complex.cos x) x := by sorry

This theorem states that the complex sine function is differentiable at every point. Specifically, the derivative of the complex sine function at any point `x` in the complex numbers, is given by the complex cosine function evaluated at that point `x`.

The complex sine function is complex differentiable, with derivative equal to the complex conjugate of the complex cosine function at each point in the complex numbers.


CategoryTheory.IsSplitEpi.id

theorem CategoryTheory.IsSplitEpi.id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
      [hf : CategoryTheory.IsSplitEpi f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.section_ f) f = CategoryTheory.CategoryStruct.id Y :=
  by sorry

This theorem states that, for any category `C`, and any objects `X` and `Y` in `C`, given a morphism `f` from `X` to `Y` that is a split epimorphism, the composition of the section of `f` (denoted by `CategoryTheory.section_ f`) with `f` itself is the identity morphism on `Y`. In the language of category theory, this means that if `f` is a split epimorphism, then there exists a morphism from `Y` to `X` that "undoes" the effect of `f` when composed with it, leaving the identity on `Y`. This is a fundamental property in category theory relating to the concept of splitting idempotents.

For any object `X`, `Y` in a category `C` and a split epimorphism `f` from `X` to `Y`, `CategoryTheory.section_ f ∘ f = id_Y`.


theorem Real.cos_pi_div_two_sub : ∀ (x : ℝ), Real.cos (Real.pi / 2 - x) = Real.sin x := by sorry

This theorem states that for all real numbers `x`, the cosine of the quantity `π/2 - x` is equal to the sine of `x`. In other words, it captures the property of the cosine and sine functions that `cos(π/2 - x) = sin(x)` for all `x` in the real numbers, where `π` is the mathematical constant pi and `cos` and `sin` represent the cosine and sine functions respectively.

For all real numbers x, cos(π/2 - x) = sin(x).


theorem directed_id : ∀ {α : Type u} {r : α → α → Prop} [inst : IsDirected α r], Directed r id := by sorry

This theorem states that for any given type `α` and a relation `r` on `α` such that `α` is directed with respect to `r`, the identity function `id` is also directed with respect to the same relation `r`. In other words, given any two elements in the range of the identity function, there exists a third element that is related (under `r`) to both of them.

If `α` is a directed type and `r` is a relation on `α` such that `α` is directed with respect to `r`, then the identity function `id` on `α` is also a directed function with respect to `r`.


theorem Real.hasDerivAt_arctan : ∀ (x : ℝ), HasDerivAt Real.arctan (1 / (1 + x ^ 2)) x := by sorry

This theorem states that for all real numbers `x`, the derivative of the arctan function at the point `x` is `1 / (1 + x ^ 2)`. In other words, if you were to draw a tangent line at any point on the graph of the arctan function, the slope of that line would be `1 / (1 + x ^ 2)`. This is a fundamental result in calculus and is used extensively in areas of mathematics that involve trigonometry and differentiation.

The derivative of the arctan function is equal to 1 / (1 + x^2).


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

The theorem `Partrec₂.comp` states that for all types `α`, `β`, `γ`, and `σ` that are `Primcodable`, if we have three functions `f` (from `β` and `γ` to an option type `σ`, i.e., `f` may not return a value for some inputs), `g` (from `α` to `β`), and `h` (from `α` to `γ`), then if `f` is partially recursive (in two variables) and both `g` and `h` are computable, then the function that takes `a` of type `α` and applies `f` to `g(a)` and `h(a)` is also partially recursive.

Essentially, this theorem expresses a property of composition of functions in the context of computability theory - given computable and partially recursive functions, we can construct a new function that is also partially recursive by applying these functions in a certain way.

If `f` is a partially recursive function from `β` to `option σ` and `g : α → β` and `h : α → γ` are computable functions, then the function `x ↦ some (f (g x)) (h x)` is also partially recursive from `α` to `option σ`.


theorem CovBy.pred_eq :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] {a b : α}, a ⋖ b → Order.pred b = a := by sorry

This theorem, `CovBy.pred_eq`, states that for any given type `α` which has a partial order and a predecessor order, and any two elements `a` and `b` of this type, if `a` is covered by `b` (denoted as `a ⋖ b` meaning `a < b ∧ ¬∃ c, a < c ∧ c < b`), then the predecessor of `b` (computed with `Order.pred b`) is equal to `a`. Essentially, if `b` directly follows `a` in the order, then `a` is identified as the predecessor of `b`.

If `a` is covered by `b` in a partially ordered type, then `Order.pred b = a`.


theorem Function.apply_update :
    ∀ {ι : Sort u_1} [inst : DecidableEq ι] {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i)
      (g : (i : ι) → α i) (i : ι) (v : α i) (j : ι),
      f j (Function.update g i v j) = Function.update (fun k => f k (g k)) i (f i v) j :=
  by sorry

The theorem `Function.apply_update` states that for any types `ι`, `α`, and `β`, where `α` and `β` are type functions indexed by `ι`, given a function `f` that maps an element of type `ι` and its corresponding `α` value to a `β` value, another function `g` that maps an element of `ι` to an `α` value, an element `i` of type `ι`, a value `v` of type `α i`, and another element `j` of type `ι`, applying `f` to `j` and the result of updating `g` at `i` with `v`, is equivalent to updating the function that maps `k` to `f k (g k)` at `i` with `f i v`, and then applying this to `j`. This theorem essentially describes how function application interacts with function update.

For any functions `f : ι → α → β` and `g : ι → α`, given `i : ι`, `v : α i`, and `j : ι`, `f i (g ^^ update i v) = update i (f i v) (g) ^^ f j`.


theorem le_sup_sdiff : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a ≤ b ⊔ a \ b := by sorry

This theorem states that for any type `α` that forms a Generalized Coheyting Algebra, and for any elements `a` and `b` of type `α`, `a` is less than or equal to the sup (supremum) of `b` and the set difference `a \ b`. In mathematical terms, this can be written as: ∀ a, b ∈ α, a ≤ sup(b, a \ b).

For any Generalized Cocompleteness Algebra type `α` and elements `a, b` in `α`, `a` is less than or equal to the supremum of `b` and the set difference `a \ b`. Mathematically expressed: `∀ a, b ∈ α, a ≤ sup(b, a \ b)`.


theorem Function.iterate_add : ∀ {α : Type u} (f : α → α) (m n : ℕ), f^[m + n] = f^[m] ∘ f^[n] := by sorry

This theorem, named `Function.iterate_add`, is a property of function iteration in mathematics. For any function `f` from a type `α` to itself and any two natural numbers `m` and `n`, iterating the function `f` `(m + n)` times is equal to first iterating the function `f` `m` times and then iterating the result `n` times. In other words, it states that the application of `f` `(m + n)` times is the same as applying `f` `m` times, and then applying `f` `n` times to the result.

For any function `f` from a type `α` to itself and natural numbers `m` and `n`, `(iterate f (m + n)) = (iterate f m) (iterate f n)`.


theorem Matrix.conjTranspose_mul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Fintype n] [inst_1 : NonUnitalSemiring α]
      [inst_2 : StarRing α] (M : Matrix m n α) (N : Matrix n l α),
      Matrix.conjTranspose (M * N) = Matrix.conjTranspose N * Matrix.conjTranspose M :=
  by sorry

The theorem `Matrix.conjTranspose_mul` states that for any two matrices `M` and `N` with elements in a non-unital semiring `α` that also forms a star-ring, the conjugate transpose of the product of `M` and `N` is equal to the product of the conjugate transpose of `N` and the conjugate transpose of `M`. In other words, if `M` is a matrix from `m` to `n` and `N` is a matrix from `n` to `l`, then the rule `(M * N)† = N† * M†` holds true. Here `†` denotes the conjugate transpose of a matrix and `*` denotes matrix multiplication.

For matrices M from m to n and N from n to l over a non-unital semiring α that forms a star-ring, the conjugate transpose of their product equals the product of their conjugate transposes: (M * N)† = N† * M† .


theorem Set.disjoint_singleton : ∀ {α : Type u} {a b : α}, Disjoint {a} {b} ↔ a ≠ b := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of type `α`, the singleton sets `{a}` and `{b}` are disjoint (in the sense that their infimum is the bottom element) if and only if `a` is not equal to `b`. In other words, two single-element sets are disjoint according to our definition if the elements they contain are distinct.

For any type `α` and elements `a` and `b` of type `α`, the singleton sets `{a}` and `{b}` have empty intersection, i.e., their infimum is the bottom element, if and only if `a` is not equal to `b`.


theorem Cardinal.aleph0_ne_zero : Cardinal.aleph0 ≠ 0 := by sorry

This theorem states that the smallest infinite cardinal number, often represented as `ℵ₀` (aleph null), is not equal to zero. In the context of set theory, `ℵ₀` is the cardinality of the set of natural numbers, implying that the set of natural numbers is not empty, hence its cardinality cannot be zero.

The theorem asserts that `ℵ₀ ≠ 0`, where `ℵ₀` is the cardinality of the set of natural numbers.


theorem symm_le_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α], Filter.map Prod.swap (uniformity α) ≤ uniformity α := by sorry

This theorem states that for any type `α` that has an associated uniform space structure, the forward map of the uniformity of `α` under the product swap operation is less than or equal to the uniformity of `α`. In other words, if we take the uniformity (which is a filter on the product `α × α`) and apply the product swap operation (which swaps the elements of an ordered pair), the resulting mapped filter is still less than or equal to the original uniformity. This theorem is fundamental in the theory of uniform spaces, ensuring a sort of symmetry property for the uniformity filter.

The forward map of a uniformity on a type under the product swap operation is less than or equal to the original uniformity.


theorem Multiset.exists_mem_of_ne_zero : ∀ {α : Type u_1} {s : Multiset α}, s ≠ 0 → ∃ a, a ∈ s := by sorry

The theorem `Multiset.exists_mem_of_ne_zero` states that for any type `α` and any multiset `s` of that type, if the multiset `s` is not empty (i.e., `s ≠ 0`), then there exists an element `a` such that `a` is a member of `s`. This is essentially saying that a non-empty multiset always contains at least one element.

If `s` is a non-empty multiset, then there exists an element `a` such that `a ∈ s`.


theorem Sbtw.ne_left :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Sbtw R x y z → y ≠ x :=
  by sorry

This theorem, named `Sbtw.ne_left`, states that for any points `x`, `y`, and `z` in an affine space `P`, which is a vector space `V` over an ordered ring `R`, if `y` is strictly between `x` and `z` (as defined by the `Sbtw` function), then `y` is not equal to `x`. This is captured mathematically as: for all `x`, `y`, `z` in `P`, `Sbtw R x y z` implies `y ≠ x`.

In an affine space over an ordered ring, if point `y` is strictly between points `x` and `z`, then `y` is distinct from `x`.


theorem QuotientMap.isClosed_preimage :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      QuotientMap f → ∀ {s : Set Y}, IsClosed (f ⁻¹' s) ↔ IsClosed s :=
  by sorry

The theorem `QuotientMap.isClosed_preimage` states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, given that `f` is a quotient map (which is defined as a surjective function such that a set `s` in `Y` is open if and only if its preimage in `X` is an open set), then for any set `s` of type `Y`, the preimage of `s` under `f` is closed if and only if `s` is closed. In other words, a set in the codomain `Y` is closed if and only if its corresponding preimage in the domain `X` is closed, when the function mapping `X` to `Y` is a quotient map.

For a surjective function `f` between types `X` and `Y` being a quotient map implies that the preimage of a closed set in `Y` under `f` is closed in `X`.


/-- The complex hyperbolic cosine function is everywhere differentiable, with the derivative
`sinh x`.  -/
theorem Complex.hasDerivAt_cosh : ∀ (x : ℂ), HasDerivAt Complex.cosh (Complex.sinh x) x := by sorry

The theorem states that the complex hyperbolic cosine function is differentiable at every point in the complex plane. Moreover, the derivative of the complex hyperbolic cosine function at any point 'x' in the complex plane is given by the value of the complex hyperbolic sine function at that point.

The complex hyperbolic cosine function has a complex differentiable derivative equal to the complex hyperbolic sine function at every point in the complex plane.


theorem Multiset.erase_of_not_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∉ s → Multiset.erase s a = s := by sorry

This theorem states that for any type `α` with decidable equality, for any element `a` of `α`, and for any multiset `s` of elements of `α`, if `a` is not a member of `s`, then erasing `a` from `s` leaves `s` unchanged. In simpler terms, removing an element that doesn't exist in a multiset doesn't change the multiset.

For any type `α` with decidable equality, and for any multiset `s` of elements from `α` and element `a` not in `s`, the multiset `s` is equal to the multiset obtained by erasing `a` from `s`.


theorem tendsto_atTop_iSup :
    ∀ {α : Type u_1} {ι : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α] [inst_2 : CompleteLattice α]
      [inst_3 : SupConvergenceClass α] {f : ι → α}, Monotone f → Filter.Tendsto f Filter.atTop (nhds (⨆ i, f i)) :=
  by sorry

The theorem `tendsto_atTop_iSup` states that for any types `α` and `ι`, where `α` has a topological space structure and is also a complete lattice, and `ι` is preordered, given a function `f` from `ι` to `α`, if `f` is monotone, then `f` tends to the supremum of `f` at `∞`. In other words, for every neighborhood of the supremum of `f`, the pre-image of that neighborhood under `f` contains all sufficiently large elements of `ι`.

For any monotone function `f` from a preordered type `ι` to a complete lattice `α` with topological space structure, if `∞` is in `ι` and `f(∞)` is the supremum of `f` over `ι`, then for every neighborhood of `f(∞)` in `α`, the preimage `f⁻¹(U)` contains all `i` in `ι` such that `i` is larger than some element in `ι`.


/-- The range of an indexed cardinal function, whose outputs live in a higher universe than the
inputs, is always bounded above.  -/
theorem Cardinal.bddAbove_range : ∀ {ι : Type u} (f : ι → Cardinal.{max u v}), BddAbove (Set.range f) := by sorry

This theorem states that for any type `ι` and a function `f` from `ι` to a cardinal number in a universe that is potentially larger than the universe of `ι`, the range of `f` is always bounded above. In the language of mathematics, this means there exists an upper bound for the set of cardinal numbers that are produced as outputs by the function `f`.

For any type `ι` and function `f` from `ι` to a cardinal number, there exists a cardinal number that is an upper bound for the range of `f`.


theorem MeasureTheory.snorm_mono_measure :
    ∀ {α : Type u_1} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ ν : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] (f : α → F), ν ≤ μ → MeasureTheory.snorm f p ν ≤ MeasureTheory.snorm f p μ :=
  by sorry

The theorem `MeasureTheory.snorm_mono_measure` states that for any types `α` and `F` with `α` being a measurable space and `F` being a normed additive commutative group, any extended nonnegative real number `p`, and any two measures `μ` and `ν` on `α`, if `ν` is less than or equal to `μ` (i.e., every set that `ν` assigns a finite measure to is also assigned a finite measure by `μ`), then the `ℒp` seminorm of a function `f` from `α` to `F` with respect to the measure `ν` is less than or equal to the `ℒp` seminorm of `f` with respect to the measure `μ`. This theorem asserts the monotonicity of the `ℒp` seminorm with respect to the underlying measure.

For any measurable space `α`, normed additive commutative group `F`, extended nonnegative real number `p`, and measures `μ` and `ν` on `α` with `ν` less than or equal to `μ`, the `ℒp` seminorm of a function from `α` to `F` is monotone with respect to the underlying measure, i.e., the seminorm with respect to `ν` is less than or equal to the seminorm with respect to `μ`.


/-- The norm of the tensor product of a scalar linear map and of an element of a normed space
is the product of the norms.  -/
theorem ContinuousLinearMap.norm_smulRight_apply :
    ∀ {𝕜 : Type u_1} {E : Type u_4} {Fₗ : Type u_7} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup Fₗ]
      [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 Fₗ] (c : E →L[𝕜] 𝕜)
      (f : Fₗ), ‖ContinuousLinearMap.smulRight c f‖ = ‖c‖ * ‖f‖ :=
  by sorry

This theorem states that for any scalar linear map 'c' from a normed space 'E' to a field '𝕜' and any element 'f' of a normed space 'Fₗ', the norm of the tensor product of 'c' and 'f' (denoted as `ContinuousLinearMap.smulRight c f`) is equal to the product of the individual norms of 'c' and 'f'. In other words, ‖ContinuousLinearMap.smulRight c f‖ = ‖c‖ * ‖f‖. This is valid in the context where 'E' and 'Fₗ' are normed additive commutative groups, '𝕜' is a non-trivially normed field, and both 'E' and 'Fₗ' are normed spaces over '𝕜'.

The norm of the tensor product of a continuous linear map and an element from two normed spaces is equal to the product of their individual norms.


theorem neg_add' : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -(a + b) = -a - b := by sorry

This theorem, named `neg_add'`, states that for any type `α` that is a commutative monoid under subtraction (meaning subtraction can be applied in any order without changing the result), and for any two elements `a` and `b` of this type, the negation of the sum of `a` and `b` is equal to the result of subtracting `b` from the negation of `a`. In mathematical notation, this is saying that for all `a` and `b`, `-(a + b) = -a - b`.

For any commutative monoid `α` under subtraction, the negation of the sum of two elements `a` and `b` equals the difference between the negations of `a` and `b`, i.e., `-(a + b) = -a - b`.


theorem Num.mul_to_nat : ∀ (m n : Num), ↑(m * n) = ↑m * ↑n := by sorry

This theorem states that for all numbers `m` and `n` of type `Num`, the casting of the product of `m` and `n` into a `Nat` (natural number) is equal to the product of `m` cast to a `Nat` and `n` cast to a `Nat`. In mathematical terms, for all `m` and `n`, `(m * n)` cast to a natural number is equal to `(m` cast to a natural number`) * (n` cast to a natural number`).

For all natural numbers `m` and `n`, `(m : Nat) * n = m * (n : Nat)`.


theorem Ordinal.sub_le : ∀ {a b c : Ordinal.{u_4}}, a - b ≤ c ↔ a ≤ b + c := by sorry

This theorem, `Ordinal.sub_le`, states that for any three ordinals `a`, `b`, and `c`, the ordinal obtained by subtracting `b` from `a` is less than or equal to `c`, if and only if `a` is less than or equal to the sum of `b` and `c`. In mathematical notation, this can be stated as \(a - b \leq c \Leftrightarrow a \leq b + c\). This theorem establishes a connection between the operations of subtraction and addition on ordinals.

For any ordinals `a`, `b`, and `c`, `a - b <= c` if and only if `a <= b + c`.


theorem Basis.mk_apply :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
      [inst_2 : Module R M] (hli : LinearIndependent R v) (hsp : ⊤ ≤ Submodule.span R (Set.range v)) (i : ι),
      (Basis.mk hli hsp) i = v i :=
  by sorry

The theorem `Basis.mk_apply` states that for any type `ι`, any ring `R`, any additive commutative group `M`, and any function `v` from `ι` to `M`, given that `v` is linearly independent over `R` and the span of the range of `v` is the whole module `M` (i.e., every element of `M` can be expressed as a linear combination of elements in the range of `v`), then for any `i` of type `ι`, the `i`th element of the basis created by `v` is exactly the `i`th element of `v`. In other words, the basis created using `v` under these conditions is identical to `v` itself.

If `v` is a linearly independent function from type `ι` to an additive commutative group `M` over ring `R` such that the span of `v` equals `M`, then the basis obtained from `v` is equal to `v` itself.


theorem Equiv.Perm.ofSubtype_apply_of_mem :
    ∀ {α : Type u} {p : α → Prop} [inst : DecidablePred p] {a : α} (f : Equiv.Perm (Subtype p)) (ha : p a),
      (Equiv.Perm.ofSubtype f) a = ↑(f { val := a, property := ha }) :=
  by sorry

This theorem states that for any type `α` and a decidable predicate `p` on `α`, given a permutation `f` on the subtype of `α` satisfying `p`, and an element `a` of `α` that satisfies `p`, applying the permutation on `α` that extends `f` (obtained through `Equiv.Perm.ofSubtype`) to `a` yields the same result as applying `f` to `a` (considered as an element of the subtype). In other words, for those elements of `α` which satisfy `p`, the behavior of the extended permutation matches that of the original one.

For any type `α` and decidable predicate `p` on `α`, if `f` is a permutation on the subtype of `α` satisfying `p`, then for all `a` in `α` satisfying `p`, `f a = (Equiv.Perm.ofSubtype f) a`.


theorem finsum_congr_Prop :
    ∀ {M : Type u_2} [inst : AddCommMonoid M] {p q : Prop} {f : p → M} {g : q → M} (hpq : p = q),
      (∀ (h : q), f ⋯ = g h) → finsum f = finsum g :=
  by sorry

This theorem, `finsum_congr_Prop`, states that for any type `M` that is equipped with an additive commutative monoid structure, for any two propositions `p` and `q`, and for any functions `f : p → M` and `g : q → M`, if `p` is equal to `q` and for every element `h` of `q`, `f` applied to a certain argument (which depends on `h`) is equal to `g h`, then the sum of `f x` over all `x` in the support of `f` (as defined by `finsum`) is equal to the sum of `g x` over all `x` in the support of `g`. This theorem essentially states that under these conditions, the finitary sums of `f` and `g` are equal.

For any additive commutative monoid-structured type M and propositions p and q, if the functions f from p to M and g from q to M satisfy p = q and ∀h ∈ q, f(x h) = g h for some x, then ∑x ∈ supp(f) f x = ∑x ∈ supp(g) g x.


theorem Polynomial.commute_X : ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), Commute Polynomial.X p := by sorry

This theorem states that for any type `R` that forms a semiring, and for any polynomial `p` with coefficients from `R`, the polynomial variable `X` commutes with `p`. In other words, the order in which `X` and `p` are multiplied does not affect the result; mathematically, this means `X * p = p * X` for all polynomials `p` in the semiring `R`.

For any semiring `R` and polynomial `p` with coefficients from `R`, the commutativity of multiplication holds between `X` and `p`, that is, `X * p = p * X`.


theorem tsub_tsub :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst : OrderedSub α]
      (b a c : α), b - a - c = b - (a + c) :=
  by sorry

This theorem, `tsub_tsub`, is applicable for any type `α` that satisfies the properties of a PartialOrder, an AddCommSemigroup, a Subtraction operation, and an OrderedSubtraction. The theorem states that for any three elements `b`, `a`, and `c` of type `α`, the operation of subtracting `a` and `c` from `b` separately in sequence (i.e., `(b - a) - c`) is equivalent to subtracting the sum of `a` and `c` from `b` in a single step (i.e., `b - (a + c)`). In mathematical terms, this theorem asserts the property: `b - a - c = b - (a + c)`.

For any type `α` with PartialOrder, AddCommSemigroup, Subtraction, and OrderedSubtraction structures, the sequence of operations `(a - b) - c` and `a - (b + c)` are equal for all `a, b, c ∈ α`.


theorem LieModuleHom.map_lie :
    ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
      [inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N] (f : M →ₗ⁅R,L⁆ N) (x : L) (m : M),
      f ⁅x, m⁆ = ⁅x, f m⁆ :=
  by sorry

This theorem states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative groups `M` and `N` that are also `R`-modules, given a Lie module homomorphism `f` from `M` to `N` and elements `x` from `L` and `m` from `M`, the application of `f` to the Lie bracket of `x` and `m` is equal to the Lie bracket of `x` and the application of `f` to `m`. In other words, the Lie module homomorphism `f` preserves the operation of the Lie bracket.

Given a Lie module homomorphism `f` between commutative `R`-modules `M` and `N` over a commutative ring `R`, and Lie rings `L`, the application of `f` to the Lie bracket of an element `x` in `L` and an element `m` in `M` is equal to the Lie bracket of `x` and `f(m)`.


/-- Concatenating the first element of a tuple with its tail gives back the original tuple  -/
theorem Fin.cons_self_tail :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i), Fin.cons (q 0) (Fin.tail q) = q := by sorry

This theorem states that for any natural number `n` and any function `q` from `Fin (n + 1)` to some type `α`, concatenating the first element of the tuple generated by `q` with the tail of the same tuple (the last `n` entries of the tuple) yields the original tuple. In other words, it formalizes the idea that combining the first element of a sequence with the rest of the sequence should reproduce the original sequence. This is a fundamental property in the manipulation of sequences or tuples.

For any natural number `n` and function `q` from `Fin (n + 1)` to type `α`, `q 0 :: tail q` equals `q`.


theorem PosNum.to_nat_to_int : ∀ (n : PosNum), ↑↑n = ↑n := by sorry

This theorem states that for any positive number `n` of type `PosNum`, the double coercion of `n` to natural number and then to integer is equal to the direct coercion of `n` to integer. Essentially, it ensures that converting a positive number to a natural number and then to an integer yields the same result as directly converting the positive number to an integer.

For any positive number `n`, the double coercion from `PosNum` to `Nat` and then to `Int` equals the direct coercion from `PosNum` to `Int`. In mathematical notation: `(coe : PosNum → Nat) (coe : Nat → Int) (n : PosNum) = coe : PosNum → Int`.


theorem MeasureTheory.Measure.add_apply :
    ∀ {α : Type u_1} {_m : MeasurableSpace α} (μ₁ μ₂ : MeasureTheory.Measure α) (s : Set α),
      ↑↑(μ₁ + μ₂) s = ↑↑μ₁ s + ↑↑μ₂ s :=
  by sorry

This theorem, `MeasureTheory.Measure.add_apply`, states that for any given type `α`, any measurable space over `α` (denoted as `_m`), two measures `μ₁` and `μ₂` over `α`, and a set `s` of `α`, the measure of the set `s` under the sum of the two measures `μ₁ + μ₂` is equal to the sum of the measures of the set `s` under `μ₁` and `μ₂` individually. In other words, it defines how addition of two measures acts on a set: the measure of the set with respect to the added measures is just the sum of the measures of the set with respect to each measure individually.

For any measurable spaces `(_m : MeasurableSpace α)`, measures `(μ₁ μ₂ : Measure α)`, and set `(s : Set α)`, the measure of `s` under the sum `(μ₁ + μ₂)` equals the sum of the measures of `s` under `μ₁` and `μ₂`.


theorem Submodule.eq_top_iff' :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {p : Submodule R M}, p = ⊤ ↔ ∀ (x : M), x ∈ p :=
  by sorry

This theorem states that for any type `R` with a semiring structure, any type `M` with an additive commutative monoid structure, and `M` being a module over `R`, a submodule `p` of `M` is equal to the top submodule if and only if all elements of `M` are contained in `p`. In other words, a submodule is the entire module itself if it contains every element of the module.

A submodule of an `R`-module `M` is equal to the entire module if and only if every element of `M` is contained in the submodule.


theorem MeasureTheory.IsStoppingTime.measurableSet_le :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι}, MeasureTheory.IsStoppingTime f τ → ∀ (i : ι), MeasurableSet {ω | τ ω ≤ i} :=
  by sorry

This theorem states that for any types `Ω` and `ι`, any measurable space `m` over `Ω`, any preorder on `ι`, any filtration `f` of `m` over `ι`, and any function `τ` from `Ω` to `ι`, if `τ` is a stopping time with respect to `f`, then for every `ι`, the set of all `ω` in `Ω` such that `τ ω` is less than or equal to `i` is a measurable set in the ambient measure space. In other words, the preimage of any set `{j | j ≤ i}` along `τ` is measurable with respect to the filtration `f` at time `i`, underscoring the intuitive understanding of a stopping time as a rule that can be determined with the information available at time `i`.

For any measurable space `(Ω, m)`, preorder `≤` on `ι`, filtration `f` of `m` over `ι`, and function `τ: Ω → ι`, if `τ` is a stopping time with respect to `f`, then for every `i ∈ ι`, the set `{ω ∈ Ω | τ(ω) ≤ i}` is measurable in `(Ω, m)` with respect to `f` at time `i`.


theorem Int.mul_add : ∀ (a b c : ℤ), a * (b + c) = a * b + a * c := by sorry

This is the distributive property of multiplication over addition for integers. The theorem states that for all integers `a`, `b`, and `c`, the product of `a` and the sum of `b` and `c` is equal to the sum of the product of `a` and `b` and the product of `a` and `c`. In mathematical notation, this is expressed as `a * (b + c) = a * b + a * c`.

The distributive property of multiplication over addition for integers states that for all integers `a`, `b`, and `c`, `a * (b + c)` equals `a * b + a * c`.


theorem Function.Injective.of_comp_iff :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
      Function.Injective f → ∀ (g : γ → α), Function.Injective (f ∘ g) ↔ Function.Injective g :=
  by sorry

The theorem `Function.Injective.of_comp_iff` states that for any types `α`, `β`, and `γ`, and any function `f` from `α` to `β`, if `f` is injective, then for any function `g` from `γ` to `α`, `f ∘ g` (the composition of `f` and `g`) is injective if and only if `g` is injective. In other words, when composing with an injective function, the injectivity of the resulting function is equivalent to the injectivity of the original function.

If `f: α -> β` is injective, then `f ∘ g: γ -> β` is injective if and only if `g: γ -> α` is injective.


theorem iInf_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {γ : Type u_9} {f : β → γ} {g : γ → α} {t : Set β},
      ⨅ c ∈ f '' t, g c = ⨅ b ∈ t, g (f b) :=
  by sorry

The theorem `iInf_image` states that for any types `α`, `β`, and `γ` where `α` is a complete lattice, and for any functions `f` mapping from `β` to `γ` and `g` mapping from `γ` to `α`, and for any set `t` of type `β`, the infimum (greatest lower bound, denoted by `⨅`) over the image of the set `t` under the function `f`, of `g(c)` where `c` belongs to the image set, is equal to the infimum over the set `t`, of `g(f(b))` where `b` belongs to the set `t`. In other words, applying the function `f` before or after taking the infimum (with respect to `g`) does not change the result.

For any complete lattice α, functions f: β → γ and g: γ → α, and set t ∈ β, the infimum (g ∘ f)(t) = (∧ x ∈ t. g(f(x))) where ∧ denotes the infimum over the set.


theorem iSup_prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_4} [inst : CompleteLattice α] {f : β × γ → α},
      ⨆ x, f x = ⨆ i, ⨆ j, f (i, j) :=
  by sorry

This theorem, `iSup_prod`, states that for any types `α`, `β` and `γ`, with `α` being a complete lattice and `f` being a function from the product type `β × γ` to `α`, the supremum of `f` over all elements `x` of the product type is equal to the double supremum of `f` over all elements `i` of type `β` and `j` of type `γ`. In other words, the supremum of the function `f` when taken over the entire cartesian product corresponds to taking the supremum first over one component and then over the other.

For any complete lattice `α`, function `f` from the product type `β × γ` to `α`, and all `i ∈ β` and `j ∈ γ`, `⨆{x : β × γ | f x} = ⨆{i : β} ⨆{j : γ} (f i, j)`.


/-- Alias of `Nat.cast_lt` specialized to `PartENat` - -/
theorem PartENat.coe_lt_coe : ∀ {x y : ℕ}, ↑x < ↑y ↔ x < y := by sorry

This theorem states that for all natural numbers `x` and `y`, the operation of casting `x` and `y` into the `PartENat` type and comparing them is equivalent to directly comparing `x` and `y` in their original type. In other words, the inequality holds in the `PartENat` type if and only if it holds in the `Nat` type. Here, the `PartENat` type refers to partial extended natural numbers, which includes all natural numbers plus infinity.

For all natural numbers x and y, x < y in Nat if and only if x.toPartENat() < y.toPartENat() in PartENat.


/-- A group homomorphism sends inverses to inverses.  -/
theorem IsGroupHom.map_inv :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : Group β] {f : α → β},
      IsGroupHom f → ∀ (a : α), f a⁻¹ = (f a)⁻¹ :=
  by sorry

This theorem states that for any group homomorphism `f` from a group `α` to another group `β`, the inverse of an element `a` in the domain group `α` is mapped to the inverse of the image of `a` in the codomain group `β`. In mathematical terms, if `f` is a group homomorphism, and `a` is an element in group `α`, then `f(a⁻¹) = (f(a))⁻¹`. This property is one of the defining characteristics of a group homomorphism.

For any group homomorphism `f` and element `a` in a group, `f(a^(-1)) = (f(a))^(-1)`.


theorem Units.mul_left_inj : ∀ {α : Type u} [inst : Monoid α] (a : αˣ) {b c : α}, b * ↑a = c * ↑a ↔ b = c := by sorry

This theorem, `Units.mul_left_inj`, states that for any type `α` that forms a monoid, given a unit `a` of `α` and any two elements `b` and `c` of `α`, the equality `b * a = c * a` holds if and only if `b = c`. In other words, multiplying a monoid element by a unit on the right side is an injective operation, meaning it preserves distinctness. If the products of `b` and `c` with `a` are equal, then `b` and `c` must have been equal to begin with.

For any monoid type `α` and unit `a` in `α`, the multiplication by `a` on the right is an injection: `(x : α) → x * a = y * a ↔ x = y`.