theorem pow_le_pow_left :
    ∀ {R : Type u_3} [inst : OrderedSemiring R] {a b : R}, 0 ≤ a → a ≤ b → ∀ (n : ℕ), a ^ n ≤ b ^ n := by sorry

This theorem states that for any type `R` that is an ordered semiring, given any two elements `a` and `b` of `R` such that `a` is non-negative and less than or equal to `b`, the power of `a` raised to any natural number `n` will always be less than or equal to the power of `b` raised to the same `n`. In LaTeX notation, this can be expressed as: for all $a, b \in R$ and $n \in \mathbb{N}$, if $0 \leq a \leq b$, then $a^n \leq b^n$.

For any ordered semiring `R` and natural number `n`, if `a` is a non-negative element of `R` less than or equal to `b`, then `a^n` is less than or equal to `b^n`.


theorem Multiset.nodup_of_le : ∀ {α : Type u_1} {s t : Multiset α}, s ≤ t → Multiset.Nodup t → Multiset.Nodup s := by
  sorry

The theorem `Multiset.nodup_of_le` states that for any types `α` and multisets `s` and `t` of type `α`, if `s` is a sub-multiset of `t` (denoted by `s ≤ t`) and `t` is a set with no duplicates (denoted by `Multiset.Nodup t`), then `s` should also be a set with no duplicates (denoted by `Multiset.Nodup s`). In other words, a subset of a duplicate-free set is also duplicate-free.

If `s` is a sub-multiset of the duplicate-free multiset `t`, then `s` is also a duplicate-free multiset.


theorem left_ne_zero_of_mul : ∀ {M₀ : Type u_2} [inst : MulZeroClass M₀] {a b : M₀}, a * b ≠ 0 → a ≠ 0 := by sorry

This theorem states that for any type `M₀` that has a multiplication and zero structure (i.e., a `MulZeroClass`), if the product of two elements `a` and `b` is not zero, then `a` cannot be zero. In other words, in any multiplication operation, if the product is non-zero, then none of the multiplicands can be zero.

If `M₀` is a type with a multiplication and zero structure, then for all `a` and `b` in `M₀`, `a ≠ 0` implies `a * b ≠ 0`.


theorem dvd_antisymm_of_normalize_eq :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {a b : α},
      normalize a = a → normalize b = b → a ∣ b → b ∣ a → a = b :=
  by sorry

This theorem states that for any type `α` that has instances of `CancelCommMonoidWithZero` and `NormalizationMonoid`, and any elements `a` and `b` of that type, if `a` and `b` are normalized (i.e., `normalize a = a` and `normalize b = b`), and `a` divides `b` while `b` divides `a`, then `a` must be equal to `b`. This is essentially an antisymmetry property under division for normalized elements in a normalization monoid with cancellation.

If `α` is a type with instances of `CancelCommMonoidWithZero` and `NormalizationMonoid`, and `a` and `b` are normalized elements of `α` such that `a` divides `b` and `b` divides `a`, then `a = b`.


theorem le_add_right : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b c : α}, a ≤ b → a ≤ b + c := by
  sorry

This theorem, `le_add_right`, states that for any type `α` that forms a canonically ordered additive commutative monoid (a mathematical structure with an operation that is both commutative and associative, an identity element, and an ordering compatible with the operation), if `a` is less than or equal to `b`, then `a` is also less than or equal to the addition of `b` and `c`. Here, `a`, `b`, and `c` are elements of `α`. This theorem is a property of ordered monoids, capturing the idea that adding something to `b` cannot decrease its value.

For any additively commutative monoid with a canonical order, if `a` is less than or equal to `b`, then `a` is less than or equal to `b + c`.


theorem Set.Iic_subset_Iic : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Iic a ⊆ Set.Iic b ↔ a ≤ b := by sorry

The theorem `Set.Iic_subset_Iic` states that for any type `α` equipped with a preorder, and any two elements `a` and `b` of this type, the left-infinite right-closed interval up to `a` is a subset of the left-infinite right-closed interval up to `b` if and only if `a` is less than or equal to `b`. In other words, all elements less than or equal to `a` are also less than or equal to `b` if and only if `a ≤ b`. This theorem is a fundamental property of ordered sets.

For any preordered type `α` and elements `a` and `b`, the left-infinite right-closed interval `{ x : α | x ≤ a }` is subset of the left-infinite right-closed interval `{ x : α | x ≤ b }` if and only if `a ≤ b`.


/-- Deprecated. Use `DFunLike.congr_fun` instead.  -/
theorem ContinuousMap.congr_fun :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : C(α, β)},
      f = g → ∀ (x : α), f x = g x :=
  by sorry

This theorem, `ContinuousMap.congr_fun`, states that for any two continuous functions `f` and `g` from a topological space `α` to another topological space `β`, if `f` and `g` are the same function (i.e., `f = g`), then the outputs of `f` and `g` for any given input `x` from `α` are the same (i.e., `f x = g x`). This theorem has been deprecated and it is recommended to use `DFunLike.congr_fun` instead.

For any continuous functions `f` and `g` from a topological space `α` to another topological space `β`, if `f` is equal to `g`, then `f x = g x` for all `x` in `α`.


theorem min_self : ∀ {α : Type u} [inst : LinearOrder α] (a : α), min a a = a := by sorry

The theorem `min_self` states that for all types `α` which have a `LinearOrder` instance, the minimum of a value `a` and itself is always `a`. In other words, for any type `α` that can be ordered in a linear fashion (like integers or real numbers), if you compare a value with itself, the smaller value is always going to be the value itself.

For all types `α` with a `LinearOrder`, the reflexive property holds: `a ≤ a` for all `a` in `α`.


theorem sup_le_sup_right : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a ≤ b → ∀ (c : α), a ⊔ c ≤ b ⊔ c := by
  sorry

The theorem `sup_le_sup_right` states that for all types `α` that form a semilattice with a supremum (the least upper bound), given any three elements `a`, `b`, and `c` of type `α`, if `a` is less than or equal to `b`, then the supremum of `a` and `c` is less than or equal to the supremum of `b` and `c`. This essentially indicates that the supremum operation in a semilattice respects the order of the elements involved.

For all types `α` with a supremum and any elements `a`, `b`, `c` of type `α`, if `a ≤ b`, then `sup(a, c) ≤ sup(b, c)`.


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

This theorem, `Set.compl_union`, states that for all types `α`, and for any two sets `s` and `t` of this type, the complement of the union of `s` and `t` is equal to the intersection of the complement of `s` and the complement of `t`. In mathematical terms, this can be written as $(s \cup t)^c = s^c \cap t^c$. This is a fundamental theorem in set theory that reflects the relationship between union, intersection, and complement operations in sets.

The complement of the union of two sets is equal to the intersection of their complements: $(s \cup t)^c = s^c \cap t^c$.


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

This theorem, `eq_neg_iff_add_eq_zero`, states that for any type `G` that is an additive group, and for any two elements `a` and `b` from `G`, `a` is equal to the negation of `b` if and only if the sum of `a` and `b` is zero. In mathematical terms, it's saying that for all a, b in an additive group G, a = -b if and only if a + b = 0.

For any additive group G and elements a, b in G, a = -b if and only if a + b = 0.


theorem MvPolynomial.rename_X :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] (f : σ → τ) (i : σ),
      (MvPolynomial.rename f) (MvPolynomial.X i) = MvPolynomial.X (f i) :=
  by sorry

The theorem `MvPolynomial.rename_X` states that for any commutative semiring `R` and any types `σ` and `τ`, if you have a function `f` that maps values from type `σ` to type `τ`, and an element `i` of type `σ`, then renaming the variables of the degree `1` multivariate polynomial `X_i` using the function `f` yields the degree `1` multivariate polynomial `X_{f(i)}`. In simpler terms, renaming the variable of a degree `1` monomial using a renaming function is equivalent to applying the renaming function to the variable and then constructing the degree `1` monomial.

For any commutative semiring `R`, given a function `f : σ → τ` and an element `i : σ`, the degree 1 multivariate polynomial `X_i` with respect to `R` is equal to the degree 1 multivariate polynomial `X_{f(i)}` with respect to `R` obtained by applying the function `f` to the variable name.


theorem Ordinal.familyOfBFamily'.proof_1 :
    ∀ {ι : Type u_1} (r : ι → ι → Prop) [inst : IsWellOrder ι r] {o : Ordinal.{u_1}},
      Ordinal.type r = o → ∀ (i : ι), Ordinal.typein r i < o :=
  by sorry

This theorem asserts the following: for any type `ι`, any relation `r` on `ι` that gives it the structure of a well order, and any ordinal `o`, if the order type of `r` is equal to `o`, then the order type of every element `i` in `ι` (under the induced order `r`) is strictly less than `o`. This essentially implies that within a well-ordered set, the order type of each element is less than the order type of the entire set.

In a well-ordered set, the order type of each element is strictly less than the order type of the set.


theorem Int.eq_nat_or_neg : ∀ (a : ℤ), ∃ n, a = ↑n ∨ a = -↑n := by sorry

This theorem states that for every integer `a`, there exists a natural number `n` such that `a` equals `n` or `a` equals negative `n`. In other words, any integer is either a natural number or the negative of a natural number. This theorem embodies the concept that integers are composed of natural numbers and their negatives.

For every integer `a`, there exists a natural number `n` such that `a = n` or `a = -n`.


theorem Partrec.of_eq :
    ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] {f g : α →. σ},
      Partrec f → (∀ (n : α), f n = g n) → Partrec g :=
  by sorry

The theorem `Partrec.of_eq` states that for any two partial functions `f` and `g` from a type `α` to another type `σ` (both of which are encoded by a primitive recursive function), if `f` is partial recursive and `f` equals `g` for all values in `α`, then `g` is also partial recursive. In other words, the partial recursive property is preserved under pointwise equality between two functions.

If two partial functions from type α to σ, encoded by primitive recursive functions, are equal at all values in α where they are defined, then the second function is also partial recursive.


theorem Equiv.apply_eq_iff_eq : ∀ {α : Sort u} {β : Sort v} (f : α ≃ β) {x y : α}, f x = f y ↔ x = y := by sorry

This theorem states that for any two elements `x` and `y` of some type `α`, and a given equivalence `f` between type `α` and some other type `β`, the equality of `f(x)` and `f(y)` (i.e., the images of `x` and `y` under the equivalence `f`) is equivalent to the equality of `x` and `y` themselves. In other words, an equivalence preserves the equality of elements: if two elements are equal, their images under the equivalence are equal, and vice versa.

For any equivalence relation `f` between types `α` and `β`, and for all `x` and `y` in `α`, `x = y` if and only if `f(x) = f(y)`.


theorem mul_inv : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a * b)⁻¹ = a⁻¹ * b⁻¹ := by sorry

The theorem `mul_inv` states that for any division commutative monoid `α` and any elements `a` and `b` from `α`, the inverse of the product of `a` and `b` is equal to the product of the inverse of `a` and the inverse of `b`. In other words, taking the inverse of a product is the same as taking the product of the inverses. This is expressed in the language of mathematics as `(a * b)⁻¹ = a⁻¹ * b⁻¹`.

For any commutative monoid `α` and elements `a, b` in `α`, `(a * b)⁻¹ = a⁻¹ * b⁻¹`.


theorem WithTop.some_le_some : ∀ {α : Type u_1} {a b : α} [inst : LE α], some a ≤ some b ↔ a ≤ b := by sorry

This theorem, `WithTop.some_le_some`, states that for any type `α` and any two elements `a` and `b` of that type, with the condition that the type `α` has a less-than-or-equal-to (`LE`) relation, the relation 'less than or equal to' for the option type of `α` with an extra top element (`some a ≤ some b`) is equivalent to the relation 'less than or equal to' for the original type elements (`a ≤ b`).

For any type `α` with a `LE` relation and elements `a` and `b`, `some a ≤ some b` if and only if `a ≤ b`.


theorem Eq.not_lt : ∀ {α : Type u} [inst : Preorder α] {x y : α}, x = y → ¬x < y := by sorry

This theorem states that for any type `α` that has a preorder (a mathematical model that can describe an ordering among its elements), and for any two elements `x` and `y` from that type, if `x` is equal to `y`, then `x` is not less than `y`. In other words, an element cannot be less than itself in a preorder, reflecting the antisymmetry property of preorders in mathematical terms.

In a preorder, for all types `α` and elements `x` and `y` of type `α`, if `x = y`, then `x ≤ y` implies `y ≤ x`.


theorem Ordinal.le_zero : ∀ {o : Ordinal.{u_3}}, o ≤ 0 ↔ o = 0 := by sorry

The theorem `Ordinal.le_zero` states that for any ordinal `o` in the universe `u_3`, `o` is less than or equal to zero if and only if `o` is equal to zero. This theorem reflects that in the context of ordinals, there is no ordinal number less than zero. In other words, zero is the smallest ordinal number.

For any ordinal number `o`, `o <= 0` if and only if `o = 0`.


theorem Finset.insert_eq_of_mem :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α}, a ∈ s → insert a s = s := by sorry

This theorem states that for any type `α` that has decidable equality, any finite set `s` of `α`, and any element `a` of `α`, if `a` is already an element of `s`, then inserting `a` into `s` does not change `s`. In other words, inserting an existing element into a finite set has no effect on the set, as sets do not contain duplicate elements.

For any finite type `α` with decidable equality, adding an existing element to a finite set `s` of `α` does not change `s`.


OrderHom.ext

theorem OrderHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f g : α →o β), ⇑f = ⇑g → f = g := by
  sorry

This theorem states that for any two order-preserving functions `f` and `g` from a preorder `α` to a preorder `β`, if the functions `f` and `g` are equal when applied to every element (denoted by `⇑f = ⇑g`), then the functions `f` and `g` themselves are equal (`f = g`). In other words, two order-preserving functions are considered identical if and only if they return the same result for every input from the preordered set.

If `α` is a preorder and `f` and `g` are order-preserving functions from `α` to a preorder `β` with `⇑f = ⇑g`, then `f = g`.


theorem IsGLB.of_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      (∀ {x y : α}, f x ≤ f y ↔ x ≤ y) → ∀ {s : Set α} {x : α}, IsGLB (f '' s) (f x) → IsGLB s x :=
  by sorry

This theorem states that for any two types `α` and `β` with preorder (a reflexive and transitive binary relation) structures, and a function `f` from `α` to `β`, if the function `f` preserves the preorder (meaning if `f x` is less than or equal to `f y` if and only if `x` is less than or equal to `y`), then for any set `s` of elements of type `α` and an element `x` of type `α`, if `f x` is the greatest lower bound of the image of the set `s` under the function `f`, then `x` is the greatest lower bound of the set `s`. In other words, if `f x` is the largest value that is less than or equal to all elements in the image of `s` under `f`, then `x` itself is the largest value that is less than or equal to all elements in `s`.

If `f` is a function from preordered types `α` to `β` that preserves the preorder, and `x` is the greatest lower bound of `s ↦ f(s)` in `β`, then `x` is the greatest lower bound of `s` in `α`.


theorem Ideal.map_le_iff_le_comap :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] {f : F} {I : Ideal R} {K : Ideal S}, Ideal.map f I ≤ K ↔ I ≤ Ideal.comap f K :=
  by sorry

The theorem `Ideal.map_le_iff_le_comap` states that for any given semirings `R` and `S`, a function `f` of type `F` that is `FunLike` from `R` to `S`, a `RingHomClass` instance for `F`, `R` and `S`, and ideals `I` of `R` and `K` of `S`, the image of the ideal `I` under the function `f` is a subset of the ideal `K` if and only if the ideal `I` is a subset of the preimage of the ideal `K` under function `f`. In other words, mapping an ideal `I` through `f` yields a sub-ideal of `K` exactly when `I` itself is a sub-ideal of the ideal that maps to `K` under `f`.

For any semirings R, S, FunLike function f from R to S with a RingHomClass instance, ideals I of R, and ideals K of S, I ↦ f(I) ⊆ K if and only if I ⊆ f⁻¹(K).


Computable.const

theorem Computable.const :
    ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] (s : σ), Computable fun x => s := by
  sorry

The theorem named `Computable.const` states that for any types `α` and `σ` that have a `Primcodable` instance (indicating that elements of these types can be encoded as natural numbers), and for any specific value `s` of type `σ`, the function that maps every element of type `α` to the constant value `s` is `Computable`. In other words, constant functions are computable.

For types `α` and `σ` with `Primcodable` instances, and a fixed `σ` value `s`, the function mapping `α` elements to the constant `s` is computable.


theorem csInf_le' :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α} {a : α}, a ∈ s → sInf s ≤ a := by sorry

The theorem `csInf_le'` states that for any type `α` that has an instance of `ConditionallyCompleteLinearOrderBot`, for any set `s` of type `α`, and for any element `a` of type `α`, if `a` is an element of the set `s`, then the greatest lower bound (infimum) of the set `s`, denoted as `sInf s`, is less than or equal to the element `a`. This theorem is a fundamental property in order theory, ensuring that the infimum of a set does not exceed any element of the set itself.

For any set `s` in a type `α` with a `ConditionallyCompleteLinearOrderBot`, if an element `a` is in `s`, then `inf s ≤ a`.


/-- Negation of the condition `P : Prop` in a `ite` is the same as swapping the branches.  -/
theorem ite_not :
    ∀ {α : Sort u_1} (P : Prop) {x : Decidable P} (x_1 y : α), (if ¬P then x_1 else y) = if P then y else x_1 := by
  sorry

This theorem states that the negation of a condition `P` in an `if-then-else` (abbreviated as `ite`) expression is equivalent to swapping the branches of the `ite`. In more detail, for any type `α`, any proposition `P`, any decidable instance of `P`, and any two instances `x_1`, `y` of `α`, the value of the `ite` expression which checks if `P` is not true and returns `x_1` if so and `y` otherwise, is the same as the value of the `ite` expression which checks if `P` is true and returns `y` if so and `x_1` otherwise.

For any type `α`, proposition `P`, decidable `P`, and instances `x_1`, `y` of `α`, `ite (not P) x_1 y` is equal to `ite P y x_1`.


theorem Ordinal.sup_le :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}}, (∀ (i : ι), f i ≤ a) → Ordinal.sup f ≤ a := by
  sorry

The theorem `Ordinal.sup_le` states that for any type `ι`, any function `f` mapping from `ι` to the order type `Ordinal.{max u v}`, and any ordinal `a`, if every ordinal in the range of `f` is less than or equal to `a`, then the supremum of the set of ordinals generated by `f` is also less than or equal to `a`. In other words, if every ordinal that `f` can produce is bounded above by `a`, then the largest such ordinal (the supremum) is also bounded above by `a`.

If `f` is a function from an ordinal `ι` to the ordinals such that the image of `f` is bounded above by an ordinal `a`, then the supremum of the image of `f` is also less than or equal to `a`.


theorem LinearMap.mem_ker :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_12} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] {f : F}
      {y : M}, y ∈ LinearMap.ker f ↔ f y = 0 :=
  by sorry

The theorem `LinearMap.mem_ker` states that for any semirings `R` and `R₂`, additively commutative monoids `M` and `M₂`, `R`-module `M`, `R₂`-module `M₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a function `f` from `M` to `M₂` that is also a semilinear map, and any element `y` of `M`, `y` is in the kernel of `f` if and only if the result of applying `f` to `y` is the zero element in `M₂`. The kernel of a linear map is the set of all elements that map to zero. In other words, the theorem characterizes the kernel of a semilinear map in terms of the function's action on the elements.

A semilinear map from an `R`-module to an `R₂`-module, induced by a ring homomorphism from `R` to `R₂`, maps an element to zero in the target module if and only if that element is in the kernel of the map.


theorem le_mul_of_one_le_right :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : PosMulMono α],
      0 ≤ a → 1 ≤ b → a ≤ a * b :=
  by sorry

This theorem states that for any type `α` that has multiplication and one as a multiplicative identity (i.e., it is a `MulOneClass`), is ordered (i.e., it has a `Preorder`, meaning it has a less than or equal to relation that is reflexive and transitive), and multiplication by nonnegative elements is monotonically increasing (i.e., it has the `PosMulMono` property), if `a` and `b` are elements of `α` where `a` is nonnegative and `b` is at least one, then `a` is less than or equal to the product of `a` and `b`. In mathematical terms, the theorem says: if $0 \leq a$ and $1 \leq b$, then $a \leq a \cdot b$.

If `α` is a type with multiplicative identity one, preorder, and monotonically increasing multiplication by nonnegative elements, then for all nonnegative `a` and `b` in `α` with `b` being at least one, we have `a ≤ a * b`.


theorem Finset.image₂_singleton_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {b : β},
      Finset.image₂ f s {b} = Finset.image (fun a => f a b) s :=
  by sorry

This theorem, `Finset.image₂_singleton_right`, states that for any types `α, β, γ`, where `γ` has decidable equality, for any binary function `f : α → β → γ`, any finite set `s : Finset α`, and any element `b : β`, the image under `f` of the Cartesian product of the set `s` and the singleton set containing `b` is equal to the image under `f` of `s` where `f` is partially applied with `b`. In mathematical terms, this can be expressed as \(f(s \times \{b\}) = \{f(a, b) | a \in s\}\).

For any type `γ` with decidable equality, given a binary function `f : α → β → γ` and a finite set `s : Finset α`, the image of the Cartesian product `s × {b}`, for some `b : β`, under `f` is equal to the image of `s` under the partial application of `f` with `b`. In other words, `f(s × {b}) = {f(a, b) | a ∈ s}`.


theorem Submodule.mem_span_singleton :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y : M},
      x ∈ Submodule.span R {y} ↔ ∃ a, a • y = x :=
  by sorry

This theorem, `Submodule.mem_span_singleton`, states that for any semiring `R` and any additive commutative monoid `M` that is also an `R`-module, and for any two elements `x` and `y` of `M`, the element `x` is in the submodule spanned by the singleton set `{y}` if and only if there exists an element `a` in `R` such that `a` scaled by `y` equals `x`. In other words, `x` is in the span of `{y}` if and only if `x` is a scalar multiple of `y`.

For any semiring `R`, additive commutative monoid `M` being an `R`-module, and `x, y` in `M`, `x` belongs to the submodule spanned by `{y}` if and only if there exists `a` in `R` such that `x = a * y`.


Set.Infinite.mono

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

This theorem, referred to as `Set.Infinite.mono`, states that for any type `α` and any two sets `s` and `t` of this type, if `s` is a subset of `t` and `s` is an infinite set, then `t` is also an infinite set. It asserts the preservation of the property of infiniteness under the operation of set inclusion, meaning that if an infinite set is contained within another set, the latter set must also be infinite.

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


IsSeparable.separable

theorem IsSeparable.separable :
    ∀ (F : Type u_1) {K : Type u_2} [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K]
      [inst_3 : IsSeparable F K] (x : K), Polynomial.Separable (minpoly F x) :=
  by sorry

This theorem states that for any types `F` and `K`, where `F` is a commutative ring, `K` is a ring, and `F` is an algebra over `K`, if `K` is separable over `F`, then the minimal polynomial of any element `x` of `K` over `F` is a separable polynomial. Here, a polynomial being separable means that it is coprime with its derivative. The minimal polynomial of `x` over `F` is the unique monic polynomial with coefficients in `F` that has `x` as a root and has the lowest degree among all such polynomials.

If `F` is a commutative ring, `K` is a separable extension of `F` as a ring, and `F` is an algebra over `K`, then the minimal polynomial of any element in `K` over `F` is a separable polynomial.


theorem Nat.div_lt_iff_lt_mul : ∀ {k x y : ℕ}, 0 < k → (x / k < y ↔ x < y * k) := by sorry

This theorem states that for any natural numbers `k`, `x`, and `y`, with `k` being greater than zero, the condition of `x` divided by `k` being less than `y` is equivalent to the condition of `x` being less than `y` times `k`. In other words, determining whether one natural number divided by another is less than a third number is the same as determining whether the first number is less than the product of the third number and the divisor.

For any natural numbers $k$, $x$, and $y$ with $k > 0$, $x / k < y$ if and only if $x < y \cdot k$.


theorem iUnion_compactCovering :
    ∀ (X : Type u_1) [inst : TopologicalSpace X] [inst_1 : SigmaCompactSpace X], ⋃ n, compactCovering X n = Set.univ :=
  by sorry

This theorem states that for any type `X` that has a topology and is a `σ-compact` space (i.e., it can be written as a countable union of compact subsets), the union over all natural numbers `n` of the `compactCovering` of `X` by `n` is equal to the universal set. In other words, every point in the topological space `X` is contained in some compact subset specified by the `compactCovering` function, which is chosen to be monotone. This is a way of saying that the space can be covered entirely by these compact subsets.

For any σ-compact topological space X, the union of the first n compact coverings of X for all natural numbers n is equal to X.


theorem Mathlib.Data.Finset.Basic._auxLemma.136 : ∀ {α : Type u_1} {s : Finset α}, (s = ∅) = ∀ (x : α), x ∉ s := by
  sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.136`, states that for any type `α` and any finite set `s` of type `α`, the condition that `s` is equivalent to the empty set is equivalent to the condition that for any element `x` of type `α`, `x` is not an element of `s`. In other words, a finite set is empty if and only if it does not contain any elements.

A finite set `s` of type `α` is equivalent to the empty set if and only if there does not exist an element `x` of type `α` such that `x ∈ s`.


theorem Mathlib.CategoryTheory.Limits.Shapes.Types._auxLemma.1 :
    ∀ (α : Type u) (p : α → Prop), (∀ (x : (CategoryTheory.forget (Type u)).obj α), p x) = ∀ (x : α), p x := by sorry

This theorem, often called as `_auxLemma.1`, describes a relationship between objects in a category and a particular property. Specifically, for all types `α` and any property `p` that might apply to elements of `α`, the theorem states that checking this property for every element in the image of `α` under the forgetful functor from the category of types to the category of sets is equivalent to checking the property for every element of `α` itself.

In more mathematical terms, if `α` is a type and `p` is some property, then `∀ (x : (CategoryTheory.forget (Type u)).obj α), p x` is equivalent to `∀ (x : α), p x`. This essentially says that the forgetful functor doesn't change the underlying set of elements, so checking a property `p` on all elements remains the same before and after applying the functor.

The forgetful functor from the category of types to sets preserves the property of element-wise satisfaction of a given property.


theorem Nat.cast_sub : ∀ {R : Type u} [inst : AddGroupWithOne R] {m n : ℕ}, m ≤ n → ↑(n - m) = ↑n - ↑m := by sorry

This theorem states that for all types `R` that form an additive group with a unit element (which means `R` has operations for addition, zero, negation, and one), and for all natural numbers `m` and `n` where `m` is less than or equal to `n`, the cast of the subtraction of `m` from `n` (`n - m`) to `R` is equal to the subtraction of the cast of `m` to `R` from the cast of `n` to `R` (`↑n - ↑m`). Essentially, this captures the idea that casting doesn't interfere with subtraction: the order of casting and subtraction can be swapped without changing the result.

For all additive groups `R` with unit and natural numbers `m ≤ n`, the cast of `n - m` to `R` equals the cast of `n` to `R` minus the cast of `m` to `R` (i.e., `↑(n - m) = ↑n - ↑m`).


theorem Set.inter_eq_right : ∀ {α : Type u} {s t : Set α}, s ∩ t = t ↔ t ⊆ s := by sorry

This theorem, `Set.inter_eq_right`, states that for any type `α` and any two sets `s` and `t` of type `α`, the intersection of `s` and `t` is equal to `t` if and only if `t` is a subset of `s`. In mathematical terms, given any two sets `s` and `t`, we have that `s ∩ t = t` is equivalent to `t ⊆ s`. This theorem captures one of the fundamental properties of the intersection operation in set theory.

The intersection of two sets is equal to the smaller set if and only if the smaller set is a subset of the larger set. (i.e., `s ∩ t = t` if and only if `t ⊆ s`).


theorem Nat.cast_two : ∀ {R : Type u_1} [inst : AddMonoidWithOne R], ↑2 = 2 := by sorry

This theorem, `Nat.cast_two`, states that for any type `R` that is an instance of the typeclass `AddMonoidWithOne`, the natural number cast of `2` to `R` is equal to `2`. In other words, within the context of an additive monoid with a distinct one element, casting the natural number `2` to any such type `R` will result in `2` of type `R`.

For any additive monoid with one unit `R`, the conversion of the natural number `2` to `R` is equal to `2` in `R`.


theorem compl_injective : ∀ {α : Type u} [inst : BooleanAlgebra α], Function.Injective compl := by sorry

The theorem `compl_injective` states that for all types `α` equipped with a Boolean algebra structure, the complement function `compl` is injective. In more mathematical terms, the complement function `compl`, defined on a Boolean algebra, is such that whenever `compl x = compl y` for any two elements `x` and `y` from the Boolean algebra, it implies that `x = y`. Thus, the complement function doesn't map different elements to the same value.

For all Boolean algebras α, the complement function is injective, that is, complements of distinct elements are distinct.


/-- See `lt_tsub_iff_right_of_le` for a weaker statement in a partial order.  -/
theorem lt_tsub_iff_right :
    ∀ {α : Type u_1} {a b c : α} [inst : LinearOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α]
      [inst_3 : OrderedSub α], a < b - c ↔ a + c < b :=
  by sorry

The theorem `lt_tsub_iff_right` states that for any type `α`, and any three elements `a`, `b`, and `c` of type `α` (where `α` is a linear ordered additive commutative semigroup with an ordered subtraction operation), the inequality `a` is less than the difference `b - c` is equivalent to the inequality `a + c` is less than `b`. It essentially shows a relationship between subtraction and addition in an ordered mathematical structure.

For any linear ordered additive commutative semigroup type `α` and elements `a, b, c` of `α`, `a < b - c` if and only if `a + c < b`.


theorem Mathlib.Data.Set.Defs._auxLemma.13 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β → γ} {s : Set α} {t : Set β} {c : γ},
      (c ∈ Set.image2 f s t) = ∃ a ∈ s, ∃ b ∈ t, f a b = c :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, and for any binary function `f : α → β → γ`, and any sets `s : Set α` and `t : Set β`, and any element `c : γ`, the membership of `c` in the image of the function `f` applied over sets `s` and `t` is equivalent to the existence of an element `a` in set `s` and an element `b` in set `t` such that the application of function `f` to `a` and `b` results in `c`. In mathematical terms, it says that \(c\) is in the image of \(f\) over sets \(s\) and \(t\) if and only if there exist elements \(a\) in \(s\) and \(b\) in \(t\) such that \(f(a, b) = c\).

For all types `α`, `β`, `γ`, sets `s : Set α`, `t : Set β`, function `f : α → β → γ`, and element `c : γ`, `c ∈ image f s t` if and only if there exist `a ∈ s` and `b ∈ t` such that `c = f a b`.


theorem Fin.rev_rev : ∀ {n : ℕ} (i : Fin n), Fin.rev (Fin.rev i) = i := by sorry

This theorem states that for any natural number `n` and any value `i` of the finite set `Fin n`, applying the `Fin.rev` function twice (i.e., reversing the mapping twice) results in the original value `i`. In other words, the double application of `Fin.rev` is an identity operation on any element of the set `Fin n`.

For all natural numbers `n` and elements `i` of `Fin n`, `Fin.rev (Fin.rev i) = i`.


theorem List.get_ofFn :
    ∀ {α : Type u} {n : ℕ} (f : Fin n → α) (i : Fin (List.length (List.ofFn f))),
      List.get (List.ofFn f) i = f (Fin.cast ⋯ i) :=
  by sorry

This theorem, `List.get_ofFn`, states that for any type `α` and positive integer `n`, given a function `f` from the finite set `Fin n` to `α` and an index `i` within the length of the list created by the function `List.ofFn f`, the element at index `i` in the `List.ofFn f` is the same as the result of the function `f` applied to `i` cast into the same `Fin` type. In other words, this theorem guarantees that the `List.ofFn` function correctly generates a list by applying function `f` to each element in the finite set `Fin n`.

For any type `α` and positive integer `n`, the element at index `i` in the list `List.ofFn f` equals `f` applied to the index `i` considered as a finite number in `Fin n`.


HasFDerivAt.hasFDerivWithinAt

theorem HasFDerivAt.hasFDerivWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s : Set E}, HasFDerivAt f f' x → HasFDerivWithinAt f f' s x :=
  by sorry

The theorem `HasFDerivAt.hasFDerivWithinAt` states that if a function `f` of type `E → F` has a continuous linear map `f'` as its derivative at a certain point `x`, then `f` also has `f'` as its derivative within any set `s` of elements of type `E` at the same point `x`. This applies in the context where `𝕜` is a nontrivially normed field, `E` is a normed additive commutative group over `𝕜`, and `F` is also a normed additive commutative group over `𝕜`. The derivatives are defined in the sense of Fréchet derivatives. This theorem is essentially asserting that if a derivative exists at a point, it remains the same regardless of the context or 'set' you consider around that point.

If a Fréchet derivative exists for a function between normed additive commutative groups over a nontrivially normed field at a point, then it is the derivative within any neighborhood of that point.


Function.Injective.nontrivial

/-- Pushforward a `Nontrivial` instance along an injective function.  -/
theorem Function.Injective.nontrivial :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Nontrivial α] {f : α → β}, Function.Injective f → Nontrivial β := by sorry

This theorem states that if there exists a function `f` from type `α` to type `β` that is injective, which means each input maps to a unique output in `β`, and `α` is nontrivial (that is, `α` contains at least two distinct elements), then `β` is also nontrivial. In other words, if we have a nontrivial type `α` and an injective function from `α` to `β`, there must be at least two distinct elements in `β` as well. The purpose of this theorem is to transfer the property of nontriviality from one type to another via an injective function.

If `α` is a nontrivial type and `f : α → β` is an injective function, then `β` is also a nontrivial type.


theorem one_zpow : ∀ {α : Type u_1} [inst : DivisionMonoid α] (n : ℤ), 1 ^ n = 1 := by sorry

This theorem states that for any type `α` that is a `DivisionMonoid` and for any integer `n`, raising 1 to the power `n` will always yield 1. In mathematical terms, this is the principle that any power of 1 is still 1, which holds true for all division monoids and integers.

For any division monoid `α` and integer `n`, 1 raised to the power of `n` equals 1.


theorem Set.image2_singleton_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {t : Set β} {a : α}, Set.image2 f {a} t = f a '' t :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, any binary function `f` from `α` and `β` to `γ`, any set `t` of type `β`, and any element `a` of type `α`, the image under `f` of the set consisting only of element `a` and the set `t` is equal to the set of the image of `t` under the function `f` when `a` is the first argument of `f`. In mathematical terms, for a function `f : α × β → γ`, the image of `f` over `a` singleton and `t` is the same as the image of `t` under the function `f(a, .)`.

For any function $f : \alpha \times \beta \rightarrow \gamma$, any $a \in \alpha$, and any $t \subseteq \beta$, the image of the singleton set $\{a\} \times t$ under $f$ equals the image of $t$ under the function $f(a, \cdot)$.


theorem Real.log_exp : ∀ (x : ℝ), Real.log (Real.exp x) = x := by sorry

This theorem states that for any real number `x`, the logarithm of the exponential of `x` is equal to `x` itself. In mathematical terms, this is expressing the property `log(exp(x)) = x` for all real `x`. This reflects the inverse relationship between the logarithm and exponential functions in real numbers.

The logarithm function is the inverse of the exponential function for real numbers, that is, log(exp(x)) = x for all real x.


theorem List.eq_of_mem_replicate : ∀ {α : Type u_1} {a b : α} {n : ℕ}, b ∈ List.replicate n a → b = a := by sorry

The theorem `List.eq_of_mem_replicate` states that for any type `α`, and any elements `a` and `b` of type `α`, and any natural number `n`, if `b` is an element in the list created by replicating `a` n times, then `b` must be equal to `a`. In other words, if `b` is in a list made up of `n` copies of `a`, then `b` has to be `a`.

For any type `α`, if `b` is the `n-th` element of a list `[a | _ | ... | _]` of length `n+1` where every element except the first `n` is `a`, then `b = a`.


Asymptotics.IsBigOWith.bound

/-- **Alias** of the forward direction of `Asymptotics.isBigOWith_iff`.

---

Definition of `IsBigOWith`. We record it in a lemma as `IsBigOWith` is irreducible.  -/
theorem Asymptotics.IsBigOWith.bound :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E} {g : α → F}
      {l : Filter α}, Asymptotics.IsBigOWith c l f g → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ :=
  by sorry

The theorem `Asymptotics.IsBigOWith.bound` states that for any real number `c`, any functions `f` and `g` from a type `α` to normed types `E` and `F` respectively, and any filter `l` on `α`, if `Asymptotics.IsBigOWith c l f g` holds true (indicating that the norm of `f` is eventually bounded by `c` times the norm of `g` under the filter `l`), then there exists an eventuality (a set of elements in `α` for which a certain condition holds, represented by `∀ᶠ (x : α) in l`) where the norm of `f` at any such element `x` is less than or equal to `c` times the norm of `g` at `x`. In mathematical terms, this states that if `f` is Big-O of `g` with constant `c` and filter `l`, then eventually (with respect to `l`), the inequality `‖f(x)‖ ≤ c * ‖g(x)‖` holds for all `x`.

If `f` is Big-O of `g` with constant `c` and filter `l`, then there exists an eventuality `x ∈ l` such that `‖f(x)‖ ≤ c * ‖g(x)‖` for all `x`.


theorem Cardinal.mk_sigma :
    ∀ {ι : Type u_2} (f : ι → Type u_1), Cardinal.mk ((i : ι) × f i) = Cardinal.sum fun i => Cardinal.mk (f i) := by
  sorry

The theorem `Cardinal.mk_sigma` states that for any type `ι` and a function `f` from `ι` to another type, the cardinality of the sigma type (i.e., dependent pair type) `(i : ι) × f i` is equal to the sum of the cardinalities of the types `f i` for each `i` in `ι`. In other words, the size of the disjoint union of all types `f i` (where `i` ranges over `ι`) is the same as the total size of all these types counted separately.

The theorem asserts that the cardinality of the dependent sum (sigma type) over a type `ι` and a function `f` from `ι` to another type equals the sum of the cardinalities of the images `f i` for all `i` in `ι`.


Set.Pairwise.mono

theorem Set.Pairwise.mono :
    ∀ {α : Type u_1} {r : α → α → Prop} {s t : Set α}, t ⊆ s → Set.Pairwise s r → Set.Pairwise t r := by sorry

The theorem `Set.Pairwise.mono` states that for any type `α` and any relation `r` defined on `α`, given two sets `s` and `t` of type `α`, if `t` is a subset of `s` and the relation `r` holds pairwise on the set `s`, then the relation `r` also holds pairwise on the set `t`. In other words, the pairwise property of a relation on a set is preserved under subset inclusion.

If `r` is a relation on a type `α` such that `r` holds pairwise for all distinct elements of a set `s`, and `t` is a subset of `s`, then `r` holds pairwise for all distinct elements of `t`.


/-- A sum of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)` is the sum of
`f 0` plus the remaining product -/
theorem Fin.sum_univ_succ :
    ∀ {β : Type u_2} [inst : AddCommMonoid β] {n : ℕ} (f : Fin (n + 1) → β),
      (Finset.sum Finset.univ fun i => f i) = f 0 + Finset.sum Finset.univ fun i => f (Fin.succ i) :=
  by sorry

The theorem `Fin.sum_univ_succ` states that for any natural number `n`, and any function `f` mapping from the finite set `Fin (n + 1)` to a type `β` equipped with an additive commutative monoid structure, the sum of the function `f` over all elements of `Fin (n + 1)` equals the sum of `f 0` and the sum of `f` applied to the "successor" of the remaining elements in the set. Here, the "successor" of an element is obtained via the function `Fin.succ`.

For any natural number `n` and additive commutative monoid-valued function `f` on `Fin (n + 1)`, the sum of `f` over all elements equals the sum of `f 0` and the sum of `f` over the remaining elements, where the remaining elements are those indexed by `Fin.succ`.


/-- An element `a` of a semigroup with a distributive negation divides the negation of an element
`b` iff `a` divides `b`.  -/
theorem dvd_neg : ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : HasDistribNeg α] {a b : α}, a ∣ -b ↔ a ∣ b := by sorry

This theorem states that for any element `a` of a semigroup (a group-like structure) that also supports a distributive negation operation, `a` divides the negation of another element `b` if and only if `a` divides `b` itself. In simpler terms, if `a` is a factor of `-b`, then `a` is also a factor of `b`, and vice versa, assuming the operations of the semigroup are compatible with the negation operation.

For any element `a` in a semigroup with distributive negation, `a` divides `b` if and only if `a` divides the negation of `b`.


theorem ZeroAtInftyContinuousMap.coe_zero :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β], ⇑0 = 0 :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` and `β` both have topological space structures and `β` has a zero element, the continuous map at infinity (denoted by `⇑0`) is equal to the zero element of `β`. In other words, in this context, the map that sends all elements of `α` to the zero of `β` is equivalent to the zero function.

For any topological spaces `α` and `β` with a zero element in `β`, the continuous map from `α` to `β` sending all elements to the zero element is the zero function.


theorem Set.image_inv : ∀ {α : Type u_2} [inst : InvolutiveInv α] {s : Set α}, Inv.inv '' s = s⁻¹ := by sorry

This theorem, named `Set.image_inv`, states that for any type `α` equipped with an involutive inverse operation, and for any set `s` of elements of type `α`, the image of `s` under the inverse operation (`Inv.inv '' s`) is equal to the inverse of `s` (`s⁻¹`). Here, an "involutive" operation is one where applying the operation twice returns the original value (i.e., for all `x` in `α`, `inv(inv(x)) = x`). The symbol `''` in `Inv.inv '' s` denotes the image of a set under a function. So `Inv.inv '' s` represents the set of all elements obtained by applying the inverse operation to each element of `s`. And `s⁻¹` represents the inverse of the set `s`.

For any set `s` of elements in a type `α` equipped with an involutive inverse operation, `Inv.image s (inv : α → α) = s⁻¹`.


theorem Complex.zero_cpow : ∀ {x : ℂ}, x ≠ 0 → 0 ^ x = 0 := by sorry

This theorem states that for any non-zero complex number `x`, the result of raising zero to the power of `x` is zero. In mathematical terms, if `x` is a complex number and `x ≠ 0`, then `0 ^ x = 0`.

For any non-zero complex number `x`, `0 ^ x = 0`.


/-- **Alias** of `lt_of_le_not_le`. -/
theorem LE.le.lt_of_not_le : ∀ {α : Type u} [inst : Preorder α] {a b : α}, a ≤ b → ¬b ≤ a → a < b := by sorry

This theorem, which is an alias of `lt_of_le_not_le`, states that for any type `α` with a preorder structure, if `a` and `b` are elements of type `α`, `a` is less than `b` if and only if `a` is less than or equal to `b` and it is not the case that `b` is less than or equal to `a`. In other words, in a preorder, `a` is strictly less than `b` if `a` is at most `b` but `b` is not at most `a`.

In a preorder, `a` is strictly less than `b` if and only if `a` is less than or equal to `b` and `b` is not less than or equal to `a`.


Derivation.ext

theorem Derivation.ext :
    ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
      [inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
      {D1 D2 : Derivation R A M}, (∀ (a : A), D1 a = D2 a) → D1 = D2 :=
  by sorry

This theorem states that for any types `R`, `A`, and `M`, given `R` and `A` are commutative semirings, `M` is an additive commutative monoid, and `M` is a module over both `R` and `A`, with `A` being an `R`-algebra, if you have two derivations `D1` and `D2` from `R` and `A` into `M`, and for every element `a` in `A`, `D1` applied to `a` equals `D2` applied to `a`, then `D1` and `D2` are identical. In simpler terms, if two derivations behave the same way for all elements of the algebra, then they are the same derivation.

If `R` and `A` are commutative semirings, `M` is an additive commutative `R`-module and `A`-module, `A` is an `R`-algebra, and for all `a` in `A`, `D1 (a) = D2 (a)`, then `D1 = D2`.


theorem Function.Surjective.forall₂ :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β},
      Function.Surjective f → ∀ {p : β → β → Prop}, (∀ (y₁ y₂ : β), p y₁ y₂) ↔ ∀ (x₁ x₂ : α), p (f x₁) (f x₂) :=
  by sorry

The theorem `Function.Surjective.forall₂` states that for any given types `α` and `β` and any function `f : α → β`, if the function `f` is surjective (i.e., for every element `b` in `β`, there exists an element `a` in `α` such that `f(a) = b`), then for any given property `p` that relates two elements in `β`, `p` holds for all pairs of elements in `β` if and only if `p` holds for all pairs of elements in `α` mapped by the function `f`. In other words, we can check the property `p` on the image of `f` instead of the entire codomain `β` if `f` is surjective.

If `f : α → β` is a surjective function, then `p(a₁, a₂) ↔ p(f a₁, f a₂)` for any binary relation `p : β → β → Prop`.


WCovBy.le

theorem WCovBy.le : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⩿ b → a ≤ b := by sorry

This theorem states that for any type `α` (assuming `α` forms a preordered set), if `a` is weakly covered by `b` (indicated by `a ⩿ b`), then `a` is less than or equal to `b` (expressed as `a ≤ b`). In other words, in a preordered set, weak coverage implies the underlying ordering.

In a preordered set, if `a` is weakly covered by `b` (`a ⩿ b`), then `a` is less than or equal to `b` (`a ≤ b`).


theorem Set.image_preimage_eq_of_subset :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β}, s ⊆ Set.range f → f '' (f ⁻¹' s) = s := by sorry

The theorem `Set.image_preimage_eq_of_subset` states that for any two types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `β`, if `s` is a subset of the range of `f`, then the image of the preimage of `s` under `f` is equal to `s`.

In simpler terms, if we take a set `s` and find all values in the domain `α` that map to `s` under `f` (this is the preimage of `s` under `f`), and then apply `f` to these values again, we get back the original set `s`. This process of "going backward" (finding the preimage) and then "going forward" (applying `f`) leaves us where we started, but only if every element of `s` is mapped to by `f`.

If `f` is a function from type `α` to type `β` and `s ⊆ Range(f)`, then `f''(⁻¹(s)) = s`.


theorem measurable_subtype_coe : ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop}, Measurable Subtype.val :=
  by sorry

The theorem `measurable_subtype_coe` asserts that for any type `α` equipped with a measurable space structure, and for any predicate `p` on `α`, the function `Subtype.val` (which maps each subtype `s : {x // p x}` to the underlying element in the base type `α`) is measurable. In other words, the preimage of any measurable set under the `Subtype.val` function is a measurable set.

For any measurable space `(α, Σ)` and measurable predicate `p : α → Prop`, the function `Subtype.val : {x // p x} → α` is measurable, i.e., for any measurable set `M ∈ Σ`, the preimage `Subtype.val⁻¹[M]` is also measurable.


/-- **Alias** of the reverse direction of `MeasureTheory.Measure.ae_le_iff_absolutelyContinuous`. -/
theorem MeasureTheory.Measure.AbsolutelyContinuous.ae_le :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      MeasureTheory.Measure.AbsolutelyContinuous μ ν → MeasureTheory.Measure.ae μ ≤ MeasureTheory.Measure.ae ν :=
  by sorry

This theorem states that for any type `α` with a `MeasurableSpace` `m0`, and any two measures `μ` and `ν` on that space, if `μ` is absolutely continuous with respect to `ν` (meaning that whenever `ν` of a set `A` is zero, then `μ` of `A` is also zero), then the "almost everywhere" filter of `μ` is less than or equal to the "almost everywhere" filter of `ν`. In terms of measure theory, this suggests that if one measure is absolutely continuous with respect to another, then almost all points that are measurable according to the first measure are also measurable according to the second.

If `μ` is absolutely continuous with respect to `ν` for measurable spaces `(α, m0)` and measures `μ` and `ν`, then the `μ`-almost everywhere filter is included in the `ν`-almost everywhere filter.


theorem self_le_add_right : ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] (a b : α), a ≤ a + b := by sorry

This theorem states that for any type `α` that is a canonically ordered additive commutative monoid, and for any two elements `a` and `b` of this type, `a` is less than or equal to the sum of `a` and `b`. In simpler terms, for any two numbers `a` and `b` in a certain kind of ordered number system, adding `b` to `a` will not make the total smaller than `a`.

For any additive commutative monoid with a canonical order `α`, for all `a, b ∈ α`, we have `a ≤ a + b`.


theorem iInf₂_le :
    ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_7} [inst : CompleteLattice α] {f : (i : ι) → κ i → α} (i : ι)
      (j : κ i), ⨅ i, ⨅ j, f i j ≤ f i j :=
  by sorry

This theorem states that for all types `α` and every function `f` from a dependent pair type `(i : ι, j : κ i)` to `α`, where `α` is a complete lattice, the infimum (or greatest lower bound) of `f` over all `i` and `j` is less than or equal to the value of `f` at any particular `(i, j)`. In other words, the value at any point in the function is always greater than or equal to the smallest value in the function.

For any complete lattice α and function f from a dependent pair type (i : ι, j : κ i) to α, the inf inf{f i j} <= f i j holds.


/-- For natural numbers the filters `Filter.cofinite` and `Filter.atTop` coincide.  -/
theorem Nat.cofinite_eq_atTop : Filter.cofinite = Filter.atTop := by sorry

This theorem states that, in the context of natural numbers, the filters `Filter.cofinite` and `Filter.atTop` are equivalent. The filter `Filter.cofinite` represents the filter of subsets whose complements are finite, while `Filter.atTop` symbolizes the limit towards positive infinity. Thus, this theorem essentially means that the collection of subsets of natural numbers with finite complements is the same as the collection of subsets of natural numbers that contain all sufficiently large numbers.

The filters of cofinite subsets and subsets containing all but finitely many natural numbers are equivalent.


theorem Submodule.range_subtype :
    ∀ {R : Type u_1} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), LinearMap.range (Submodule.subtype p) = p :=
  by sorry

The theorem `Submodule.range_subtype` states that for any type `R` with a semiring structure, any type `M` with both an addition-commutative monoid structure and a module structure over `R`, and any submodule `p` of `M`, the range of the linear map from the submodule `p` to `M` (given by the function `Submodule.subtype p`) is equal to the submodule `p` itself. Informally, this says that when we apply the embedding of the submodule `p` into `M` to every element of `p`, we get exactly `p` as a result.

For any semiring `R`, additive monoid and `R`-module `M`, and submodule `p` of `M`, the image of `p` under the submodule embedding is equal to `p`.


theorem Int.add_le_add_left : ∀ {a b : ℤ}, a ≤ b → ∀ (c : ℤ), c + a ≤ c + b := by sorry

This theorem states that for any integers `a`, `b`, and `c`, if `a` is less than or equal to `b`, then the result of adding `c` to `a` is less than or equal to the result of adding `c` to `b`. Essentially, it means that adding the same integer to both sides of a less than or equal to comparison doesn't change the truth of the inequality in the domain of integers.

For all integers `a`, `b`, and `c`, if `a ≤ b`, then `a + c ≤ b + c`.


/-- $\#(s \setminus \{a\}) = \#s - 1$ if $a \in s$.  -/
theorem Finset.card_erase_of_mem :
    ∀ {α : Type u_1} {s : Finset α} {a : α} [inst : DecidableEq α], a ∈ s → (Finset.erase s a).card = s.card - 1 := by
  sorry

This theorem states that for any type `α` with decidable equality and for any finite set `s` of type `α` and an element `a` of type `α`, if `a` is an element of `s`, then the cardinality of the set obtained by erasing `a` from `s`, denoted by `Finset.erase s a`, is equal to the cardinality of `s` minus one. In mathematical terms, if $a \in s$, then the number of elements in $s$ without $a$, denoted by $\#(s \setminus \{a\})$, is equal to the number of elements in $s$ minus one, i.e., $\#(s \setminus \{a\}) = \#s - 1$.

For any finite type `α` with decidable equality, if `a` is an element of a finite set `s` of type `α`, then the cardinality of `s` without `a` equals the cardinality of `s` minus one. (Or, in mathematical notation, if $a \in s$, then $\#(s \setminus \{a\}) = \#s - 1$.)


theorem zsmul_one : ∀ {α : Type u_3} [inst : AddGroupWithOne α] (n : ℤ), n • 1 = ↑n := by sorry

This theorem, named `zsmul_one`, states that for any integer `n` and for any type `α` that is a AddGroupWithOne (an additive group with a distinguished element 1), the scalar multiplication of `n` and 1 is equal to the coersion of `n` to `α`. In other words, multiplying 1 by any integer in an additive group with one is equal to the integer itself (after proper type coersion).

For any integer `n` and additive group with one `α`, the operation of scaling `n` by 1 in `α` is equal to the coercion of `n` to `α`.


Homeomorph.isClosedMap

theorem Homeomorph.isClosedMap :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      IsClosedMap ⇑h :=
  by sorry

The theorem `Homeomorph.isClosedMap` states that for any two topological spaces `X` and `Y`, and any homeomorphism `h` from `X` to `Y`, the function `h` is a closed map. In other words, if `U` is a closed set in `X`, then its image under `h`, i.e., `h(U)`, is a closed set in `Y`. This theorem holds for all topological spaces `X` and `Y`, and any homeomorphisms between them.

Given any topological spaces X and Y and a homeomorphism h from X to Y, the image of any closed set in X under h is a closed set in Y.


theorem tendsto_nat_cast_atTop_atTop :
    ∀ {R : Type u_2} [inst : OrderedSemiring R] [inst_1 : Archimedean R],
      Filter.Tendsto Nat.cast Filter.atTop Filter.atTop :=
  by sorry

This theorem states that for any type `R` that is an ordered semiring and also Archimedean, the function `Nat.cast` (which casts a natural number to a type `R` element) tends to infinity (`Filter.atTop`) as the natural numbers (`Filter.atTop`) tend to infinity. In other words, when the natural numbers go towards infinity, their corresponding casts in the type `R` also go towards infinity.

For any Archimedean ordered semiring `R`, the sequence `{Nat.cast x : R | x <- Filter.atTop ℕ}` tends to infinity.


theorem Finite.of_equiv : ∀ {β : Sort u_2} (α : Sort u_3) [h : Finite α], α ≃ β → Finite β := by sorry

This theorem, `Finite.of_equiv`, states that for any types `α` and `β`, if `α` is finite and there exists an equivalence between `α` and `β`, then `β` is also finite. The theorem relies on the assumption that there is a one-to-one correspondence (bijective function) between `α` and `β`, meaning that each element in `α` corresponds to a unique element in `β` and vice versa, hence their sizes are identical. Therefore, if `α` is finite, `β` must also be finite.

If `α` is a finite type and there exists a bijection between `α` and `β`, then `β` is also finite.


theorem Set.compl_iUnion : ∀ {β : Type u_2} {ι : Sort u_4} (s : ι → Set β), (⋃ i, s i)ᶜ = ⋂ i, (s i)ᶜ := by sorry

The theorem `Set.compl_iUnion` states that for any type `β` and any indexing type `ι`, if `s` is a function from `ι` to the set of `β`, then the complement of the union over all `s i` is equal to the intersection of the complements of all `s i`. This is a statement of De Morgan's law for sets. In mathematical notation, it says that $(\bigcup_{i} s_i)^c = \bigcap_{i} (s_i)^c$, where $s_i$ are the sets indexed by `i`, $^c$ denotes set complement, $\bigcup$ denotes union over all sets, and $\bigcap$ denotes intersection over all sets.

The complement of the union of a family of sets equals the intersection of their complements.


theorem Finset.image_singleton :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] (f : α → β) (a : α), Finset.image f {a} = {f a} := by sorry

The theorem `Finset.image_singleton` states that for any types `α` and `β`, where `β` has decidable equality, and for any function `f` from `α` to `β` and any element `a` of type `α`, the image of the singleton set `{a}` under the function `f` is the singleton set containing `f(a)`. In other words, applying the function `f` to each element of the singleton set `{a}` yields a new singleton set `{f(a)}`.

For any types `α` and `β` with decidable equality, and for any function `f` from `α` to `β` and element `a` of type `α`, the image of the singleton set `{a}` under `f` is the singleton set `{f(a)}`.


theorem Filter.HasBasis.ge_iff :
    ∀ {α : Type u_1} {ι' : Sort u_5} {l l' : Filter α} {p' : ι' → Prop} {s' : ι' → Set α},
      Filter.HasBasis l' p' s' → (l ≤ l' ↔ ∀ (i' : ι'), p' i' → s' i' ∈ l) :=
  by sorry

The theorem `Filter.HasBasis.ge_iff` states that for all types `α` and `ι'`, and for all filters `l` and `l'` on `α`, and for all properties `p'` on `ι'` and sets `s'` of `α` indexed by `ι'`, if the filter `l'` has a basis characterized by the property `p'` and the sets `s'`, then the filter `l` is greater than or equal to the filter `l'` if and only if for every `ι'` for which `p'` holds, the corresponding set `s'` is an element of the filter `l`. In simpler terms, it means that one filter is larger than another if it contains every set from the basis of the smaller filter that satisfies a certain property.

For filters `l` and `l'` on type `α`, `l ≥ l'` if and only if for every `ι'` such that property `p'` holds for `l'`'s basis set `s'`, `s' ∈ l`.


theorem mul_dvd_mul_left : ∀ {α : Type u_1} [inst : Monoid α] {b c : α} (a : α), b ∣ c → a * b ∣ a * c := by sorry

This theorem states that for any type `α` that has a Monoid structure, and for any elements `a`, `b`, and `c` of that type, if `b` divides `c`, then `a * b` divides `a * c`. In mathematical terms, this says that if `b | c`, then `a*b | a*c`, where `|` represents the divisibility relation. This theorem is fundamental in number theory and algebra, stating an important property about multiplication and divisibility.

For any type `α` with a Monoid structure and for all elements `a`, `b`, and `c` of `α`, if `b` divides `c`, then `a * b` divides `a * c`. (In other words, `b | c` implies `a * b | a * c` in the divisibility relation.)


/-- A constant size neighborhood of the diagonal is an entourage.  -/
theorem Metric.dist_mem_uniformity :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {ε : ℝ}, 0 < ε → {p | dist p.1 p.2 < ε} ∈ uniformity α := by sorry

This theorem states that for any pseudometric space `α` and any positive real number `ε`, the set of all pairs `p` such that the distance between the elements of `p` is less than `ε` is an element of the `uniformity` of `α`. In other words, any neighborhood of the diagonal of a given constant size `ε` is considered an entourage (a neighborhood of the diagonal in the product space) in the uniformity (a specific type of filter) of the pseudometric space.

For any pseudometric space `α` and positive real number `ε`, the closed ball of radius `ε` around the diagonal is an entourage in the uniformity of `α`.


theorem Mathlib.Data.Polynomial.Degree.Definitions._auxLemma.12 :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (Polynomial.leadingCoeff p = 0) = (p = 0) := by sorry

This theorem states that for any semiring `R` and any polynomial `p` over `R`, the leading coefficient of `p` is zero if and only if `p` is the zero polynomial. In other words, in the context of a semiring, a polynomial is zero if and only if its leading coefficient, i.e., the coefficient of its highest power of `X`, is zero.

In a semiring, a polynomial is the zero polynomial if and only if its leading coefficient is zero.


theorem measurable_zero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : Zero α],
      Measurable 0 :=
  by sorry

The theorem `measurable_zero` states that for any types `α` and `β` that both have a `MeasurableSpace` structure and `α` also has a `Zero` structure, the constant zero function (which maps every element of its domain to zero) is a measurable function. In other words, the preimage of any measurable set under the zero function is also a measurable set.

If `α` and `β` are MeasurableSpaces and `α` has a Zero structure, then the constant zero function from `α` to `β` is measurable.


theorem Prod.fst_surjective : ∀ {α : Type u_1} {β : Type u_2} [h : Nonempty β], Function.Surjective Prod.fst := by sorry

The theorem `Prod.fst_surjective` states that for all types `α` and `β`, given that `β` is nonempty, the first projection function `Prod.fst` is surjective. In other words, for every element of `α` in the product type `α × β`, there exists a pair in `α × β` such that when we apply the `Prod.fst` function (which extracts the first element of the pair), we can get any element of `α`. This means that we can reach every element of `α` by selecting some pair from `α × β` and taking its first component.

For any nonempty type `β`, the first projection function `Prod.fst` of the product type `α × β` is a surjection from `α`.


theorem CategoryTheory.FunctorToTypes.map_comp_apply :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C}
      (f : X ⟶ Y) (g : Y ⟶ Z) (a : F.obj X), F.map (CategoryTheory.CategoryStruct.comp f g) a = F.map g (F.map f a) :=
  by sorry

The theorem `CategoryTheory.FunctorToTypes.map_comp_apply` states that for any category `C`, functor `F` from `C` to the category of types, and morphisms `f` and `g` in `C`, the action of the functor on the composition of `f` and `g` when applied to an object `a` of `F.obj X` is the same as first applying the functor to `f` and `g` separately on `a` and then composing the results. This is a version of the functoriality condition that applies specifically to the category of types.

For any functor F from a category C to the category of types, and objects X, Y in C and morphisms f : X → Y and g : Y → Z in C, we have F(g ∘ f) a = F(g) (F(f) a) for all objects a of F X.


theorem isOfFinAddOrder_iff_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, IsOfFinAddOrder x ↔ ∃ n, 0 < n ∧ n • x = 0 := by sorry

This theorem states that, for any type `G` which has an additive monoid structure, an element `x` of `G` is of finite additive order if and only if there exists a positive integer `n` such that `n • x = 0`. This means that the element `x` is of finite additive order if it becomes zero when repeatedly added to itself `n` times for some positive integer `n`.

For any additive monoid `G`, an element `x` in `G` has finite additive order if and only if there exists a positive integer `n` such that `x + ... + x = 0` (n times).


theorem norm_pow : ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a : α) (n : ℕ), ‖a ^ n‖ = ‖a‖ ^ n := by sorry

This theorem is stating that for any normed division ring `α` and any element `a` of that ring, as well as any natural number `n`, the norm of `a` raised to the power of `n` is equal to the norm of `a` raised to the power of `n`. In mathematical terms, it says that for all `a` in `α` and for all natural numbers `n`, `||a^n|| = ||a||^n`.

For any normed division ring `α` and element `a` in `α`, the norm of `a` raised to the power of a natural number `n` equals the norm of `a` raised to the power of `n`. In other words, `||a^n|| = ||a||^n`.


theorem not_nonempty_iff : ∀ {α : Sort u_1}, ¬Nonempty α ↔ IsEmpty α := by sorry

This theorem states that for any type `α`, the proposition that `α` is not nonempty is equivalent to `α` being empty. Here, `Nonempty α` represents that there exists an element of type `α` and `IsEmpty α` denotes that there are no elements of type `α`. So, this theorem connects the negation of existence with the non-existence in the context of types in Lean 4.

The proposition that a type `α` has no elements is equivalent to `α` being empty.


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

The theorem `Set.image2_image_left` states that for any types `α`, `β`, `γ`, and `δ`, any sets `s` of `α` and `t` of `β`, any function `f` from `γ` to `β` to `δ`, and any function `g` from `α` to `γ`, the image of the binary function `f` on the image of `g` on `s` and `t` is the same as the image of the binary function where `f` is composed with `g` on `s` and `t`. In other words, applying `f` on the image of `g` on a set is the same as applying `f` composed with `g` directly on the set. This theorem essentially formalizes one aspect of the interchangeability of the order of operations in function application on sets.

For any sets $S:\alpha$, $T:\beta$, functions $f:\gamma \to \delta$, $g:\alpha \to \gamma$, the image of $f$ on the image of $g$ applied to $S$ and $T$ equals the image of $f \circ g$ applied to $S$ and $T$.


LE.le.trans'

/-- **Alias** of `le_trans'`. -/
theorem LE.le.trans' : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, b ≤ c → a ≤ b → a ≤ c := by sorry

This theorem, often referred to as an "alias" of `le_trans'`, is a property that states the transitivity of the less than or equal to (≤) relation over a preordered set. In more concrete terms, for any type `α` with a preorder structure, and any three elements `a`, `b`, and `c` of this type, if `b` is less than or equal to `c` and `a` is less than or equal to `b`, then it follows that `a` is less than or equal to `c`. This rule is fundamental in the theory of ordered sets.

For any preordered type `α` and elements `a`, `b`, and `c` in `α`, if `b ≤ c` and `a ≤ b`, then `a ≤ c`.


Differentiable.continuous

theorem Differentiable.continuous :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
      Differentiable 𝕜 f → Continuous f :=
  by sorry

The theorem `Differentiable.continuous` states that for any nontrivial normed field `𝕜`, if a function `f` mapping from a normed vector space `E` over `𝕜` to another normed vector space `F` over `𝕜` is differentiable at every point in `E`, then `f` is also continuous. In other words, if a function is differentiable everywhere, it is also continuous everywhere. This result holds in the context of real or complex numbers (or, more generally, in any nontrivial normed field) and with possibly infinite-dimensional vector spaces.

If a function between two normed vector spaces over a nontrivial normed field is differentiable at every point, then it is continuous.


theorem Finset.sum_mul :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : NonUnitalNonAssocSemiring α] (s : Finset ι) (f : ι → α) (a : α),
      (Finset.sum s fun i => f i) * a = Finset.sum s fun i => f i * a :=
  by sorry

The theorem `Finset.sum_mul` states that for any finite set `s` of a general type `ι`, any function `f` from `ι` to a type `α` equipped with a structure of `NonUnitalNonAssocSemiring` (a mathematical structure similar to the real numbers without the assumption that multiplication is associative and without a multiplicative identity element), and any element `a` of this type, the sum of the values of `f` over `s`, when multiplied by `a`, equals the sum over `s` of the products of `f` evaluated at each element of `s` and `a`. In mathematical terms, it says that for any set `s`, function `f` and scalar `a`, we have the equality $(\sum_{i \in s} f(i)) * a = \sum_{i \in s} (f(i) * a)$.

For any finite set $s$, function $f$ from $s$ to a non-unital non-associative semiring, and scalar $a$ in the semiring, we have $\sum\_{i \in s} f(i) \cdot a = a \cdot \sum\_{i \in s} f(i)$.


theorem Set.inter_eq_left : ∀ {α : Type u} {s t : Set α}, s ∩ t = s ↔ s ⊆ t := by sorry

This theorem, named `Set.inter_eq_left`, states that for any type `α` and any two sets `s` and `t` of that type, the intersection of `s` and `t` is equal to `s` if and only if `s` is a subset of `t`. In other words, it shows a logical equivalence between "the intersection of two sets being one of those sets" and "that set being a subset of the other set". This theorem holds true for all possible types `α` and all possible sets `s` and `t` of that type.

For any type α and sets s and t of type α, s ∩ t = s if and only if s ⊆ t.


theorem Finset.card_eq_zero : ∀ {α : Type u_1} {s : Finset α}, s.card = 0 ↔ s = ∅ := by sorry

The theorem `Finset.card_eq_zero` states that for any type `α` and any finite set `s` of type `α`, the cardinality (or size) of `s` is zero if and only if `s` is the empty set. In other words, a finite set has zero elements if and only if it is an empty set.

A finite set has zero cards if and only if it is empty.


theorem CategoryTheory.ConcreteCategory.congr_hom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X Y : C}
      {f g : X ⟶ Y}, f = g → ∀ (x : (CategoryTheory.forget C).obj X), f x = g x :=
  by sorry

This theorem states that for any category `C`, which is also a concrete category, and any two objects `X` and `Y` in this category, if we have two morphisms `f` and `g` from `X` to `Y` that are equal, then for any element `x` of `X` considered as an object in the category of types (i.e., `x` is an element of the underlying set of `X` under `CategoryTheory.forget C`), the application of `f` to `x` is equal to the application of `g` to `x`. In other words, the equality of two morphisms in a concrete category is witnessed by their equality on each element of the domain.

In a concrete category `C`, the equality of morphisms `f` and `g` from object `X` to object `Y` implies `f x = g x` for all elements `x` of `X` viewed as objects in the underlying category of types.


theorem Zsqrtd.coe_int_re : ∀ {d : ℤ} (n : ℤ), (↑n).re = n := by sorry

This theorem states that for any integer `d` and any integer `n`, the real part (`re`) of the complex number obtained by casting `n` (i.e., `↑n`) is equal to `n` itself. In other words, when any integer is considered as a complex number, its real part is the integer itself.

The real part of an integer `n` considered as a complex number equals `n` itself.


theorem Complex.cos_periodic : Function.Periodic Complex.cos (2 * ↑Real.pi) := by sorry

The theorem `Complex.cos_periodic` states that the complex cosine function, `Complex.cos`, is periodic with a period of `2 * Real.pi`. In other words, for all complex numbers `z`, the value of `Complex.cos` at `z + 2π` (where `π` is the constant `Real.pi` representing the mathematical constant pi) is equal to the value of `Complex.cos` at `z`. This is a reflection of the well-known property in trigonometry that the cosine function repeats its values every `2π` radians.

The complex cosine function, `Complex.cos`, is periodic with a period of `2 * Real.pi`. In other words, `Complex.cos (z + 2π) = Complex.cos z` for all complex numbers `z`.


theorem Finsupp.smul_single :
    ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α)
      (b : M), (c • fun₀ | a => b) = fun₀ | a => c • b :=
  by sorry

This theorem states that for any types `α`, `M`, and `R`, given the fact that `M` is a zero type and there exists a scalar multiplication by zero for `R` and `M`, for any scalar `c` of type `R`, any element `a` of type `α`, and any element `b` of type `M`, scalar multiplication distributes over the function `fun₀` which maps `a` to `b`. More specifically, `c` times the function `fun₀` that maps `a` to `b` equals the function `fun₀` that maps `a` to `c` times `b`. This essentially states the property of scalar multiplication regarding functions in the context of a single function mapping.

For any type `α`, scalar ring `R`, zero type `M`, scalar multiplication on `R` and `M`, scalar `c` in `R`, element `a` in `α`, and element `b` in `M`, we have `(c • fun₀ a) = fun₀ a • c • b`, where `fun₀` is the function mapping `a` to `b`.


theorem Complex.ofReal_inv : ∀ (r : ℝ), ↑r⁻¹ = (↑r)⁻¹ := by sorry

This theorem states that for all real numbers `r`, the reciprocal of the complex number corresponding to `r` is equal to the complex number corresponding to the reciprocal of `r`. In other words, taking the reciprocal before or after the real-to-complex conversion gives the same result. Here, `↑r` denotes the complex number corresponding to the real number `r`.

For all real numbers `r`, the complex numbers `(↑r)^-1` and `↑(r^-1)` are equal.


theorem Polynomial.degree_modByMonic_lt :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] (p : Polynomial R) {q : Polynomial R},
      Polynomial.Monic q → Polynomial.degree (p %ₘ q) < Polynomial.degree q :=
  by sorry

This theorem states that for any given type `R` that constitutes a ring and is nontrivial, and for any two polynomials `p` and `q` of type `R`, if `q` is a monic polynomial (meaning its leading coefficient is 1), then the degree of the polynomial obtained by taking the modulo of `p` by `q` is strictly less than the degree of `q`.

In mathematical terms, if `p` and `q` are polynomials over a nontrivial ring, and `q` is monic, then the degree of `p mod q` is less than the degree of `q`.

For any nontrivial ring `R`, if `p` and `q` are polynomials over `R` with `q` monic, then the degree of `p` modulo `q` is strictly less than the degree of `q`.


theorem Fin.zero_le : ∀ {n : ℕ} (a : Fin (n + 1)), 0 ≤ a := by sorry

This lean theorem, `Fin.zero_le`, states that for all natural numbers `n` and for any element `a` of the type `Fin (n + 1)`, the number 0 is less than or equal to `a`. In other words, this theorem ensures that no element of the `Fin (n + 1)` type can be less than 0. The `Fin (n + 1)` type in Lean represents a finite set with `n + 1` elements.

For all natural numbers `n` and elements `a` in `Fin (n + 1)`, `0 ≤ a`.


theorem isNoetherian_iff_wellFounded :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      IsNoetherian R M ↔ WellFounded fun x x_1 => x > x_1 :=
  by sorry

This theorem states that for any given Type `R` and `M` where `R` is a semiring, `M` is an additive commutative monoid and `M` is also a module over `R`, the type `M` is Noetherian if and only if the relation "greater than" (`>`) on the elements of `M` is well-founded. In terms of mathematics, a module `M` over a ring `R` is said to be Noetherian if every non-empty set of submodules of `M` has a maximal element, and a relation is well-founded if there are no infinite decreasing chains. This theorem connects these two concepts, showing that they are equivalent in this context.

A module over a semiring is Noetherian if and only if the "greater than" relation on its elements is well-founded.


theorem Complex.ofReal_exp : ∀ (x : ℝ), ↑(Real.exp x) = Complex.exp ↑x := by sorry

This theorem states that for every real number `x`, the complex version of the real exponential of `x` is equal to the complex exponential of the complex version of `x`. In other words, when the real exponential function is applied to a real number and then raised to the complex plane, it equals applying the complex exponential function directly to the complex version of that real number. This theorem is verifying the behavior of the real exponential function when extended to the complex plane.

For every real number x, the complex exponential of the complex number x equals the real exponential of x lifted to the complex plane.


/-- On non-dependent functions, `Pi.single` can be expressed as an `ite` -/
theorem Pi.single_apply :
    ∀ {I : Type u} {β : Type u_2} [inst : DecidableEq I] [inst_1 : Zero β] (i : I) (x : β) (i' : I),
      Pi.single i x i' = if i' = i then x else 0 :=
  by sorry

The theorem `Pi.single_apply` states that for any given types `I` and `β`, with `I` having a decidable equality operation and `β` having a zero element, and for any elements `i` and `i'` of `I` and any element `x` of `β`, the value of the function `Pi.single` at index `i'` is `x` if `i'` is equal to `i` and is `0` otherwise. In other words, `Pi.single` generates a function that maps `i` to `x` and all other indices to `0`, behaving similar to an `if-then-else` construct.

For any types `I` with decidable equality and having a zero element `β`, the function `Pi.single` maps index `i'` to element `x` if `i'` equals `i`, and to zero otherwise.


theorem Filter.HasBasis.eventually_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → ∀ {q : α → Prop}, (∀ᶠ (x : α) in l, q x) ↔ ∃ i, p i ∧ ∀ ⦃x : α⦄, x ∈ s i → q x :=
  by sorry

The theorem `Filter.HasBasis.eventually_iff` states that for any type `α`, a filter `l`, and a function `s` mapping type `ι` to a set of `α`, if `l` has a basis that satisfies property `p` and is given by `s`, then for any predicate `q` on `α`, the statement "eventually in `l`, `q` holds for `x`" is equivalent to: there exists an `i` such that `i` satisfies `p` and for all `x` in the set `s i`, `q x` holds. In other words, the property `q` holds eventually in `l` if and only if there is an index from the basis of `l` whose corresponding set has all its elements satisfying `q`.

A filter on a type has a basis satisfying property p if and only if for every predicate q, eventual membership in the filter under p is equivalent to belonging to some set in the basis of the filter where q holds for all elements.


theorem Filter.tendsto_fst :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.Tendsto Prod.fst (f ×ˢ g) f := by sorry

The theorem `Filter.tendsto_fst` states that for any types `α` and `β` and for any filters `f : Filter α` and `g : Filter β`, the first projection function `Prod.fst` tends to `f` when taking the product filter `f ×ˢ g`. In other words, for each neighborhood of `f`, the pre-image under `Prod.fst` of that neighborhood is a neighborhood in the product filter `f ×ˢ g`. This is a formalization of the intuitive idea that when you project a product of topological spaces onto one of the factors, you preserve the limit properties of the filter basis.

Given filters `f` on type `α` and `g` on type `β`, the first projection function `Prod.fst` is a continuous map from the product filter `f ×ˢ g` to `f`.


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

This theorem states that for any given type `α` that forms a Monoid, the multiplication of two elements `a` and `b` from the group of units of `α` (denoted as `αˣ`), when coerced to `α`, is equal to the product of `a` and `b` individually coerced to `α`. In other words, the coercion operation preserves the multiplication operation from the group of units to the monoid.

For any monoid `α` and units `a, b` in `αˣ`, the coercion of `a * b` from `αˣ` to `α` is equal to the coercion of `a` and `b` individually from `αˣ` to `α` multiplied in `α`.


NonUnitalRingHom.ext

theorem NonUnitalRingHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : NonUnitalNonAssocSemiring α] [inst_1 : NonUnitalNonAssocSemiring β]
      ⦃f g : α →ₙ+* β⦄, (∀ (x : α), f x = g x) → f = g :=
  by sorry

This theorem, `NonUnitalRingHom.ext`, states that for any types `α` and `β` that are NonUnitalNonAssocSemirings, if we have two non-unital ring homomorphisms `f` and `g` from `α` to `β`, and for every element `x` in `α` the application of `f` and `g` to `x` are equal, then the homomorphisms `f` and `g` themselves are equal. In short, two non-unital ring homomorphisms are equal if they produce the same result for every input from the domain.

If `α` and `β` are NonUnitalNonAssocSemirings, and `f` and `g` are non-unital ring homomorphisms from `α` to `β` such that `f x = g x` for all `x` in `α`, then `f = g`.


theorem CategoryTheory.coe_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X Y Z : C}
      (f : X ⟶ Y) (g : Y ⟶ Z), ⇑(CategoryTheory.CategoryStruct.comp f g) = ⇑g ∘ ⇑f :=
  by sorry

This theorem, `CategoryTheory.coe_comp`, states that in any category `C` that is also a concrete category, for any three objects `X`, `Y`, and `Z` in `C`, and any two morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the action of the composition of `f` and `g` (denoted as `CategoryTheory.CategoryStruct.comp f g`) on any element is the same as first applying `f` and then `g`. This is the categorical analogue of the statement that function composition in set theory is associative, i.e., `(g ∘ f)(x) = g(f(x))` for all `x` in the domain of `f`.

In any concrete category, the composition of morphisms is associative with respect to the underlying functions, i.e., `f ∘ g(x) = g(f(x))` for all objects `x` in the domain of `f`.


theorem Nat.dvd_iff_mod_eq_zero : ∀ (m n : ℕ), m ∣ n ↔ n % m = 0 := by sorry

This theorem states that for all natural numbers 'm' and 'n', 'm' divides 'n' if and only if the remainder of 'n' divided by 'm' is zero. In other words, it sets a condition for divisibility of one natural number by another. The condition is that when 'n' is divided by 'm', the modulus (remainder) should be zero. If this condition is met, then 'm' is a divisor of 'n' and vice versa.

For natural numbers m and n, m divides n if and only if n mod m = 0.


theorem List.pmap.proof_3 : ∀ {α : Type u_1} {p : α → Prop} (a : α) (l : List α), (∀ a_1 ∈ a :: l, p a_1) → p a := by
  sorry

This theorem states that for all types `α`, and for any predicate `p` defined on `α`, given an element `a` of type `α` and a list `l` of elements of type `α`, if the predicate `p` holds for every element in the list formed by prepending `a` to `l`, then the predicate `p` also holds for the element `a`.

If a predicate `p` holds for all elements in the list `a :: l`, where `a` is an element of type `α` and `l` is a list of elements of type `α`, then `p` holds for `a`.


theorem Set.iUnion_image_left :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) {s : Set α} {t : Set β},
      ⋃ a ∈ s, f a '' t = Set.image2 f s t :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, and for any sets `s` of type `α` and `t` of type `β`, the union over all elements `a` in the set `s` of the image under `f` of `t` (where `a` is held fixed and each element of `t` is mapped to `γ`), is equal to the image of the sets `s` and `t` under the binary function `f`. In other words, when we take an element from `s`, apply the function `f` to this element and each element of `t`, and then take the union over all such elements from `s`, we get exactly the set of all results of applying `f` to elements of `s` and `t`.

For any sets `s` of type `α` and `t` of type `β`, and any binary function `f` from `α` and `β` to `γ`, the set `{f(a, b) | a ∈ s, b ∈ t}` are equal to `{f(a, b) | (a, b) ∈ s × t}`.


theorem Polynomial.degree_mul :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p q : Polynomial R},
      Polynomial.degree (p * q) = Polynomial.degree p + Polynomial.degree q :=
  by sorry

The theorem `Polynomial.degree_mul` states that for any type `R` that is a semiring and has no zero divisors, and for any polynomials `p` and `q` over `R`, the degree of the product of `p` and `q` is equal to the sum of the degrees of `p` and `q`. In other words, it mathematically represents the property that the degree of the product of two polynomials is the sum of their degrees, i.e. if $p(x)$ and $q(x)$ are two polynomials, then $\deg(p(x)q(x)) = \deg(p(x)) + \deg(q(x))$.

For polynomials $p$ and $q$ over a semiring $R$ without zero divisors, the degree of their product is equal to the sum of their degrees.


theorem Complex.ofReal_injective : Function.Injective Complex.ofReal' := by sorry

The theorem `Complex.ofReal_injective` states that the function `Complex.ofReal'`, which maps a real number to a complex number (by associating the real number to the real part of the complex number and setting the imaginary part to zero), is injective. In other words, if two real numbers are mapped to the same complex number by this function, then those two real numbers must have been the same. This theorem ensures that no information is lost when real numbers are embedded into the complex numbers in this way.

The theorem `Complex.ofReal_injective` asserts that the function `Complex.ofReal'` maps distinct real numbers to distinct complex numbers.


theorem Polynomial.coeff_scaleRoots :
    ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (s : R) (i : ℕ),
      Polynomial.coeff (Polynomial.scaleRoots p s) i = Polynomial.coeff p i * s ^ (Polynomial.natDegree p - i) :=
  by sorry

The theorem `Polynomial.coeff_scaleRoots` states that for any semiring `R`, any polynomial `p` of type `R`, any scalar `s` of type `R`, and any natural number `i`, the coefficient of the `i`-th term of the polynomial obtained by scaling the roots of `p` by `s` (`Polynomial.scaleRoots p s`) is equal to the coefficient of the `i`-th term of `p` (`Polynomial.coeff p i`) multiplied by `s` raised to the power of the difference between the degree of `p` and `i` (`s ^ (Polynomial.natDegree p - i)`). In mathematical terms, if a polynomial $p$ has degree $n$ and its roots are scaled by a scalar $s$, then the coefficient of $X^i$ in the resulting polynomial is equal to the coefficient of $X^i$ in $p$ multiplied by $s^{(n - i)}$.

For any polynomial $p$ of degree $n$ over a semiring $R$ and scalar $s$ in $R$, the coefficient of the $i$-th term in the polynomial obtained by scaling the roots of $p$ by $s$ is equal to the coefficient of the $i$-th term in $p$ multiplied by $s^{n-i}$.


theorem Set.finite_coe_iff : ∀ {α : Type u} {s : Set α}, Finite ↑s ↔ Set.Finite s := by sorry

This theorem states that for any set `s` of type `α`, the set `s` is finite if and only if the subtype corresponding to `s` is also finite. In other words, it establishes the equivalence between the finiteness of a set and the finiteness of its corresponding subtype. This can be represented mathematically as `Finite ↑s ↔ Set.Finite s`, where `Finite ↑s` refers to the finiteness of the subtype corresponding to set `s` and `Set.Finite s` refers to the finiteness of set `s`.

A set `s` is finite if and only if its subtype is finite. (In Lean: `Finite ↑s ↔ Set.Finite s`)


theorem ContinuousOn.comp_continuous :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {g : β → γ} {f : α → β} {s : Set β},
      ContinuousOn g s → Continuous f → (∀ (x : α), f x ∈ s) → Continuous (g ∘ f) :=
  by sorry

This theorem states that given three topological spaces `α`, `β`, and `γ`, along with two functions `f : α → β` and `g : β → γ`, and a set `s` in `β`, if the function `g` is continuous on the set `s`, and the function `f` is continuous everywhere and maps every element of `α` into the set `s`, then the composition function `g ∘ f` (which maps `α` to `γ` through `β`) is also continuous everywhere. In other words, the continuity of a composite function is preserved when the component functions are continuous, with the first function mapping into a set where the second function is continuous.

If functions `f : α → β`, `g : β → γ` are continuous, `s ⊆ β`, and `f` maps every `x ∈ α` into `s` and `g` is continuous on `s`, then `g ∘ f` is continuous.


theorem Filter.tendsto_inf :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x : Filter α} {y₁ y₂ : Filter β},
      Filter.Tendsto f x (y₁ ⊓ y₂) ↔ Filter.Tendsto f x y₁ ∧ Filter.Tendsto f x y₂ :=
  by sorry

The `Filter.tendsto_inf` theorem states that for any given function `f` from some type `α` to some type `β`, and any filter `x` on `α` and filters `y₁` and `y₂` on `β`, the function `f` has a limit at the intersection of `y₁` and `y₂` if and only if `f` has a limit at both `y₁` and `y₂`. In other words, the limit of `f` evaluated at `x` exists in the intersection of the filters `y₁` and `y₂` when the limit of `f` evaluated at `x` exists in both `y₁` and `y₂` separately.

The theorem asserts that a function's limit at the intersection of two filters exists if and only if it exists in each filter separately.


theorem isGLB_sInf : ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] (s : Set α), IsGLB s (sInf s) := by sorry

This theorem states that for any type `α`, which is a complete semilattice with respect to the infimum operation, and for any set `s` of type `α`, the infimum of `s` (denoted as `sInf s`) is a greatest lower bound of set `s`. In other words, the infimum of a set in a complete semilattice is the largest element that is less than or equal to all elements of the set.

In a complete semilattice, the infimum of a set is its greatest lower bound.


theorem dist_one_right : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a : E), dist a 1 = ‖a‖ := by sorry

This theorem, `dist_one_right`, states that for any type `E` that is a seminormed group, the distance from any element `a` of type `E` to the number 1 is equal to the norm of `a`. The `dist` function in this context defines the distance between two elements in a seminormed group, while `‖a‖` denotes the norm of `a`. In general, the norm of a vector in a normed group is a non-negative value that represents the "length" or "size" of the vector.

For any seminormed group `E` and element `a` in `E`, the distance from `a` to 1 is equal to the norm of `a`. (i.e. `dist a 1 = ‖a‖`)


theorem isClosed_Iic :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIicTopology α] {a : α},
      IsClosed (Set.Iic a) :=
  by sorry

The theorem `isClosed_Iic` states that for any type `α` equipped with a topology and a preorder, and under the condition that the type has a closed left-infinite right-closed interval (`ClosedIicTopology`), then for any element `a` of type `α`, the left-infinite right-closed interval up to `a` (`Set.Iic a`) is a closed set in the topological space. In other words, it confirms that for any given point in the ordered topological space, the set of all points less than or equal to that point forms a closed set.

If `α` is a type equipped with a topology and a preorder, and `α` has a closed left-infinite right-closed interval topology, then for any `a` in `α`, the set `Set.Iic a` of all points less than or equal to `a` is a closed set.


MeasureTheory.Lp.aestronglyMeasurable

theorem MeasureTheory.Lp.aestronglyMeasurable :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), MeasureTheory.AEStronglyMeasurable (↑↑f) μ :=
  by sorry

The theorem `MeasureTheory.Lp.aestronglyMeasurable` states that for any measurable space `α`, type `E` that forms a normed additive commutative group, extended nonnegative real number `p`, and a measure `μ` on `α`, every function `f` that lies in the `Lp` space (the space of functions whose p-th power of absolute value is integrable) with respect to `E`, `p`, and `μ`, is almost everywhere strongly measurable with respect to the measure `μ`. In other words, `f` is equal almost everywhere to the limit of a sequence of simple functions (functions that take a finite number of values), as defined by the `AEStronglyMeasurable` property.

Every `Lp` function on a measurable space with respect to a given measure is almost everywhere equal to a simple function.


theorem Option.map_map :
    ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} (h : β → γ) (g : α → β) (x : Option α),
      Option.map h (Option.map g x) = Option.map (h ∘ g) x :=
  by sorry

The theorem `Option.map_map` states that for any types `α`, `β`, and `γ`, and for any functions `h : β → γ` and `g : α → β`, and for any optional value `x` of type `Option α`, mapping function `h` over the result of mapping function `g` over `x` is equivalent to mapping the composition function `h ∘ g` over `x`. In other words, the process of mapping over optional values is associative with respect to function composition. This is a formal statement of the property of functor composition in the context of the `Option` functor.

For any types `α`, `β`, and `γ`, and functions `g : α → β` and `h : β → γ`, the optional value `Option.map (h ∘ g) x` is equal to `Option.map h (Option.map g x)`, where `x` is an optional value of type `Option α`.


theorem Ioi_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a b : α},
      a < b → Set.Ioi a ∈ nhds b :=
  by sorry

This theorem states that for any given type `α` which has a topological space structure, a linear order and a topology where the lower bounded closed intervals are closed, and for any two elements `a` and `b` of `α`, if `a` is strictly less than `b`, then the left-open right-infinite interval greater than `a` is a neighborhood of `b`. In mathematical terms, if $a < b$, then the set of all elements greater than $a$ is a neighborhood of $b$ in the topological space.

For any topological space `α` endowed with a linear order and a topology where lower bounded closed intervals are closed, the left-open right-infinite interval around an element `a` is a neighborhood of any element `b` strictly greater than `a`.


/-- **Alias** of the reverse direction of `monotone_comp_ofDual_iff`. -/
theorem Antitone.dual_left :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Antitone f → Monotone (f ∘ ⇑OrderDual.ofDual) :=
  by sorry

The theorem `Antitone.dual_left` states that for any types `α` and `β`, both equipped with a preorder relation, and for any function `f` from `α` to `β`, if `f` is antitone (meaning, if `a ≤ b` then `f b ≤ f a`), then the composition of `f` with the identity function on the dual order of `α` is monotone (meaning, if `a ≤ b` in the dual order then `f a ≤ f b` in `β`). In essence, this theorem asserts that an antitone function becomes a monotone function when applied to the dual of an ordered type.

If `f: α → β` is antitone between preordered types `α` and `β`, then `f ∘ Id_α'` is monotone, where `Id_α'` is the identity function on the dual order of `α`.