Disjoint.preimage

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

The theorem `Disjoint.preimage` states that for every two types `α` and `β`, and a function `f` from `α` to `β`, if two sets `s` and `t` of type `β` are disjoint, then the preimage of `s` and `t` under the function `f` are also disjoint. Here, "disjoint" means that the greatest lower bound (infimum or `⊓`) of any two elements, one from each set, is the smallest element in the set (`⊥`). The preimage of a set under a function is the set of all inputs that the function maps to elements in the set.

If `s` and `t` are disjoint sets in type `β`, then the preimages `f⁁⁻¹(s)` and `f⁁⁻¹(t)` are disjoint subsets of type `α`.


theorem codisjoint_iff_le_sup :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b ↔ ⊤ ≤ a ⊔ b := by sorry

The theorem `codisjoint_iff_le_sup` states that for any type `α` with an order structure that is both a semilattice with respect to the operation 'sup' (denoted by ⊔) and has a top element (denoted by ⊤), and for any two elements `a` and `b` of this type, `a` and `b` are codisjoint if and only if the top element (⊤) is less than or equal to the supremum of `a` and `b` (denoted by a ⊔ b). Here, 'codisjoint' means that for any element `x` in the order, if `a` and `b` are both less than or equal to `x`, then the top element is less than or equal to `x`.

For any semilattice with top element order structure type α, elements a and b are codisjoint if and only if ⊤ ≤ a ⊔ b.


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

This theorem, `Nat.add_right_comm`, states that for any three natural numbers `n`, `m`, and `k`, the sum of `n`, `m`, and `k` remains the same even if the order of `m` and `k` is switched. In other words, it asserts the commutativity of addition on the right side, specifically that `n + m + k` is equal to `n + k + m`. This theorem is a variation of the general commutative law of addition, which states that the order of the numbers being added does not change the sum.

For all natural numbers n, m, and k, the expression n + m + k is equal to n + k + m.


theorem Filter.map_id' : ∀ {α : Type u} {f : Filter α}, Filter.map (fun x => x) f = f := by sorry

This theorem, `Filter.map_id'`, states that for any type `α` and any filter `f` of this type, the forward map of `f` using the identity function (function that maps each element to itself) is equal to `f` itself. In other words, applying the identity function to each element of a filter does not change the filter. In the language of mathematics, if we have a filter `F` on a set `A`, mapping `F` with the identity function on `A` yields `F` itself.

For any filter `f` on type `α`, the application of the identity function maps `f` to itself, i.e., `Filter.map id f = f`.


theorem IsUnit.unit_spec : ∀ {M : Type u_1} [inst : Monoid M] {a : M} (h : IsUnit a), ↑(IsUnit.unit h) = a := by sorry

This theorem, `IsUnit.unit_spec`, states that for any type `M` that has a `Monoid` instance and for any element `a` of `M` that is a unit (i.e., it has a two-sided inverse), the element of the group of units corresponding to `a` (obtained through the `IsUnit.unit` function) is equal to `a` when the function is applied to the proof that `a` is a unit. In other words, it ensures that the `IsUnit.unit` function correctly identifies the monoid unit element associated with a given unit element in the monoid `M`.

For any type `M` with a `Monoid` instance and any unit `a` in `M`, `IsUnit.unit a` equals `a`.


theorem min_le_min : ∀ {α : Type u} [inst : LinearOrder α] {a b c d : α}, a ≤ c → b ≤ d → min a b ≤ min c d := by sorry

This theorem states that for any linearly ordered type `α` and any four elements `a`, `b`, `c` and `d` of that type, if `a` is less than or equal to `c` and `b` is less than or equal to `d`, then the minimum of `a` and `b` is less than or equal to the minimum of `c` and `d`. This theorem is a generalization of the property of the min function in order theory, asserting the monotonicity of the min function in each of its arguments.

For any linearly ordered type `α` and elements `a, b, c, d` of `α`, if `a ≤ c` and `b ≤ d`, then `min {a, b} ≤ min {c, d}`.


QuadraticForm.Isometry.ext

theorem QuadraticForm.Isometry.ext :
    ∀ {R : Type u_2} {M₁ : Type u_4} {M₂ : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
      [inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {Q₁ : QuadraticForm R M₁}
      {Q₂ : QuadraticForm R M₂} ⦃f g : Q₁ →qᵢ Q₂⦄, (∀ (x : M₁), f x = g x) → f = g :=
  by sorry

This theorem, labeled `QuadraticForm.Isometry.ext`, asserts that for any types `R`, `M₁`, and `M₂` with `R` being a commutative semiring and `M₁`, `M₂` being modules over `R`, and for any quadratic forms `Q₁` on `M₁` and `Q₂` on `M₂`, if two isometric maps `f` and `g` from `Q₁` to `Q₂` coincide on every point in `M₁`, then `f` and `g` are indeed the same map. In other words, the uniqueness of an isometry between two quadratic forms is determined by its action on all elements of the domain.

If two isometric maps between quadratic forms over a commutative semiring and their modules coincide on all domain elements, then they are equal.


theorem Algebra.eq_top_iff :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {S : Subalgebra R A}, S = ⊤ ↔ ∀ (x : A), x ∈ S :=
  by sorry

This theorem, `Algebra.eq_top_iff`, states that for any given types `R` and `A` with `R` being a commutative semiring and `A` a semiring, and given an algebra structure between `R` and `A`; for any subalgebra `S` of `A` over `R`, `S` is equal to the top element (`⊤`) if and only if every element `x` of type `A` is contained in `S`. In other words, a subalgebra is equal to the whole algebra if and only if it contains every element of the algebra.

A subalgebra of a commutative semiring `A` over a commutative semiring `R` is equal to the top element of `A` if and only if it contains every element of `A`.


/-- By definition, if `x` is not invertible then `inverse x = 0`.  -/
theorem Ring.inverse_non_unit : ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), ¬IsUnit x → Ring.inverse x = 0 :=
  by sorry

This theorem states that for any element `x` in a monoid with zero `M₀`, if `x` is not a unit (i.e., it does not have a two-sided inverse), then the inverse of `x` as defined in the `Ring.inverse` function is zero. This is a direct result of the definition of `Ring.inverse`, which assigns `0` to non-invertible elements of the monoid.

If `x` is a non-unit in a monoid `M₀` with zero element, then `Ring.inverse x = 0`.


theorem invOf_eq_right_inv : ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible a], a * b = 1 → ⅟a = b :=
  by sorry

This theorem, `invOf_eq_right_inv`, states that for any type `α` that is a monoid, given any elements `a` and `b` of `α`, where `a` is invertible, if the product of `a` and `b` is the identity element of the monoid, then the multiplicative inverse of `a` is `b`. In mathematical notation, this is saying that if `a * b = 1` then `1/a = b` for any invertible element `a` in a monoid.

If `a` is an invertible element in a monoid `α` and `a * b = 1`, then `b = 1/a`.


theorem Multiset.mem_of_le : ∀ {α : Type u_1} {s t : Multiset α} {a : α}, s ≤ t → a ∈ s → a ∈ t := by sorry

This theorem states that for any type `α`, and any two multisets `s` and `t` of that type, and any element `a` of that type, if `s` is contained within or equal to `t` (denoted by `s ≤ t`), and `a` is an element of `s` (denoted by `a ∈ s`), then `a` must also be an element of `t` (denoted by `a ∈ t`). In other words, any element of a subset of a multiset is also an element of the multiset itself.

If `s` is a multiset of type `α` and `a` is an element of `s` with `s ≤ t`, then `a` is an element of `t`.


theorem ENNReal.ofReal_mul : ∀ {p q : ℝ}, 0 ≤ p → ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q := by
  sorry

The theorem `ENNReal.ofReal_mul` states that for all real numbers `p` and `q`, if `p` is nonnegative then the function `ENNReal.ofReal` applied to the product `p * q` is equal to the product of `ENNReal.ofReal p` and `ENNReal.ofReal q`. In other words, this theorem is asserting that the function `ENNReal.ofReal` preserves multiplication for nonnegative real numbers.

For all non-negative real numbers p and q, `ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q`.


theorem Filter.Ici_mem_atTop : ∀ {α : Type u_3} [inst : Preorder α] (a : α), Set.Ici a ∈ Filter.atTop := by sorry

The theorem `Filter.Ici_mem_atTop` states that for any type `α` equipped with a preorder, and for any element `a` of that type, the set of all elements greater than or equal to `a` (`Set.Ici a`) is a member of the filter representing the limit towards positive infinity (`Filter.atTop`). In other words, as we go towards positive infinity in our ordered set, we will always encounter the set of elements that are greater than or equal to a given element `a`.

For any preordered type `α` and element `a` in `α`, the upward-closed set `{x : α | x ≥ a}` is a member of the filter `Filter.atTop`.


theorem List.ofFn_eq_map : ∀ {α : Type u_1} {n : ℕ} {f : Fin n → α}, List.ofFn f = List.map f (List.finRange n) := by
  sorry

This theorem states that for any type `α` and natural number `n`, if `f` is a function that maps `Fin n` to `α`, then creating a list by applying `f` to each element from `0` to `n-1` (as done by `List.ofFn f`) is equivalent to first creating a list of all elements from `0` to `n-1` (as done by `List.finRange n`) and then mapping `f` over this list (i.e., `List.map f (List.finRange n)`). In other words, the theorem asserts the equality between two different ways of creating a list from a function that takes elements in `Fin n`.

For any type `α` and natural number `n`, the function `List.map f (List.finRange n)` equals `List.ofFn f` when `f` maps `Fin n` to `α`.


theorem SetLike.coe_set_eq : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, ↑p = ↑q ↔ p = q := by sorry

This theorem, `SetLike.coe_set_eq`, states that for any two types `A` and `B`, and a `SetLike` instance `i` from `A` to `B`, the two instances `p` and `q` of type `A` are equal if and only if their coercions to type `B` are equal. In other words, it describes the equivalence between equality of two objects of a certain type and the equality of their corresponding objects under a certain `SetLike` mapping.

For any type `A`, `B`, and `SetLike` instance `i` from `A` to `B`, `a = b` if and only if `i a = i b`.


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

This theorem states that for any ring `R`, additive commutative group `M`, and a `Module` structure over `R` and `M`, given a basis indexed by a type `ι` and assuming that `R` satisfies the strong rank condition, then the cardinality of the index set `ι` lifted to the maximum of its own universe and the universe of `M` is equal to the rank of the module `M` over `R` lifted to the maximum of its own universe and the universe of `ι`. In simpler terms, this theorem bridges the cardinality of the basis of a module and the rank of the module, under strong rank conditions.

Given a ring `R`, an additive commutative group `M` with a `Module` structure over `R`, a basis `β: ι -> M`, and `R` satisfying the strong rank condition, the cardinality of `ι` equals the rank of `M` over `R`.


theorem Subgroup.gc_map_comap :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
      GaloisConnection (Subgroup.map f) (Subgroup.comap f) :=
  by sorry

The theorem `Subgroup.gc_map_comap` states that for any two types `G` and `N` with `Group` instances, and any monoid homomorphism `f` from `G` to `N`, there exists a Galois connection between the function `Subgroup.map f` and `Subgroup.comap f`. In the context of groups and subgroups, this means that the image of a subgroup under the monoid homomorphism `f` is less than or equal to a subgroup in `N` if and only if the original subgroup is less than or equal to the preimage of that subgroup in `N` under `f`. This characterizes a certain correspondence between the structure of subgroups in `G` and `N` induced by the monoid homomorphism `f`.

For any group homomorphism `f` between groups `G` and `N`, there exists a Galois connection between `Subgroup.map f` and `Subgroup.comap f`, meaning that `Subgroup.map f(H) ≤ Subgroup.comap f(K)` in `N` if and only if `H ≤ K` in `G`.


theorem Mathlib.Order.Lattice._auxLemma.11 : ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, (a ⊓ b ≤ a) = True :=
  by sorry

This theorem, named `Mathlib.Order.Lattice._auxLemma.11`, asserts that for any type `α` with a structure of a semilattice under the infimum operation (`SemilatticeInf α`), for any two elements `a` and `b` of this type, the infimum of `a` and `b` is always less than or equal to `a`. This is a basic property of infimums (also known as "greatest lower bounds") in order theory and is always true, hence the result is `True`. In mathematical language, this can be written as $a \land b \leq a$.

For any semilattice `α` and elements `a, b` in `α`, the infimum of `a` and `b` is less than or equal to `a`. In mathematical notation: `∧-elim ∧(SemilatticeInf α a b) a`.


theorem Mathlib.Data.Set.Pairwise.Basic._auxLemma.2 :
    ∀ {α : Type u_1} (a : α) (r : α → α → Prop), Set.Pairwise {a} r = True := by sorry

The theorem states that for any type `α`, any element `a` of type `α`, and any relation `r` between elements of type `α`, the relation `r` holds pairwise on the set that only contains the element `a`. In other words, the relation `r` holds for all distinct pairs of elements in the singleton set `{a}`, which is trivially true since there are no distinct pairs in a singleton set.

For any type `α`, relation `r` on `α`, and element `a` in `α`, the singleton set {`a`} satisfies pairwise `r`. That is, `a` `r` `a` and there are no other distinct elements to check.


theorem isCoprime_comm : ∀ {R : Type u} [inst : CommSemiring R] {x y : R}, IsCoprime x y ↔ IsCoprime y x := by sorry

This theorem states that the property of being coprime is commutative for any two elements `x` and `y` in a commutative semiring `R`. In other words, `x` and `y` being coprime implies `y` and `x` are also coprime, and vice versa. Here, two elements are defined as coprime if there exist two other elements `a` and `b` such that `a * x + b * y = 1`.

In a commutative semiring, x and y being coprime is equivalent to y and x being coprime.


/-- Every polynomial splits in the field extension `f : K →+* k` if `k` is algebraically closed.

See also `IsAlgClosed.splits_domain` for the case where `K` is algebraically closed.
 -/
theorem IsAlgClosed.splits_codomain :
    ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : IsAlgClosed k] [inst_2 : Field K] {f : K →+* k}
      (p : Polynomial K), Polynomial.Splits f p :=
  by sorry

This theorem states that every polynomial splits in the field extension represented by the function `f : K →+* k` if `k` is algebraically closed. Here, "splits" means that the polynomial is either zero or all of its irreducible factors have degree 1. The theorem applies to any polynomial `p` of the field `K`. Additionally, there is a related theorem, `IsAlgClosed.splits_domain`, which handles the case where `K` is algebraically closed.

In an algebraically closed field extension `f : K →+* k`, every polynomial `p` from the base field `K` splits into linear factors.


theorem FirstOrder.Field.FieldAxiom.toProp_of_model :
    ∀ {K : Type u_2} [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Zero K] [inst_4 : One K]
      [inst_5 : FirstOrder.Ring.CompatibleRing K] [inst_6 : K ⊨ FirstOrder.Language.Theory.field]
      (ax : FirstOrder.Field.FieldAxiom), FirstOrder.Field.FieldAxiom.toProp K ax :=
  by sorry

This theorem states that for any type `K` that has addition, multiplication, negation, a zero, and a one, and is compatible with the ring language in the sense of first order logic, if `K` satisfies the first order theory of fields, then any field axiom (represented by `ax`) is valid in `K`. In other words, the property corresponding to the field axiom holds in `K`.

If `K` is a type with additions, multiplications, negation, zero, and one, compatible with the ring language, and satisfies the first-order theory of fields in Lean 4, then every field axiom holds in `K`.


theorem Real.cos_antiperiodic : Function.Antiperiodic Real.cos Real.pi := by sorry

The theorem `Real.cos_antiperiodic` states that the real cosine function, denoted by `Real.cos`, is antiperiodic with an antiperiod of pi (`Real.pi`). In other words, for any real number `x`, the cosine of `x + pi` is equal to the negative of the cosine of `x`, or formally, $\cos(x + \pi) = -\cos(x)$ for all real `x`. This fact is a well-known property of the cosine function in trigonometry.

The cosine function is antiperiodic with a period of pi, i.e., $\cos(x+\pi) = -\cos(x)$ for all real numbers $x$.


theorem Polynomial.C_eq_nat_cast : ∀ {R : Type u} [inst : Semiring R] (n : ℕ), Polynomial.C ↑n = ↑n := by sorry

This theorem, `Polynomial.C_eq_nat_cast`, states that for any natural number `n` and any type `R` with a semiring structure, applying the constant polynomial function `Polynomial.C` to the natural number `n` casted to `R` is equivalent to simply casting `n` to `R`. Essentially, it is asserting the equality between the constant polynomial at `n` and the cast of `n` in the context of a semiring.

For any semiring `R` and natural number `n`, `Polynomial.C (cast R n) = cast R n`.


theorem Nat.zero_lt_of_lt : ∀ {a b : ℕ}, a < b → 0 < b := by sorry

This theorem, `Nat.zero_lt_of_lt`, states that for any two natural numbers `a` and `b`, if `a` is less than `b`, then `0` is less than `b`. Essentially, it asserts that if a natural number is greater than any other natural number, then it must be greater than zero.

For all natural numbers `a` and `b`, if `a` < `b`, then 0 < `b`.


theorem Function.LeftInverse.comp_eq_id :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.LeftInverse f g → f ∘ g = id := by sorry

The theorem `Function.LeftInverse.comp_eq_id` states that for all types `α` and `β`, and for all functions `f` from `α` to `β` and `g` from `β` to `α`, if `f` is a left inverse function to `g`, then the composition of `f` and `g` is the identity function. In mathematical terms, if for all `x` in `α`, `f(g(x)) = x`, then `f(g) = id`.

If function `f` is a left inverse of `g` (i.e., `f ∘ g = id_α`), then `g ∘ f = id_β`.


theorem Int.not_le : ∀ {a b : ℤ}, ¬a ≤ b ↔ b < a := by sorry

This theorem states that for all integers `a` and `b`, `a` is not less than or equal to `b` if and only if `b` is strictly less than `a`. In mathematical terms, it illustrates the antecedent relationship between the negation of the "less than or equal to" comparison and the "strictly less than" comparison for integers.

For integers `a` and `b`, `a` is not less than or equal to `b` if and only if `b` is strictly less than `a`. In Lean, this can be expressed as `∀ (a b : ℤ), a ≤ b ��ври b < a`.


theorem Multiset.powerset_coe' :
    ∀ {α : Type u_1} (l : List α), Multiset.powerset ↑l = ↑(List.map Multiset.ofList (List.sublists' l)) := by sorry

This theorem states that, for any type `α` and list of that type, the powerset of the multiset created from that list is equal to the multiset created from mapping the function `Multiset.ofList` (which converts a list to a multiset) over all the sublists of the original list. The sublists are generated in a specific order where the first element of the list is treated as the most significant bit (MSB). This theorem essentially defines the relationship between the powerset of a multiset and the sublists of the original list.

For any type `α`, the powerset of the multiset obtained from a list of `α` using `Multiset.ofList` is equal to the multiset obtained from mapping `Multiset.ofList` over all sublists of that list treated as binary sequences with the first element as the most significant bit.


theorem ContinuousMap.Homotopy.apply_zero :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
      (F : ContinuousMap.Homotopy f₀ f₁) (x : X), F (0, x) = f₀ x :=
  by sorry

This theorem states that for any two continuous maps `f₀` and `f₁` from a topological space `X` to another topological space `Y`, and any homotopy `F` between `f₀` and `f₁`, the value of `F` at `(0, x)` is equal to the value of `f₀` at `x` for any `x` in `X`. In other words, at the start of the homotopy (when the homotopy parameter is 0), `F` coincides with the initial map `f₀`.

Given continuous maps `f₀` and `f₁` from a topological space `X` to a topological space `Y`, and a homotopy `F` between them, for all `x` in `X`, `F 0 x = f₀ x`.


theorem Finset.image₂_eq_empty_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      Finset.image₂ f s t = ∅ ↔ s = ∅ ∨ t = ∅ :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` where `γ` has decidable equality, given a binary function `f : α → β → γ` and two finite sets `s : Finset α` and `t : Finset β`, the image of the function `f` applied to `s` and `t` results in an empty set if and only if either `s` or `t` (or both) are empty. In other words, when you apply a function to every combination of elements from two sets, if the resulting set is empty, then at least one of the original sets was empty.

For functions between types with decidable equality, the image of a binary function applied to two finite sets is empty if and only if at least one of the sets is empty.


theorem Real.sin_sq_add_cos_sq : ∀ (x : ℝ), Real.sin x ^ 2 + Real.cos x ^ 2 = 1 := by sorry

This theorem states that for any real number `x`, the square of the sine of `x` plus the square of the cosine of `x` equals 1. In other words, it is the real-number version of the Pythagorean trigonometric identity: $\sin^2(x) + \cos^2(x) = 1$ for all real numbers `x`.

For all real numbers x, the sum of the squares of sine and cosine of x is equal to 1: $\sin^2(x) + \cos^2(x) = 1$.


theorem iSup_mono' :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : CompleteLattice α] {f : ι → α} {g : ι' → α},
      (∀ (i : ι), ∃ i', f i ≤ g i') → iSup f ≤ iSup g :=
  by sorry

The theorem `iSup_mono'` states that for any two types `α` and `ι` (respectively `ι'`) with `α` being a complete lattice, and any two functions `f : ι → α` and `g : ι' → α`, if for every element of `ι` there exists an element in `ι'` such that the value of `f` at that element is less than or equal to the value of `g` at the corresponding element, then the supremum (greatest lower bound) of the range of `f` is less than or equal to the supremum of the range of `g`. In other words, if `f` is pointwise less than or equal to `g`, then the supremum of `f` is less than or equal to the supremum of `g`.

If `α` is a complete lattice and `f : ι → α` is pointwise less than or equal to `g : ι' → α`, then `sup (range f) ≤ sup (range g)`.


theorem MeasureTheory.map_add_right_eq_self :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Add G] (μ : MeasureTheory.Measure G)
      [inst_2 : MeasureTheory.Measure.IsAddRightInvariant μ] (g : G),
      MeasureTheory.Measure.map (fun x => x + g) μ = μ :=
  by sorry

This theorem states that for any type `G` that has a measurable space structure and an addition operation, for any measure `μ` on `G` that is right-invariant under addition, and for any element `g` of `G`, the pushforward of `μ` along the map that adds `g` to each element is just `μ` itself. In other words, if a measure does not change when we shift all points in the space by a fixed amount, then applying this shift and measuring gives the same result as measuring without shifting.

For any right-invariant measure `μ` on a measurable additive group `G`, the pushforward of `μ` under the translation by any element `g` in `G` is equal to `μ` itself.


theorem multiplicity.finite_nat_iff : ∀ {a b : ℕ}, multiplicity.Finite a b ↔ a ≠ 1 ∧ 0 < b := by sorry

The theorem `multiplicity.finite_nat_iff` states that for any two natural numbers `a` and `b`, the multiplicity of `a` in `b` is finite if and only if `a` is not equal to 1 and `b` is greater than 0. Here, the multiplicity of `a` in `b` refers to the highest power of `a` that divides `b`. This theorem connects the finiteness of this multiplicity with the conditions on the numbers themselves, specifically that `a` is not 1 and `b` is positive.

The natural number `a` has finite multiplicity in `b` if and only if `a ≠ 1` and `b` is positive.


/-- A module over a division ring is noetherian if and only if it is finitely generated.  -/
theorem IsNoetherian.iff_fg :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
      IsNoetherian K V ↔ Module.Finite K V :=
  by sorry

This theorem states that for any module `V` over a division ring `K`, the module is Noetherian if and only if it is finitely generated. In mathematical terms, a Noetherian module is one where every submodule is finitely generated, and this theorem states that such a property is equivalent to the module itself being finitely generated. The theorem applies to any type `K` that forms a division ring and any type `V` that forms an additive commutative group and a module over `K`.

A module over a division ring is Noetherian if and only if it is finitely generated.


theorem Set.IsWF.min_mem :
    ∀ {α : Type u_2} [inst : Preorder α] {s : Set α} (hs : Set.IsWF s) (hn : Set.Nonempty s), Set.IsWF.min hs hn ∈ s :=
  by sorry

This theorem states that, for any type `α` with a preorder relation, and for any set `s` of type `α`, if `s` is well-founded with respect to the `<` relation (that is, there are no infinitely decreasing sequences) and `s` is nonempty, then the minimum element of `s` (obtained via the `Set.IsWF.min` function) is indeed an element of `s`. In other words, the function `Set.IsWF.min` is guaranteed to return an element that belongs to the set `s`, provided `s` is both well-founded and nonempty.

If `s` is a nonempty, well-founded set with respect to a preorder relation in Lean, then `Set.IsWF.min s` is an element of `s`.


theorem Function.Surjective.iSup_congr :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : SupSet α] {f : ι → α} {g : ι' → α} (h : ι → ι'),
      Function.Surjective h → (∀ (x : ι), g (h x) = f x) → ⨆ x, f x = ⨆ y, g y :=
  by sorry

The theorem `Function.Surjective.iSup_congr` states that for any types `α`, `ι`, and `ι'`, given a `SupSet` instance for `α`, and functions `f : ι → α`, `g : ι' → α`, and a surjective function `h : ι → ι'`, if for all `x` in `ι`, `g (h x)` equals `f x`, then the supremum of the image of `f` equals the supremum of the image of `g`. Here, `⨆ x, f x` means the supremum (greatest element) of the image of `f`, and similarly for `g`. This theorem essentially says that a surjective transformation of the indexing set of a supremum doesn't change the supremum, as long as the function values are preserved under the transformation.

If `f : ι → α` and `g : ι' → α` are functions with `ι` and `ι'` having a `SupSet` instance, and `h : ι → ι'` is surjective such that `g (h x) = f x` for all `x` in `ι`, then `⨆ x, f x = ⨆ x, g x`.


Measurable.neg

theorem Measurable.neg :
    ∀ {G : Type u_2} {α : Type u_3} [inst : Neg G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableNeg G]
      {m : MeasurableSpace α} {f : α → G}, Measurable f → Measurable fun x => -f x :=
  by sorry

The theorem `Measurable.neg` states that, for any type `G` equipped with a negation operation and a measurable structure, and any type `α` with a measurable space structure, if we have a measurable function `f` from `α` to `G`, then the function obtained by applying the negation operation to the output of `f` (i.e., the function `x => -f x`) is also measurable. This means that if we take any measurable set in `G`, the preimage of this set under the negation of `f` is also measurable in `α`.

If `f: α → G` is a measurable function between measurable spaces `(α, Σα)` and `(G, ΣG)`, where `G` is a negated type equipped with a negation operation, then the function `x ↦ -(f x)` is measurable.


theorem Set.sep_univ : ∀ {α : Type u} {p : α → Prop}, {x | x ∈ Set.univ ∧ p x} = {x | p x} := by sorry

This theorem states that for any type `α` and any property `p` that elements of `α` may or may not satisfy, the set of elements in `α` that satisfy both the condition of being in the universal set and the property `p` is equal to the set of elements in `α` that satisfy the property `p` alone. In other words, restricting the universe with the universal set on a type `α` (which contains all elements of `α`) has no effect when further narrowing down the elements of `α` with property `p`. The universal set here acts as an identity element for set restriction in this context.

For any type `α` and property `p`, the set of elements in `α` that satisfy both the universal condition and property `p` equals the set of elements in `α` that satisfy property `p`.


LinearMap.isLinear

theorem LinearMap.isLinear :
    ∀ {R : Type u_1} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (fₗ : M →ₗ[R] M₂), IsLinearMap R ⇑fₗ :=
  by sorry

This theorem states that for any semiring `R` and any two additive commutative monoids `M` and `M₂` over `R`, every linear map `fₗ` from `M` to `M₂` is a linear map in the sense of the `IsLinearMap` predicate. In more detail, if `M` and `M₂` are modules over `R`, and `fₗ` is a linear map from `M` to `M₂`, then `fₗ` satisfies the properties of additivity and scalar multiplication required to be a linear map according to the definition of `IsLinearMap`.

For any semiring `R`, any additive commutative monoids `M` and `M₂` over `R`, and any linear map `f` from `M` to `M₂`, `f` is a linear map (satisfying additivity and scalar multiplication properties).


theorem Mathlib.Order.UpperLower.Basic._auxLemma.23 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = (↑p = ↑q) := by sorry

This theorem, `Mathlib.Order.UpperLower.Basic._auxLemma.23`, states that for all types `A` and `B` where `B` is a member of a set-like structure `A`, and for all `p` and `q` of type `A`, `p` is equal to `q` if and only if the underlying elements (or coercions) of `p` and `q` are equal. This theorem establishes the equivalence between equality of set-like elements and their corresponding underlying elements.

For all types `A` and `B` with `B` an element of `A`, and all `p` and `q` in `A` of the same type as `B`, `p = q` if and only if the underlying elements of `p` and `q` are equal.


Dioph.ext

theorem Dioph.ext : ∀ {α : Type u} {S S' : Set (α → ℕ)}, Dioph S → (∀ (v : α → ℕ), v ∈ S ↔ v ∈ S') → Dioph S' := by
  sorry

The theorem `Dioph.ext` states that for any type `α` and any two sets `S` and `S'` of functions from `α` to natural numbers, if the set `S` is Diophantine (i.e., there exists a polynomial on `α ⊕ β` such that a function `v` is in `S` if and only if there exists a function `t : ℕ^β` such that the polynomial applied to the sum of `v` and `t` is zero), and every function `v` is in `S` if and only if it is in `S'`, then the set `S'` is also Diophantine. In other words, a Diophantine property is preserved under set equivalence.

If two sets of functions from a type to natural numbers have the same elements and one is Diophantine, then so is the other.


theorem inv_eq_of_mul_eq_one_right : ∀ {G : Type u_1} [inst : DivisionMonoid G] {a b : G}, a * b = 1 → a⁻¹ = b := by
  sorry

This theorem states that for any type `G` that forms a Division Monoid (a set with a binary operation, an identity element, and an inverse for each element), given two elements `a` and `b` from `G`, if the product of `a` and `b` equals the identity element `1`, then the inverse of `a` is equal to `b`. In mathematical terms, for any elements `a`, `b` of a division monoid `G`, if `a * b = 1`, then `a⁻¹ = b`.

In a division monoid, if the product of two elements equals the identity, then they are inverses of each other.


theorem Real.sqrt_sq_eq_abs : ∀ (x : ℝ), Real.sqrt (x ^ 2) = |x| := by sorry

This theorem states that for every real number `x`, the square root of `x` squared is equal to the absolute value of `x`. In other words, taking the square root of the square of any real number will always yield the non-negative value of that number, effectively the absolute value. This is expressed mathematically as: ∀ (x : ℝ), √(x^2) = |x|.

For all real numbers x, the square root of x squared equals its absolute value. That is, √(x^2) = |x|.


theorem Nat.sub_succ_lt_self : ∀ (a i : ℕ), i < a → a - (i + 1) < a - i := by sorry

This theorem, `Nat.sub_succ_lt_self`, states that for all natural numbers `a` and `i`, if `i` is less than `a`, then the difference between `a` and the successor of `i` is less than the difference between `a` and `i`. Intuitively, incrementing `i` decreases the difference between `a` and `i`, and so `a - (i + 1)` is strictly less than `a - i`.

For all natural numbers `a` and `i`, if `i` < `a`, then `a - (i + 1)` < `a - i`.


/-- A minimal polynomial is nonzero.  -/
theorem minpoly.ne_zero :
    ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B}
      [inst_3 : Nontrivial A], IsIntegral A x → minpoly A x ≠ 0 :=
  by sorry

The theorem `minpoly.ne_zero` states that for any algebra `B` over a commutative ring `A` (both `A` and `B` are types), and for any element `x` of `B`, if `A` is nontrivial and `x` is integral over `A`, then the minimal polynomial of `x` over `A` is not zero. Here, an element being integral means that it is a root of some monic polynomial with coefficients in `A`, and a nontrivial ring means a ring with at least two distinct elements.

If `A` is a nontrivial commutative ring and `x` is an element integral over `A` in the algebra `B` over `A`, then the minimal polynomial of `x` over `A` is non-zero.


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

This theorem states that for any type `α` and any set `s` of elements of that type, if every element of `α` is not a member of `s`, then `s` must be equivalent to the empty set. In other words, if no element belongs to the set `s`, it is identical to the empty set. This is a fundamental property of sets in mathematics.

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


Measurable.inv

theorem Measurable.inv :
    ∀ {G : Type u_2} {α : Type u_3} [inst : Inv G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableInv G]
      {m : MeasurableSpace α} {f : α → G}, Measurable f → Measurable fun x => (f x)⁻¹ :=
  by sorry

The theorem `Measurable.inv` states that for any type `G` with an `Inv` (inverse) operation and a `MeasurableSpace` structure and any type `α` with a `MeasurableSpace` structure, if `G` also has a `MeasurableInv` structure (where the preimage of every measurable set under inversion is measurable) and if we have a measurable function `f` from `α` to `G`, then the function which takes `x` in `α` and maps it to the inverse of `f(x)` in `G`, is also measurable. In mathematical terms, if `f : α → G` is a measurable function, then the function `x ↦ (f(x))⁻¹` is also measurable.

If `f : α → G` is a measurable function between measurable spaces `α` and `G`, where `G` is endowed with an inverse operation and a measurable inverse structure, then the function `x ↦ (f(x))⁻¹` is measurable.


theorem Mathlib.MeasureTheory.Function.L1Space._auxLemma.1 :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      (f : α → β), MeasureTheory.HasFiniteIntegral f μ = (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ < ⊤) :=
  by sorry

This theorem in the Lean 4 library, `Mathlib.MeasureTheory.Function.L1Space._auxLemma.1`, states that for any types `α` and `β`, and for any measurable space `α` with a measure `μ`, and `β` being a normed add commutative group, a function `f` from `α` to `β` has a finite integral with respect to the measure `μ` if and only if the Lebesgue integral over this measure space of the nonnegative part of the norm of `f` is less than infinity. In simpler terms, the function `f` has a finite integral under the measure `μ` when the integral of the non-negative value of the norm of `f` is finite. This theorem links the concept of having a finite integral with the finitude of the integral of the norm, using the `ENNReal.ofReal` function to ensure non-negativity.

A measurable function from a measure space to a normed add commutative group has a finite integral if and only if the integral of the non-negative part of its norm is finite.


IsLocalization.injective

theorem IsLocalization.injective :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
      [inst_3 : IsLocalization M S], M ≤ nonZeroDivisors R → Function.Injective ⇑(algebraMap R S) :=
  by sorry

This theorem states that for any commutative ring `R`, a submonoid `M` of `R`, a type `S` which is also a commutative ring and an algebra over `R`, and given that `S` is a localization of `R` at `M`, if `M` is a subset of the non-zero divisors of `R`, then the algebra homomorphism from `R` to `S` (given by the `Algebra` structure) is injective. In other words, if every element of the submonoid `M` is a non-zero divisor in `R`, then no two distinct elements in `R` have the same image in `S` under the algebra map.

If `R` is a commutative ring, `M` is a commutative submonoid of non-zero divisors in `R`, `S` is a commutative ring and an `R`-algebra that is a localization of `R` at `M`, then the algebra homomorphism from `R` to `S` is injective.


theorem MonoidHom.map_multiset_prod :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] (f : α →* β) (s : Multiset α),
      f (Multiset.prod s) = Multiset.prod (Multiset.map (⇑f) s) :=
  by sorry

The theorem `MonoidHom.map_multiset_prod` states that for any two types `α` and `β` with commutative monoid structures, a monoid homomorphism `f` from `α` to `β`, and a multiset `s` of type `α`, applying `f` to the product of the multiset `s` (i.e., `f (Multiset.prod s)`) is equal to the product of the multiset obtained by mapping `f` over `s` (i.e., `Multiset.prod (Multiset.map (⇑f) s)`). In other words, this theorem asserts that a monoid homomorphism preserves the product operation on multisets, and this behavior is invariant to the order of operations due to the commutative property.

For any commutative monoids `α` and `β`, a monoid homomorphism `f` from `α` to `β` preserves the product operation on multisets, i.e., `f (Multiset.prod s) = Multiset.prod (Multiset.map (f) s)`.


theorem UniqueFactorizationMonoid.factors_prod :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
      a ≠ 0 → Associated (Multiset.prod (UniqueFactorizationMonoid.factors a)) a :=
  by sorry

The theorem `UniqueFactorizationMonoid.factors_prod` in Lean 4 states that for all non-zero elements `a` of any Type `α` that forms a CancelCommMonoidWithZero and a UniqueFactorizationMonoid, `a` is associated with the product of its prime factors. That is, `a` can be written as a product of its prime factors times some unit. In the context of number theory, this roughly translates to the unique factorization theorem, also known as the fundamental theorem of arithmetic, which states that every integer greater than 1 is either a prime number itself or can be factorized as a product of prime numbers.

Every non-zero element in a Type α that is both a cancel commutative monoid with identity and a unique factorization monoid can be expressed as the product of its prime factors up to units.


theorem Nat.add_zero : ∀ (n : ℕ), n + 0 = n := by sorry

This theorem, `Nat.add_zero`, states that for any natural number `n`, the sum of `n` and zero is `n`. In other words, adding zero to any natural number doesn't change the value of the natural number. This is a fundamental property of addition, known as the identity property.


theorem Set.countable_empty : ∀ {α : Type u}, Set.Countable ∅ := by sorry

The theorem `Set.countable_empty` states that for any type `α`, the empty set of `α` is countable. In other words, there exists an injective map from the empty set to the set of natural numbers. This is true because the empty set does not contain any elements, so it's trivial to map it injectively (without duplicates) to the set of natural numbers.

The empty set of any type is countable, i.e., there exists an injective function from the empty set to the natural numbers.


theorem Set.not_nontrivial_iff : ∀ {α : Type u} {s : Set α}, ¬Set.Nontrivial s ↔ Set.Subsingleton s := by sorry

The theorem `Set.not_nontrivial_iff` states that for any type `α` and for any set `s` of type `α`, the set `s` is not nontrivial if and only if it is a subsingleton. In other words, a set is not nontrivial, meaning it doesn't have at least two distinct elements, if and only if it is a subsingleton, which means it has at most one element. This theorem provides a logical equivalence between the absence of nontriviality and the presence of subsingleton property in a set.

A set is not nontrivial if and only if it is a subsingleton. (In other words, a set has at most one element if and only if it does not have at least two distinct elements.)


/-- If `a ≤ b`, then `(-∞, a) ⊆ (-∞, b)`. In preorders, this is just an implication. If you need
the equivalence in linear orders, use `Iio_subset_Iio_iff`.  -/
theorem Set.Iio_subset_Iio : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → Set.Iio a ⊆ Set.Iio b := by sorry

This theorem states that if `a` is less than or equal to `b` in a given preorder `α`, then the left-infinite right-open interval `(-∞, a)` is a subset of the interval `(-∞, b)`. In other words, if a number is strictly less than `a`, it will also be strictly less than `b` if `a ≤ b`. For linear orders, you should use the theorem `Iio_subset_Iio_iff` for the equivalent condition.

If `a ≤ b` holds in a preorder `α`, then `(-∞, a) ⊆ (-∞, b)`.


CentroidHom.ext

theorem CentroidHom.ext :
    ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] {f g : CentroidHom α}, (∀ (a : α), f a = g a) → f = g := by
  sorry

This theorem, `CentroidHom.ext`, states that for all types `α` in a non-unital non-associative semiring, if two centroid homomorphisms `f` and `g` from `α` are such that they produce the same output for every element of `α`, then `f` and `g` are the same function. In other words, two centroid homomorphisms are equal if they have the same effect on all elements of their domain.

If `α` is a non-unital non-associative semiring and centroid homomorphisms `f` and `g` from `α` agree on all elements, then `f` equals `g`.


theorem Linarith.nat_cast_nonneg : ∀ (α : Type u) [inst : OrderedSemiring α] (n : ℕ), 0 ≤ ↑n := by sorry

This theorem, `Linarith.nat_cast_nonneg`, asserts that for every type `α` which is an ordered semiring, the cast of any natural number `n` to `α` is always non-negative. In other words, when a natural number is transformed into a type that forms an ordered semiring, the value will be greater than or equal to zero.

For every ordered semiring type `α`, the coercion from natural numbers to `α` preserves non-negativity, i.e., `0 ≤ n → 0 ≤ α.to_nat n`.


Subring.ext

/-- Two subrings are equal if they have the same elements.  -/
theorem Subring.ext : ∀ {R : Type u} [inst : Ring R] {S T : Subring R}, (∀ (x : R), x ∈ S ↔ x ∈ T) → S = T := by sorry

This theorem states that for any type `R` equipped with a ring structure, if `S` and `T` are two subrings of `R` and every element `x` of `R` belongs to `S` if and only if it belongs to `T`, then `S` and `T` are equal. In other words, two subrings of a given ring are considered identical if they contain exactly the same elements.

If two subrings of a ring contain the same elements, then they are equal.


theorem Pi.mul_apply :
    ∀ {I : Type u} {f : I → Type v₁} (x y : (i : I) → f i) (i : I) [inst : (i : I) → Mul (f i)],
      (x * y) i = x i * y i :=
  by sorry

This theorem states that for any type `I` and a function `f` mapping `I` to another type `v₁`, given two functions `x` and `y` from `I` to `f i` and an element `i` of type `I`, and assuming that a multiplication operation is defined for each `f i`, the result of multiplying the functions `x` and `y` (i.e., `(x * y)`) applied to `i` is equal to the result of multiplying the values of `x i` and `y i`. In other words, it formalizes the property of point-wise multiplication of functions.

For any type `I` and function `f : I -> Type`, given functions `x, y : I -> f i`, and an element `i : I` with a defined multiplication operation on `f i`, we have `(x * y) i = x i * y i`.


theorem Complex.isPrimitiveRoot_exp :
    ∀ (n : ℕ), n ≠ 0 → IsPrimitiveRoot (Complex.exp (2 * ↑Real.pi * Complex.I / ↑n)) n := by sorry

This theorem, `Complex.isPrimitiveRoot_exp`, states that for any natural number `n` that is not zero, the complex number obtained as the result of the complex exponential function applied to `(2 * pi * i / n)` is a primitive nth root of unity. Here, `pi` refers to the mathematical constant Pi, `i` is the imaginary unit, and the complex exponential function is defined via its Taylor series. A primitive nth root of unity is a complex number whose nth power equals 1 and that is not a kth power of any other complex number for any positive integer k smaller than n. The notation `Complex.exp (2 * ↑Real.pi * Complex.I / ↑n)` represents the complex exponential function applied to the complex number `(2 * pi * i / n)`. The arrow `↑` is the coercion operator in Lean, which allows for the conversion between types — in this case, from real numbers to complex numbers.

For any natural number $n \neq 0$, the complex number $\exp\left(\frac{2\pi i}{n}\right)$ is a primitive $n$th root of unity.


theorem MeasureTheory.lintegral_def :
    ∀ {α : Type u_5} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
      MeasureTheory.lintegral μ f = ⨆ g, ⨆ (_ : ↑g ≤ f), MeasureTheory.SimpleFunc.lintegral g μ :=
  by sorry

The theorem `MeasureTheory.lintegral_def` states that for any measurable space `α` and a measure `μ` on that space, the lower Lebesgue integral of a function `f` mapping from `α` to the extended nonnegative real numbers is equal to the supremum of the integrals of all simple functions `g` that are less than or equal to `f`. This supremum is taken over all such simple functions `g` and their corresponding integral values calculated using the measure `μ`. In other words, in mathematical terms, if $\mu$ is a measure and $f: \alpha \rightarrow [0, \infty]$ is a function, then the lower Lebesgue integral of $f$ with respect to $\mu$ is given by $\sup \{\int g \, d\mu : g \text{ is a simple function and } g \leq f\}$.

The lower Lebesgue integral of a measurable function with respect to a measure is equal to the supremum of the integrals of all simple functions less than or equal to it.


FreeAddGroup.reduce.red

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

This theorem characterizes the `reduce` function in the `FreeAddGroup` context. It states that for any type `α` with a decidable equality and any list `L` of pairs of elements from `α` and boolean values, there is a reflexive-transitive reduction from `L` to its maximally reduced form as computed by the `reduce` function. In other words, given a "word" (represented as a list of pairs of elements and booleans), the `reduce` function will transform this word to its maximally reduced form following the reflexive and transitive property.

For any decidably equal type α and list L of pairs of elements from α with boolean values, the `reduce` function in the `FreeAddGroup` context produces the reflexive-transitive closure of L.


theorem Nat.lt_add_of_pos_right : ∀ {k n : ℕ}, 0 < k → n < n + k := by sorry

This theorem states that for any two natural numbers `k` and `n`, if `k` is greater than zero then `n` is less than `n + k`. In other words, adding a positive natural number `k` to another natural number `n` always results in a number that is larger than `n`.

For all natural numbers `k` and `n`, if `k > 0` then `n < n + k`.


theorem Nat.cast_commute : ∀ {α : Type u_1} [inst : NonAssocSemiring α] (n : ℕ) (x : α), Commute (↑n) x := by sorry

The theorem `Nat.cast_commute` states that for any given type `α`, which has the structure of a non-associative semiring, and for any natural number `n` and any element `x` of type `α`, the cast of `n` to `α` commutes with `x`. In other words, multiplying `n` (after casting to `α`) with `x` yields the same result as multiplying `x` with `n` (after casting to `α`), i.e., `n * x = x * n` holds.

For any non-associative semiring type `α` and natural number `n`, the operation of casting `n` to `α` commutes with multiplication by any element `x` in `α`, i.e., `n * x = x * n`.


SchwartzMap.smooth

/-- Every Schwartz function is smooth.  -/
theorem SchwartzMap.smooth :
    ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (f : SchwartzMap E F) (n : ℕ∞), ContDiff ℝ n ⇑f :=
  by sorry

This theorem states that every Schwartz function is smooth, which means it is infinitely differentiable. In more detail, for any types `E` and `F` (where `E` and `F` are normed additive commutative groups and normed spaces over the real numbers), and for any function `f` that is a Schwartz map from `E` to `F`, the function `f` is continuously differentiable at any order `n`, where `n` is a natural number or infinity.

Every Schwartz function is infinitely differentiable.


ContinuousWithinAt.tendsto

/-- If a function is continuous within `s` at `x`, then it tends to `f x` within `s` by definition.
We register this fact for use with the dot notation, especially to use `Filter.Tendsto.comp` as
`ContinuousWithinAt.comp` will have a different meaning.  -/
theorem ContinuousWithinAt.tendsto :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {x : α}, ContinuousWithinAt f s x → Filter.Tendsto f (nhdsWithin x s) (nhds (f x)) :=
  by sorry

This theorem states that if a function is continuous within a set `s` at a point `x`, then the function `f` tends to `f(x)` within the set `s` as `x` approaches `x`. This is registered for use with the dot notation, particularly for using `Filter.Tendsto.comp`. Notably, `ContinuousWithinAt.comp` will have a distinct meaning. The theorem is defined for any types `α` and `β` that come equipped with topological spaces, a function `f` from `α` to `β`, a set `s` of `α`, and a point `x` of `α`.

If a function `f` is continuous at `x` in set `s`, then `f` converges to `f(x)` as `x` approaches any point in `s`.


theorem Ideal.mem_sInf :
    ∀ {R : Type u} [inst : Semiring R] {s : Set (Ideal R)} {x : R}, x ∈ sInf s ↔ ∀ ⦃I : Ideal R⦄, I ∈ s → x ∈ I := by
  sorry

The theorem `Ideal.mem_sInf` is about the membership condition in the infimum of a set of ideals in a semiring. It states that, for any type `R` equipped with a semiring structure, a set `s` of ideals in `R`, and an element `x` of `R`, `x` is a member of the infimum of `s` if and only if for every ideal `I` in `s`, `x` is a member of `I`. In other words, an element is in the infimum of a set of ideals if it is contained in every ideal of the set.

An element x belongs to the infimum of a set S of ideals in a semiring R if and only if x is contained in every ideal I in S.


theorem Int.natAbs_dvd_natAbs : ∀ {a b : ℤ}, Int.natAbs a ∣ Int.natAbs b ↔ a ∣ b := by sorry

This theorem is stating a relationship between the absolute values of integers and the divisibility of those integers. More specifically, for any two integers `a` and `b`, the absolute value of `a` divides the absolute value of `b` if and only if `a` divides `b`. This means that the concept of divisibility is preserved when taking the absolute values of the integers.

For all integers a and b, |a| |b| if and only if a | b. (Where "|" represents the absolute value and "|/" represents divisibility.)


theorem AddMonoidHom.mrange_eq_map :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F), AddMonoidHom.mrange f = AddSubmonoid.map f ⊤ :=
  by sorry

The theorem `AddMonoidHom.mrange_eq_map` states that for any types `M`, `N`, and `F`, where `M` and `N` have the structure of add-zero classes, `F` behaves like a function from `M` to `N` and `F` is an additive monoid homomorphism, then for any instance `f` of `F`, the range of `f` (considered as an additive monoid homomorphism) is equal to the image of the entire additive submonoid of `M` under `f`. In simpler terms, this theorem says that the set of all outputs of `f` is the same as the set of all values `f` can produce when applied to all elements of `M`.

For any additive monoid homomorphism `f` from an add-zero class `M` to an add-zero class `N`, the image of the submonoid generated by `M` under `f` equals the range of `f`.


theorem eq_of_le_of_not_lt : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → ¬a < b → a = b := by sorry

This theorem states that for any type `α` that has a partial order, if `a` and `b` are elements of type `α`,  `a` is less than or equal to `b`, and it is not true that `a` is strictly less than `b`, then `a` must be equal to `b`. The proof is left as an exercise. This theorem essentially encapsulates the relationship between the less-than-or-equal-to relation (`≤`), the strictly-less-than relation (`<`), and the equality relation (`=`) in a partial order.

In a partially ordered type, if `a` is less than or equal to `b` and not strictly less than `b`, then `a` equals `b`.


/-- Unfolds the definition of the `p`-adic norm of `q` when `q ≠ 0`.  -/
theorem padicNorm.eq_zpow_of_nonzero : ∀ {p : ℕ} {q : ℚ}, q ≠ 0 → padicNorm p q = ↑p ^ (-padicValRat p q) := by sorry

This theorem describes the `p`-adic norm of a rational number `q` when `q` is not zero. Specifically, for any natural number `p` and any rational number `q`, if `q` is not equal to zero, then the `p`-adic norm of `q` is equal to `p` raised to the power of the negative of the `p`-adic valuation of `q`. The `p`-adic valuation of `q` is the difference between the `p`-adic valuation of the numerator of `q` and the `p`-adic valuation of the denominator of `q`.

For any natural number $p$ and rational number $q \neq 0$, the $p$-adic norm of $q$ is equal to $p^{-\text{vp}(q)}$, where $\text{vp}(q) = \text{vp}(q_\text{num}) - \text{vp}(q_\text{den})$, and $\text{vp}(x)$ denotes the $p$-adic valuation of $x$.


theorem IsOpen.mem_nhdsSet :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, IsOpen s → (s ∈ nhdsSet t ↔ t ⊆ s) := by sorry

This theorem states that for any type `X` equipped with a topological structure (denoted as `TopologicalSpace X`) and for any two sets `s` and `t` of type `X`, if `s` is an open set, then `s` belongs to the filter of neighborhoods of `t` (denoted as `nhdsSet t`) if and only if `t` is a subset of `s`. In mathematical terms, an open set `s` is in the neighborhood filter of a set `t` precisely when `t` is contained in `s`.

For any topological space X and sets s and t in X, s is in the neighborhood filter of t if and only if t is a subset of s.


theorem Submodule.sub_mem :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] {module_M : Module R M} (p : Submodule R M)
      {x y : M}, x ∈ p → y ∈ p → x - y ∈ p :=
  by sorry

This theorem, `Submodule.sub_mem`, states that for any ring `R` and any additive commutative group `M` which is a module over `R`, and any submodule `p` of `M`, if `x` and `y` are both elements of `p`, then the subtraction of `y` from `x` is also an element of `p`. This theorem essentially asserts the closed property of subtraction operation in the context of a submodule.

For any ring `R`, additive commutative group `M` being an `R`-module, and submodule `p` of `M`, if `x, y ∈ p`, then `x - y ∈ p`.


theorem Nat.one_lt_iff_ne_zero_and_ne_one : ∀ {n : ℕ}, 1 < n ↔ n ≠ 0 ∧ n ≠ 1 := by sorry

This theorem is stating that for any natural number `n`, the condition `1 < n` is equivalent to the conditions `n ≠ 0` and `n ≠ 1`. In other words, a natural number `n` is greater than one if and only if `n` is not equal to zero and `n` is not equal to one.

For any natural number `n`, the conditions `1 < n`, `n ≠ 0`, and `n ≠ 1` are equivalent.


theorem AddUnits.neg_add_cancel_left :
    ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) (b : α), ↑(-a) + (↑a + b) = b := by sorry

This theorem, `AddUnits.neg_add_cancel_left`, states that for any type `α` that is an additive monoid and given any element `a` of `AddUnits α` and `b` of α, adding the additive inverse of `a` (`-a`) to the sum of `a` and `b` will cancel `a`, producing `b` as the result. In mathematical terms, this can be written as `(-a) + (a + b) = b` where `a` is an element of the additive units of α and `b` is an element of α.

For any additive monoid type `α` and elements `a` in its additive units and `b` in `α`, `-a + (a + b) = b`.


theorem subsingleton_iff : ∀ {α : Type u_1}, Subsingleton α ↔ ∀ (x y : α), x = y := by sorry

This theorem, `subsingleton_iff`, states that for any type `α`, `α` is a subsingleton if and only if for any two elements `x` and `y` of `α`, `x` equals `y`. In other words, a type is a subsingleton when all its elements are equal. Subsingletons in Lean 4 are types that have at most one element.

A type `α` is a subsingleton if and only if every two elements `x` and `y` in `α` are equal, i.e., `x = y`.


/-- `smul` can be moved from one side of the product to the other . -/
theorem TensorProduct.smul_tmul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {R' : Type u_2} [inst_1 : Monoid R'] {M : Type u_4} {N : Type u_5}
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : DistribMulAction R' M] [inst_7 : DistribMulAction R' N] [inst_8 : TensorProduct.CompatibleSMul R R' M N]
      (r : R') (m : M) (n : N), (r • m) ⊗ₜ[R] n = m ⊗ₜ[R] (r • n) :=
  by sorry

This theorem states that for any commutative semiring `R`, any monoid `R'`, and any two modules `M` and `N` over `R` that also have a distribution action of `R'`, the scalar multiplication `smul` can be moved from one side of the tensor product to the other. More specifically, for any element `r` from `R'`, `m` from `M` and `n` from `N`, the tensor product of the scalar multiplication of `r` and `m` with `n` is equal to the tensor product of `m` with the scalar multiplication of `r` and `n`, given that the scalar multiplication and tensor product are compatible.

For any commutative semiring `R`, monoid `R'`, and modules `M` and `N` over `R` with a distribution action of `R'`, the scalar multiplication of `R'` commutes with the tensor product of `M` and `N`, i.e., `r * (m ⊤ n) = (r * m) ⊤ n` for all `r` in `R`, `m` in `M`, and `n` in `N`.


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

This theorem is about the concept of absolute value in mathematics. Specifically, it states that for any absolute value function `abv` from a semiring `R` to an ordered semiring `S`, an element `x` in `R` will have an absolute value of zero if and only if `x` itself is zero. This mirrors the familiar property of absolute value in real numbers where the absolute value of a number is zero if and only if the number itself is zero.

For any semiring homomorphism (absolute value function) `abv` from a semiring `R` to an ordered semiring `S`, `abv(x) = 0` if and only if `x = 0`.


theorem le_self_mul : ∀ {α : Type u} [inst : CanonicallyOrderedCommMonoid α] {a c : α}, a ≤ a * c := by sorry

This theorem states that for any type `α` which is a canonically ordered commutative monoid, and any elements `a` and `c` of `α`, `a` is less than or equal to the product of `a` and `c`. This is a property of the multiplicative structure in canonically ordered commutative monoids.

In a canonically ordered commutative monoid `α`, for all elements `a` and `c` in `α`, we have `a ≤ a * c`.


theorem UniformInducing.uniformContinuous_iff :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : UniformSpace γ]
      {f : α → β} {g : β → γ}, UniformInducing g → (UniformContinuous f ↔ UniformContinuous (g ∘ f)) :=
  by sorry

The theorem `UniformInducing.uniformContinuous_iff` states that for any types `α`, `β`, and `γ` equipped with uniform spaces, and any functions `f : α → β` and `g : β → γ`, if `g` is a uniform inducing function, then `f` is uniformly continuous if and only if the composition of `g` and `f` (denoted `g ∘ f`) is uniformly continuous. In other words, the uniform continuity of `f` can be characterized through the uniform continuity of its composition with a uniform inducing function `g`.

Given uniform spaces on types α, β, and γ, and uniformly inducing function g : β → γ, the function f : α → β is uniformly continuous if and only if the composition g ∘ f is uniformly continuous.


theorem Multiset.mem_filter :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α},
      a ∈ Multiset.filter p s ↔ a ∈ s ∧ p a :=
  by sorry

This theorem, `Multiset.mem_filter`, states a property about filtering a multiset. Specifically, for any type `α`, a predicate `p` that is decidable for members of type `α`, an element `a` of type `α`, and a multiset `s` of elements of type `α`, an element `a` is in the filtered multiset (where the multiset `s` is filtered by the predicate `p`) if and only if the element `a` is in the original multiset `s` and the predicate `p` is true for `a`. In other words, the theorem provides a condition for membership in a filtered multiset - an item appears in the filtered version if it appears in the original and satisfies the filter condition.

For any type `α`, decidable predicate `p` on `α`, multiset `s` over `α`, and `a` in `α`, `a` is in the filtered multiset `Multiset.filter p s` if and only if `a` is in `s` and `p(a)` holds.


theorem mul_neg_of_neg_of_pos :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : MulPosStrictMono α],
      a < 0 → 0 < b → a * b < 0 :=
  by sorry

The theorem `mul_neg_of_neg_of_pos` states that, for any type `α` that is a multiplication zero class (`MulZeroClass`), has a preorder, and satisfies the property of strict monotonicity of multiplication by positive elements (`MulPosStrictMono`), if `a` is less than zero and `b` is greater than zero, then the product of `a` and `b` is less than zero. In other words, it states that multiplying a negative number by a positive number results in a negative number, under the conditions specified by the typeclasses involved.

If `α` is a type with multiplication, zero, preorder, and strict monotonicity properties such that `a` is negative and `b` is positive, then `a * b` is negative.


theorem List.mem_map_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {l : List α} (f : α → β), a ∈ l → f a ∈ List.map f l := by sorry

This theorem states that for any type `α` and `β`, any element `a` of type `α`, any list `l` of elements of type `α`, and any function `f` from `α` to `β`, if `a` is an element of the list `l`, then `f(a)`, the result of applying the function `f` to `a`, is an element of the list obtained by applying the function `f` to each element of the list `l`. This is a statement about list transformation: elements in the original list maintain their membership in the transformed list when a function is applied to them.

If `a` is an element of list `l` of type `α`, then `f(a)` is an element of the list `map f l` of type `β`, where `map f l` is the list obtained by applying the function `f` to each element of `l`.


/-- A subsemiring `S` includes `closure s` if and only if it includes `s`.  -/
theorem Subsemiring.closure_le :
    ∀ {R : Type u} [inst : NonAssocSemiring R] {s : Set R} {t : Subsemiring R}, Subsemiring.closure s ≤ t ↔ s ⊆ ↑t := by
  sorry

This theorem states that, for any type `R` with the structure of a nonassociative semiring, and any set `s` of elements of `R` and any subsemiring `t` of `R`, the subsemiring generated by `s` (denoted as `Subsemiring.closure s`) is a subset of `t` if and only if `s` is a subset of `t`. In other words, a subsemiring `t` includes the smallest possible subsemiring `Subsemiring.closure s` which includes all elements of `s` if and only if `t` includes all elements of `s` directly.

For any nonassociative semiring `R`, set `s` of elements in `R`, and subsemiring `t` of `R`, `Subsemiring.closure s ⊆ t` if and only if `s ⊆ t`.


theorem Real.sSup_of_not_bddAbove : ∀ {s : Set ℝ}, ¬BddAbove s → sSup s = 0 := by sorry

The theorem `Real.sSup_of_not_bddAbove` states that for any set `s` of real numbers, if `s` is not bounded above, then the supremum of `s` is equal to zero. This means if there is no real number that serves as an upper bound for all elements in the set `s`, then the least upper bound (or supremum) of this set is zero.

If a set of real numbers has no upper bound, then its supremum equals 0.


QuotientGroup.eq

theorem QuotientGroup.eq : ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {a b : α}, ↑a = ↑b ↔ a⁻¹ * b ∈ s := by
  sorry

This theorem states that for any group `α` and any subgroup `s` of `α`, two elements `a` and `b` of `α` are equivalent in the quotient group `α / s` if and only if the element obtained by multiplying the inverse of `a` with `b` belongs to the subgroup `s`. In mathematical terms, $a \sim b$ in the quotient group if and only if $a^{-1}b \in s$.

In a group, two elements are equivalent in the quotient group if and only if their product with the inverse of one element belongs to the subgroup. ($a \sim b$ in the quotient group if and only if $a^{-1}b \in s$).


theorem Finset.mem_image₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {c : γ}, c ∈ Finset.image₂ f s t ↔ ∃ a ∈ s, ∃ b ∈ t, f a b = c :=
  by sorry

The theorem `Finset.mem_image₂` states that for any types `α`, `β`, and `γ` with a decidable equality operation on `γ`, and any binary function `f : α → β → γ`, finite sets `s : Finset α` and `t : Finset β`, and an element `c : γ`, that element `c` is in the image of the binary function `f` applied across the Cartesian product of sets `s` and `t` if and only if there exist elements `a` in `s` and `b` in `t` such that applying `f` to `a` and `b` yields `c`. In mathematical terms, $c \in Im(f; s \times t)$ if and only if $\exists a \in s, b \in t : f(a, b) = c$.

The theorem asserts that an element is in the image of a binary function applied to the Cartesian product of two finite sets if and only if there exist elements in each set whose application of the function results in that element.


theorem Set.infinite_univ : ∀ {α : Type u} [h : Infinite α], Set.Infinite Set.univ := by sorry

This theorem states that for any type `α` that is infinite, the universal set of `α`, denoted by `Set.univ`, is also infinite. Here, `Infinite α` is a hypothesis which asserts the infiniteness of the type `α`, and `Set.Infinite` is a property of a set that it is not finite. Therefore, the theorem essentially states that the infiniteness of a type implies the infiniteness of the universal set over that type.

If `α` is an infinite type, then `Set.univ (α : Type)` is an infinite set.


theorem Units.smul_def :
    ∀ {M : Type u_3} {α : Type u_5} [inst : Monoid M] [inst_1 : SMul M α] (m : Mˣ) (a : α), m • a = ↑m • a := by sorry

This theorem, `Units.smul_def`, states that for any type `M` that is a monoid and any type `α` that allows scalar multiplication by `M`, if we have a unit `m` of `M` and an element `a` of `α`, then the scalar multiplication of `a` by `m` (written as `m • a`) is equivalent to the scalar multiplication of `a` by the value of `m` (written as `↑m • a`). In other words, the scalar multiplication operation behaves the same way whether we consider `m` as a unit or as a value of the monoid `M`.

For any monoid `M` and type `α` with scalar multiplication, and for any unit `m` in `M` and element `a` in `α`, `m • a` is equal to `↑m • a`.


theorem small_of_surjective :
    ∀ {α : Type v} {β : Type w} [inst : Small.{u, v} α] {f : α → β}, Function.Surjective f → Small.{u, w} β := by sorry

The theorem `small_of_surjective` states that for all types `α` and `β`, if `α` is a "small" type and there exists a surjective function `f` from `α` to `β`, then `β` is also a "small" type. Here, a function `f` is surjective if for every element of `β`, there exists an element of `α` such that applying `f` to this element of `α` gives the element of `β`. The term "small" refers to a concept in type theory, usually referring to types that are not too large in some sense. This theorem is saying that the "smallness" property is preserved under surjective functions.

If `α` is a small type and there exists a surjective function from `α` to `β`, then `β` is also a small type.


theorem Complex.arg_ofReal_of_nonneg : ∀ {x : ℝ}, 0 ≤ x → Complex.arg ↑x = 0 := by sorry

The theorem `Complex.arg_ofReal_of_nonneg` states that for every real number `x` that is equal to or greater than zero, the argument function (`arg`) of the complex number created from `x` (denoted as `↑x`) is equal to zero. The argument function of a complex number is a way to measure the angle that the complex number forms with the positive real axis when it is represented in the plane. In this specific case, the theorem says that any non-negative real number forms an angle of zero degrees with the positive real axis when it is seen as a complex number.

For every non-negative real number x, the argument of the complex number ↑x is equal to 0.


theorem MeasureTheory.lintegral_one :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}, ∫⁻ (x : α), 1 ∂μ = ↑↑μ Set.univ := by sorry

This theorem states that for any type `α`, any measurable space `m` of type `α`, and any measure `μ` from the Measure Theory, the Lebesgue integral (denoted by ∫⁻) of the constant function 1 with respect to the measure `μ` is equal to the measure of the universal set (i.e., the set of all elements) of type `α`. In mathematical terms, it denotes that the integral over the entire space of the constant function 1 is just the total measure of the space.

For any measurable space `(α, m)` and measure `μ` from Measure Theory, ∫⁻(1 dμ) = m α.


theorem Linarith.mul_nonpos : ∀ {α : Type u_1} [inst : OrderedRing α] {a b : α}, a ≤ 0 → 0 < b → b * a ≤ 0 := by sorry

This theorem states that for any ordered ring `α`, for any two elements `a` and `b` in `α`, if `a` is less than or equal to zero and `b` is greater than zero, then the product of `b` and `a` is less than or equal to zero. Here, an ordered ring is a ring with an order relation that is compatible with the ring operations.

In an ordered ring, the product of any element less than or equal to zero with any positive element is less than or equal to zero.


theorem Set.pairwise_insert_of_symmetric :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
      Symmetric r → (Set.Pairwise (insert a s) r ↔ Set.Pairwise s r ∧ ∀ b ∈ s, a ≠ b → r a b) :=
  by sorry

This theorem states that for any type `α`, a binary relation `r` defined on `α`, a set `s` of `α`, and an element `a` of `α`, if the relation `r` is symmetric, then the relation `r` holds pairwise on the set obtained by inserting `a` into `s` if and only if `r` holds pairwise on the set `s` and `r` holds between `a` and any distinct element `b` in `s`. This theorem connects the property of pairwise relations on a set with the concept of symmetric relations. It essentially says that inserting an element into a set preserves the pairwise property of a symmetric relation.

For any type `α`, set `s` of `α`, element `a` in `α`, and symmetric binary relation `r` on `α`, `r` holds pairwise on `s ∪ {a}` if and only if `r` holds pairwise on `s` and `r(a, b)` for all distinct `b` in `s`.


theorem LinearMap.range_eq_map :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] (f : F), LinearMap.range f = Submodule.map f ⊤ :=
  by sorry

The theorem `LinearMap.range_eq_map` states that for all types `R`, `R₂`, `M`, `M₂` and `F`, if `R` and `R₂` are semirings, `M` and `M₂` are additive commutative monoids, `M` and `M₂` are modules over `R` and `R₂` respectively, `τ₁₂` is a surjective ring homomorphism from `R` to `R₂`, `F` is a function-like type from `M` to `M₂`, and `f` is an instance of `F`, then the range of the linear map `f` is equal to the image of the top-level submodule (denoted as `⊤`) under the map `f`. Basically, it says that the set of all possible outputs of a linear map `f` is the same as the set of all results of applying `f` to every element of the top-level submodule.

For a surjective ring homomorphism τ₁₂ from semirings R to R₂, and a linear map f from an additive commutative monoid and module M over R to an additive commutative monoid and module M₂ over R₂, the range of f equals the image of the top-level submodule ⊤ under f.


theorem MeasureTheory.SimpleFunc.finite_range :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β),
      Set.Finite (Set.range ↑f) :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.finite_range` states that for any measurable space `α` and type `β`, the range of any simple function (a function from `α` to `β` that only takes a finite number of distinct values) is a finite set. In other words, there exists a natural number `n` such that there is an equivalence between the range of the simple function and the set of natural numbers less than `n`.

A simple function from a measurable space to a type with a finite range is equal in size to some finite set.


theorem Nat.div_eq : ∀ (x y : ℕ), x / y = if 0 < y ∧ y ≤ x then (x - y) / y + 1 else 0 := by sorry

This theorem expresses how division is calculated for two natural numbers `x` and `y`. If `y` is positive and less than or equal to `x`, then the quotient of `x / y` is computed by subtracting `y` from `x`, performing the division of the result by `y`, and then adding one. If `y` is not positive or is greater than `x`, then the quotient of `x / y` is simply zero. In essence, this theorem captures the core behavior of integer division in mathematics.

For natural numbers `x` and `y` with `y > 0` and `y <= x`, the quotient `x / y` equals `(x - y) / y + 1`. Otherwise, `x / y` equals 0.


theorem iSup_comm :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : CompleteLattice α] {f : ι → ι' → α},
      ⨆ i, ⨆ j, f i j = ⨆ j, ⨆ i, f i j :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, and any two sorts `ι` and `ι'`, the supremum (⨆) of the function `f` where `f` takes arguments of `ι` and `ι'` does not depend on the order of supremum calculation. In other words, taking the supremum first over `ι`, then `ι'`, yields the same result as taking the supremum first over `ι'`, then `ι`. This property is known as the commutativity of the double supremum operation.

For any complete lattice `α`, the order of calculating supremums commutes: sup(_ i, sup(_ j, a)) = sup(_ j, sup(_ i, a)).


theorem mul_lt_mul' :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a b c d : α}, a ≤ c → b < d → 0 ≤ b → 0 < c → a * b < c * d := by
  sorry

This theorem states that for any strictly ordered semiring `α`, given four elements `a`, `b`, `c`, and `d` of `α`, if `a` is less than or equal to `c`, `b` is less than `d`, `b` is non-negative and `c` is positive, then the product of `a` and `b` is less than the product of `c` and `d`. In mathematical notation, this would be written as: if $a \leq c$, $b < d$, $b \geq 0$ and $c > 0$, then $a \cdot b < c \cdot d$.

If `a` is a non-negative element less than a positive element `c` in a strictly ordered semiring, then `a` multiplied by another non-negative element `b` is strictly less than `c` multiplied by another element `d`. In mathematical notation: `0 ≤ a ≤ c`, `b > 0` implies `a * b < c * d`.


theorem Mathlib.Data.Set.Lattice._auxLemma.1 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

This theorem states that for any type `α`, any sort `ι`, any element `x` of type `α`, and any indexed family of sets `s` of type `α` indexed by `ι`, the membership of `x` in the union of all sets in the family `s` is equivalent to the existence of an index `i` such that `x` is a member of the set `s i`. In other words, an element belongs to the union of a collection of sets if and only if it belongs to at least one of the sets in the collection.

For any type `α`, sort `ι`, element `x` of type `α`, and indexed family `s` of sets over `α` indexed by `ι`, `x ∈ ⋃ i, s i <--> ∃ i, x ∈ s i`.


theorem MeasureTheory.ae_zero : ∀ {α : Type u_1} {_m0 : MeasurableSpace α}, MeasureTheory.Measure.ae 0 = ⊥ := by sorry

This theorem states that for any type `α` and any measurable space `_m0` on `α`, the "almost everywhere" filter of the zero measure is the bottom filter. In more mathematical terms, it means that in any measurable space, the set of all points where a null measure is non-zero is empty.

In any measurable space, the filter of sets of measure zero is the bottom filter.


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

This theorem states that for any two types `α` and `β`, a function `l` from `α` to `β`, a function `u` from `β` to `α`, and two elements `a` and `b` of type `α`, given that there exists a Galois coinsertion for `l` and `u`, and both `α` and `β` are semilattice sups, then applying `u` to the sup of `l a` and `l b` yields the same result as taking the sup of `a` and `b` itself. In other words, the sup operation (usually depicted as `⊔`), when applied after the function `l` and then `u`, is preserved. This theorem is a fundamental property of Galois coinsertions in the context of ordered algebraic structures.

For any semilattice suprema `l a`, `l b` of types `α`, and functions `l : α → β`, `u : β → α` with a Galois coinsertion, we have `u (l a ⊔ l b) = a ⊔ b`.


/-- `Quotient.mk'` is a surjective function.  -/
theorem surjective_quotient_mk' : ∀ (α : Sort u_3) [s : Setoid α], Function.Surjective Quotient.mk' := by sorry

The theorem `surjective_quotient_mk'` states that for all types α equipped with a setoid relation, the canonical quotient map `Quotient.mk'` is a surjective function. In other words, for every element in the quotient set, there exists an element in the original set such that the quotient map applied to this element produces the given element in the quotient set. Surjectivity of `Quotient.mk'` ensures that every equivalence class in the quotient set can be generated by some element from the original set.

For any setoid type α, the quotient map `Quotient.mk'` is a surjection from α to its quotient set.


theorem le_generateFrom :
    ∀ {α : Type u} {t : TopologicalSpace α} {g : Set (Set α)},
      (∀ s ∈ g, IsOpen s) → t ≤ TopologicalSpace.generateFrom g :=
  by sorry

This theorem states that for any type `α`, given a topological space `t` over this type and a set `g` of subsets of `α`, if every set in `g` is open in the topological space `t`, then `t` is coarser (i.e., less fine or equal) than the topological space generated from `g`. This generated topology consists of the smallest topological space that contains `g` as their open sets.

In mathematical terms, we have a topological space `(α, t)` and a collection `g` of its open subsets. If `g` contains only open sets of `(α, t)`, then the topology `t` is less fine than or equal to the topology generated from the sets in `g`.

If a collection `g` of subsets of a topological space `(α, t)` consists only of open sets, then the topology generated from `g` is coarser than or equal to `t`.


IsBoundedBilinearMap.continuous

/-- Useful to use together with `Continuous.comp₂`.  -/
theorem IsBoundedBilinearMap.continuous :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E × F → G},
      IsBoundedBilinearMap 𝕜 f → Continuous f :=
  by sorry

This theorem states that for all normed spaces E, F, G over a non-trivially normed field 𝕜, if a function `f` from the Cartesian product of E and F to G is a bounded bilinear map, then `f` is continuous. This theorem is particularly useful when used in combination with the `Continuous.comp₂` theorem.

A bounded bilinear map between two normed spaces over a non-trivially normed field is continuous.


Continuous.snd

/-- Postcomposing `f` with `Prod.snd` is continuous  -/
theorem Continuous.snd :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y × Z}, Continuous f → Continuous fun x => (f x).2 :=
  by sorry

This theorem states that for any three types `X`, `Y`, and `Z`, given that `X`, `Y`, and `Z` are topological spaces, and there is a continuous function `f` from `X` to the product space `Y × Z`, the function obtained by post-composing `f` with `Prod.snd` (which extracts the second component of the product) is also continuous. In other words, if `f` is a continuous function that produces pairs of elements, the operation of taking the second element of the pair produced by `f` is also a continuous function.

Given three topological spaces X, Y, and Z, and a continuous function f : X → Y × Z, the function Proj.snd ∘ f : X → Z is continuous.


theorem mem_closure_of_tendsto :
    ∀ {X : Type u} {α : Type u_1} {x : X} {s : Set X} [inst : TopologicalSpace X] {f : α → X} {b : Filter α}
      [inst_1 : Filter.NeBot b], Filter.Tendsto f b (nhds x) → (∀ᶠ (x : α) in b, f x ∈ s) → x ∈ closure s :=
  by sorry

This theorem states that, given a type `X` equipped with a topological space structure, a type `α`, an element `x` of `X`, a set `s` of `X`, a function `f` from `α` to `X`, and a filter `b` on `α` which is not the bottom filter, if the function `f` tends from filter `b` to the neighborhood filter of `x` and almost every element `x` in the filter `b` is in the set `s` when mapped under function `f`, then `x` is in the closure of the set `s` in the topology of `X`. In other words, if a function satisfies these conditions, then the limit point of the function belongs to the closure of the set through which almost all points in the filter pass under the function.

If a function from a non-bottom filter on a space equipped with a topology maps almost all filter elements to a set and tends to a limit point in the neighborhood of a point in the space, then that limit point is in the closure of the set in the topology.


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

This theorem states that for any type `α` that has a preorder structure, and for any two elements `a` and `b` of this type, the left-closed right-closed interval from `a` to `b` (denoted as `Set.Icc a b`, including all `x` such that `a ≤ x ≤ b`) is a subset of the left-infinite right-closed interval ending at `b` (denoted as `Set.Iic b`, including all `x` such that `x ≤ b`).

For any preorder type `α` and elements `a ≤ b` in `α`, the left-closed right-closed interval `Set.Icc a b` is a subset of the left-infinite right-closed interval `Set.Iic b`.


theorem Complex.log_im : ∀ (x : ℂ), (Complex.log x).im = Complex.arg x := by sorry

The theorem `Complex.log_im` states that for all complex numbers `x`, the imaginary part of the natural logarithm of `x` is equal to the argument of `x`. This means that when you take the natural logarithm of a complex number and then obtain the imaginary part of the result, it is the same as getting the argument of the original complex number. The "argument" of a complex number is the angle it makes with the positive real axis when represented in polar coordinates.

The theorem `Complex.log_im` asserts that for all complex numbers x, Im (log x) = Arg x, where log is the natural logarithm, Im denotes the imaginary part, and Arg represents the argument.


/-- The fundamental property of the operator norm: `‖f x‖ ≤ ‖f‖ * ‖x‖`.  -/
theorem NormedAddGroupHom.le_opNorm :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂) (x : V₁), ‖f x‖ ≤ ‖f‖ * ‖x‖ :=
  by sorry

This Lean theorem, `NormedAddGroupHom.le_opNorm`, is stating the fundamental property of the operator norm in the context of normed additive commutative groups. Specifically, for any two types `V₁` and `V₂` that are seminormed additive commutative groups, and for any normed additive group homomorphism `f` from `V₁` to `V₂`, the norm of `f(x)` is always less than or equal to the product of the norm of `f` and the norm of `x`. This is often referred to as the inequality of the operator norm.

For any normed additive commutative groups V₁ and V₂ and any normed additive group homomorphism f from V₁ to V₂, the norm of f(x) is less than or equal to the norm of f multiplied by the norm of x for all x in V₁.


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

The theorem `Set.image2_image_right` states that for all sets `s` of type `α` and `t` of type `β`, and for all functions `f : α → γ → δ` and `g : β → γ`, the image of the binary function `f` on the set `s` and the image of `g` on set `t` (`g '' t`) is equal to the image of the binary function `(fun a b => f a (g b))` on the sets `s` and `t`. In other words, it shows that applying the function `g` to the elements of `t` before or after forming the image under the binary function `f` does not change the resulting set.

For all sets `s` of type `α`, `t` of type `β`, functions `f : α → γ → δ`, and `g : β → γ`, the images `f '' s` and `(g '' t) → δ` under the binary functions `f` and `(λ a b, f a (g b))` are equal.


ContDiff.add

/-- The sum of two `C^n`functions is `C^n`.  -/
theorem ContDiff.add :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      {f g : E → F}, ContDiff 𝕜 n f → ContDiff 𝕜 n g → ContDiff 𝕜 n fun x => f x + g x :=
  by sorry

This theorem states that given two functions `f` and `g` that are `C^n` (i.e., continuously differentiable n times) from a normed space `E` to a normed space `F` over a nontrivially normed field `𝕜`, the sum of these two functions is also `C^n`. In other words, the sum of two continuously differentiable functions is also continuously differentiable.

Given two `C^n` functions `f : E -> F` and `g : E -> F` from a normed space `E` to a normed space `F` over a nontrivially normed field `𝕜`, their sum `f + g : E -> F` is also a `C^n` function.


theorem Nat.add_one_sub_one : ∀ (n : ℕ), n + 1 - 1 = n := by sorry

This theorem states that for any natural number `n`, if you add 1 to `n` and then subtract 1, you will get `n` back. In other words, the operations of adding 1 and subtracting 1 on a natural number cancel each other out, leaving the original number unchanged. This is expressed formally in Lean 4 as `n + 1 - 1 = n` for all natural numbers `n`.

For all natural numbers `n`, the operation of adding 1 and then subtracting 1 is equal to the identity function, that is, `n + 1 - 1 = n`.


/-- The multiplicity of `a` as root of a nonzero polynomial `p` is at least `n` iff
`(X - a) ^ n` divides `p`.  -/
theorem Polynomial.le_rootMultiplicity_iff :
    ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R},
      p ≠ 0 → ∀ {a : R} {n : ℕ}, n ≤ Polynomial.rootMultiplicity a p ↔ (Polynomial.X - Polynomial.C a) ^ n ∣ p :=
  by sorry

This theorem states that for any commutative ring `R`, a nonzero polynomial `p` of `R`, an element `a` of `R`, and a natural number `n`, the multiplicity of `a` as a root of `p` is greater than or equal to `n` if and only if the polynomial `(X - a) ^ n` divides `p`. Here, `X` represents the polynomial variable and `C a` represents the constant polynomial `a`. The multiplicity of `a` as a root of `p` is defined as the largest power of `(X - a)` that divides `p`.

For any commutative ring R, a nonzero polynomial p of R, an element a of R, and a natural number n, the element a is a root of multiplicity greater than or equal to n of polynomial p if and only if (X - a) ^ n divides p.


theorem HahnSeries.support_nonempty_iff :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] {x : HahnSeries Γ R},
      Set.Nonempty (HahnSeries.support x) ↔ x ≠ 0 :=
  by sorry

The theorem `HahnSeries.support_nonempty_iff` states that for any given type `Γ` which has a partial order, any given type `R` which has a zero element, and any `HahnSeries` `x` of type `Γ` and `R`, the support set of `x` (i.e., the set of indices at which `x` has non-zero coefficients) is non-empty if and only if `x` is not equal to zero. In other words, a Hahn series is non-zero if and only if it has at least one non-zero coefficient.

A Hahn series over a type with a partial order and a zero element is non-zero if and only if its support set is non-empty.


/-- **Alias** of `div_le_div_of_nonneg_left`. -/
theorem div_le_div_of_le_left :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 ≤ a → 0 < c → c ≤ b → a / b ≤ a / c := by sorry

This theorem, `div_le_div_of_le_left`, states that for any type `α` that forms a linearly ordered semifield (a field that has a total order that is compatible with the field operations), and for any three elements `a`, `b`, and `c` of type `α`, if `a` is greater than or equal to 0, `c` is strictly greater than 0, and `c` is less than or equal to `b`, then the quotient of `a` divided by `b` is less than or equal to the quotient of `a` divided by `c`. This theorem is an alias of `div_le_div_of_nonneg_left`.

If `α` is a linearly ordered semifield, `a ≥ 0`, `c > 0`, and `c ≤ b`, then `a / b ≤ a / c`.


theorem tendsto_zero_iff_norm_tendsto_zero :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddGroup E] {f : α → E} {a : Filter α},
      Filter.Tendsto f a (nhds 0) ↔ Filter.Tendsto (fun x => ‖f x‖) a (nhds 0) :=
  by sorry

The theorem `tendsto_zero_iff_norm_tendsto_zero` states that for any seminormed additive group `E`, any type `α`, any function `f` from `α` to `E`, and any filter `a` on `α`, the function `f` tends towards zero at the filter `a` if and only if the norm of the function `f` also tends towards zero at the same filter `a`. In other words, a function's values get arbitrarily close to zero under the filter if and only if their norms also get arbitrarily close to zero.

For any seminormed additive group `E`, function `f` from type `α` to `E`, and filter `a` on `α`, the function `f` tends towards zero at `a` if and only if the norm of `f` tends towards zero at `a`.


theorem PartENat.ne_top_iff : ∀ {x : PartENat}, x ≠ ⊤ ↔ ∃ n, x = ↑n := by sorry

This theorem states that for every object `x` of type `PartENat` (which is the type of natural numbers including infinity), `x` is not equal to infinity if and only if there exists a natural number `n` such that `x` is equal to the embedding of `n` into `PartENat`. In other words, a `PartENat` object is not infinity precisely when it is the embedding of a natural number.

For every `PartENat` object `x`, `x` is finite if and only if there exists a natural number `n` such that `x` is equal to the embedding of `n` into `PartENat`.


theorem CategoryTheory.IsPullback.of_vert_isIso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z}
      {g : Y ⟶ Z} [inst_1 : CategoryTheory.IsIso snd] [inst_2 : CategoryTheory.IsIso f],
      CategoryTheory.CommSq fst snd f g → CategoryTheory.IsPullback fst snd f g :=
  by sorry

This theorem states that in a category `C` with objects `P`, `X`, `Y`, and `Z`, given morphisms `fst : P ⟶ X`, `snd : P ⟶ Y`, `f : X ⟶ Z` and `g : Y ⟶ Z`, if `snd` and `f` are isomorphisms and the diagram commutes (i.e., `fst` followed by `f` equals `snd` followed by `g`), then the square formed by these morphisms is a pullback square. A pullback square is a special kind of diagram in category theory that represents the limit of a diagram.

Given morphisms `fst : P ⟶ X`, `snd : P ⟶ Y`, `f : X ⟶ Z`, and `g : Y ⟶ Z` in a category `C` such that `snd` and `f` are isomorphisms and the diagram commutes (`fst ∘ f = snd ∘ g`), then `(fst, f)` is the pullback of `(snd, g)`.


theorem MeasureTheory.Measure.map_zero :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] (f : α → β),
      MeasureTheory.Measure.map f 0 = 0 :=
  by sorry

This theorem states that for any function `f` from a measurable space `α` to another measurable space `β`, the pushforward of the zero measure (denoted as `0`) under `f` is always the zero measure. The pushforward of a measure gives a new measure on `β`, defined by applying the function `f` to the elements of `α`. However, when the original measure is `0`, the pushforward is also `0` regardless of the function `f`.

For any measurable function `f` from a measurable space `α` to a measurable space `β`, the pushforward of the zero measure on `α` is the zero measure on `β`.


OrderEmbedding.wellFounded

theorem OrderEmbedding.wellFounded :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β],
      α ↪o β → (WellFounded fun x x_1 => x < x_1) → WellFounded fun x x_1 => x < x_1 :=
  by sorry

The theorem `OrderEmbedding.wellFounded` states that for any two types `α` and `β` with a pre-ordering, if there exists an order-preserving embedding from `α` to `β` and if `α` is well-founded (i.e., there are no infinitely descending sequences in `α`), then `β` is also well-founded. In other words, the well-foundedness property for a relation is preserved under order-preserving embeddings.

If `α` is a well-founded type with a pre-order and there exists an order-preserving embedding from `α` to `β`, then `β` is also well-founded.


/-- Subtracting two points in the subspace produces a vector in the direction.  -/
theorem AffineSubspace.vsub_mem_direction :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p1 p2 : P},
      p1 ∈ s → p2 ∈ s → p1 -ᵥ p2 ∈ AffineSubspace.direction s :=
  by sorry

The theorem `AffineSubspace.vsub_mem_direction` states that for any ring `k`, any additively commutative group `V`, any module `V` over `k`, any torsor `P` over `V`, and any affine subspace `s` of `P` with respect to `k`, if `p1` and `p2` are any two points in the subspace `s`, then the subtracted vector `p1 -ᵥ p2` will always be a member of the direction of the subspace `s`. Here, the direction of an affine subspace is defined as the submodule spanned by the pairwise differences of points in the subspace.

For any ring `k`, additively commutative group `V`, module `V` over `k`, torsor `P` over `V`, and affine subspace `s` of `P` with respect to `k`, if `p1` and `p2` are in `s`, then `p1 - p2` lies in the submodule spanned by the differences of points in `s`.


theorem LinearMap.comp_apply :
    ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_10} {M₂ : Type u_11} {M₃ : Type u_12}
      [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁]
      [inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂}
      {module_M₃ : Module R₃ M₃} {σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃}
      [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f : M₂ →ₛₗ[σ₂₃] M₃) (g : M₁ →ₛₗ[σ₁₂] M₂) (x : M₁),
      (LinearMap.comp f g) x = f (g x) :=
  by sorry

This theorem, `LinearMap.comp_apply`, states that for all semirings `R₁`, `R₂`, `R₃`, additive commutative monoids `M₁`, `M₂`, `M₃`, where `M₁` is a module over `R₁`, `M₂` is a module over `R₂`, and `M₃` is a module over `R₃`, along with ring homomorphisms `σ₁₂` from `R₁` to `R₂`, `σ₂₃` from `R₂` to `R₃`, and `σ₁₃` from `R₁` to `R₃` that satisfy the ring homomorphism composition triple condition, given two linear maps `f` from `M₂` to `M₃` and `g` from `M₁` to `M₂`, and an element `x` of `M₁`, the application of the composition of `f` and `g` to `x` is the same as first applying `g` to `x` and then applying `f` to the result. This corresponds to the standard mathematical concept of function composition in the context of linear maps and modules.

For linear maps `f : M₂ → M₃` and `g : M₁ → M₂` between modules over semirings `R₁`, `R₂`, `R₃`, and ring homomorphisms `σ₁₂`, `σ₂₃`, `σ₁₃` satisfying the ring homomorphism composition condition, `f (g x) = g (σ₁₃ x) ∘ f` for all `x` in `M₁`.