theorem CategoryTheory.Injective.comp_factorThru :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J X Y : C} [inst_1 : CategoryTheory.Injective J]
      (g : X ⟶ J) (f : X ⟶ Y) [inst_2 : CategoryTheory.Mono f],
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Injective.factorThru g f) = g :=
  by sorry

The theorem `CategoryTheory.Injective.comp_factorThru` states that in any category `C`, for objects `J`, `X`, and `Y` such that `J` is injective, given a morphism `g` from `X` to `J` and a monomorphism `f` from `X` to `Y`, the factorization of `g` through `f` (represented by `CategoryTheory.Injective.factorThru g f`) followed by `f` (represented by `CategoryTheory.CategoryStruct.comp f (CategoryTheory.Injective.factorThru g f)`) is equal to `g`. In other words, the composition of `f` and the factorisation of `g` through `f` yields `g`, affirming that `g` can indeed be factored through the monomorphism `f`.

In a category with injective objects, given a morphism and a monomorphism between their sources, the composition of the morphism with the factorization of the morphism through the monomorphism equals the morphism itself.


theorem Nonempty.map2 :
    ∀ {α : Sort u_2} {β : Sort u_3} {γ : Sort u_4}, (α → β → γ) → Nonempty α → Nonempty β → Nonempty γ := by sorry

This theorem states that for any three types `α`, `β`, and `γ`, given a function from `α` and `β` to `γ`, if `α` and `β` are nonempty, then `γ` is also nonempty. In mathematical terms, it says that if we have a function `f: α × β → γ` and we know that there exists at least one element in both `α` and `β`, then there exists at least one element in `γ`.

If `α × β` is nonempty and `f: α × β → γ` is a function, then `γ` is nonempty.


theorem convex_Ici :
    ∀ {𝕜 : Type u_1} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : OrderedAddCommMonoid β] [inst_2 : Module 𝕜 β]
      [inst_3 : OrderedSMul 𝕜 β] (r : β), Convex 𝕜 (Set.Ici r) :=
  by sorry

This theorem, `convex_Ici`, states that for any ordered semiring `𝕜`, ordered additively commutative monoid `β`, module `𝕜 β` and ordered scalar multiplication `𝕜 β`, and for any real number `r`, the left-closed right-infinite interval `Set.Ici r` is a convex set. In other words, for any `r` in `β`, the set of all elements in `β` that are greater than or equal to `r`, forms a convex set under the conditions defined for `𝕜` and `β`.

For any ordered semiring `𝕜`, ordered additively commutative monoid `β`, and ordered scalar multiplication `𝕜 β`, the set `Set.Ici r` of elements in `β` greater than or equal to a real number `r` is a convex set.


theorem Nat.sInf_mem : ∀ {s : Set ℕ}, Set.Nonempty s → sInf s ∈ s := by sorry

The theorem `Nat.sInf_mem` states that for any non-empty set `s` of natural numbers, the infimum (greatest lower bound) of the set `s`, denoted as `sInf s`, is an element of the set `s`. This theorem implies that a non-empty set of natural numbers always contains its infimum.

Given a non-empty set of natural numbers `s`, its infimum `sInf s` is an element of `s`.


theorem Bool.decide_coe : ∀ (b : Bool) {h : Decidable (b = true)}, decide (b = true) = b := by sorry

The theorem `Bool.decide_coe` states that for any Boolean value `b` and a decidable proposition that `b` equals `true`, the Lean function `decide` applied to the proposition `b = true` is equal to `b` itself. In other words, if you have a Boolean `b` and can decide whether `b` is `true`, using `decide` to make this decision will give you `b` itself.

If `b : Bool` is decidable, then `decide (b = true) = b`.


theorem nontrivial_of_ne : ∀ {α : Type u_1} (x y : α), x ≠ y → Nontrivial α := by sorry

This theorem states that for any type `α` and any two elements `x` and `y` of that type, if `x` is not equal to `y`, then `α` is nontrivial. In mathematical terms, a type is nontrivial if it contains at least two distinct elements, thus if there exists two elements that are not equal, this directly confirms the nontriviality of the type.

If `α` has distinct elements `x` and `y`, then `α` is nontrivial.


theorem Set.compl_inter_self : ∀ {α : Type u} (s : Set α), sᶜ ∩ s = ∅ := by sorry

This theorem states that for any set `s` of any type `α`, the intersection of the complement of `s` (denoted as `sᶜ`) with `s` itself, is equal to the empty set. In other words, there are no elements that are both in `s` and not in `s` at the same time, which conforms to the principle of contradiction in set theory.

For any set `s` of type `α`, the intersection of `s` and its complement `sᶜ` is the empty set. (Or, more succinctly: `s ∩ sᶜ = ∅`.)


theorem RingHom.ker_eq_comap_bot :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rcf : RingHomClass F R S] (f : F), RingHom.ker f = Ideal.comap f ⊥ :=
  by sorry

The theorem `RingHom.ker_eq_comap_bot` states that for any given types `R`, `S`, and `F`, along with the condition that `R` and `S` are semirings, `F` is a function-like from `R` to `S`, and there exists a ring homomorphism class between `F`, `R`, and `S`, the kernel of a ring homomorphism `f` is equal to the preimage of the bottom ideal under `f`. In other words, the set of all elements in the domain `R` that map to the zero element in the codomain `S` (which forms an ideal in `R`) is exactly the preimage of the zero ideal (denoted by `⊥`) under the ring homomorphism.

The kernel of a ring homomorphism from a semiring to another semiring equals the preimage of the bottom ideal under the homomorphism.


theorem Set.mem_Ici : ∀ {α : Type u_1} [inst : Preorder α] {a x : α}, x ∈ Set.Ici a ↔ a ≤ x := by sorry

The theorem `Set.mem_Ici` states that for any type `α` with a preorder and any elements `a` and `x` of `α`, `x` belongs to the left-closed right-infinite interval starting at `a` if and only if `a` is less than or equal to `x`. In other words, this theorem describes the condition for a value `x` to be in the interval that starts at `a` and includes all values greater than or equal to `a`.

For any preordered type `α` and elements `a` and `x` of `α`, `x` belongs to the left-closed right-infinite interval starting at `a` if and only if `a` is less than or equal to `x`.


theorem GaloisCoinsertion.l_injective :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : PartialOrder α] [inst_1 : Preorder β],
      GaloisCoinsertion l u → Function.Injective l :=
  by sorry

The theorem `GaloisCoinsertion.l_injective` states that for any two types `α` and `β`, if there is a function `l` from `α` to `β` and a function `u` from `β` to `α`, such that `α` has a partial order and `β` has a preorder, and there is a Galois coinsertion between `l` and `u`, then the function `l` is injective. Here, the injective means that for all `x` and `y` in `α`, if `l(x) = l(y)` then `x = y`. The Galois coinsertion, in this case, is a specific relationship between the functions `l` and `u` related to their ordering properties.

If there is a Galois coinsertion between functions `l: α → β` and `u: β → α` with `α` a partial order and `β` a preorder, then `l` is an injective function.


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

The theorem `GaloisInsertion.l_iSup_u` states that for all types `α` and `β`, and for all functions `l : α → β` and `u : β → α`, given `α` and `β` are both complete lattices, and that there is a Galois insertion between `l` and `u`, then for any function `f : ι → β`, where ι is an arbitrary type, the lift of the supremum (least upper bound) of `u` applied to `f i` for all `i` under `l` equals to the supremum of `f i` for all `i`. Symbolically, this can be expressed as \(l (\bigvee_{i} u(f(i))) = \bigvee_{i} f(i)\).

Given types `α` and `β`, functions `l : α → β` and `u : β → α` between complete lattices with a Galois insertion, and a function `f : ι → β`, the lift of the supremum of `u(f i)` under `l` is equal to the supremum of `f i` for all `i`. Symbolically, \(l (\bigvee\_{i} u(f(i))) = \bigvee\_{i} f(i)\).


UniformEmbedding.embedding

theorem UniformEmbedding.embedding :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformEmbedding f → Embedding f :=
  by sorry

This theorem states that if 'f' is a function from one type 'α' to another type 'β', both equipped with a uniform space structure, and 'f' is a uniform embedding, then 'f' is also an embedding. In the context of topology and metric spaces, a uniform embedding means that the function 'f' not only maps 'α' to 'β' bijectively but also preserves the uniform structure, i.e., 'f' is a homeomorphism and it uniformly continues the given function. An embedding in this context means that 'f' is an injective function that induces a topology on 'α' that makes 'f' a homeomorphism onto its image.

If 'f' is a uniform embedding of a uniform space ('α, dα) into another uniform space ('β, dβ), then 'f' is an embedding of ('α, dα) into ('β, dβ).


theorem Filter.filter_eq : ∀ {α : Type u} {f g : Filter α}, f.sets = g.sets → f = g := by sorry

This theorem states that for any two filters `f` and `g` of the same type `α`, if their sets of elements are equal, then the filters themselves are equal. In other words, two filters are identical if and only if they contain the same sets.

If two filters `f` and `g` over type `α` have equal elements, then `f = g`.


Function.IsFixedPt.eq

/-- If `x` is a fixed point of `f`, then `f x = x`. This is useful, e.g., for `rw` or `simp`. -/
theorem Function.IsFixedPt.eq : ∀ {α : Type u} {f : α → α} {x : α}, Function.IsFixedPt f x → f x = x := by sorry

The theorem `Function.IsFixedPt.eq` states that for any type `α`, any function `f` from `α` to `α`, and any element `x` of `α`, if `x` is a fixed point of the function `f`, then the function `f` applied to `x` equals `x`. In other words, if `x` remains unchanged under the action of `f`, then `f(x) = x`. This theorem can be useful for rewriting or simplification tactics in Lean.

If `f` is a function from type `α` to itself and `x` is a fixed point of `f`, then `f(x) = x`.


theorem Fintype.card_eq_one_iff : ∀ {α : Type u_1} [inst : Fintype α], Fintype.card α = 1 ↔ ∃ x, ∀ (y : α), y = x := by
  sorry

The theorem `Fintype.card_eq_one_iff` states that for every type `α` which is a finite type, the cardinality (number of elements) of `α` is equal to one if and only if there exists an element `x` in `α` such that every element `y` in `α` is equal to `x`. In other words, a finite type has exactly one element if and only if all elements in that type are the same.

A finite type `α` has exactly one element if and only if all elements in `α` are equal.


theorem Multiset.nodup_cons :
    ∀ {α : Type u_1} {a : α} {s : Multiset α}, Multiset.Nodup (a ::ₘ s) ↔ a ∉ s ∧ Multiset.Nodup s := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any multiset `s` of type `α`, the multiset `s` has no duplicates (the condition expressed by `Multiset.Nodup`) after prepending with the element `a` (denoted by `a ::ₘ s`) if and only if two conditions hold: the element `a` is not already in `s` (`a ∉ s`), and `s` itself has no duplicates (`Multiset.Nodup s`).

For any type `α` and element `a` not in a multiset `s` of type `α`, the multiset `a :: s` has no duplicates if and only if `s` itself has no duplicates.


AbsoluteValue.nonneg

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

This theorem states that for any types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, and any absolute value function `abv` from `R` to `S`, the absolute value of any element `x` of `R` is always nonnegative. In mathematical terms, it asserts that for all `x` in `R`, `0 ≤ |x|`.

For any semiring `R`, ordered semiring `S`, and absolute value function `abv` from `R` to `S`, |x| ≥ 0 for all x in R.


theorem MeasureTheory.toMeasure_apply :
    ∀ {α : Type u_1} [ms : MeasurableSpace α] (m : MeasureTheory.OuterMeasure α)
      (h : ms ≤ MeasureTheory.OuterMeasure.caratheodory m) {s : Set α},
      MeasurableSet s → ↑↑(MeasureTheory.OuterMeasure.toMeasure m h) s = ↑m s :=
  by sorry

The theorem `MeasureTheory.toMeasure_apply` states that for any type `α` with an associated measurable space `ms`, an outer measure `m` on `α`, and a set `s` of type `α`, if the measurable space `ms` is a subspace of the Carathéodory-measurable space associated with the outer measure `m` and the set `s` is a measurable set, then the measure of the set `s` under the measure induced by the outer measure `m` is equal to the outer measure of the set `s` under `m`.

If `ms` is a Carathéodory measurable space and `s` is a measurable set in the measurable space `ms` with respect to an outer measure `m`, then `m(s) = (m $|$ ms)(s)`.


theorem Nat.mod_add_mod : ∀ (m n k : ℕ), (m % n + k) % n = (m + k) % n := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `k`, the remainder left when `m` is divided by `n` added to `k` and then the result divided by `n` is equal to the remainder when `m` plus `k` is divided by `n`. In other words, the modulo operation distributes over addition. The theorem is given by the expression `(m % n + k) % n = (m + k) % n`, where `%` denotes the modulo operation.

For any natural numbers `m`, `n`, and `k`, `(m % n + k) % n = (m + k) % n` holds true for the modulo operation.


/-- **Alias** of the forward direction of `isLUB_iff_sSup_eq`. -/
theorem IsLUB.sSup_eq :
    ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, IsLUB s a → sSup s = a := by sorry

The theorem `IsLUB.sSup_eq` states that for any type `α` which has a structure of a complete semilattice with supremum, any set `s` of type `α`, and any element `a` of type `α`, if `a` is a least upper bound of the set `s`, then the supremum of the set `s` is equal to `a`. In other words, if `a` is the smallest element that is greater than or equal to all elements in `s`, then `a` is precisely the supremum of `s`. The theorem is a specific case from a more general theorem `isLUB_iff_sSup_eq`.

If `α` is a complete semilattice with supremum and `a` is the least upper bound of a set `s` in `α`, then `a` equals the supremum of `s`.


Continuous.max

theorem Continuous.max :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α]
      {f g : β → α} [inst_3 : TopologicalSpace β], Continuous f → Continuous g → Continuous fun b => max (f b) (g b) :=
  by sorry

This theorem states that for any two continuous functions `f` and `g` mapping from a topological space `β` to a linearly ordered topological space `α` with an order-closed topology, the function that sends each element of `β` to the maximum of the corresponding elements in `f` and `g` is also continuous. In other words, if `f` and `g` are continuous functions, then the function that takes a point `b` in `β` and maps it to the greater of `f(b)` and `g(b)` is also continuous.

If `f` and `g` are continuous functions mapping from a topological space `β` to a linearly ordered topological space `α` with order-closed topology, then the function that maps each point `b` in `β` to the maximum of `f(b)` and `g(b)` is also continuous.


Ideal.Quotient.eq

theorem Ideal.Quotient.eq :
    ∀ {R : Type u} [inst : CommRing R] {I : Ideal R} {x y : R},
      (Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y ↔ x - y ∈ I :=
  by sorry

The theorem `Ideal.Quotient.eq` states that for any commutative ring `R` and any ideal `I` in `R`, and for any two elements `x` and `y` from the ring `R`, the image of `x` and `y` under the quotient map are equal if and only if the difference of `x` and `y` belongs to the ideal `I`. In other words, the quotient map sends `x` and `y` to the same equivalent class in the quotient ring `R/I` precisely when the difference `x - y` is an element of the ideal `I`.

For any commutative ring R and ideal I, and any x, y in R, the quotient map sends x and y to the same coset in R/I if and only if x - y is in I.


theorem Nat.dvd_refl : ∀ (a : ℕ), a ∣ a := by sorry

This theorem, `Nat.dvd_refl`, states that for any natural number `a`, `a` divides `a`. In the language of number theory, this is saying that any natural number is a divisor of itself. The symbol `∣` is used to represent the "divides" relation.

For all natural numbers `a`, `a` divides `a`. In mathematical notation: ∀ (a : Nat), a | a.


theorem ComplexShape.prev_eq' :
    ∀ {ι : Type u_1} (c : ComplexShape ι) {i j : ι}, c.Rel i j → ComplexShape.prev c j = i := by sorry

This theorem states that for any type `ι`, and for any `ComplexShape` `c` on `ι`, if there is a relation `Rel` from `i` to `j` in `ComplexShape` `c`, then the `prev` function of `ComplexShape` `c` applied to `j` is equal to `i`. In essence, it establishes that if a relation between `i` and `j` exists in `ComplexShape` `c`, then `i` is the 'previous' element of `j` in the `ComplexShape`.

For any `ComplexShape` `c` and elements `i` and `j` of its index type `ι`, if there is a relation from `i` to `j` in `ComplexShape` `c`, then `prev c i = j`.


theorem List.mem_of_ne_of_mem : ∀ {α : Type u_1} {a y : α} {l : List α}, a ≠ y → a ∈ y :: l → a ∈ l := by sorry

This theorem states that for any type `α`, and any elements `a` and `y` of this type, and any list `l` of elements of type `α`, if `a` is not equal to `y` and `a` is an element of the list that results from prepending `y` to `l`, then `a` must be an element of `l`. In other words, if an item is in a list with a head it's not equal to, then it must be somewhere in the tail of the list.

If `a` is distinct from `y` and appears in the list `y :: l`, then `a` is an element of `l`.


theorem Nat.div2_bit : ∀ (b : Bool) (n : ℕ), Nat.div2 (Nat.bit b n) = n := by sorry

This theorem states that for any boolean `b` and natural number `n`, the result of dividing by 2 (using the `Nat.div2` function which takes the floor of `n/2`) the natural number formed by appending the boolean `b` as a binary digit to `n` (using the `Nat.bit` function) is equal to the original number `n`. In other words, appending a binary digit to a number and then halving effectively removes the appended digit.

For any natural number `n` and boolean `b`, `Nat.div2 (Nat.bit0 (Nat.succ n) b) = n`. (Here, `Nat.bit0` is used instead of `Nat.bit` to append the bit at the least significant position.)


theorem List.sublists'_cons :
    ∀ {α : Type u} (a : α) (l : List α),
      List.sublists' (a :: l) = List.sublists' l ++ List.map (List.cons a) (List.sublists' l) :=
  by sorry

The theorem `List.sublists'_cons` states that for all types `α` and any element `a` of type `α` and list `l` of type `List α`, the list of all non-contiguous sublists of the list resulting from prepending `a` to `l` (`a :: l`) is equal to the concatenation of the list of all non-contiguous sublists of `l` and the result of mapping the function `List.cons a` (which prepends `a` to its argument list) over the list of all non-contiguous sublists of `l`. This essentially means that every sublist of `a :: l` either is a sublist of `l`, or is formed by adding `a` to the start of a sublist of `l`.

For all types `α` and lists `l` of `α`, the sublists of `a :: l` are exactly the sublists of `l` together with the lists obtained by prefixing `a` to each sublist of `l`.


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

This theorem states that for any partial equivalence `e` between two types `α` and `β`, and any element `x` of type `β` that lies in the target of `e`, applying the partial equivalence `e` to the result of applying the inverse of `e` (denoted as `PartialEquiv.symm e`) to `x`, results in `x` itself. In other words, it asserts the right inverse property for a partial equivalence, i.e., if we apply the function and then its inverse, we get back to the original element.

For any partial equivalence `e` between types `α` and `β`, if `x` is in the target of `e`, then `e (x) = x ↔ ∃ y : α, e.symm x = y ∧ e y = x`.


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

The theorem `Real.exp_le_exp` states that for all real numbers `x` and `y`, the exponential of `x` is less than or equal to the exponential of `y` if and only if `x` is less than or equal to `y`. This theorem formalizes the monotonicity of the exponential function over the real numbers in Lean 4. In other words, in the context of real numbers, the exponential function preserves the order of its inputs.

For all real numbers x and y, x <= y implies exp x <= exp y.


theorem Filter.gc_map_comap :
    ∀ {α : Type u} {β : Type v} (m : α → β), GaloisConnection (Filter.map m) (Filter.comap m) := by sorry

The theorem `Filter.gc_map_comap` states that for any type `α` and `β`, and any function `m` mapping from `α` to `β`, there is a Galois Connection between the function `Filter.map m`, which transforms a filter on `α` into a filter on `β` by applying `m`, and the function `Filter.comap m`, which computes the preimage of a filter on `β` under `m` to give a filter on `α`. In other words, for all filters `a` on `α` and `b` on `β`, the filter obtained by mapping `a` through `m` is less than or equal to `b` if and only if `a` is less than or equal to the filter obtained by taking the preimage of `b` under `m`. This theorem relates the concept of Galois Connections to the operations of mapping and taking preimages of filters.

For any function `m` between types `α` and `β`, the maps `Filter.map m` and `Filter.comap m` define a Galois connection between filters on `α` and `β`, meaning that `Filter.map m (Filter.downset x a) = Filter.downset (m x) (Filter.map m a)` and `Filter.map m (Filter.upset x a) = Filter.upset (m x) (Filter.comap m a)` for all `x` in `α` and filters `a` on `α`.


/-- If two filters are disjoint, then a function cannot tend to both of them along a non-trivial
filter.  -/
theorem Filter.Tendsto.not_tendsto :
    ∀ {α : Type u} {β : Type v} {f : α → β} {a : Filter α} {b₁ b₂ : Filter β},
      Filter.Tendsto f a b₁ → ∀ [inst : Filter.NeBot a], Disjoint b₁ b₂ → ¬Filter.Tendsto f a b₂ :=
  by sorry

The theorem `Filter.Tendsto.not_tendsto` states that given arbitrary types `α` and `β`, a function `f` from `α` to `β`, a filter `a` on `α`, and two filters `b₁` and `b₂` on `β`, if `f` tends to `b₁` along `a` and `a` is not the trivial filter, then if `b₁` and `b₂` are disjoint filters, `f` cannot tend to `b₂` along `a`. In other words, a function cannot approach two disjoint filters simultaneously along a non-trivial filter.

If a function from a non-trivial filter on one set to disjoint filters on another set tends to one of those filters, it cannot tend to the other filter along the same filter.


theorem Real.cos_pi : Real.cos Real.pi = -1 := by sorry

The theorem `Real.cos_pi` states that the cosine of pi in real numbers is equal to -1. In other words, it asserts that the value of the function `Real.cos` at the point `Real.pi` is -1. This is a standard result in trigonometry, represented here in Lean 4.

The theorem `Real.cos_pi` asserts that `Real.cos (Real.pi) = -1` in Lean 4.


theorem Submodule.mul_le :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {M N P : Submodule R A}, M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P :=
  by sorry

This theorem, `Submodule.mul_le`, states that for any Commutative Semiring `R`, Semiring `A` and an algebra `A` over `R`, and for any submodules `M`, `N`, and `P` of `A`, the product of `M` and `N` is a subset of `P` if and only if for all elements `m` in `M` and `n` in `N`, the product `m * n` is an element of `P`. This is a theorem about the multiplicative properties of submodules in a ring.

For any commutative semirings R, semiring A, algebra A over R, and submodules M, N, and P of A, M * N ⊆ P if and only if m * n ∈ P for all m ∈ M and n ∈ N.


LinearEquiv.surjective

theorem LinearEquiv.surjective :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
      Function.Surjective ⇑e :=
  by sorry

The theorem `LinearEquiv.surjective` states that, for any semirings `R` and `S`, additive commutative monoids `M` and `M₂`, and any modules `M` over `R` and `M₂` over `S`, given any two ring homomorphisms `σ : R →+* S` and `σ' : S →+* R` such that `σ` and `σ'` form a ring homomorphism inverse pair both ways, and given a linear equivalence `e : M ≃ₛₗ[σ] M₂`, the function `e` is surjective. That is, for every element in `M₂`, there exists an element in `M` such that applying the linear equivalence to this element results in the element in `M₂`.

Given any ring homomorphism inverse pair σ : R →+* S and σ' : S →+* R between semirings R and S, and a linear equivalence e : M ≃ₛₗ[σ] M₂ between additive commutative monoids M over R and M₂ over S, e is a surjection.


theorem Nat.ascFactorial_zero : ∀ (n : ℕ), Nat.ascFactorial n 0 = 1 := by sorry

This theorem states that for any natural number `n`, the ascending factorial of `n` with 0 as the second argument is equal to 1. In other words, it states that the product of an empty sequence of consecutive natural numbers, starting from any given natural number `n`, is always 1.

For any natural number `n`, the product of the empty sequence of natural numbers starting from `n` is equal to 1.


theorem map_dvd :
    ∀ {M : Type u_2} {N : Type u_3} [inst : Semigroup M] [inst_1 : Semigroup N] {F : Type u_4} [inst_2 : FunLike F M N]
      [inst_3 : MulHomClass F M N] (f : F) {a b : M}, a ∣ b → f a ∣ f b :=
  by sorry

The theorem `map_dvd` is a statement about the behavior of certain function-like objects under divisibility. Specifically, it says that for all types `M` and `N` with a semigroup structure, any instance of `FunLike` from `M` to `N` that also has a multiplication homomorphism structure (`MulHomClass`), and any elements `a` and `b` of `M`, if `a` divides `b` then the image of `a` under the function divides the image of `b` under the same function. This theorem is a property generally expected of homomorphisms in mathematics, and it expresses that homomorphisms, in some sense, preserve the divisibility relationship between elements.

If `f` is a homomorphism from a semigroup (M, +) to a semigroup (N, +) and `a` divides `b` in M, then `f(a)` divides `f(b)` in N.


theorem CategoryTheory.Limits.IsLimit.uniq_cone_morphism :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {s t : CategoryTheory.Limits.Cone F}, CategoryTheory.Limits.IsLimit t → ∀ {f f' : s ⟶ t}, f = f' :=
  by sorry

This theorem states that for any type `J` (viewed as a category under instance `inst`), any type `C` (viewed as a category under instance `inst_1`), any functor `F` from `J` to `C`, and any two cones `s` and `t` over `F`, if `t` is a limit cone, then any two morphisms `f` and `f'` from `s` to `t` must be identical. This is a restatement of the uniqueness property of limit cones in category theory: any two morphisms from a cone to a limit cone are necessarily the same.

Given any functor F from category J to category C, any limit cone t over F, and any two morphisms f and f' from a cone s to t, if t is a limit cone, then f and f' are equal.


Con.mul

/-- Multiplicative congruence relations preserve multiplication.  -/
theorem Con.mul : ∀ {M : Type u_1} [inst : Mul M] (c : Con M) {w x y z : M}, c w x → c y z → c (w * y) (x * z) := by
  sorry

This theorem states that if we have a congruence relation `c` on a type `M` that has a multiplication operation, then the multiplication operation is preserved under this relation. Formally, if `w` is congruent to `x` and `y` is congruent to `z` under this relation, then the product `w * y` is congruent to `x * z`.

If `c` is a congruence relation on type `M` with multiplication operation, then for all `w ≡x` and `y ≡ z` in `c`, we have `w * y ≡ x * z`.


/-- Also known as the maximality axiom.  -/
theorem CategoryTheory.GrothendieckTopology.top_mem :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C),
      ⊤ ∈ J.sieves X :=
  by sorry

This theorem, also known as the maximality axiom, states that for any category 'C' and any Grothendieck topology 'J' on 'C', the maximal sieve (represented as '⊤') is in the collection of sieves 'J.sieves' for any object 'X' of the category. In other words, in the context of Grothendieck topologies in category theory, the largest possible sieve is always considered a covering sieve for any given object in the category.

In any category with a Grothendieck topology, the maximal sieve is a covering sieve for every object.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.9 :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {a b : E} {r : ℝ}, (b ∈ Metric.sphere a r) = (‖b - a‖ = r) := by
  sorry

This theorem states that for any seminormed add group `E`, and any elements `a` and `b` of `E`, along with a real number `r`, `b` being in the sphere of radius `r` centered at `a` is equivalent to the norm of the difference between `b` and `a` being equal to `r`. In other words, it states that `b` lies on the sphere with center `a` and radius `r` if and only if the distance from `b` to `a` is exactly `r`.

For any seminormed add group `E` and real number `r`, the element `b` lies in the sphere of radius `r` centered at `a` if and only if the norm of `a - b` is equal to `r`.


theorem Summable.comp_injective :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommGroup α] [inst_1 : UniformSpace α]
      [inst_2 : UniformAddGroup α] {f : β → α} [inst_3 : CompleteSpace α] {i : γ → β},
      Summable f → Function.Injective i → Summable (f ∘ i) :=
  by sorry

The theorem `Summable.comp_injective` states that for any three types `α`, `β`, and `γ`, where `α` is an additive commutative group, a uniform space, a uniform additive group, and a complete space, if there is a function `f` from `β` to `α` which is summable, and another function `i` from `γ` to `β` which is injective, then the composition function `f ∘ i` (i.e., `f(i(x))` for all `x` in `γ`) is also summable. This means that if you have an infinite series that sums to a value and you apply an injective function to the indices of this series, the resulting series is also summable.

If `f` is a summable function from an injective `i : γ → β` to an additive commutative group `α`, then the composition `f ∘ i` is also summable.


Partrec.comp

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

The theorem `Partrec.comp` states that for any three types `α`, `β`, and `σ` which are all Primcodable, if we have a partially recursive function `f` from `β` to `σ` and a computable function `g` from `α` to `β`, then the composition of `f` and `g`, i.e., the function that applies `g` to an input from `α` and then applies `f` to the result, is itself partially recursive. This is essentially a statement about the closure of the class of partially recursive functions under function composition with a computable function.

If `f` is a partially recursive function from `β` to `σ` and `g` is a computable function from `α` to `β`, then the function `COMP(g, f)` defined as `COMP(g, f) (x) = f (g (x))` is also partially recursive.


theorem MeasureTheory.condexp_of_stronglyMeasurable :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0)
      [hμm : MeasureTheory.SigmaFinite (μ.trim hm)] {f : α → F'},
      MeasureTheory.StronglyMeasurable f → MeasureTheory.Integrable f μ → MeasureTheory.condexp m μ f = f :=
  by sorry

This theorem states that for any types `α` and `F'` with `F'` being a normed additive commutative group, a normed space over the field of real numbers, and a complete space, and given measurable spaces `m` and `m0` and a measure `μ` such that `m` is a sub-sigma-algebra of `m0`, and `μ` is sigma-finite with respect to the trimmed measure, for any function `f` from `α` to `F'`, if `f` is strongly measurable and integrable with respect to `μ`, then the conditional expectation of `f` with respect to `μ` and `m` is equal to `f` itself. In mathematical terms, if a function is both strongly measurable and has a finite integral, then its conditional expectation is the function itself.

If `α` is a type, `F'` is a complete, normed additive commutative group over the real numbers, `m` is a sub-σ-algebra of a σ-finite measure space `(m0, μ)`, and `f: α → F'` is a strongly measurable and integrable function, then `μ-cond(f) = f`, where `μ-cond(f)` denotes the conditional expectation of `f` with respect to `m`.


/-- An induction principle for additive closure membership. If `p` holds for `0` and all
elements of `s`, and is preserved under addition, then `p` holds for all elements of the
additive closure of `s`. -/
theorem AddSubmonoid.closure_induction :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M} {p : M → Prop} {x : M},
      x ∈ AddSubmonoid.closure s → (∀ x ∈ s, p x) → p 0 → (∀ (x y : M), p x → p y → p (x + y)) → p x :=
  by sorry

The theorem `AddSubmonoid.closure_induction` is an induction principle for membership in the additive closure of a set. In more detail, for any type `M` that is an instance of `AddZeroClass`, a set `s` of elements of type `M`, and a property `p` that holds for each element of type `M`, if an element `x` belongs to the additive closure of the set `s`, `p` holds for `0` and all elements of `s`, and `p` is preserved under addition, then `p` also holds for `x`. In other words, any property of elements of the original set that is closed under addition and holds for the additive identity, also holds for all elements in the additive closure of the set.

If `s` is a set of additive elements in an additive semigroup `M` such that for all `x` in the additive closure of `s`, `p(x)` holds whenever `p(0)` holds and `p(x)` is the sum of `p(a)` and `p(b)` for any `a, b` in `s`, then `p` holds for all elements in the additive closure of `s`.


theorem Function.Antiperiodic.sub_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddGroup α] [inst_1 : InvolutiveNeg β],
      Function.Antiperiodic f c → ∀ (x : α), f (x - c) = -f x :=
  by sorry

The theorem `Function.Antiperiodic.sub_eq` states that for any types `α` and `β`, a function `f` from `α` to `β`, and a value `c` of type `α`, under the conditions that `α` forms an additive group and `β` has an involutive negation operation, if the function `f` is antiperiodic with antiperiod `c`, then for every `x` of type `α`, the value of `f` at `x - c` is equal to the negation of `f` at `x`. In simpler terms, if shifting the input of `f` by `c` results in the negation of `f`, then the same holds if we shift the input by `-c`.

If `f` is an antiperiodic function from an additive group `α` to a type `β` with involutive negation, with antiperiod `c`, then `f(x - c) = -f(x)` for all `x` in `α`.


theorem Finset.image₂_inter_subset_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s s' : Finset α}
      {t : Finset β} [inst_1 : DecidableEq α],
      Finset.image₂ f (s ∩ s') t ⊆ Finset.image₂ f s t ∩ Finset.image₂ f s' t :=
  by sorry

The theorem `Finset.image₂_inter_subset_left` states that, for any types `α`, `β`, and `γ` with `γ` having decidable equality, for any binary function `f` from `α` and `β` to `γ`, for any finite sets `s`, `s'` of `α`, and `t` of `β`, with `α` having decidable equality, the image under `f` of the intersection of `s` and `s'` with `t` is a subset of the intersection of the images under `f` of `s` with `t` and `s'` with `t`.

In mathematical terms, this is saying that given a function `f: α × β → γ`, and finite sets `s, s' ⊆ α`, `t ⊆ β`, we have `f((s ∩ s') × t) ⊆ f(s × t) ∩ f(s' × t)`. Here, `f(S × T)` for sets `S ⊆ α` and `T ⊆ β` denotes the image of the cartesian product `S × T` under the function `f`.

For any function $f:\alpha \times \beta \to \gamma$ with $\gamma$ having decidable equality, and finite sets $s, s' \subseteq \alpha$, $t \subseteq \beta$ of type $\alpha$ with decidable equality, we have $f((s \cap s') \times t) \subseteq f(s \times t) \cap f(s' \times t)$.


theorem comp_mem_uniformity_sets :
    ∀ {α : Type ua} [inst : UniformSpace α] {s : Set (α × α)}, s ∈ uniformity α → ∃ t ∈ uniformity α, compRel t t ⊆ s :=
  by sorry

This theorem states that for any type `α` equipped with a UniformSpace structure and for any set `s` of pairs of `α`, if `s` is a member of the uniformity filter of `α`, then there exists another set `t` in the uniformity filter such that the composition of relations `t` with itself is a subset of `s`. In other words, if `s` is a set of "sufficiently close" pairs in our uniform space, we can find another set of "sufficiently close" pairs `t` such that for any pair in `t`, there's a "middle" element making this pair and another pair in `t` "close" in the sense of belonging to `s`.

Given a UniformSpace `α` and a set `s` of pairwise `α × α` in its uniformity filter, there exists a set `t` in the uniformity filter such that `t` is closed under composition with itself and is contained in `s`.


theorem Filter.map₂_mono_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β},
      f₁ ≤ f₂ → Filter.map₂ m f₁ g ≤ Filter.map₂ m f₂ g :=
  by sorry

The theorem `Filter.map₂_mono_right` states that for any types `α`, `β`, and `γ`, a binary function `m : α → β → γ`, two filters `f₁` and `f₂` on `α`, and a filter `g` on `β`, if `f₁` is a subfilter of `f₂` (i.e., `f₁ ≤ f₂`), then the image of the binary function `m` under the filter `f₁` and `g` is a subfilter of the image of `m` under the filter `f₂` and `g` (i.e., `Filter.map₂ m f₁ g ≤ Filter.map₂ m f₂ g`). This theorem essentially states a monotonicity property of the `map₂` operation with respect to the right argument.

If `f₁ ≤ f₂` are filters on `α` and `γ` is a type, then the image of `f₁` under the function `m : α → β → γ` and filter `g` on `β`, `Filter.map₂ m f₁ g`, is a subfilter of the image of `f₂` under the same function and filter, `Filter.map₂ m f₂ g`.


theorem Finset.min'_mem :
    ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty), Finset.min' s H ∈ s := by sorry

This theorem states that for any given type `α` which has a linear order, and any nonempty finite set `s` of elements of that type, the minimum element of `s` (denoted by `Finset.min' s H` where `H` is a proof of nonemptiness) is indeed an element of `s`. In mathematical terms, if `s` is a nonempty finite set in a totally ordered set, the minimum element of `s` belongs to `s`.

If `s` is a nonempty finite subset of a totally ordered set `α`, then `Finset.min s` is an element of `s`.


theorem Nat.count_eq_card_filter_range :
    ∀ (p : ℕ → Prop) [inst : DecidablePred p] (n : ℕ), Nat.count p n = (Finset.filter p (Finset.range n)).card := by
  sorry

This theorem states that for any given predicate `p` on natural numbers that is decidable and any natural number `n`, the count of natural numbers `k` less than `n` that satisfy the predicate `p` is equal to the cardinality (size) of the set obtained by filtering the set of natural numbers less than `n` (represented as a finite set) according to the predicate `p`. In other words, it establishes an equivalence between counting elements that satisfy a predicate in a list and filtering those elements in a set.

For any decidable predicate `p` on natural numbers, the number of natural numbers less than `n` satisfying `p` is equal to the size of the filter of natural numbers less than `n` that satisfy `p`.


/-- `Fintype.prod_equiv` is a specialization of `Finset.prod_bij` that
automatically fills in most arguments.

See `Equiv.prod_comp` for a version without `h`.
 -/
theorem Fintype.prod_equiv :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : CommMonoid α]
      (e : ι ≃ κ) (f : ι → α) (g : κ → α),
      (∀ (x : ι), f x = g (e x)) → (Finset.prod Finset.univ fun x => f x) = Finset.prod Finset.univ fun x => g x :=
  by sorry

The theorem `Fintype.prod_equiv` states that for any types `ι`, `κ`, and `α` with `ι` and `κ` being finite types and `α` being a type with a commutative multiplication, given a bijection `e` from `ι` to `κ`, and any two functions `f` from `ι` to `α` and `g` from `κ` to `α` such that `f` at any `x` in `ι` is equal to `g` at `e x` in `κ`, then the product of `f x` as `x` ranges over all elements of type `ι` is equal to the product of `g x` as `x` ranges over all elements of type `κ`. In other words, it says that the product of the function values over a finite set is invariant under a renaming of the elements of the set, provided the renaming is a bijection and the function is adapted accordingly.

For finite types `ι` and `κ` and a commutative type `α` with a bijection `e` between them, if functions `f : ι → α` and `g : κ → α` satisfy `f x = g (e x)` for all `x`, then the product of `f` is equal to the product of `g`.


theorem zpow_mul : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), a ^ (m * n) = (a ^ m) ^ n := by sorry

This theorem, `zpow_mul`, states that for any type `α` that has a DivisionMonoid structure, and for any object `a` of type `α` and any integers `m` and `n`, the power of `a` to the product of `m` and `n` is the same as the power of `a` to the `m` raised to the `n`. In mathematical terms, it essentially states that `a^(m*n) = (a^m)^n`. This is a standard property of exponentiation in the context of division monoids.

For any object `a` in a type `α` with DivisionMonoid structure, `a^(m*n) = (a^m)^n`.


theorem uniformity_eq_comap_nhds_zero :
    ∀ (α : Type u_1) [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α],
      uniformity α = Filter.comap (fun x => x.2 - x.1) (nhds 0) :=
  by sorry

The theorem `uniformity_eq_comap_nhds_zero` states that for any type `α` that has a uniform space structure, an additive group structure, and is a uniform additive group, the uniformity of `α` is equal to the filter obtained by applying the `comap` function to the difference function `(fun x => x.2 - x.1)` and the neighborhood filter at `0`. In essence, it articulates a connection between the uniformity of the type and the neighborhood of `0` under the operation of subtraction in the context of uniform additive groups.

For any uniform additive group α, the uniformity of α is equal to the filter obtained by applying the `comap` function to the difference function and the neighborhood filter at 0.


theorem continuous_nnnorm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E], Continuous fun a => ‖a‖₊ := by sorry

This theorem states that for any type `E` that has an instance of `SemionormedAddGroup`, the non-negative norm function, which takes a value `a` and returns its non-negative norm `‖a‖₊`, is continuous. In mathematical terms, if you have a seminormed additive group, the operation of finding the non-negative norm of any element in that group is a continuous operation.

For any seminormed add group `E`, the non-negative norm function `‖._‖₊ : E → ℝ` is a continuous function.


theorem measurableSet_lt :
    ∀ {α : Type u_1} {δ : Type u_5} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : MeasurableSpace δ] [inst_4 : LinearOrder α]
      [inst_5 : OrderClosedTopology α] [inst : SecondCountableTopology α] {f g : δ → α},
      Measurable f → Measurable g → MeasurableSet {a | f a < g a} :=
  by sorry

The theorem `measurableSet_lt` states that for any two functions `f` and `g` from a measurable space `δ` to a linearly ordered topological space `α`, if both `f` and `g` are measurable functions, then the set of all elements `a` in `δ` such that `f(a)` is less than `g(a)` is also a measurable set. This means, in terms of properties of measurable spaces, that if we look at the set of all inputs where `f` is less than `g`, this set is nicely behaved from a measure-theoretic perspective. This result relies on `α` having a topology compatible with its linear order (i.e., it is an order-closed topology) and being second-countable, which roughly means that it has a countable base for its topology.

If `δ` is a measurable space, `α` is a linearly ordered, second-countable topological space with an order-closed topology, and `f` and `g` are measurable functions from `δ` to `α`, then the set {`a` in `δ` | `f(a)` < `g(a)`} is a measurable subset of `δ`.


theorem Finsupp.coe_smul :
    ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M),
      ⇑(b • v) = b • ⇑v :=
  by sorry

This theorem, `Finsupp.coe_smul`, states that for any types `α`, `M`, and `R` given that `M` has a zero element and `R` and `M` form a scalar multiplication zero class, for any scalar `b` of type `R` and any function `v` from `α` to `M`, the result of applying (or 'coercing') the function resulting from scalar multiplication of `b` and `v` is equivalent to the result of scalar multiplication of `b` and the result of applying `v`. In other words, it describes a property of scalar multiplication with respect to function application which is distributive in nature.

For any type `α`, scalar ring `R`, zero element `0` of `R`, and function `v` from `α` to an `R`-module `M`, the coercion of the scalar multiplication of `b` in `R` with the function `v` is equal to the function obtained by applying scalar multiplication to each element in the domain of `v` with `b` and then applying `v`.


theorem Set.compl_union_self : ∀ {α : Type u} (s : Set α), sᶜ ∪ s = Set.univ := by sorry

The theorem `Set.compl_union_self` states that for any set `s` of any type `α`, the union of the set `s` and its complement `sᶜ` (i.e., the set of all elements not in `s`) is `Set.univ`, the universal set of type `α`. In other words, every element of type `α` is either in `s` or not in `s`. This is a formalization of the principle of excluded middle in the context of sets.

For any set `s` of type `α`, `s ∪ sᶜ = Set.univ` (the universal set of type `α`).


MeasureTheory.Integrable.congr

theorem MeasureTheory.Integrable.congr :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f g : α → β}, MeasureTheory.Integrable f μ → f =ᶠ[MeasureTheory.Measure.ae μ] g → MeasureTheory.Integrable g μ :=
  by sorry

The theorem `MeasureTheory.Integrable.congr` states that given any two functions `f` and `g` from a measurable space `α` to a normed additive commutative group `β`, and a measure `μ` on the space `α`, if the function `f` is integrable with respect to the measure `μ` and the function `f` equals to the function `g` almost everywhere with respect to the measure `μ`, then the function `g` is also integrable with respect to the measure `μ`. In other words, the integrability of a function is preserved under equality almost everywhere.

If two measurable functions from a measurable space to a normed additive commutative group are equal almost everywhere with respect to a measure, and one is integrable, then the other is also integrable.


theorem Finset.card_cons : ∀ {α : Type u_1} {s : Finset α} {a : α} (h : a ∉ s), (Finset.cons a s h).card = s.card + 1 :=
  by sorry

The theorem `Finset.card_cons` states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, if `a` does not belong to `s`, then the cardinality (i.e., the number of elements) of the set formed by adding `a` to `s` (using the `Finset.cons` function) is equal to the cardinality of `s` plus one. In more mathematical terms, if $a \notin s$, then $| \{a\} \cup s | = |s| + 1$.

For any type `α` and finite set `s` of type `α`, if `a` is not an element of `s`, then the cardinality of `s ∪ {a}` equals the cardinality of `s` plus one.


theorem Complex.cos_zero : Complex.cos 0 = 1 := by sorry

The theorem `Complex.cos_zero` states that the cosine of zero in the complex number system is equal to one. This is derived from the definition of the complex cosine function, which is defined in terms of the exponential function. In more mathematical terms, this theorem is stating that `cos(0) = 1` for complex numbers.

The theorem asserts that the complex cosine of zero is equal to one, i.e., `cos(0) = 1` in the complex number system.


theorem MeasureTheory.Measure.prod_apply :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν] {s : Set (α × β)},
      MeasurableSet s → ↑↑(MeasureTheory.Measure.prod μ ν) s = ∫⁻ (x : α), ↑↑ν (Prod.mk x ⁻¹' s) ∂μ :=
  by sorry

This theorem, called `MeasureTheory.Measure.prod_apply`, states that for any types `α` and `β`, given the measurable spaces on `α` and `β`, a measure `μ` on `α`, a sigma-finite measure `ν` on `β`, and a measurable set `s` of pairs `(α, β)`, the measure of `s` with respect to the product measure of `μ` and `ν` is equal to the integral over `α` of the measure of the pre-image of `s` under the function that pairs `x` with elements of `β`, with respect to the measure `μ`. This is a formalization of the property of product measures in measure theory.

For measurable spaces (α, μ) and (β, ν), and measurable set S of pairs (α, β), the product measure μ × ν of μ and ν satisfies (μ × ν)(S) = ∫x:α. μ( {α : α | (α, ∃β. (α, β) ∈ S) } ) dμ.


theorem Finset.image₂_union_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s s' : Finset α}
      {t : Finset β} [inst_1 : DecidableEq α],
      Finset.image₂ f (s ∪ s') t = Finset.image₂ f s t ∪ Finset.image₂ f s' t :=
  by sorry

The theorem `Finset.image₂_union_left` states that for any types `α`, `β`, `γ`, a binary function `f : α → β → γ`, two finite sets `s` and `s'` of type `α`, and a finite set `t` of type `β`, the image of the function `f` over the union of `s` and `s'` and `t` is equal to the union of the image of `f` over `s` and `t` and the image of `f` over `s'` and `t`. Here, the image of a function over a finite set is defined as the set of all possible outputs of the function when applied to elements in the set. This theorem essentially reflects the distributive property of union over function application.

For functions `f : α → β → γ`, sets `s : Finset α`, `s' : Finset α`, and `t : Finset β`, the image of `f` over the union of `s` and `t` is equal to the union of the images of `f` over `s` and `t` and over `s'` and `t`.


Set.OrdConnected.isPreconnected

theorem Set.OrdConnected.isPreconnected :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {s : Set α}, Set.OrdConnected s → IsPreconnected s :=
  by sorry

This theorem states that for any type `α` that has the structure of both a conditionally complete linear order and a topological space with an order topology, and is densely ordered, if a set `s` of type `α` is order-connected (every interval [a, b] with a, b in the set lies within the set), then it is also preconnected.

In a preconnected set, there is no non-trivial open partition: for any two open sets `u` and `v`, if the set `s` is a subset of the union of `u` and `v`, and `s` intersects both `u` and `v`, then it must also intersect the intersection of `u` and `v`. This intersection is nonempty.

In a densely ordered type `α` with both a conditional complete linear order and a topology, every order-connected subset is preconnected.


theorem Finset.coe_Ici :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] (a : α), ↑(Finset.Ici a) = Set.Ici a := by
  sorry

This theorem states that for any type `α` (assumed to have a preorder and locally finite order-top structure) and any element `a` of type `α`, the coercion of the finset of all elements greater than or equal to `a` (`Finset.Ici a`) to a set is equal to the set of all elements greater than or equal to `a` (`Set.Ici a`). In other words, the set of elements in the finset that are greater than or equal to a given value `a` is the same as the set of all elements in the type that are greater than or equal to `a`.

For any type `α` with preorder and locally finite order-topology, and any `a` in `α`, the set `{x : α | x ≥ a}` is equal to the finset `Finset.Ici a`.


theorem Finset.coe_Iic :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α), ↑(Finset.Iic a) = Set.Iic a := by
  sorry

The theorem `Finset.coe_Iic` states that for any type `α` that has a preorder and is a locally finite order at the bottom (those where every bounded below set has an infimum), and for any element `a` of type `α`, the coercion of the finite set of elements `x` such that `x` is less than or equal to `a` (denoted as `Finset.Iic a`) into a set is equal to the left-infinite, right-closed interval of all `x` in `α` such that `x` is less than or equal to `a` (denoted as `Set.Iic a`). In other words, the function `Finset.coe_Iic` asserts the equivalence of the finite set and the infinite set representations of an interval bounded on one side.

The theorem `Finset.coe_Iic` asserts that the coercion of the finite set of elements less than or equal to an element `a` in a locally finite order type `α` is equal to the left-infinite, right-closed interval of elements less than or equal to `a` in `α`.


theorem dvd_pow_self : ∀ {α : Type u_1} [inst : Monoid α] (a : α) {n : ℕ}, n ≠ 0 → a ∣ a ^ n := by sorry

This theorem states that for any type `α` which forms a Monoid, and any element `a` of type `α`, `a` divides `a` to the power of `n` for any natural number `n` that is not zero. In mathematical terms, if `a` is an element of a Monoid and `n` is a non-zero natural number, then `a` divides `a^n`.

For any monoid `α` and its element `a`, and any non-zero natural number `n`, `a` divides `a^n`.


OrderEmbedding.monotone

theorem OrderEmbedding.monotone :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β), Monotone ⇑f := by sorry

The theorem `OrderEmbedding.monotone` states that for any two types `α` and `β` with a preorder relation, any order-embedding function `f` from `α` to `β` is monotone. In other words, if `α` and `β` are preordered sets, and `f` is a function that preserves the order from `α` to `β`, then for any two elements `a` and `b` in `α` where `a` is less than or equal to `b`, the image of `a` under `f` is less than or equal to the image of `b` under `f`.

If `f` is an order-embedding function from preordered sets `(α, ≤α)` to `(β, ≤β)`, then for all `a ≤ b` in `α`, we have `f(a) ≤ f(b)` in `β`.


IsIdempotentElem.eq

theorem IsIdempotentElem.eq : ∀ {M : Type u_1} [inst : Mul M] {p : M}, IsIdempotentElem p → p * p = p := by sorry

This theorem states that for any type `M` equipped with a multiplication operation, if an element `p` of `M` is idempotent (which means that `p * p = p`), then the theorem guarantees that indeed `p * p = p`. In essence, it confirms the property defined by `IsIdempotentElem`, which is being true for idempotent elements.

If `M` is a type with multiplication and `p` is an idempotent element in `M` (i.e., `p * p = p`), then `p * p` equals `p`.


HEq.symm

theorem HEq.symm : ∀ {α β : Sort u} {a : α} {b : β}, HEq a b → HEq b a := by sorry

This theorem states that heterogeneous equality (`HEq`) in Lean 4 is symmetrical. Specifically, for any two types `α` and `β` in a given sort `u`, and any two values `a` of type `α` and `b` of type `β`, if `a` is heterogeneously equal to `b`, then `b` is also heterogeneously equal to `a`. Heterogeneous equality allows comparison of values of different types, contrasting with homogeneous equality which requires both values to be of the same type.

For all types `α` and `β` in sort `u` and values `a : α` and `b : β`, if `a =_|_ b` then `b =_|_ a`, where `=_|_` denotes heterogeneous equality.


ENNReal.trichotomy

theorem ENNReal.trichotomy : ∀ (p : ENNReal), p = 0 ∨ p = ⊤ ∨ 0 < p.toReal := by sorry

The theorem `ENNReal.trichotomy` states that for every extended nonnegative real number `p`, one and only one of the following three conditions holds: `p` is equal to zero, `p` is equal to positive infinity (denoted by '⊤'), or the real number representation of `p` is strictly greater than zero.

Every extended nonnegative real number `p` is equal to zero, positive infinity, or lies strictly between them.


/-- A countably generated filter admits a basis formed by an antitone sequence of sets.  -/
theorem Filter.exists_antitone_basis :
    ∀ {α : Type u_1} (f : Filter α) [inst : Filter.IsCountablyGenerated f], ∃ x, Filter.HasAntitoneBasis f x := by sorry

This theorem states that for any countably generated filter `f` over a type `α`, there exists a sequence `x` such that `x` forms an antitone basis for the filter `f`. In other words, if a filter is generated by countably many sets, it's possible to find a sequence of sets that descends (each set is contained in the ones before it) and can serve as a base for the filter.

For any countably generated filter on a type, there exists a countable antichain that generates the filter.


theorem List.Nodup.of_map :
    ∀ {α : Type u} {β : Type v} (f : α → β) {l : List α}, List.Nodup (List.map f l) → List.Nodup l := by sorry

This theorem states that for any types `α` and `β`, and for any function `f : α → β`, if a list `l` of type `α` doesn't have any duplicates after applying the function `f` to each of its elements (i.e., the list obtained by `List.map f l` has no duplicates), then it can be concluded that the original list `l` itself also doesn't have any duplicates. In other words, no-duplication is preserved under the mapping operation.

If `f : α -> β` is a function without duplicates on the list `l : List α`, then `l` itself is a list without duplicates.


theorem Nat.mod_self : ∀ (n : ℕ), n % n = 0 := by sorry

This theorem states that for every natural number `n`, the remainder of `n` divided by itself is always `0`. In other words, any natural number `n` modulo `n` equals `0`. This corresponds to the mathematical concept that any number is exactly divisible by itself, leaving no remainder.


AffineIsometry.isometry

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

The theorem `AffineIsometry.isometry` states that for any normed field `𝕜`, seminormed add-commutative group `V` and `V₂`, normed spaces over `𝕜` for `V` and `V₂`, pseudometric spaces `P` and `P₂`, where `V` and `V₂` are normed add-torsors for `P` and `P₂` respectively, the function `f` which is an affine isometry from `P` to `P₂` over `𝕜`, is an isometry. In other words, it preserves the edistance, meaning that the edistance between the images of any two points under `f` is equal to the edistance between the points themselves in the original space.

If `f` is an affine isometry from a normed add-torsor `(V, P)` to a normed add-torsor `(V₂, P₂)` over a normed field `𝕜`, then `f` preserves the Euclidean distance, i.e., `d(x, y) = d(f(x), f(y))` for all `x, y` in `V`.


theorem Set.nonempty_Iio :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α} [inst_1 : NoMinOrder α], Set.Nonempty (Set.Iio a) := by sorry

This theorem, `Set.nonempty_Iio`, states that for any type `α` equipped with a preorder and a property that it does not have a minimal element (`NoMinOrder`), the left-infinite right-open interval `(Set.Iio a)` is nonempty. In other words, there always exists an element `x` in the type `α` such that `x` is less than `a`. This is expressed using the property `Set.Nonempty` which is a way of stating that a set is not empty.

If `α` is a type equipped with a preorder and has no minimal element, then the left-infinite right-open interval `(Set.Iio a)` of `α` is nonempty.


theorem Set.nonempty_Ioi :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α} [inst_1 : NoMaxOrder α], Set.Nonempty (Set.Ioi a) := by sorry

The theorem `Set.nonempty_Ioi` states that for any type `α` that has a `Preorder` relationship (which means that it has a binary relation that is reflexive and transitive) and a property of `NoMaxOrder` (which means there is no maximum element), and for any element `a` of type `α`, the set of elements that are greater than `a` (`Set.Ioi a`) is non-empty. In other words, there is always an element in type `α` that is larger than `a`.

For any type `α` with a `Preorder` and `NoMaxOrder` relation, the set of elements strictly greater than any given element `a` is non-empty.


theorem Set.nonempty_Ioc : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Nonempty (Set.Ioc a b) ↔ a < b := by
  sorry

The theorem `Set.nonempty_Ioc` states that for any type `α` with a preorder (a binary relation that is reflexive and transitive) and any two elements `a` and `b` of that type, the interval `(a, b]` (i.e., the set of all elements `x` such that `a < x ≤ b`) is nonempty (i.e., contains at least one element) if and only if `a < b`. This essentially says that an interval `(a, b]` has elements if `a` is strictly less than `b`.

For any type with a preorder, the interval (a, b] is nonempty if and only if a < b.


theorem Submodule.Quotient.mk_eq_zero :
    ∀ {R : Type u_1} {M : Type u_2} {x : M} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (p : Submodule R M), Submodule.Quotient.mk x = 0 ↔ x ∈ p :=
  by sorry

The theorem `Submodule.Quotient.mk_eq_zero` states that for any ring `R`, any additive commutative group `M`, and any module `M` over `R`, for any submodule `p` of `M` and any element `x` of `M`, the quotient of `x` by `p` (represented by `Submodule.Quotient.mk x`) is equal to zero if and only if `x` is an element of the submodule `p`. In other words, when considering the quotient space `M/p`, an element `x` in `M` becomes zero if it belongs to the submodule `p` being quotiented out.

For any ring `R`, additive commutative group `M`, module `M` over `R`, submodule `p` of `M`, and element `x` in `M`, `Submodule.Quotient.mk x = 0` if and only if `x` is in `p` in the quotient space `M/p`.


/-- If `f` is a nontrivial countably generated filter, then there exists a sequence that converges
to `f`.  -/
theorem Filter.exists_seq_tendsto :
    ∀ {α : Type u_3} (f : Filter α) [inst : Filter.IsCountablyGenerated f] [inst : Filter.NeBot f],
      ∃ x, Filter.Tendsto x Filter.atTop f :=
  by sorry

The theorem `Filter.exists_seq_tendsto` states that for any nontrivial countably generated filter `f` on a type `α`, there exists a sequence `x` that converges to `f`. In other words, for every neighborhood of `f`, all but finitely many elements of the sequence `x` are in that neighborhood. This is the notion of the sequence `x` tending to the filter `f` as it goes to infinity.

For every nontrivial countably generated filter `f` on type `α`, there exists a sequence `x : α^ℕ` such that for every neighborhood `n` of `f`, all but finitely many elements of `x` belong to `n`.


theorem Num.ofNat'_zero : Num.ofNat' 0 = 0 := by sorry

The theorem `Num.ofNat'_zero` states that when the function `Num.ofNat'`, which converts a natural number (`Nat`) to a numerical value (`Num`), is applied to the natural number zero, it returns the numerical value zero. This function uses a binary recursive method to compute the corresponding `Num` value of a `Nat` value.

The theorem `Num.ofNat'_zero` asserts that `Num.ofNat' 0 = 0`.


theorem Int.dvd_iff_emod_eq_zero : ∀ (a b : ℤ), a ∣ b ↔ b % a = 0 := by sorry

This theorem states that for any two integers `a` and `b`, `a` divides `b` if and only if the remainder of `b` divided by `a` equals zero. This is a reciprocal relationship, meaning that if `a` divides `b` then `b` modulus `a` will be zero, and conversely, if `b` modulus `a` equals zero then `a` is a divisor of `b`. This theorem is a fundamental property of integral division.

For integers `a` and `b`, `a` divides `b` if and only if `b` mod `a` = 0.


theorem Int.ofNat_one : ↑1 = 1 := by sorry

This is a theorem named `Int.ofNat_one` in Lean 4, which states that the integer representation of the natural number 1 is equal to 1. In other words, when the natural number 1 is cast to an integer, the resulting integer is still 1.

The theorem `Int.ofNat_one` in Lean 4 asserts that the conversion of the natural number 1 to an integer results in the integer 1. In mathematical notation, 1 = (1 : int).


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

This theorem, named `Eq.not_gt`, states that for any type `α` that has a preorder relationship, and for any two elements `x` and `y` of this type, if `x` equals `y`, then it is not true that `y` is less than `x`. In simple terms, if `x` and `y` are equal, `y` cannot be less than `x`, which aligns with the basic understanding of equality and ordering.

For any type with a preorder relation, if x equals y, then y is not less than x.


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

This theorem states that for any type `α` that has a preorder, and any two elements `a` and `b` of that type, the left-closed right-infinite interval starting at `a` is a subset of the left-closed right-infinite interval starting at `b` if and only if `b` is less than or equal to `a`. In more mathematical terms, it asserts that for all `a` and `b` in a preordered set, $[a, \infty)$ is contained in $[b, \infty)$ if and only if $b \leq a$.

For any preordered type `α`, elements `a` and `b` in `α` satisfy $[a, \infty) \subseteq [b, \infty)$ if and only if `b` is less than or equal to `a`.


Real.IsConjExponent.pos

theorem Real.IsConjExponent.pos : ∀ {p q : ℝ}, Real.IsConjExponent p q → 0 < p := by sorry

This theorem states that for any two real numbers `p` and `q`, if `p` and `q` are conjugate exponents (as defined by the `Real.IsConjExponent` predicate), then `p` must be greater than zero. Essentially, this is a property about the relationship between conjugate exponents in real numbers.

If `p` and `q` are real numbers such that they are conjugate exponents (`Real.IsConjExponent p q` holds), then `p` is positive (`0 < p`).


id.def

theorem id.def : ∀ {α : Sort u} (a : α), id a = a := by sorry

This theorem states that for any type `α`, applying the identity function `id` to any element `a` of that type will return the element itself. In other words, for any type and its element, `id a` is always equal to `a`. This is a fundamental property of identity functions in mathematics.

For all types `α` and elements `a` of type `α`, `id a = a`.


theorem Polynomial.eq_C_content_mul_primPart :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] (p : Polynomial R),
      p = Polynomial.C (Polynomial.content p) * Polynomial.primPart p :=
  by sorry

The theorem `Polynomial.eq_C_content_mul_primPart` states that for any polynomial `p` over a Commutative Ring `R` that also is a Domain and a Normalized GCD Monoid, `p` is equal to the product of a constant polynomial (whose constant is the greatest common divisor of the coefficients of `p`) and the primitive part of `p`. In essence, this theorem is expressing that any polynomial can be represented as a product of a constant polynomial and its primitive part.

For any polynomial `p` over a commutative ring `R` that is a domain and a normalized GCD monoid, `p` equals the product of the constant polynomial with the greatest common divisor of its coefficients and the primitive part of `p`.


theorem Equiv.addRight_symm :
    ∀ {G : Type u_10} [inst : AddGroup G] (a : G), (Equiv.addRight a).symm = Equiv.addRight (-a) := by sorry

The theorem `Equiv.addRight_symm` states that for any type `G` that forms an additive group, for every element `a` of `G`, the inverse of the permutation resulting from right addition by `a` is the same as the permutation resulting from right addition by `-a`. In other words, adding `a` to the right and then adding `-a` to the right is equivalent to doing nothing, demonstrating the symmetry of right addition in an additive group.

For any additive group G and element a in G, the right addition by a and then by -a is equal to the identity permutation on G.


theorem inf_le_of_left_le : ∀ {α : Type u} [inst : SemilatticeInf α] {a b c : α}, a ≤ c → a ⊓ b ≤ c := by sorry

This theorem states that for any type `α` that has an instance of a semilattice with an infimum operation (denoted by `⊓`), given any three elements `a`, `b`, and `c` of type `α`, if `a` is less than or equal to `c`, then the infimum (`⊓`) of `a` and `b` is also less than or equal to `c`. This is a property of semilattices where the infimum of any two elements is less than or equal to any element greater than or equal to both of them.

If `α` is a semilattice with an infimum operation `⊓`, then for all `a`, `b`, and `c` in `α` with `a ≤ c`, it follows that `a ⊓ b ≤ c`.


/-- Given a point, a bounded subset is included in some ball around this point  -/
theorem Metric.isBounded_iff_subset_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} (c : α),
      Bornology.IsBounded s ↔ ∃ r, s ⊆ Metric.closedBall c r :=
  by sorry

This theorem states that for any given point `c` in a pseudo-metric space `α`, a subset `s` of `α` is bounded with respect to the associated bornology if and only if there exists a real number `r` such that `s` is a subset of the closed ball around `c` with radius `r`. A closed ball in this context is defined as the set of all points `y` in `α` such that the distance from `y` to `c` is less than or equal to `r`.

A subset of a pseudo-metric space is bounded with respect to the associated bornology if and only if it is contained in the closed ball around some point with a finite radius.


theorem Multiset.noncommProd_coe :
    ∀ {α : Type u_3} [inst : Monoid α] (l : List α) (comm : Set.Pairwise {x | x ∈ ↑l} Commute),
      Multiset.noncommProd (↑l) comm = List.prod l :=
  by sorry

This theorem, `Multiset.noncommProd_coe`, states that for any type `α` that forms a monoid, given a list `l` of elements of `α` such that each pair of distinct elements in `l` commute (i.e., their multiplication is commutative), when `l` is considered as a multiset and its elements' non-commutative product is calculated using `Multiset.noncommProd`, the result is equal to the usual product of the list `l` computed using `List.prod`. In simpler terms, even if we treat our list as a multiset and consider a non-commutative product, as long as all elements commute, we get the same result as the standard list product.

For any commutative monoid type `α` and list `l` of `α` such that each pair of distinct elements commutes, `Multiset.noncommProd l = List.prod l`.


/-- Continuity from below: the measure of the union of a directed sequence of (not necessarily
-measurable) sets is the supremum of the measures.  -/
theorem MeasureTheory.measure_iUnion_eq_iSup :
    ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      {s : ι → Set α}, Directed (fun x x_1 => x ⊆ x_1) s → ↑↑μ (⋃ i, s i) = ⨆ i, ↑↑μ (s i) :=
  by sorry

The theorem `MeasureTheory.measure_iUnion_eq_iSup` states that for any types `α` and `ι`, a measurable space `m` over `α`, a measure `μ` on that measurable space, and a countable family of sets `s` indexed by `ι`, if the family of sets is directed with respect to the subset relation (i.e., for any two sets in the family, there is another set in the family that contains both), then the measure of the union of all sets in the family equals the supremum of the measures of the individual sets in the family. In terms for measure theory, this property is referred to as "continuity from below".

For any measurable space `(α, m)`, measure `μ`, and countable family `{S_i}_ι` of measurable sets directed by subset relation, `μ(⋃_ι S_i) = ‾sup_ι μ(S_i)`.


theorem LieModule.lowerCentralSeries_succ :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (k : ℕ),
      LieModule.lowerCentralSeries R L M (k + 1) = ⁅⊤, LieModule.lowerCentralSeries R L M k⁆ :=
  by sorry

The theorem `LieModule.lowerCentralSeries_succ` is a statement about the structure of the lower central series of a Lie module. Specifically, it states that for any commutative ring `R`, Lie ring `L`, and additive commutative group `M`, where `M` is a `R`-module and a `L`-module, the `(k + 1)`-th term of the lower central series is generated by the Lie bracket operation on the `k`-th term and the Lie algebra's whole space. This theorem is fundamental in the study of the structure of Lie algebras and their associated modules.

For any commutative ring `R`, Lie ring `L`, and additive abelian group `M` being an `R`-module and `L`-module, the lower central series of `M` as a Lie module is generated by the Lie brackets of `M` with itself and the whole space of `M`.


theorem Nat.add_le_add : ∀ {a b c d : ℕ}, a ≤ b → c ≤ d → a + c ≤ b + d := by sorry

This theorem states that for any four natural numbers `a`, `b`, `c`, and `d`, if `a` is less than or equal to `b` and `c` is less than or equal to `d`, then the sum of `a` and `c` is less than or equal to the sum of `b` and `d`. This property is a key aspect of the order-preserving nature of addition in the natural numbers.

For all natural numbers a, b, c, and d, if a ≤ b and c ≤ d then a + c ≤ b + d.


theorem Mathlib.Data.FinEnum._auxLemma.1 : ∀ {α : Type u} [inst : FinEnum α] (x : α), (x ∈ FinEnum.toList α) = True :=
  by sorry

The theorem `Mathlib.Data.FinEnum._auxLemma.1` states that for any type `α` that has a `FinEnum` instance (i.e., `α` is a finite enumerable type), any value `x` of type `α` is guaranteed to be present in the exhaustive list of all possible values of type `α` generated by `FinEnum.toList α`. That is, `x` belongs to the list produced by the function `FinEnum.toList α` regardless of the specific `x` chosen. The theorem allows us to assert the completeness and correctness of the `FinEnum` enumeration for any finite enumerable type `α`.

For any finite enumerable type `α`, every element `x` of `α` is present in the list produced by `FinEnum.toList α`.


/-- A free module with a basis indexed by a `Fintype` is finite.  -/
theorem Module.Finite.of_basis :
    ∀ {R : Type u_1} {M : Type u_2} {ι : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Finite ι], Basis ι R M → Module.Finite R M :=
  by sorry

This theorem states that a free module with a basis indexed by a `Fintype` (finite type) is finite. More formally, for any given Semiring `R`, Additive Commutative Monoid `M`, and any type `ι` that is finite, if there exists a basis indexed by `ι` for the module `M` over the ring `R`, then the module `M` over the ring `R` is finite. This theorem is fundamental in the theory of modules over rings, especially in the context of finite dimensional vector spaces.

A free module over a ring with a finite basis is finite.


theorem GaloisConnection.l_u_l_eq_l :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : PartialOrder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ (a : α), l (u (l a)) = l a :=
  by sorry

The theorem `GaloisConnection.l_u_l_eq_l` states that for any types `α` and `β` equipped with a preorder and a partial order respectively, and given functions `l : α → β` and `u : β → α` that establish a Galois connection between `α` and `β`, for any element `a` of type `α`, applying `l` to `u` of `l` of `a` gives back `l` of `a`. This property is essentially saying that the application of `l` after `u` after `l` is idempotent.

For any Galois connection between preordered type `α` and ordered type `β` with functions `l : α → β` and `u : β → α`, the composition `l ∘ u ∘ l` equals `l`.


/-- The intersection of a compact set and a closed set is a compact set.  -/
theorem IsCompact.inter_right :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsClosed t → IsCompact (s ∩ t) := by sorry

The theorem `IsCompact.inter_right` states that for any topological space `X` and any two sets `s` and `t` of `X`, if `s` is a compact set and `t` is a closed set, then the intersection of `s` and `t` (denoted by `s ∩ t`) is also a compact set. In mathematical terms, compactness and closure properties are preserved under intersection in a topological space.

If `s` is a compact and `t` is a closed set in a topological space, then their intersection `s ∩ t` is a compact set.


Filter.EventuallyEq.inter

theorem Filter.EventuallyEq.inter :
    ∀ {α : Type u} {s t s' t' : Set α} {l : Filter α}, s =ᶠ[l] t → s' =ᶠ[l] t' → s ∩ s' =ᶠ[l] t ∩ t' := by sorry

The theorem `Filter.EventuallyEq.inter` states that for any type `α`, sets `s`, `t`, `s'`, `t'` of type `α` and a filter `l` on `α`, if `s` is eventually equal to `t` under the filter `l` and `s'` is eventually equal to `t'` under the same filter, then the intersection of `s` and `s'` is eventually equal to the intersection of `t` and `t'` under the filter `l`. Here, the term "eventually equal" refers to the idea that for all elements beyond a certain point in the filtered set, the property holds.

If filters `l` make sets `s` and `t` eventually equal, and sets `s'` and `t'` similarly, then the intersections of `s` and `s'` and `t` and `t'` are eventually equal under filter `l`.


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

The theorem `Finset.sdiff_disjoint` states that for any type `α` which has a decidable equality and given any two finite sets `s` and `t` of type `α`, the set difference `t \ s` is disjoint with set `s`. In the context of lattice theory, two elements are disjoint if their greatest lower bound (infimum) is the bottom element. Here, it implies that there is no element in the set `s` that is also in the set `t \ s`, that is, the set `s` and the set `t \ s` have no common elements.

For finite sets `s` and `t` of type `α` with decidable equality, `s` has no elements in common with the set difference `t \ s`.


theorem Bool.and_false : ∀ (b : Bool), (b && false) = false := by sorry

This theorem states that for any boolean value `b`, the logical AND between this boolean `b` and `false` is always `false`. By the definition of logical AND, this result is true because the AND operation between any value and `false` always results in `false`.

For any boolean value `b`, `b` and `false` logically AND-ed together equal `false`.


theorem CategoryTheory.Idempotents.Karoubi.hom_ext :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      (f g : P ⟶ Q), f.f = g.f → f = g :=
  by sorry

This theorem, `CategoryTheory.Idempotents.Karoubi.hom_ext`, states that for any category `C` and any two objects `P` and `Q` in the Karoubi envelope of `C`, if two morphisms `f` and `g` from `P` to `Q` satisfy `f.f = g.f`, then `f` is equal to `g`. In other words, this theorem asserts that, in the Karoubi envelope of a category, two morphisms are equal if and only if their underlying morphisms in the original category are equal. This theorem aids in proving the equivalence between the Karoubi envelope and the category of idempotents.

In the Karoubi envelope of a category, two morphisms between objects have the same underlying morphism in the original category if and only if they are equal.


theorem AEMeasurable.mono_measure :
    ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      {μ ν : MeasureTheory.Measure α}, AEMeasurable f μ → ν ≤ μ → AEMeasurable f ν :=
  by sorry

The theorem `AEMeasurable.mono_measure` states that for any types `α` and `β`, where `α` has a measurable space structure `m0` and `β` has a measurable space structure `inst`, any function `f` from `α` to `β`, and any two measures `μ` and `ν` on the measurable space `α`, if the function `f` is almost everywhere measurable with respect to the measure `μ` and the measure `ν` is less than or equal to the measure `μ` (i.e., `ν` is a sub-measure of `μ`), then the function `f` is also almost everywhere measurable with respect to the measure `ν`. In other words, almost everywhere measurability of a function is preserved under taking sub-measures.

If a function between measurable spaces is almost everywhere measurable with respect to a measure and is sub-measurable (i.e., the smaller measure is less than or equal to the larger one), then the function is almost everywhere measurable with respect to the smaller measure.


theorem dense_univ : ∀ {X : Type u} [inst : TopologicalSpace X], Dense Set.univ := by sorry

The theorem `dense_univ` states that for any type `X` with a topology, the universal set of `X` is dense. This means that in any topological space, every point belongs to the closure of the universal set, which includes all elements of the space. In other words, there's no point in the space that isn't arbitrarily close to some element of the universal set.

In any topological space, the universal set is dense, meaning every point belongs to the closure of the universal set.


theorem Mathlib.Algebra.GroupWithZero.Divisibility._auxLemma.1 :
    ∀ {α : Type u_1} [inst : SemigroupWithZero α] {a : α}, (0 ∣ a) = (a = 0) := by sorry

This theorem, `Mathlib.Algebra.GroupWithZero.Divisibility._auxLemma.1`, states that for any type `α` that is an instance of a `SemigroupWithZero`, and for any element `a` of type `α`, `0` divides `a` if and only if `a` is equal to `0`. In other words, in any zero-containing semigroup, the only element that zero can divide is zero itself. This is a fundamental property of multiplication in mathematical structures with a zero element.

In any semigroup with zero, an element is divisible by zero if and only if it is equal to zero.


theorem Finset.insert_eq : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), insert a s = {a} ∪ s := by
  sorry

The theorem `Finset.insert_eq` states that for any given type `α` with decidable equality, for any element `a` of type `α`, and for any finite set `s` of elements of type `α`, inserting the element `a` into the set `s` is equivalent to forming the union of the singleton set containing `a` and the set `s`.

For any decidably equated type `α` and any finite set `s` of elements from `α`, the singleton set `{a}` and the set `s ∪ {a}` are equal. (Here, `a` is an arbitrary element of type `α`.)


theorem Polynomial.derivative_C :
    ∀ {R : Type u} [inst : Semiring R] {a : R}, Polynomial.derivative (Polynomial.C a) = 0 := by sorry

The theorem `Polynomial.derivative_C` states that for any semiring `R` and any element `a` of `R`, the formal derivative of the constant polynomial `a` is `0`. In other words, when we compute the derivative of a polynomial that is simply a constant (with no variable term), the result is always zero, which aligns with our understanding from basic calculus.

For any semiring R and any constant polynomial f(x) = a in R[x], its derivative f'(x) equals 0.


theorem one_le_kstar : ∀ {α : Type u_1} [inst : KleeneAlgebra α] {a : α}, 1 ≤ KStar.kstar a := by sorry

The theorem `one_le_kstar` states that for any given type `α` which is an instance of `KleeneAlgebra`, and for any element `a` of type `α`, `1` is less than or equal to `kstar` of `a`. Here, `KStar.kstar` is a function that takes an element from the Kleene algebra and returns an element of the same type. The comparison `1 ≤ KStar.kstar a` is made with respect to the partial order defined by the Kleene algebra structure on `α`.

For any element `a` in a Kleene algebra `α`, `1` is less than or equal to the Kleene star operation `kstar` applied to `a`. In mathematical notation: `1 ≤ KStar.kstar a`.


theorem Nat.not_succ_le_zero : ∀ (n : ℕ), Nat.succ n ≤ 0 → False := by sorry

This theorem asserts that for any natural number `n`, the successor of `n` cannot be less than or equal to zero. In other words, if you have any natural number and add one to it, the result is never less than or equal to zero. This makes sense since natural numbers start from zero and increase; thus, their successors are always greater than zero.

For all natural numbers n, the successor of n is strictly greater than zero.


theorem GaloisCoinsertion.u_surjective :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : PartialOrder α] [inst_1 : Preorder β],
      GaloisCoinsertion l u → Function.Surjective u :=
  by sorry

The theorem `GaloisCoinsertion.u_surjective` states that for any two types `α` and `β`, and any two functions `l : α → β` and `u : β → α`, given that `α` is a partial order and `β` is a preorder, if a Galois coinsertion exists between `l` and `u`, then the function `u` is surjective. In other words, for every element of type `β`, there exists an element of type `α` such that applying the function `u` to the element of type `β` yields this element of `α`.

If `l : α → β` and `u : β → α` define a Galois coinsertion between partial order `α` and preorder `β`, then `u` is a surjection.


ProbabilityTheory.kernel.IndepFun.comp

theorem ProbabilityTheory.kernel.IndepFun.comp :
    ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {γ' : Type u_7}
      {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω} {κ : ↥(ProbabilityTheory.kernel α Ω)}
      {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'} {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
      {mγ : MeasurableSpace γ} {mγ' : MeasurableSpace γ'} {φ : β → γ} {ψ : β' → γ'},
      ProbabilityTheory.kernel.IndepFun f g κ μ →
        Measurable φ → Measurable ψ → ProbabilityTheory.kernel.IndepFun (φ ∘ f) (ψ ∘ g) κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.IndepFun.comp` states that for all types α, Ω, β, β', γ, γ', given an appropriate measurable space for each type, a kernel κ, a measure μ, two functions f and g from Ω to β and Ω to β' respectively, and two measurable functions φ and ψ from β to γ and β' to γ' respectively, if the functions f and g are independent with respect to the kernel κ and the measure μ, then the composition of φ and f, and ψ and g are also independent with respect to the same kernel κ and measure μ. In other words, if f and g are independent, then their measurable transformations φ and ψ maintain this independence.

If functions f and g are independent with respect to kernel κ and measure μ, then the compositions φ∘f and ψ∘g are also independent with respect to kernel κ and measure μ.


theorem MeasurableSpace.gc_comap_map :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β), GaloisConnection (MeasurableSpace.comap f) (MeasurableSpace.map f) :=
  by sorry

The theorem `MeasurableSpace.gc_comap_map` states that for any function `f` from type `α` to type `β`, there exists a Galois connection between the reverse image function (`MeasurableSpace.comap f`) and the forward image function (`MeasurableSpace.map f`) of a measurable space. This essentially means that for any two sets `a` and `b` from the measurable spaces `α` and `β` respectively, the set `a` is a subset of the preimage of `b` under `f` if and only if the image of `a` under `f` is a subset of `b`. These conditions of the Galois connection establish a correspondence between the comap and map of the given function `f`.

The theorem `MeasurableSpace.gc_comap_map` asserts that for any function `f` between measurable spaces, the reverse image function `MeasurableSpace.comap f` and forward image function `MeasurableSpace.map f` form a Galois connection, that is, `a ⊆ f⁻¹[b] < Rav equiv b ⊆ f[a]`.


MeasureTheory.Submartingale.adapted

theorem MeasureTheory.Submartingale.adapted :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0} [inst_4 : LE E],
      MeasureTheory.Submartingale f ℱ μ → MeasureTheory.Adapted ℱ f :=
  by sorry

The theorem `MeasureTheory.Submartingale.adapted` states that for any type of event space `Ω`, any type of expected value `E`, any type of index `ι` with a preorder structure, a measurable space `m0`, a measure `μ` on this space, a normed add commutative group structure and normed space structure over the real numbers `ℝ` on `E`, and complete space structure on `E`, if `f` is a submartingale with respect to a filtration `ℱ` and measure `μ`, then `f` is adapted to the filtration `ℱ`. Here, `f` being a submartingale means it is a type of stochastic process that has the property of having an expected value that is greater than or equal to the previous expected value, given the past events. Being adapted to the filtration means that for all `i`, `f i` is `ℱ i`-measurable, i.e., `f i` respects the σ-algebra structure of `ℱ i`.

If `f` is a submartingale with respect to a filtration `ℱ` and measure `μ` over a measurable space `(Ω, Σ)` with a complete normed add commutative group and normed space structure over the real numbers, then `f` is adapted to `ℱ`, i.e., `f i` is `ℱ i`-measurable for all indices `i`.


theorem Filter.eventuallyEq_of_mem :
    ∀ {α : Type u} {β : Type v} {l : Filter α} {f g : α → β} {s : Set α}, s ∈ l → Set.EqOn f g s → f =ᶠ[l] g := by sorry

This theorem states that for any two functions `f` and `g` of type `α → β`, if they are equal on a set `s` of type `α` and this set `s` is in a filter `l` of type `α`, then `f` and `g` are eventually equal with respect to the filter `l`. In mathematical terms, this means that for all elements in the filter `l`, the functions `f` and `g` will produce the same output. The "eventually equal" part (`=ᶠ[l]`) signifies that this equality holds for all elements in the filter `l` beyond a certain point.

If functions `f` and `g` are equal on a set `s` that is in a filter `l`, then `f` and `g` are eventually equal with respect to the filter `l`, i.e., for all `x` in `l`, `f x = g x`.


theorem Mathlib.Data.Part._auxLemma.14 :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {o : Part α} {b : β}, (b ∈ Part.map f o) = ∃ a ∈ o, f a = b := by sorry

This theorem states that for any types `α` and `β`, a function `f` from `α` to `β`, a partial function `o` from `α`, and a value `b` of type `β`, `b` belongs to the result of mapping `f` over `o` (expressed as `b ∈ Part.map f o`) if and only if there exists a value `a` in `o` such that `f` applied to `a` equals `b`. This theorem essentially describes the behavior of the `map` operation on partial functions in terms of element membership.

For any types `α`, `β`, function `f` from `α` to `β`, partial function `o` from `α`, and value `b` of type `β`, `b` is in the image of `f` under `o` (`b ∈ Part.map f o`) if and only if there exists an `a` in the domain of `o` such that `f(a) = b`.


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

This theorem, `Set.image2_inter_subset_right`, states that for any types `α`, `β`, and `γ` and for any binary function `f` from `α → β → γ` and sets `s` of type `α` and `t`, `t'` of type `β`, the image of function `f` applied to the set `s` and the intersection of `t` and `t'` is a subset of the intersection of the image of `f` applied to the set `s` and `t` and the image of `f` applied to the set `s` and `t'`. In mathematical terms, it can be expressed as $f(s, t \cap t') \subseteq f(s, t) \cap f(s, t')$.

For any types `α`, `β`, and `γ`, and sets `s` of type `α` and `t`, `t'` of type `β`, the image of the binary function `f` from `α × β` to `γ` applied to the cartesian product of `s` and `t ∩ t'` is a subset of the image of `f` applied to the cartesian product of `s` and `t` and the image of `f` applied to the cartesian product of `s` and `t'`. In mathematical terms, $f(s \times (t \cap t')) \subseteq f(s \times t) \cap f(s \times t')$.


theorem OrderIso.map_top :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : PartialOrder β] [inst_2 : OrderTop α] [inst_3 : OrderTop β]
      (f : α ≃o β), f ⊤ = ⊤ :=
  by sorry

This theorem, `OrderIso.map_top`, states that for any two types `α` and `β` where `α` is an ordered type having a top element, `β` is a partially ordered type also having a top element, and there is an order isomorphism `f` from `α` to `β`, applying the order isomorphism `f` to the top element of `α` gives the top element of `β`. In more mathematical terms, if `⊤` is the top element in `α`, then `f(⊤) = ⊤` in `β`.

For any ordered type `α` with top element `⊤` and a order isomorphism `f` to a partially ordered type `β` with top element `⊤`, `f(⊤) = ⊤`.


Sublattice.infClosed

theorem Sublattice.infClosed : ∀ {α : Type u_2} [inst : Lattice α] (L : Sublattice α), InfClosed ↑L := by sorry

This theorem states that for any type `α` that forms a lattice, given a sublattice `L` of `α`, `L` is "inf-closed". In mathematical terms, this means that for any two elements `a` and `b` in the sublattice `L`, their infimum (`a ⊓ b`) is also in `L`. This property is fundamental to the theory of lattices and sublattices.

For any lattice `α` and sublattice `L` of `α`, the infimum of any two elements in `L` lies in `L`.


/-- The nonsingular inverse is the same as `invOf` when `A` is invertible.  -/
theorem Matrix.invOf_eq_nonsing_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
      [inst_3 : Invertible A], ⅟A = A⁻¹ :=
  by sorry

The theorem `Matrix.invOf_eq_nonsing_inv` states that for any type `n` with a finite number of elements (`Fintype n`) and decidable equality (`DecidableEq n`), and any commutative ring `α`, for any `n` by `n` matrix `A` with elements from `α` that is invertible (`Invertible A`), the multiplicative inverse of `A` (`⅟A`) is equal to its nonsingular inverse (`A⁻¹`). In simpler terms, this theorem asserts that for a square matrix `A` from a commutative ring which is invertible, its multiplicative inverse and nonsingular inverse are the same.

For any commutative ring α, finite type n with decidable equality, and invertible n by n matrix A over α, the multiplicative inverse and nonsingular inverse of A are equal.


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

The theorem `Finset.inter_subset_left` states that for any type `α` that has decidable equality, and for any two finite sets `s₁` and `s₂` of this type, the intersection of `s₁` and `s₂` is a subset of `s₁`. This reflects the general set theory principle that the intersection of two sets is always a subset of each of the intersecting sets.

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


/-- Additive group homomorphisms preserve integer scaling. -/
theorem map_zsmul :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
      [inst_2 : SubtractionMonoid H] [inst_3 : AddMonoidHomClass F G H] (f : F) (n : ℤ) (g : G), f (n • g) = n • f g :=
  by sorry

The theorem `map_zsmul` states that, for any types `G`, `H`, and `F`, if `F` has a structure of `FunLike` from `G` to `H`, `G` is an additive group, `H` is a subtraction monoid, and `F` is an additive monoid homomorphism from `G` to `H`, then any additive group homomorphism `f` from `G` to `H` preserves the operation of integer scaling. In other words, mapping an element `g` from `G` scaled by an integer `n` under `f` is the same as scaling the mapping of `g` under `f` by the same integer `n`. Formally, for all `f`, `n` and `g`, `f(n • g) = n • f(g)`.

Given an additive group `G`, a subtraction monoid `H`, and an additive monoid homomorphism `F` from `G` to `H`, any additive group homomorphism `f` from `G` to `H` satisfies `f(n * g) = n * f(g)` for all `n` in `ℤ` and `g` in `G`.


Set.OrdConnected.inter

theorem Set.OrdConnected.inter :
    ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α},
      Set.OrdConnected s → Set.OrdConnected t → Set.OrdConnected (s ∩ t) :=
  by sorry

This theorem states that for any type `α` that has a preorder relation, if `s` and `t` are two sets of `α` that are order-connected (meaning that for every pair of points in the set, every point between them is also in the set), then the intersection of `s` and `t` is also an order-connected set.

If `s` and `t` are order-connected subsets of a preordered type `α`, then their intersection `s INTER t` is also an order-connected subset.


theorem IsLUB.upperBounds_eq :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, IsLUB s a → upperBounds s = Set.Ici a := by sorry

This theorem states that for any set `s` of a type `α` under a Preorder relation, if a number `a` is a least upper bound of `s`, then the set of all upper bounds of `s` is equivalent to the set of all numbers greater than or equal to `a`. In mathematical terms, if `a` is a least upper bound (LUB) of a set `s`, then the set of upper bounds of `s` is the same as the interval `[a, +∞)`.

If `a` is the least upper bound of a set `s` under a preorder relation, then the set of upper bounds of `s` is equal to the set of numbers greater than or equal to `a`.