theorem iSup_subtype' :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : (i : ι) → p i → α},
      ⨆ i, ⨆ (h : p i), f i h = ⨆ x, f ↑x ⋯ :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice and a predicate `p` on a sort `ι`, given a function `f` that maps an element of `ι` satisfying `p` to `α`, the supremum taken over all elements `i` and `h` such that `h` is the proof of `p i` equals the supremum taken over all `x` where `x` is of type `Subtype p` (i.e., elements of `ι` that satisfy `p`). In other words, it tells us that we can find the supremum in the lattice by either going through each element and its corresponding proof or by just considering the subtype of elements that satisfy the predicate.

Given a complete lattice `α` and a predicate `p` on a sort `ι`, the supremum of `{i | ∃h, p i ∧ f i = x}` equals the supremum of `{x | x ∈ Subtype p}`.


theorem add_left_cancel_iff :
    ∀ {G : Type u_1} [inst : Add G] [inst_1 : IsLeftCancelAdd G] {a b c : G}, a + b = a + c ↔ b = c := by sorry

This theorem states that for any type `G` which has a defined addition operation and possesses the left cancellation property under addition, given any three elements `a`, `b`, and `c` of `G`, the statement `a + b = a + c` is equivalent to `b = c`. In other words, the addition operation is left-cancellable in `G`: if adding `a` to `b` results in the same value as adding `a` to `c`, then `b` must be equal to `c`.

For any type `G` with left-cancellative addition operation, `a + b = a + c` implies `b = c`.


/-- `cyclotomic n R` comes from `cyclotomic n ℤ`.  -/
theorem Polynomial.map_cyclotomic_int :
    ∀ (n : ℕ) (R : Type u_1) [inst : Ring R],
      Polynomial.map (Int.castRingHom R) (Polynomial.cyclotomic n ℤ) = Polynomial.cyclotomic n R :=
  by sorry

This theorem states that for any natural number `n` and any ring `R`, the `n`-th cyclotomic polynomial with coefficients in `R` is obtained by mapping the `n`-th cyclotomic polynomial with coefficients in the ring of integers `ℤ` across the ring homomorphism from `ℤ` to `R`. This is achieved by using the `Polynomial.map` function with the `Int.castRingHom R` as the ring homomorphism.

The `n`-th cyclotomic polynomial over a ring `R` is the image of the `n`-th cyclotomic polynomial over the integers under the ring homomorphism from the integers to `R`.


theorem Int.add_sub_cancel : ∀ (a b : ℤ), a + b - b = a := by sorry

This theorem, `Int.add_sub_cancel`, states that for any two integers `a` and `b`, if you add `b` to `a` and then subtract `b`, you will get back `a`. In mathematical terms, it expresses the property \(a + b - b = a\) for all integers \(a\) and \(b\). This is a basic property of addition and subtraction in the set of integers, reflecting the cancellation law of addition/subtraction.

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


SetTheory.PGame.Equiv.symm

theorem SetTheory.PGame.Equiv.symm : ∀ {x y : SetTheory.PGame}, x ≈ y → y ≈ x := by sorry

This theorem states that in the framework of Set Theory and specifically with PGames, if a PGame `x` is equivalent to PGame `y` then `y` is also equivalent to `x`. In other words, the equivalence relation between PGames is symmetric.

In the context of Set Theory and PGames, the equivalence relation on PGames is symmetric.


/-- Being `Cⁿ` in the model space is a local property, invariant under smooth maps. Therefore,
it will lift nicely to manifolds.  -/
theorem contDiffWithinAt_localInvariantProp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
      {E' : Type u_5} [inst_4 : NormedAddCommGroup E'] [inst_5 : NormedSpace 𝕜 E'] {H' : Type u_6}
      [inst_6 : TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') (n : ℕ∞),
      StructureGroupoid.LocalInvariantProp (contDiffGroupoid ⊤ I) (contDiffGroupoid ⊤ I')
        (ContDiffWithinAtProp I I' n) :=
  by sorry

This theorem states that being `C^n` (having `n` continuous derivatives) in the model space is a property that is local and invariant under smooth maps. Hence, this property can be uplifted to manifolds smoothly. This is established for any non-trivially normed field, any normed additive commutative group, any normed space, and any topological space that are given as inputs. The theorem also requires a model with corners `I` and `I'` for the spaces and a natural number `n` to define the degree of differentiability. The local invariant property is then defined in terms of the groupoid of all `C^n` maps and the property of being `C^n` within a set.

The property of being `C^n` (having `n` continuous derivatives) is a local and invariant property under smooth maps, allowing its uplift to manifolds in any non-trivially normed field, normed additive commutative group, normed space, and topological space.


theorem Multiset.coe_toList : ∀ {α : Type u_1} (s : Multiset α), ↑(Multiset.toList s) = s := by sorry

This theorem states that for any type `α` and any multiset `s` of type `α`, when you convert `s` to a list using the `Multiset.toList` function and then convert it back to a multiset (`↑` is the Lean notation for this conversion), you get the original multiset `s` back. In other words, the process of converting a multiset to a list and back again is lossless; no information about the multiset is lost in this process.

For any type `α` and multiset `s` of type `α`, the conversion from `s` to the list obtained by `Multiset.toList s` and back to a multiset using the lift operation (`↑`) results in the original multiset: `Multiset.toList ↑s = ↑(Multiset.toList s)`.


CategoryTheory.Pi.ext

theorem CategoryTheory.Pi.ext :
    ∀ {I : Type w₀} (C : I → Type u₁) [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i}
      {f g : X ⟶ Y}, (∀ (i : I), f i = g i) → f = g :=
  by sorry

This theorem, `CategoryTheory.Pi.ext`, states that for any type `I` and a type-dependent family of categories `C`, if `X` and `Y` are two objects in the product category (where the objects are the product of the objects in the individual categories), and if `f` and `g` are two morphisms between these objects, then if for every object `i` in `I` the component of `f` and `g` at `i` are identical, then the morphisms `f` and `g` are identical. In other words, two morphisms in a product category are equal if and only if their components are equal in each of the original categories.

In the product category of a family of categories `C` indexed by type `I`, two morphisms between objects `X` and `Y` are equal if and only if their component morphisms at every object `i` in `I` are equal.


theorem isOpen_empty : ∀ {X : Type u} [inst : TopologicalSpace X], IsOpen ∅ := by sorry

The theorem `isOpen_empty` states that for any type `X` equipped with a topological space structure, the empty set is open in this topological space. In mathematical terms, this theorem asserts that in any topological space, the empty set is always an open set, which is a fundamental axiom of topology.

In any topological space, the empty set is an open set.


Isometry.continuous

/-- An isometry is continuous.  -/
theorem Isometry.continuous :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → Continuous f :=
  by sorry

This theorem states that an isometry is continuous. More specifically, for any two types `α` and `β` that are pseudoemetric spaces, if `f` is a function mapping from `α` to `β` and `f` is an isometry (i.e., it preserves the extended distance between any two points in `α`), then `f` is also a continuous function. This is a fundamental theorem in topology and metric spaces, showing the continuity of distance-preserving transformations.

If `f` is an isometry between pseudometric spaces `α` and `β`, then `f` is a continuous function.


theorem Computation.ret_mem : ∀ {α : Type u} (a : α), a ∈ Computation.pure a := by sorry

This theorem, `Computation.ret_mem`, states that for any type `α` and any element `a` of this type, `a` is an element of the computation that immediately terminates with result `a`. In other words, whenever a computation is defined to immediately terminate with a result `a`, `a` is guaranteed to be a part of that computation.

For any type `α` and element `a` of `α`, the computation that immediately terminates with result `a` is an element of the computation that represents `a`.


theorem Nat.add_lt_add_left : ∀ {n m : ℕ}, n < m → ∀ (k : ℕ), k + n < k + m := by sorry

This theorem states that for all natural numbers `n` and `m`, if `n` is less than `m`, then for any natural number `k`, the sum of `k` and `n` is less than the sum of `k` and `m`. In simpler terms, it asserts that adding a constant to both sides of a valid inequality between natural numbers preserves the inequality.

For all natural numbers `n` and `m` with `n < m`, for any natural number `k`, `k + n < k + m`.


theorem Nat.add_mul_mod_self_left : ∀ (x y z : ℕ), (x + y * z) % y = x % y := by sorry

This theorem states that for all natural numbers `x`, `y`, and `z`, the remainder of the division of `(x + y * z)` by `y` is the same as the remainder of the division of `x` by `y`. In other words, adding a multiple of `y` to `x` doesn't change the remainder of `x` divided by `y`. This is a formulation of a property of modular arithmetic.

For all natural numbers x, y, and z, (x + y \* z) mod y = x mod y.


theorem one_half_pos : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α], 0 < 1 / 2 := by sorry

This theorem states that for any semi-field that is linearly ordered, the value of one half (1/2) is always greater than zero. The semi-field is represented by any type `α`. A linearly ordered semi-field is a structure that combines properties of an ordered ring (like the integers with their usual ordering) and a field (like the rational numbers, real numbers, or complex numbers), but with the additional restriction that multiplication of non-zero elements never gives zero.

In a linearly ordered semi-field, the multiplicative identity (1) has a positive square root, i.e., 1/2 > 0.


theorem LinearMap.map_smulₛₗ :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
      (f : M →ₛₗ[σ] M₃) (c : R) (x : M), f (c • x) = σ c • f x :=
  by sorry

This theorem states that for any semirings `R` and `S`, additive commutative monoids `M` and `M₃`, `R`-module `M`, `S`-module `M₃`, ring homomorphism `σ` from `R` to `S`, linear map `f` from `M` to `M₃`, scalar `c` from `R`, and element `x` from `M`, the result of applying `f` to the scalar multiplication of `c` and `x` (i.e., `f (c • x)`) is equal to the scalar multiplication of `σ c` and `f x` (i.e., `σ c • f x`). In other words, it's demonstrating that a linear map distributes over scalar multiplication, under the provided conditions.

For any semirings R and S, additive commutative monoids M and M₃, R-module M, S-module M₃, ring homomorphism σ from R to S, and linear map f from M to M₃, the law f (c • x) = σ (c) • f (x) holds for all scalars c in R and elements x in M.


theorem PartialHomeomorph.map_source :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {x : X}, x ∈ e.source → ↑e x ∈ e.target :=
  by sorry

This theorem, `PartialHomeomorph.map_source`, states that for any partial homeomorphism `e` from a topological space `X` to another topological space `Y`, if an element `x` from `X` belongs to the source of `e`, then the image of `x` under `e` will belong to the target of `e`. The theorem is applicable to all types `X` and `Y` that have a topological space structure.

For any partial homeomorphism between topological spaces, the image of a source element maps to the target.


/-- Given any distinguished triangle `T`, then we know `T.rotate` is also distinguished.
 -/
theorem CategoryTheory.Pretriangulated.rot_of_distTriang :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
        CategoryTheory.Pretriangulated.Triangle.rotate T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles :=
  by sorry

This theorem states that in a pretriangulated category `C` (a category with extra structure that allows the definition of distinguished triangles), if we have a distinguished triangle `T`, then the rotated version of `T` is also a distinguished triangle. The rotation process is defined by some Functor called `CategoryTheory.shiftFunctor`, which moves objects and morphisms 'up'. This holds for any object `C`, irrespective of whether `C` is a zero object in the category or not. The statement of this theorem applies to an arbitrary additive functor associated with the shift functor.

In a pretriangulated category, the rotated version of a distinguished triangle is also a distinguished triangle under the shift functor.


theorem not_isMin : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : NoMinOrder α] (a : α), ¬IsMin a := by sorry

The theorem `not_isMin` states that for any type `α` that has a preorder relationship and does not have a minimal element (expressed by the `NoMinOrder α` condition), no element `a` of type `α` can be a minimal element. This is to say, there is no element `a` in `α` such that for any other element `b` in `α`, if `b` is less than or equal to `a`, then `a` is less than or equal to `b`. The statement essentially defines a property of an ordered set without a minimum, where no element `a` can be a "minimal" element where no elements in the set are strictly less than `a`.

In a preordered type `α` without a minimal element, there is no element that is minimal (i.e., less than or equal to every other element).


theorem Mathlib.Data.Finset.Antidiagonal._auxLemma.1 :
    ∀ {A : Type u_1} [inst : AddMonoid A] [self : Finset.HasAntidiagonal A] {n : A} {a : A × A},
      (a ∈ Finset.antidiagonal n) = (a.1 + a.2 = n) :=
  by sorry

This theorem, `Mathlib.Data.Finset.Antidiagonal._auxLemma.1`, states that for any type `A` which has an addition operation (from the `AddMonoid A` instance), and a defined `Finset.HasAntidiagonal` instance, a pair of elements (`a : A × A`) is in the antidiagonal of `n` if and only if the sum of the elements of the pair equals to `n`. The antidiagonal of `n` is a set of pairs whose sum is `n`.

For any type `A` with an addition operation and a `Finset.HasAntidiagonal` instance, the antidiagonal of `n` is the set of pairs `(a, b)` in `A × A` such that `a + b = n`.


theorem Finset.card_compl :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Finset α), sᶜ.card = Fintype.card α - s.card := by
  sorry

The theorem `Finset.card_compl` states that for any given type `α` that has decidable equality and is finite (i.e., it is a fintype), and for any finite set `s` of type `α`, the number of elements in the complement of `s` (`sᶜ.card`) is equal to the difference between the total number of elements of type `α` (`Fintype.card α`) and the number of elements in `s` (`s.card`). In other words, it captures the intuitive idea that the size of the complement of a set is the size of the whole space minus the size of the set itself.

For any finite type `α` with decidable equality and any finite set `s` of type `α`, the cardinality of the complement `sᶜ` is equal to the total cardinality of `α` minus the cardinality of `s`.


theorem Nat.lt_irrefl : ∀ (n : ℕ), ¬n < n := by sorry

This theorem, `Nat.lt_irrefl`, states that for all natural numbers `n`, `n` is not less than `n`. In other words, no natural number is less than itself.

For all natural numbers n, n ≤ n is false.


theorem IsLUB.csSup_eq :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α},
      IsLUB s a → Set.Nonempty s → sSup s = a :=
  by sorry

This theorem states that for any type `α` which is a conditionally complete lattice, any set `s` of type `α`, and any element `a` of type `α`, if `a` is a least upper bound of the set `s` and the set `s` is not empty, then the supremum of the set `s` is equal to `a`. In other words, it ensures that in a conditionally complete lattice, the supremum of a non-empty set, if it exists, is its unique least upper bound.

In a conditionally complete lattice, if a non-empty set has a least upper bound, then its least upper bound is unique and equals the supremum of the set.


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

The theorem `Polynomial.coeff_C_zero` states that for any arbitrary type `R` and any element `a` of type `R`, given that `R` is a semiring, the coefficient of the constant polynomial `a` at degree 0 is `a`. In other words, if you have a constant polynomial whose only term is `a*X^0` (which simplifies to `a` as anything raised to the power of 0 is 1), then the coefficient for the `X^0` term (i.e., the term with degree 0) is `a`.

For any semiring `R` and its element `a`, the constant polynomial `a` has coefficient `a` at degree 0.


theorem uniqueDiffOn_univ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E], UniqueDiffOn 𝕜 Set.univ :=
  by sorry

The theorem `uniqueDiffOn_univ` states that for any nontrivially normed field `𝕜` and any normed additive commutative group `E` that is also a normed space over `𝕜`, the entire set `Set.univ` (i.e., the set of all elements of `E`) has the property of unique differentiability. In other words, every point in this set has a unique differential, a central concept in differential calculus, when the underlying field is `𝕜` and the space is `E`.

For any nontrivially normed field `𝕜` and normed additive commutative group `E` that is also a normed space over `𝕜`, every element in `E` has a unique differential.


theorem iSup_neg : ∀ {α : Type u_1} [inst : CompleteLattice α] {p : Prop} {f : p → α}, ¬p → ⨆ (h : p), f h = ⊥ := by
  sorry

This theorem, `iSup_neg`, states that for any type `α` that forms a complete lattice, any proposition `p`, and any function `f` from `p` to `α`, if the proposition `p` is not true (denoted `¬p`), then the supremum (denoted `⨆ (h : p), f h`) of the function `f` over all `p` is the bottom element of the lattice (denoted `⊥`). Essentially, if the proposition does not hold, then the supremum of the function over the proposition equals the least element in the lattice.

If `α` is a complete lattice, `p` is a proposition over `α`, and `f` is a function from `p` to `α`, then `⨆ (h : ¬p), f h = ⊥`.


theorem div_le_iff' : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < b → (a / b ≤ c ↔ a ≤ b * c) :=
  by sorry

This theorem states that for any type `α`, given a linearly ordered semiring structure on `α`, and any three elements `a`, `b`, `c` of `α`, if `b` is greater than 0, then the inequality `a / b ≤ c` is equivalent to the inequality `a ≤ b * c`. This theorem essentially represents one way of transferring the division by `b` in the first inequality to a multiplication by `b` in the second inequality.

For any linearly ordered semiring `α` and elements `a, b, c` of `α` with `b > 0`, the inequalities `a / b <= c` and `a <= b * c` are equivalent.


Set.IsPWO.mono

theorem Set.IsPWO.mono : ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, Set.IsPWO t → s ⊆ t → Set.IsPWO s := by
  sorry

The theorem `Set.IsPWO.mono` states that for all types `α` equipped with a preorder, if we have two sets `s` and `t` of this type such that `t` is partially well-ordered and `s` is a subset of `t`, then `s` is also partially well-ordered. In other words, the property of being partially well-ordered is preserved under taking subsets. In this context, a set is partially well-ordered if any infinite sequence from the set contains a monotone subsequence of length 2 or, equivalently, an infinite monotone subsequence.

If `α` is a type with a preorder, and `s` is a subset of the partially well-ordered set `t`, then `s` is also partially well-ordered.


theorem Finset.weightedVSub.proof_1 :
    ∀ {V : Type u_2} {P : Type u_1} [inst : AddCommGroup V] [S : AddTorsor V P], Nonempty P := by sorry

This theorem states that for any given type `V` which is an additive commutative group, and any given type `P` which is an additive torsor over `V`, there is at least one non-empty instance of `P`. In other words, if you have a vector space `V` and a point space `P` over `V`, then `P` cannot be empty.

For any additive commutative group `V` and an additive torsor `P` over `V`, there exists a non-empty `x : P`.


/-- Two `R`-linear maps from `Finsupp X M` which agree on each `single x y` agree everywhere.

We formulate this fact using equality of linear maps `φ.comp (lsingle a)` and `ψ.comp (lsingle a)`
so that the `ext` tactic can apply a type-specific extensionality lemma to prove equality of these
maps. E.g., if `M = R`, then it suffices to verify `φ (single a 1) = ψ (single a 1)`.  -/
theorem Finsupp.lhom_ext' :
    ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] ⦃φ ψ : (α →₀ M) →ₗ[R] N⦄,
      (∀ (a : α), φ ∘ₗ Finsupp.lsingle a = ψ ∘ₗ Finsupp.lsingle a) → φ = ψ :=
  by sorry

The theorem `Finsupp.lhom_ext'` states that for any semiring `R`, and for any types `α`, `M` and `N` with `M` and `N` being `R`-modules, if we have two `R`-linear maps `φ` and `ψ` from `Finsupp X M` to `N`, and these two maps agree on each `Finsupp.single a` for every `a` in `α`, then these two maps are equal everywhere.

The formulation of this fact is done using equality of linear maps `φ.comp (Finsupp.lsingle a)` and `ψ.comp (Finsupp.lsingle a)` to allow the `ext` tactic to apply a type-specific extensionality lemma to prove the equality of these maps. As an example, if `M` is equivalent to `R`, it suffices to verify `φ (Finsupp.single a 1) = ψ (Finsupp.single a 1)`.

For any semiring `R`, and `R`-modules `M` and `N`, if two `R`-linear maps from `Finsupp X M` to `N` agree on each `Finsupp.single a` for every `a` in `α`, then they are equal everywhere.


/-- The distance between two functions is controlled by the supremum of the pointwise distances.  -/
theorem BoundedContinuousFunction.dist_le :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      {f g : BoundedContinuousFunction α β} {C : ℝ}, 0 ≤ C → (dist f g ≤ C ↔ ∀ (x : α), dist (f x) (g x) ≤ C) :=
  by sorry

This theorem, `BoundedContinuousFunction.dist_le`, states that for any two bounded continuous functions `f` and `g` from a topological space `α` to a pseudo metric space `β`, and any non-negative real number `C`, the distance between `f` and `g` is at most `C` if and only if the distance between `f(x)` and `g(x)` is at most `C` for all `x` in `α`. Here, the distance between two functions is defined as the supremum of the pointwise distances.

For bounded continuous functions $f$ and $g$ from a topological space $\alpha$ to a pseudo metric space $\beta$, and real number $C \geq 0$, $ \sup\_{x \in \alpha} d(f(x), g(x)) \leq C $ if and only if $ d(f, g) \leq C $, where $d(f,g)$ is the pointwise supremum distance between $f$ and $g$.


theorem Set.mapsTo_preimage : ∀ {α : Type u} {β : Type v} (f : α → β) (t : Set β), Set.MapsTo f (f ⁻¹' t) t := by sorry

The theorem `Set.mapsTo_preimage` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, and any set `t` of type `β`, the image of the preimage of `t` under `f` is contained in `t`. In other words, if we take any set `t`, find its preimage under `f`, and then apply `f` to this preimage, all the resulting elements are guaranteed to be in `t`. This can also be expressed as: for all elements `x` in the preimage of `t` under `f`, `f(x)` is in `t`.

For all functions $f:\alpha \to \beta$ and sets $t \subseteq \beta$, the image of $f$'s preimage under $t$ is contained in $t$: $f\^{-1}(t) \subseteq t$.


theorem continuous_mul_right :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [inst_2 : ContinuousMul M] (a : M),
      Continuous fun b => b * a :=
  by sorry

This theorem states that for any type 'M' equipped with a topological space structure, a multiplication operation, and a continuous multiplication operation, multiplication from the right by a fixed element 'a' from 'M' is a continuous function. In other words, given any element 'a' in 'M', the function that multiplies each element 'b' in 'M' by 'a' (from the right) preserves the topological structure; i.e., the preimage of any open set in 'M' under this function is also an open set in 'M'.

For any topological space '(M, τ)' equipped with a multiplication operation and a continuous multiplication function, right multiplication by a fixed element 'a' in 'M' is a continuous function.


theorem Polynomial.eval₂_sub :
    ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R} {S : Type u_1} [inst_1 : Ring S] (f : R →+* S) {x : S},
      Polynomial.eval₂ f x (p - q) = Polynomial.eval₂ f x p - Polynomial.eval₂ f x q :=
  by sorry

The theorem `Polynomial.eval₂_sub` states for any rings `R` and `S`, any homomorphism `f` from `R` to `S`, and any values `p`, `q`, and `x` where `p` and `q` are polynomials over `R` and `x` is a value in `S`, the evaluation of the difference of `p` and `q` at `x` using the homomorphism `f` is equal to the difference of the evaluations of `p` and `q` at `x` using the homomorphism `f`. In other words, we have the equality `Polynomial.eval₂ f x (p - q) = Polynomial.eval₂ f x p - Polynomial.eval₂ f x q`.

For any homomorphism `f` between rings `R` and `S`, and polynomials `p` and `q` over `R` and value `x` in `S`, we have `Polynomial.eval₂ f x (p - q) = Polynomial.eval₂ f x p - Polynomial.eval₂ f x q`.


theorem Multiset.coe_eq_coe : ∀ {α : Type u_1} {l₁ l₂ : List α}, ↑l₁ = ↑l₂ ↔ List.Perm l₁ l₂ := by sorry

This theorem states that for any two lists `l₁` and `l₂` of any type `α`, the multisets obtained from `l₁` and `l₂` are equal if and only if `l₁` and `l₂` are permutations of each other. In other words, two lists generate the same multiset exactly when they contain the same elements, possibly in different orders.

For any lists `l₁` and `l₂` of type `α`, `multiset l₁ = multiset l₂` if and only if `l₁` is a permutation of `l₂`.


/-- **Alias** of the reverse direction of `half_lt_self_iff`. -/
theorem half_lt_self : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 0 < a → a / 2 < a := by sorry

This theorem, `half_lt_self`, states that for any type `α` that is a `LinearOrderedSemifield` (which means it possesses ordering and field-like properties, such as addition and multiplication), for any element `a` of this type, if `a` is greater than zero, then `a` divided by 2 is less than `a`. In other words, for any positive number, halving it will always result in a value less than the original.

For any `LinearOrderedSemifield` type `α` and positive element `a`, we have `0 < a` implies `a / 2 < a`.


/-- If two points belong to some set, their edistance is bounded by the diameter of the set  -/
theorem EMetric.edist_le_diam_of_mem :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {s : Set α}, x ∈ s → y ∈ s → edist x y ≤ EMetric.diam s := by
  sorry

The theorem `EMetric.edist_le_diam_of_mem` states that in a pseudoemetric space, for any given set and any two points within that set, the extended distance (or edistance) between these two points is always less than or equal to the diameter of the set. In other words, the maximum possible distance between any two points in a set can never be exceeded by the distance between any specific pair of points within that same set. This is a fundamental property of distances in general metric and pseudoemetric spaces.

In a pseudometric space, the edistance between any two points in a set is less than or equal to the diameter of that set.


theorem Function.extend_apply' :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (g : α → γ) (e' : β → γ) (b : β),
      (¬∃ a, f a = b) → Function.extend f g e' b = e' b :=
  by sorry

This theorem `Function.extend_apply'` states that for any types `α`, `β`, and `γ`, and any functions `f : α → β`, `g : α → γ`, and `e' : β → γ`, and for any value `b : β`, if there does not exist a value `a : α` such that `f a = b`, then the function `Function.extend f g e'` applied to `b` equals `e' b`. In simpler terms, this theorem describes a condition under which the extension of a function `f` behaves like the function `e'` for a particular value `b`.

If `f : α → β` has no preimage under `b : β`, then `Function.extend f g e' b = e' b`.


theorem Int.mul_neg : ∀ (a b : ℤ), a * -b = -(a * b) := by sorry

This theorem states that for all integer values `a` and `b`, the product of `a` and the negation of `b` (`-b`) is equal to the negation of the product of `a` and `b` (`-(a * b)`). In other words, multiplying an integer by another integer's negative is the same as negating the product of the two integers. This is consistent with the property of multiplication over the set of integers in mathematics.

For all integers `a` and `b`, `a * -b` equals `- (a * b)`.


theorem Subtype.coe_inj : ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, ↑a = ↑b ↔ a = b := by sorry

This theorem, named `Subtype.coe_inj`, states that for any type `α` and a predicate `p` over `α`, if `a` and `b` are instances of the subtype `p`, then the coercion of `a` to `α` is equal to the coercion of `b` to `α` if and only if `a` is equal to `b`. In other words, distinct elements of the subtype remain distinct when coerced to the base type. This is a statement about the injectivity of the coercion function from the subtype to the base type.

If `α` is a type and `p` is a predicate on `α`, then for all `a` and `b` in the subtype `p ⊆ α`, the coercion of `a` to `α` equals the coercion of `b` to `α` if and only if `a` equals `b`.


theorem WithTop.coe_eq_coe : ∀ {α : Type u_1} {a b : α}, ↑a = ↑b ↔ a = b := by sorry

This theorem states that for any type `α` and any two values `a` and `b` of type `α`, the equality of their coe (ie., their coerced/converted values) in the WithTop type is equivalent to their equality in the original type. In other words, `a` and `b` are equal if and only if their coerced versions are equal. This theorem provides the basis for doing equality checks on possibly infinite objects (i.e., values of the `WithTop α` type).

For any type `α` and values `a` and `b` of type `α`, the equality `a = b` holds if and only if the equality of their coerced values `coe a = coe b` in `WithTop α` holds.


/-- If `f : ℕ → M` has sum `m`, then the partial sums `∑ i in range n, f i` converge
to `m`. -/
theorem HasSum.tendsto_sum_nat :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℕ → M},
      HasSum f m → Filter.Tendsto (fun n => Finset.sum (Finset.range n) fun i => f i) Filter.atTop (nhds m) :=
  by sorry

This theorem states that if a function `f` from natural numbers to a type `M` has a sum `m`, then the partial sums `∑ i in range n, f i`, where the range is a set of natural numbers less than `n`, converge to `m` as `n` goes to infinity. Here, `M` is a type that forms an additive commutative monoid and also has a topological space structure. The convergence is expressed in terms of filters: `Filter.Tendsto` is used to assert that the limit of the sequence of partial sums (considered as a function of `n`) as `n` goes to infinity (represented by `Filter.atTop`) is `m` (represented by the neighborhood filter `nhds m`).

If `f` is a function from natural numbers to an additive commutative monoid and topological space `M`, with `m` being the sum of `f` over finite natural number sets and `n` tending to infinity, then `∑ i in range n, f i` converges to `m` in the sense of `Filter.Tendsto` as `n` approaches infinity.


theorem continuousAt_fst :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X × Y},
      ContinuousAt Prod.fst p :=
  by sorry

The theorem `continuousAt_fst` states that for all types `X` and `Y` that have a topological space structure, and for every pair `p` with elements from `X` and `Y`, the first projection function `Prod.fst`, which returns the first element of the pair, is continuous at the point `p`. In mathematical terms, this means that for any sequence of points in `X × Y` that converges to `p`, the sequence of their first components also converges to the first component of `p`.

For every topological space `(X,τX)` and `(Y,τY)`, and every point `(pX, pY)` in their product `(X × Y, τX × τY)`, the first projection function `Prod.fst` is continuous at `(pX, pY)`, that is, for any convergent sequence `(x_n, y_n)` in `X × Y` with limit `(pX, pY)`, the sequence `x_n` converges to `pX` in `X`.


theorem Real.rpow_int_cast : ∀ (x : ℝ) (n : ℤ), x ^ ↑n = x ^ n := by sorry

This theorem states that for any real number `x` and any integer `n`, raising `x` to the power of the real number representation of `n` (denoted by `↑n`) is the same as raising `x` to the power of `n` directly. In other words, if you cast an integer to a real number and use it as the exponent in a power operation, it does not change the result.

For any real number `x` and integer `n`, `x^(↑n)` equals `x^n`.


List.Perm.subset

theorem List.Perm.subset : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Perm l₁ l₂ → l₁ ⊆ l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of this type, if `l₁` is a permutation of `l₂`, then `l₁` is a subset of `l₂`. Here, the term 'subset' is used in the sense of lists, meaning that every element of `l₁` also appears in `l₂`.

If `α` is a type and `l₁` is a permutation of `l₂`, then `l₁ ⊆ l₂` (`l₁` is a subset of `l₂`) in the sense of lists.


HasStrictFDerivAt.hasStrictDerivAt

theorem HasStrictFDerivAt.hasStrictDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {f' : 𝕜 →L[𝕜] F},
      HasStrictFDerivAt f f' x → HasStrictDerivAt f (f' 1) x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and normed additively commutative group `F` that also forms a normed space over `𝕜`, if a function `f` from `𝕜` to `F` has a strict Frechet derivative `f'` at a point `x` in `𝕜`, then `f` also has a strict derivative at `x` in the sense of strict differentiability. Specifically, the derivative at `x` is given by the value of the Frechet derivative `f'` at 1. This means that the change in `f` as we move away from `x` can be approximated by the value `f'(1)` times the change in the input, up to an error term that goes to zero faster than the change in the input.

If a function from a nontrivially normed field to a normed additively commutative group, which is also a normed space, has a strict Frechet derivative at a point, then its strict derivative at that point equals the value of its Frechet derivative at 1.


Order.Ideal.lower

theorem Order.Ideal.lower : ∀ {P : Type u_1} [inst : LE P] (s : Order.Ideal P), IsLowerSet ↑s := by sorry

This theorem states that for any type `P` with a less than or equal to (`LE`) relationship and any ideal `s` in this order (represented as `Order.Ideal P`), the set of elements of `s` (represented by `↑s`) is a lower set. In other words, if `a` and `b` are elements of type `P`, and `b` is less than or equal to `a`, and `a` is an element of the ideal `s`, then `b` is also an element of `s`, satisfying the definition of a lower set.

For any ideal `s` in the order `LE` on type `P`, the set `↑s` of elements in `s` is a lower set, i.e., if `a` is in `s` and `b ≤ a`, then `b` is also in `s`.


theorem tsub_pos_iff_lt :
    ∀ {α : Type u_1} [inst : CanonicallyLinearOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α]
      {a b : α}, 0 < a - b ↔ b < a :=
  by sorry

This theorem states that for any type `α`, which is a canonically linearly ordered additive commutative monoid with a subtraction operation and an order relation compatible with subtraction, the difference `a - b` is positive if and only if `b` is less than `a`. In other words, the theorem provides a relationship between the positivity of the subtraction of two elements and the order of these two elements in the context of a specific algebraic structure.

For any canonically linearly ordered additive commutative monoid type `α` with subtraction operation and compatible order relation, `a - b` is positive if and only if `b` is less than `a`.


theorem Real.mul_self_sqrt : ∀ {x : ℝ}, 0 ≤ x → Real.sqrt x * Real.sqrt x = x := by sorry

This theorem states that for any real number `x` that is greater than or equal to zero, the square root of `x` multiplied by itself equals `x`. In mathematical terms, it's saying that if `x` is a non-negative real number, then $\sqrt{x} \cdot \sqrt{x} = x$. This is the fundamental property of square roots applied to non-negative real numbers.

For any non-negative real number `x`, $\sqrt{x} \cdot \sqrt{x} = x$.


theorem Filter.comap_id : ∀ {α : Type u} {f : Filter α}, Filter.comap id f = f := by sorry

This theorem states that for all types `α` and for all filters `f` of type `α`, the comap (comap stands for the preimage or the inverse image function) of the identity function `id` on the filter `f` is equal to `f` itself. In terms of mathematical language, given a filter `f` on a set `α`, the preimage of `f` under the identity mapping is just `f`. This is a property of filters in the context of topology or set theory.

For all filters $f$ on a type $\alpha$, the preimage of $f$ under the identity function is equal to $f$ (i.e., comap(id) $f$ = $f$).


/-- To prove a proposition about a nonempty `s : Finset α`, it suffices to show it holds for all
singletons and that if it holds for nonempty `t : Finset α`, then it also holds for the `Finset`
obtained by inserting an element in `t`.  -/
theorem Finset.Nonempty.cons_induction :
    ∀ {α : Type u_4} {p : (s : Finset α) → s.Nonempty → Prop},
      (∀ (a : α), p {a} ⋯) →
        (∀ ⦃a : α⦄ (s : Finset α) (h : a ∉ s) (hs : s.Nonempty), p s hs → p (Finset.cons a s h) ⋯) →
          ∀ {s : Finset α} (hs : s.Nonempty), p s hs :=
  by sorry

The theorem `Finset.Nonempty.cons_induction` states that to prove a property `p` about a nonempty finite set `s` of some type `α`, it is sufficient to verify two conditions. Firstly, `p` must hold for every singleton set - a set containing just one element `a` of type `α`. Secondly, if `p` is true for some nonempty finite set `t` and an element `a` is not in `t`, then `p` remains true when `a` is added to `t` to form a new set. In other words, the theorem provides a method for inductive reasoning over nonempty finite sets.

Given a property `p` and a nonempty finite set `s` of type `α`, if `p` holds for all singletons and for every `a` not in a set `t` with `p(t)`, then `p` holds for `s`.


theorem Mathlib.Order.CompleteLattice._auxLemma.8 :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i :=
  by sorry

The theorem `Mathlib.Order.CompleteLattice._auxLemma.8` states that for any type `α` that is a complete lattice, any function `f` from some index type `ι` to `α`, and any element `a` of `α`, the condition that `a` is less than or equal to the indexed infimum of `f` (denoted as `iInf f`) is equivalent to the condition that `a` is less than or equal to `f i` for all `i` in `ι`. In other words, an element is less than or equal to the infimum of the function's range if and only if it is less than or equal to all elements in the function's range.

For any complete lattice α and function f from an index type ι to α, an element a of α is less than or equal to the infimum of f if and only if it is less than or equal to f(i) for all i in ι.


theorem forall₄_congr :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4}
      {p q : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Prop},
      (∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), p a b c d ↔ q a b c d) →
        ((∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), p a b c d) ↔
          ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), q a b c d) :=
  by sorry

This theorem states that for any four dependent types `α`, `β`, `γ`, and `δ`, and any two properties `p` and `q` that each take four arguments of these types respectively, if for all possible arguments `p` and `q` are logically equivalent (meaning `p` is true if and only if `q` is true), then the universal quantifications over `p` and `q` are also logically equivalent. That is, `p` holds for all combinations of arguments if and only if `q` does so as well.

If for all dependent types `α`, `β`, `γ`, and `δ` and properties `p` and `q` taking four arguments each, `p ↔ q` implies `∀ (a: α) (b: β) (c: γ) (d: δ), p a b c d ↔ q a b c d`, then the universal quantifications over `p` and `q` are logically equivalent.


theorem MeasureTheory.trim_measurableSet_eq :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} (hm : m ≤ m0),
      MeasurableSet s → ↑↑(μ.trim hm) s = ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.trim_measurableSet_eq` states that for any type `α`, given two measurable spaces `m` and `m0` over `α`, a measure `μ` on `α`, and a set `s` of type `α`, if `m` is a sub-measurable-space of `m0` (denoted `m ≤ m0`), and if `s` is a measurable set, then the measure of `s` with respect to the trimmed measure (obtained by trimming `μ` using `m`) is equal to the measure of `s` with respect to the original measure `μ`.

In other words, trimming a measure does not change the measure of measurable sets in the original measure space.

For any measurable spaces `m ≤ m0` over type `α`, measure `μ` on `α`, and measurable set `s` of type `α`, the trimmed measure of `s` using `m` equals the original measure of `s` with respect to `μ`.


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

This theorem states that for any ring `R`, any additive commutative group `M`, and any module `M` over the ring `R`, given the strong rank condition for `R`, and for any type `ι` which forms a basis of the module `M`, the cardinality of the basis type `ι` (denoted by `Cardinal.mk ι`) is equal to the rank of the module `M` over the ring `R` (denoted by `Module.rank R M`). Essentially, it is saying that the number of elements in a basis of a module (its cardinality) is equal to the rank of the module. This is a generalization of the familiar concept from linear algebra, where the rank of a vector space is the number of vectors in any basis.

For any ring `R`, additive commutative group `M` as an `R`-module, and type `ι` forming a basis of `M`, the cardinality of `ι` equals the rank of `M` over `R`.


theorem Filter.Tendsto.isBoundedUnder_le :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : BoundedLENhdsClass α]
      {f : Filter ι} {u : ι → α} {a : α},
      Filter.Tendsto u f (nhds a) → Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u :=
  by sorry

The theorem `Filter.Tendsto.isBoundedUnder_le` states that for any types `ι` and `α`, and given a preorder on `α` along with a topological space structure and a proof that `α` is a `BoundedLENhdsClass`, if we have a function `u` from `ι` to `α` and a filter `f` on `ι` such that `u` tends to a specific value `a` in `α` with respect to `f` (meaning, the limit of `u` as `ι` approaches `a` through the filter `f` exists), then it follows that the image of the filter `f` under the function `u` is eventually bounded with respect to the less than or equal to relation. In other words, there exists some bound such that all elements of the image of `f` under `u` are less than or equal to this bound eventually.

If `α` is a `BoundedLENhdsClass` with a preorder, `u` is a function from `ι` to `α`, `f` is a filter on `ι`, and `a` is the limit of `u` as `ι` approaches `a` through `f`, then the image of `f` under `u` is eventually bounded by some element in `α` with respect to the less than or equal to relation.


theorem eq_zero_or_neZero : ∀ {R : Type u_1} [inst : Zero R] (a : R), a = 0 ∨ NeZero a := by sorry

This theorem, `eq_zero_or_neZero`, states that for any type `R` that has a `Zero` instance (essentially, a type that has a concept of "zero"), any element `a` of type `R` either equals zero (`a = 0`) or it does not equal zero (`NeZero a`), where `NeZero a` is a predicate that is true when `a` is not equal to zero. This is a basic law of logic and arithmetic, asserting the dichotomy that any number is either zero or not zero.

For any type `R` with a `Zero` instance, every `a` in `R` is either equal to zero or not equal to zero.


theorem Finset.image₂_nonempty_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      (Finset.image₂ f s t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
  by sorry

The theorem `Finset.image₂_nonempty_iff` states that for all types `α`, `β`, and `γ` with `γ` having decidable equality, and for all binary function `f` from `α` and `β` to `γ`, and for all finite sets `s` of type `α` and `t` of type `β`, the image of `f` over `s` and `t` is nonempty if and only if both `s` and `t` are nonempty. In other words, the image of `f` over the Cartesian product of `s` and `t` has at least one element if and only if both `s` and `t` have at least one element.

For all types `α`, `β`, and `γ` with decidable equality, and for all binary functions `f` from `α × β` to `γ`, the image of `f` over a finite set `s` of type `α` and `t` of type `β` is nonempty if and only if both `s` and `t` are nonempty.


theorem measurable_one :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : One α],
      Measurable 1 :=
  by sorry

The theorem `measurable_one` states that for any types `α` and `β`, given that `α` is a measurable space, `β` is a measurable space, and `α` has a `one` operator (essentially meaning that it has an identity element under multiplication), the constant function that always returns the `one` of `α` is measurable. In other words, the preimage of any measurable set under this function is also a measurable set.

For measurable spaces `α` and `β`, if `α` has a one operator, then the constant function from `α` to its one element is a measurable function.


theorem TensorProduct.zero_tmul :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (n : N), 0 ⊗ₜ[R] n = 0 :=
  by sorry

The theorem `TensorProduct.zero_tmul` states that for any commutative semiring `R` and types `M` and `N` which both form `R`-modules, the tensor product of zero from `M` and any element `n` from `N` is zero. In mathematical terms, given a commutative semiring `R` and `R`-modules `M` and `N`, for any `n` in `N`, `0 ⊗ₜ[R] n = 0`. This theorem establishes one of the important properties of tensor products in the context of module theory.

For any commutative semiring `R` and `R`-modules `M` and `N`, the tensor product of the zero element in `M` and any element in `N` is the zero element in the tensor product `M ⊗ₜ[R] N`.


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

The theorem `Set.iUnion_image_right` states that for every function `f` from a type `α` to a type `β` to a type `γ`, every set `s` of type `α`, and every set `t` of type `β`, the union of the image of the function `(fun x => f x b)` for each `b` in `t` over the set `s` is equal to the image of the binary function `f` over the sets `s` and `t`. This theorem connects the concept of union and image of functions in the context of sets.

For any function `f: α → β`, set `s ∈ Set α`, and set `t ∈ Set β`, the image of `f` over the union of `s` and `t` is equal to the union of the images of `f(x)` for each `x ∈ s` and `f(y)` for each `y ∈ t`.


theorem sub_lt_iff_lt_add' :
    ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α}, a - b < c ↔ a < b + c :=
  by sorry

The theorem `sub_lt_iff_lt_add'` states that for any type `α` that has an addition operation (`AddCommGroup`), a less than operation (`LT`), and respects the variant class rule for addition (`CovariantClass`), given any three elements `a`, `b`, and `c` of type `α`, the inequality `a - b < c` is equivalent to `a < b + c`. This captures a basic property of ordered additive groups.

For any additive group type `α` with a covariant less-than relation, we have `a - b < c` if and only if `a < b + c`.


theorem MeasureTheory.Measure.map_of_not_aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      {μ : MeasureTheory.Measure α}, ¬AEMeasurable f μ → MeasureTheory.Measure.map f μ = 0 :=
  by sorry

The theorem `MeasureTheory.Measure.map_of_not_aemeasurable` states that for any two types `α` and `β`, where `α` is equipped with a measurable space `m0` and `β` is equipped with a measurable space, and for any function `f` from `α` to `β`, and any measure `μ` on `α`, if `f` is not almost everywhere measurable with respect to the measure `μ`, then the pushforward of the measure `μ` by the function `f` is equal to zero. In other words, in measure theory, if a function does not coincide almost everywhere with a measurable function, then the measure transformed by this function yields zero.

If a function between measurable spaces is not almost everywhere measurable with respect to a given measure, then the pushforward measure is zero.


theorem MeasureTheory.withDensity_congr_ae :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → μ.withDensity f = μ.withDensity g :=
  by sorry

The theorem `MeasureTheory.withDensity_congr_ae` states that for any type `α`, any `MeasurableSpace α` named `m0`, any measure `μ` over that space, and any two functions `f` and `g` from `α` to the extended nonnegative real numbers, if `f` is equal to `g` almost everywhere with respect to the measure `μ` (expressed as `f =ᶠ[MeasureTheory.Measure.ae μ] g`), then the measure `μ` with the density function `f` is equal to the measure `μ` with the density function `g` (expressed as `μ.withDensity f = μ.withDensity g`). This theorem is particularly useful when working with measure theory, as it allows us to equate two measures if their density functions are equal almost everywhere.

If two functions have the same density with respect to a measure almost everywhere, then the measures with these densities are equal.


theorem UniformSpace.Completion.coe_smul :
    ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : SMul M X] [inst_2 : UniformContinuousConstSMul M X]
      (c : M) (x : X), ↑X (c • x) = c • ↑X x :=
  by sorry

This theorem states that in a uniform space `X` that supports scalar multiplication by elements from a type `M`, if the scalar multiplication is uniformly continuous, then the scalar multiplication commutes with the uniform space completion embedding. Specifically, for any scalar `c` from `M` and any element `x` from `X`, the completion of the result of scalar multiplying `x` by `c` is equal to the result of scalar multiplying the completion of `x` by `c`.

In a uniform space with scalar multiplication by type `M`, if scalar multiplication is uniformly continuous, then the completion of the product of an element and a scalar is equal to the product of their completions.


MeasurableSet.biUnion

theorem MeasurableSet.biUnion :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {f : β → Set α} {s : Set β},
      Set.Countable s → (∀ b ∈ s, MeasurableSet (f b)) → MeasurableSet (⋃ b ∈ s, f b) :=
  by sorry

The theorem `MeasurableSet.biUnion` states that for any types `α` and `β`, given a measure space `m` over `α`, a function `f` from `β` to a set of `α`, and a countable set `s` of `β`, if every set `f(b)` for all `b` in `s` is measurable, then the union of all `f(b)` for all `b` in `s` is also measurable. In simple terms, this theorem allows us to assert that if we have a countable collection of measurable sets, the union of this collection is also measurable.

If `m` is a measure space over `α`, `f` is a function from `β` to `α`, and `s` is a countable set of `β` such that every `f(b)` is measurable for all `b` in `s`, then the union of all `f(b)` for `b` in `s` is measurable.


theorem Nat.mod_two_eq_zero_or_one : ∀ (n : ℕ), n % 2 = 0 ∨ n % 2 = 1 := by sorry

This theorem states that for any natural number `n`, the remainder when `n` is divided by 2 is either 0 or 1. This is equivalent to saying that any natural number is either even (divisible by 2) or odd (leaves a remainder of 1 when divided by 2).

For any natural number n, the remainder of n when divided by 2 is either 0 or 1. (Equivalently, every natural number is either even or odd.)


theorem Finset.image_subset_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
      Finset.image f s ⊆ t ↔ ∀ x ∈ s, f x ∈ t :=
  by sorry

The `Finset.image_subset_iff` theorem states that for any types `α` and `β`, and given a function `f : α → β`, a finite set `s` of type `α` and a finite set `t` of type `β`, the image of `s` under the function `f` is a subset of `t` if and only if for every element `x` in `s`, the image of `x` under `f` is in `t`. Here, the image of a set under a function, denoted as `Finset.image f s`, is a set consisting of all the images of the elements of the original set under the function, and `DecidableEq β` indicates that equality between elements of `β` can be decided. The subset relation, denoted as `⊆`, is a binary relation between two sets that expresses the fact that every element of the first set is also an element of the second set.

For any functions `f : α → β` between types, finite sets `s : Finset α`, and `t : Finset β`, `Finset.image s f ⊆ t` if and only if for all `x ∈ s`, `f x ∈ t`.


theorem addOrderOf_nsmul_eq_zero : ∀ {G : Type u_1} [inst : AddMonoid G] (x : G), addOrderOf x • x = 0 := by sorry

The theorem `addOrderOf_nsmul_eq_zero` states that for any type `G` that has an `AddMonoid` structure, for any element `x` of `G`, the `addOrderOf` of `x` (denoted as `n`) times the scalar multiplication of `x` is equal to zero. In other words, if `n` is defined as the order of the element `x` (the smallest positive integer such that `n` times `x` equals zero, or zero if `x` has infinite order), then `n` times `x` is indeed zero.

For any AddMonoid type G and element x of G with order n, n * x = 0.


ZeroAtInftyContinuousMap.ext

theorem ZeroAtInftyContinuousMap.ext :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
      {f g : ZeroAtInftyContinuousMap α β}, (∀ (x : α), f x = g x) → f = g :=
  by sorry

This theorem states that for any two continuous maps `f` and `g` from a topological space `α` to another topological space `β` that is also a zero space, if `f` and `g` are equal at every point in `α`, then `f` and `g` are the same continuous map. In other words, two continuous maps from `α` to `β` are identical if and only if they have the same value at every point in `α`.

Two continuous functions from a topological space to a zero space are equal if and only if they agree at every point.


theorem MeasureTheory.AEEqFun.coeFn_mk :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] (f : α → β) (hf : MeasureTheory.AEStronglyMeasurable f μ),
      ↑(MeasureTheory.AEEqFun.mk f hf) =ᶠ[MeasureTheory.Measure.ae μ] f :=
  by sorry

The theorem `MeasureTheory.AEEqFun.coeFn_mk` states that for any measurable space `α`, topological space `β`, measure `μ` on `α`, and function `f` from `α` to `β` that is almost everywhere strongly measurable with respect to `μ`, the function `f` is almost everywhere equal to the function represented by the equivalence class of `f` under the relation of being almost everywhere equal. This is determined by the `MeasureTheory.AEEqFun.mk` function, which constructs the equivalence class based on the equivalence relation of being almost everywhere equal. It is worth mentioning that the "almost everywhere" condition is defined with respect to the measure `μ`.

For any measurable space `α`, topological space `β`, measure `μ` on `α`, and almost everywhere strongly measurable function `f` from `α` to `β` with respect to `μ`, `f` is almost everywhere equal to its equivalence class representative under the almost everywhere equality relation with respect to `μ`.


theorem IsCompl.compl_eq : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, IsCompl a b → aᶜ = b := by sorry

This theorem states that for any type `α` that forms a Heyting algebra, and any two elements `a` and `b` of that type, if `a` and `b` are complements of each other (as described by the `IsCompl` property), then the pseudocomplement of `a` (`aᶜ`) is equal to `b`. A Heyting algebra is a type of algebra used in mathematical logic and computer science, and the pseudocomplement is a generalized form of the concept of "not" for these types of algebras.

In a Heyting algebra, if two elements `a` and `b` are complements of each other (i.e., `a` and `b` satisfy `a ∧ b = �bot` and `a ∨ b = ⊤`), then `aᶜ = b`.


theorem if_congr :
    ∀ {α : Sort u} {b c : Prop} [inst : Decidable b] [inst_1 : Decidable c] {x y u v : α},
      (b ↔ c) → x = u → y = v → (if b then x else y) = if c then u else v :=
  by sorry

This theorem, `if_congr`, states that for any sort `α`, propositions `b` and `c`, and elements `x`, `y`, `u`, and `v` of `α`, provided that `b` and `c` are decidable, if `b` is equivalent to `c` (`b` iff `c`), and `x` is equal to `u` and `y` is equal to `v`, then the conditional expression "if `b` then `x` else `y`" is equal to "if `c` then `u` else `v`". Essentially, this means that if the conditions and corresponding values of two conditional expressions are equivalent, the two expressions are also equivalent.

If `b` is equivalent to `c`, and `x = u` and `y = v`, then the conditional expressions "if `b` then `x` else `y`" and "if `c` then `u` else `v`" are equal.


theorem IsCompl.sup_eq_top :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x y : α}, IsCompl x y → x ⊔ y = ⊤ := by sorry

This theorem states that for any type `α` that forms a lattice and has a bounded order, if `x` and `y` are elements of `α` that are complements of each other (`IsCompl x y`), then the supremum (or join) of `x` and `y`, denoted `x ⊔ y`, is equal to the top element of the lattice, `⊤`. In other words, in a bounded lattice, the supremum of any pair of complementary elements is the greatest element in the lattice.

In a bounded lattice, the supremum of any pair of complementary elements is the lattice's top element.


theorem not_and : ∀ {a b : Prop}, ¬(a ∧ b) ↔ a → ¬b := by sorry

This theorem, `not_and`, expresses a logical equivalence in the domain of propositional logic. It states that for any two propositions `a` and `b`, the negation of the conjunction `a ∧ b` (not both `a` and `b` are true at the same time) is logically equivalent to the assertion that if `a` is true, then `b` must not be true (`a` implies not `b`). This theorem can be used to transform expressions in propositional logic, and it is a fundamental result regarding the relationship between conjunction and negation.

The negation of the conjunction `a ∧ b` is logically equivalent to `a → ¬b`.


Subtype.exists

theorem Subtype.exists :
    ∀ {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop},
      (∃ x, q x) ↔ ∃ a, ∃ (b : p a), q { val := a, property := b } :=
  by sorry

This theorem, `Subtype.exists`, states that for any type `α`, any property `p` on `α`, and any property `q` on elements `a` of type `α` satisfying `p`, there exists an element `x` such that the property `q` holds for `x` if and only if there exists an element `a` and a proof `b` that `a` satisfies `p`, such that `q` holds for `a` with the proof `b`. This theorem essentially shows the equivalence between finding an element in a subtype (a type with an additional property) satisfying some conditions and finding an element in the original type with a proof that it satisfies the conditions of the subtype and the additional conditions.

For any type `α`, property `p` on `α`, and property `q` on elements `a` satisfying `p`, there exists an element `x` of type `α` with property `q` if and only if there exists an element `a` of type `α` satisfying `p` and a proof that `a` has property `p`, with `q` holding for `a` under this proof.


Associated.trans

theorem Associated.trans :
    ∀ {α : Type u_1} [inst : Monoid α] {x y z : α}, Associated x y → Associated y z → Associated x z := by sorry

The theorem `Associated.trans` states that for any type `α` that is a `Monoid`, the `Associated` relation is transitive. In other words, if `x` and `y` are associated elements in the monoid, and `y` and `z` are also associated, then `x` and `z` are associated. Here, two elements are associated if one is the product of the other and a unit of the monoid.

For any monoid `α`, if `x` is associated with `y` and `y` is associated with `z`, then `x` is associated with `z`.


theorem Set.Ico_eq_empty : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, ¬a < b → Set.Ico a b = ∅ := by sorry

The theorem `Set.Ico_eq_empty` states that for any type `α` equipped with a preorder relation, for any two elements `a` and `b` of `α`, if `a` is not less than `b`, then the left-closed right-open interval from `a` to `b` (represented by `Set.Ico a b`) is empty. In other words, if `a` is not strictly less than `b`, there are no elements `x` such that `a ≤ x` and `x < b`.

For any type `α` with a preorder relation, if `a` is not less than `b`, then the interval `[a, b)` is empty.


theorem mul_left_inj' :
    ∀ {M₀ : Type u_1} [inst : CancelMonoidWithZero M₀] {a b c : M₀}, c ≠ 0 → (a * c = b * c ↔ a = b) := by sorry

This theorem states that for any type `M₀`, given that `M₀` is a cancel monoid with zero, for any elements `a`, `b`, and `c` of `M₀`, if `c` is not zero, then `a` multiplied by `c` equals `b` multiplied by `c` if and only if `a` equals `b`. In mathematical terms, this theorem asserts the property of left cancellation in the context of multiplication for types that form a cancel monoid with zero. In essence, if you multiply two elements by the same non-zero element and get equal results, then the original two elements must have been equal.

For any cancel monoid with zero `M₀`, if `a`, `b` are in `M₀`, and `c` is non-zero in `M₀`, then `a * c = b * c` implies `a = b`.


theorem contDiffOn_univ :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞}, ContDiffOn 𝕜 n f Set.univ ↔ ContDiff 𝕜 n f :=
  by sorry

The theorem `contDiffOn_univ` states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space `E` over `𝕜`, normed additive commutative group `F`, and normed space `F` over `𝕜`, a function `f : E → F`, and a natural number `n` or infinity (`ℕ∞`), the function `f` is continuously differentiable of order `n` on the universal set (i.e., the entire domain `E`) if and only if `f` is continuously differentiable of order `n` in general. This theorem essentially says that the condition of being continuously differentiable of a certain order on the entire domain is equivalent to being continuously differentiable of that order without specifying a subset of the domain.

The theorem `contDiffOn_univ` in Lean 4 states that a function between two normed spaces is continuously differentiable of order `n` on the entire domain if and only if it is continuously differentiable of order `n` in the general sense.


theorem Mathlib.Data.Multiset.Basic._auxLemma.1 : ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ = ↑l₂) = List.Perm l₁ l₂ := by
  sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of that type, the condition of the two lists being equal when converted into multisets is equivalent to the two lists being permutations of each other. In other words, two lists are considered equal as multisets if and only if they can be obtained from each other by reordering the elements.

For any type `α`, lists `l₁` and `l₂` of type `list α` are equal as multisets if and only if they are permutations of each other.


theorem Nat.gcd_rec : ∀ (m n : ℕ), Nat.gcd m n = Nat.gcd (n % m) m := by sorry

This theorem, `Nat.gcd_rec`, asserts that for all natural numbers `m` and `n`, the greatest common divisor (gcd) of `m` and `n` is equal to the gcd of the remainder of `n` divided by `m` (`n % m`) and `m`. This theorem is a key part of Euclid's algorithm for finding the greatest common divisor of two numbers. In mathematical terms, it states that for all $m, n \in \mathbb{N}$, $\gcd(m, n) = \gcd(n \mod m, m)$.

The greatest common divisor of two natural numbers is equal to the greatest common divisor of their remainder when one is divided by the other, and the dividing number.


/-- A subgroup is closed under multiplication.  -/
theorem Subgroup.mul_mem : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x y : G}, x ∈ H → y ∈ H → x * y ∈ H := by
  sorry

This theorem states that a subgroup is closed under multiplication. Specifically, in the context of a group `G`, if `H` is a subgroup of `G`, and `x` and `y` are elements of `H`, then the product of `x` and `y` is also an element of `H`. This property is essential to the definition of a subgroup in group theory.

If `H` is a subgroup of group `G`, then for all `x, y ∈ H`, their product `x * y` is also an element of `H`.


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

The theorem `Set.image_preimage_eq` states that for any types `α` and `β`, and any function `f : α → β`, given a set `s` of type `β`, if the function `f` is surjective (i.e., every element of `β` is mapped to by some element of `α`), then the image of the preimage of `s` under `f` is equal to `s`. In other words, if we take all the elements of `α` that `f` maps into `s`, and then apply `f` to these elements, we get back exactly the set `s`. This is a fundamental property of surjective functions.

If `f : α → β` is surjective, then `f''(∫x : α, f x ∈ s) = s`, where `s ⊆ β` and `∫` denotes the set of elements of `α` mapping to `s` under `f`.


theorem Nat.mod_mod_of_dvd : ∀ {c b : ℕ} (a : ℕ), c ∣ b → a % b % c = a % c := by sorry

This theorem, `Nat.mod_mod_of_dvd`, states that for any natural numbers 'a', 'b', and 'c', if 'c' divides 'b', then the modulo of 'a' and 'b', further modulo 'c', is equal to the modulo of 'a' and 'c'. In other words, if a natural number 'c' is a divisor of 'b', the two-step modulus operation of 'a' by 'b' then by 'c' simplifies to a single modulus operation of 'a' by 'c'. This theorem can be useful when simplifying expressions involving modulus operations.

If a natural number 'c' divides 'b', then for all natural number 'a', (a mod b) mod c = a mod c.


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

This theorem states that for all types `α` and `ι`, and for all functions `κ` from `ι` to a sorted type, given `α` is a complete lattice, and given `a` of type `α` and a function `f` mapping each `ι` and `κ i` to `α`, for any `i` of type `ι` and `j` of type `κ i`, if `f i j` is less than or equal to `a`, then the infimum (`⨅`) over all `i` and for each `i`, `j` (i.e., the greatest lower bound) of `f i j` is less than or equal to `a`. In other words, if a particular value from a double-indexed set is less than or equal to `a`, then the greatest lower bound of the entire set is also less than or equal to `a`.

For any complete lattice `α`, function `κ` from a type `ι` to `α`, `a` in `α`, and function `f` mapping each pair `(i, j)` in `ι × κ` to `α` such that `f i j ≤ a` for all `i` and `j`, the infimum of `f i j` over all `i` and `j` is less than or equal to `a`.


theorem Equiv.swap_self : ∀ {α : Sort u_1} [inst : DecidableEq α] (a : α), Equiv.swap a a = Equiv.refl α := by sorry

This theorem, `Equiv.swap_self`, asserts that for any type `α` with decidable equality and for any element `a` of type `α`, the permutation function that swaps `a` with itself is equivalent to the identity function on `α`. In other words, swapping an element with itself leaves all elements in place, thus producing the identity permutation.

For any type `α` with decidable equality and any element `a` of type `α`, the identity function and the function that swaps `a` with itself are equal as permutations on `α`.


theorem mul_right_injective :
    ∀ {G : Type u_3} [inst : Mul G] [inst_1 : IsLeftCancelMul G] (a : G), Function.Injective fun x => a * x := by sorry

The theorem `mul_right_injective` states that, for any type `G` equipped with a multiplication operation and the property of left cancellation, multiplication on the right by a fixed element `a` from `G` is an injective function. In other words, if we consider the function `f(x) = a * x` where `*` represents the multiplication operation, then for all `x` and `y` in `G`, if `a * x = a * y` then `x = y`. This depends on the property of left cancellation, which asserts that for all `x`, `y`, and `z` in `G`, if `x * y = x * z` then `y = z`.

If `G` is a type equipped with multiplication and left cancellation, then right multiplication by a fixed element `a` from `G` is an injective function. That is, for all `x` and `y` in `G`, if `a * x = a * y` then `x = y`.


theorem Set.countable_iUnion :
    ∀ {α : Type u} {ι : Sort x} {t : ι → Set α} [inst : Countable ι],
      (∀ (i : ι), Set.Countable (t i)) → Set.Countable (⋃ i, t i) :=
  by sorry

The theorem `Set.countable_iUnion` states that for any type `α` and any sort `ι`, if we have a function `t` from the set of all `ι` to the set of all `α`, and if `ι` is countable, and if for each `ι`, the set `t i` is countable, then the union of all `t i` is also countable. Here, a set is defined as countable if there exists an injective map from the set to the natural numbers.

If `α` is a type, `ι` is a countable sort, and for each `ι`, the set `ti` is countable, then the union of the `ti`'s is countable. (In the language of set theory: The image of a countable set under a function whose domain and each fiber is countable is countable.)


theorem Finset.coe_filter :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Finset α), ↑(Finset.filter p s) = {x | x ∈ s ∧ p x} :=
  by sorry

The theorem `Finset.coe_filter` states for any type `α`, decidable predicate `p`, and finite set `s` of type `α`, the co-domain of the function `Finset.filter p s` is equal to the set of elements `x` such that `x` belongs to `s` and the predicate `p` is true for `x`. In other words, it's saying that filtering a finite set `s` with a predicate `p` yields a set containing only those elements of `s` which satisfy the predicate `p`.

For any type `α`, decidable predicate `p`, and finite set `s` of type `α`, the set of elements in `s` that satisfy `p` is equal to the co-domain of `Finset.filter p s`.


theorem MeasureTheory.lintegral_sum_measure :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {ι : Type u_5} (f : α → ENNReal) (μ : ι → MeasureTheory.Measure α),
      ∫⁻ (a : α), f a ∂MeasureTheory.Measure.sum μ = ∑' (i : ι), ∫⁻ (a : α), f a ∂μ i :=
  by sorry

This theorem states that for any type `α` and `ι`, a measurable space `α`, a function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), and a measure `μ` indexed by `ι`, the Lebesgue integral of the function `f` with respect to the sum of the measures is equal to the sum of the Lebesgue integrals of the function `f` with respect to each measure individually. In mathematical terms, we can express this as $\int f d(\sum_i \mu_i) = \sum_i \int f d\mu_i$.

The Lebesgue integral of a function with respect to the sum of measures is equal to the sum of integrals with respect to each measure.


theorem Mathlib.Algebra.GroupWithZero.Basic._auxLemma.3 :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {a : M₀} {n : ℕ} [inst_1 : NoZeroDivisors M₀],
      n ≠ 0 → (a ^ n = 0) = (a = 0) :=
  by sorry

This theorem, `Mathlib.Algebra.GroupWithZero.Basic._auxLemma.3`, states that for any `MonoidWithZero` (a mathematical structure that is a monoid, meaning it has an associative binary operation and an identity element, and also has a zero element distinct from the identity), in which there are no zero divisors (pairs of nonzero elements that multiply to zero), if we have a nonzero natural number `n` and an element `a` of this structure, then `a` raised to the power of `n` equals zero if and only if `a` equals zero.

For any MonoidWithZero without zero divisors, if a nonzero element a raised to the power of a natural number n equals zero, then a equals zero.


theorem Cardinal.mk_set_le : ∀ {α : Type u} (s : Set α), Cardinal.mk ↑s ≤ Cardinal.mk α := by sorry

This theorem states that for any type `α` and any set `s` of elements from `α`, the cardinality of the set `s` is less than or equal to the cardinality of the type `α`. In other words, this theorem states that the size of any subset is always less than or equal to the size of the whole set.

For any type `α` and subset `s` of `α`, the cardinality of `s` is less than or equal to the cardinality of `α`.


theorem Filter.Ioi_mem_atTop :
    ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : NoMaxOrder α] (x : α), Set.Ioi x ∈ Filter.atTop := by sorry

The theorem `Filter.Ioi_mem_atTop` states that for any type `α` with a `Preorder` relation (i.e., a binary relation that is reflexive and transitive) and without a maximum element (`NoMaxOrder`), for any element `x` of that type, the set of all elements greater than `x` (`Set.Ioi x`) is a member of the filter `atTop`. In other words, the set of all elements greater than `x` is a set that gets arbitrarily large (goes to infinity). This is captured by the filter `atTop`, which represents the limit tending to infinity in the ordered set `α`.

For any type `α` with a `NoMaxOrder` `Preorder` relation, the set of elements strictly greater than any `x` in `α` belongs to the filter `atTop`.


/-- See also `IsClosedMap.closure_image_eq_of_continuous`.  -/
theorem image_closure_subset_closure_image :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set X},
      Continuous f → f '' closure s ⊆ closure (f '' s) :=
  by sorry

This theorem states that for any two types `X` and `Y` with given topological structures, a function `f` from `X` to `Y`, and a set `s` of type `X`, if the function `f` is continuous, then the image of the closure of set `s` under function `f` is a subset of the closure of the image of set `s` under function `f`. In mathematical terms, if `f` is a continuous map, `f(closure(s)) ⊆ closure(f(s))` where `closure` represents the operation of taking the topological closure of a set.

For any continuous function `f` between topological spaces `X` and `Y`, and any set `s` in `X`, the image of the closure of `s` under `f` is contained in the closure of the image of `s` under `f`: `f(closure(s)) ⊆ closure(f(s))`.


theorem Matrix.transpose_one :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α], Matrix.transpose 1 = 1 :=
  by sorry

This theorem states that for any type `n` and any type `α` with decidable equality, given that `α` is a zero and a one (that is, it has elements identified as "zero" and "one"), the transpose of the one matrix (a matrix with ones on the diagonal and zeros elsewhere) is equal to the one matrix itself. In mathematical terms, if $\alpha$ is a field and $n$ is a set with a decidable equality relation, then the transpose of the identity matrix (of arbitrary size determined by `n`) is still the identity matrix.

For any type `n` with decidable equality and any type `α` that is a zero and one, the transpose of the identity matrix of size `n` over `α` is equal to the identity matrix itself.


theorem List.sum_append :
    ∀ {M : Type u_5} [inst : AddMonoid M] {l₁ l₂ : List M}, List.sum (l₁ ++ l₂) = List.sum l₁ + List.sum l₂ := by sorry

This theorem states that for any type `M` that forms an additive monoid, and for any two lists `l₁` and `l₂` of elements of type `M`, the sum of the elements in the concatenated list `(l₁ ++ l₂)` is equal to the sum of the sums of the elements in `l₁` and `l₂`. In other words, the sum function is distributive over list concatenation. This is analogous to the mathematical property that the sum of a sequence of numbers does not change if the sequence is split into two parts and these parts are summed separately.

For any additive monoid type `M`, the sum of elements in the concatenated list `(l₁ ++ l₂)` is equal to the sum of the sums of `l₁` and `l₂`.


theorem Polynomial.trailingDegree_eq_natTrailingDegree :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      p ≠ 0 → Polynomial.trailingDegree p = ↑(Polynomial.natTrailingDegree p) :=
  by sorry

The theorem `Polynomial.trailingDegree_eq_natTrailingDegree` states that for any non-zero polynomial `p` in a semiring `R`, the trailing degree of `p` is equal to the natural number trailing degree of `p`, when the latter is treated as an element of `ℕ∞` (the set of natural numbers extended with positive infinity). In other words, the smallest exponent of `X` that appears in `p` (which is the trailing degree of `p`) is equal to the forced natural number value of the trailing degree, where we define this forced value to be 0 when the trailing degree is positive infinity.

The trailing degree of a non-zero polynomial in a semiring equals the coerced natural number value of its trailing degree in the extended natural numbers.


/-- Analog of `Polynomial.induction_on`. -/
theorem MvPolynomial.induction_on :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {M : MvPolynomial σ R → Prop} (p : MvPolynomial σ R),
      (∀ (a : R), M (MvPolynomial.C a)) →
        (∀ (p q : MvPolynomial σ R), M p → M q → M (p + q)) →
          (∀ (p : MvPolynomial σ R) (n : σ), M p → M (p * MvPolynomial.X n)) → M p :=
  by sorry

This theorem is a form of mathematical induction for multivariate polynomials. Specifically, it states that for any kind of commutative semiring `R` and any type `σ`, if we have a property `M` that holds for all constant polynomials, is preserved under addition of any two multivariate polynomials `p` and `q` where `M` holds for both `p` and `q`, and is preserved under multiplication of any multivariate polynomial `p` by a monomial `MvPolynomial.X n` where `M` holds for `p`, then `M` holds for all multivariate polynomials `p` of type `MvPolynomial σ R`.

If `M` is a property that holds for all constant multivariate polynomials `R[x₁, …, xₙ]`, is closed under addition and multiplication, then `M` holds for all multivariate polynomials `p` of type `R[x₁, …, xₙ]`.


theorem Submodule.sum_mem :
    ∀ {R : Type u} {M : Type v} {ι : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M) {t : Finset ι} {f : ι → M}, (∀ c ∈ t, f c ∈ p) → (Finset.sum t fun i => f i) ∈ p :=
  by sorry

The theorem `Submodule.sum_mem` states that for any semiring `R`, any additive commutative monoid `M`, and any type `ι`, given a module structure on `M` over `R`, a submodule `p` of `M`, a finite set `t` of elements of type `ι`, and a function `f` mapping elements of `ι` to `M`, if every element `c` in `t` maps to an element in `p` under `f`, then the sum of `f(i)` for all `i` in `t` is also an element of `p`. In simpler terms, the sum of elements in a submodule, obtained via a function on a finite set, remains in the submodule.

If `M` is an additive commutative monoid with an `R`-module structure, `p` is a submodule of `M`, `t` is a finite set, and for all `i` in `t`, `f(i)` is in `p`, then `∑ i in t, f(i)` is in `p`.


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

This theorem states that for all natural numbers `a` and `b`, if `a` is less than `b`, then `a` is also less than `b` incremented by one. This is a basic property of the natural numbers, where increasing a number does not negate previous inequalities.

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


HEq.trans

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

This theorem, named `HEq.trans`, establishes the transitivity of heterogeneous equality (`HEq`) in Lean. Given three types `α`, `β`, and `φ`, and three objects `a : α`, `b : β`, and `c : φ`, if `a` is heterogeneously equal to `b` and `b` is heterogeneously equal to `c`, then `a` is heterogeneously equal to `c`. Heterogeneous equality allows for the comparison of objects that potentially could be of different types.

If `a` is heterogeneously equal to `b` and `b` is heterogeneously equal to `c`, then `a` is heterogeneously equal to `c`. (In other words, `HEq.trans (HEq a b) (HEq b c)` holds in Lean.)


theorem Asymptotics.IsBigOWith.congr_const :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c₁ c₂ : ℝ} {f : α → E} {g : α → F}
      {l : Filter α}, Asymptotics.IsBigOWith c₁ l f g → c₁ = c₂ → Asymptotics.IsBigOWith c₂ l f g :=
  by sorry

The theorem `Asymptotics.IsBigOWith.congr_const` states that for any two real constants `c₁` and `c₂`, two functions `f` and `g` on a type `α`, and a filter `l` on `α`, if `f` is Big-O of `g` with constant `c₁` at the filter `l` (i.e., `Asymptotics.IsBigOWith c₁ l f g` holds), and if `c₁` equals `c₂`, then `f` is also Big-O of `g` with constant `c₂` at the filter `l`. In other words, the Big-O notation's constant can be replaced by an equal constant without changing the validity of the Big-O relationship. This theorem essentially reflects the principle that the Big-O notation is insensitive to the exact value of the constant as long as it remains the same.

If `f` is Big-O of `g` with constant `c₁` at filter `l` in Lean, and `c₁` equals `c₂`, then `f` is also Big-O of `g` with constant `c₂` at filter `l`.


theorem Ordinal.mul_succ : ∀ (a b : Ordinal.{u_4}), a * Order.succ b = a * b + a := by sorry

The theorem `Ordinal.mul_succ` states that for any two ordinal numbers `a` and `b`, the product of `a` and the successor of `b` (`Order.succ b`) is equal to the sum of the product of `a` and `b` with `a`. In mathematical terms, we say for all ordinals `a` and `b`, `a * (b + 1) = a * b + a`. This corresponds to the distribution law of multiplication over addition, specifically when adding one to a number (which is the definition of successor in this context).

For any ordinal numbers `a` and `b`, `a * (Order.succ b) = a * b + a`.


theorem Int.emod_lt_of_pos : ∀ (a : ℤ) {b : ℤ}, 0 < b → a % b < b := by sorry

This theorem states that for any integer `a` and any positive integer `b`, the remainder (`a % b`) of the division of `a` by `b` is always less than `b`. This is a commonly identified property of the modulus operation in number theory.

For all integers `a` and positive integers `b`, `a % b` is less than `b`.


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

This theorem states that for any two types `α` and `β` with a lower bound (i.e., they have instances of the `OrderBot` typeclass) and a partial order (i.e., they have an instance of the `PartialOrder` typeclass), if there is an order isomorphism `f` between `α` and `β` (denoted `f : α ≃o β`), then the image of the least element of `α` under `f` is the least element of `β`. In simpler terms, the order isomorphism maps the smallest element of the first set to the smallest element of the second set.

Given types `α` and `β` with lower bounds and partial orders, an order isomorphism `f : α ≃o β` implies `f (least α) = least β`.


theorem CategoryTheory.ShortComplex.HasHomology.mk' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.HomologyData S → CategoryTheory.ShortComplex.HasHomology S :=
  by sorry

This theorem states that for any type `C` that forms a category with zero morphisms, and any short complex `S` of this category, if `S` has homology data, then `S` also has homology. In other words, a short complex in a category that has zero morphisms and homology data is guaranteed to have homology. This is a foundation theorem in the field of category theory, a branch of mathematics focused on abstract structure and relationships.

Given a type `C` forming a category with zero morphisms, every short complex `S` in `C` with homology data has well-defined homologies.


theorem two_zsmul : ∀ {G : Type w} [inst : SubNegMonoid G] (a : G), 2 • a = a + a := by sorry

This theorem states that for all types `G` which are a subtype of `SubNegMonoid`, the double scalar multiplication of any element `a` of type `G` is equal to the sum of `a` with itself. In other words, in any subtractive negation monoid, multiplying any element by 2 is the same as adding that element to itself. This is an abstract algebraic property that is familiar from ordinary arithmetic, where multiplying a number by 2 gives the same result as adding the number to itself.

For any subtractive negation monoid type `G`, the operation of multiplying an element `a` in `G` by 2 equals the operation of adding `a` to itself.


ContinuousOn.continuousAt

theorem ContinuousOn.continuousAt :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {x : α}, ContinuousOn f s → s ∈ nhds x → ContinuousAt f x :=
  by sorry

The theorem `ContinuousOn.continuousAt` states that for all types `α` and `β` equipped with topological structures, for a function `f` from `α` to `β`, a set `s` of `α`, and an element `x` of `α`, if `f` is continuous on `s` and `s` is a neighborhood of `x` (i.e., `s` is in the neighborhood filter of `x`), then `f` is continuous at `x`. In mathematical terms, if a function is continuous on a certain set that contains an open set around a point, then the function is also continuous at that point.

If a function is continuous on a neighborhood of a point, then it is continuous at that point.


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

This theorem, `sup_sup_sup_comm`, states that for any type `α` which forms a semilattice with a `sup` operation, and for any four elements `a`, `b`, `c`, and `d` of this type, the suprema (also known as the least upper bounds or joins) of these elements commute in a specific way. More specifically, the supremum of `a`, `b`, and the supremum of `c`, `d` is equal to the supremum of `a`, `c` and the supremum of `b`, `d`. In mathematical terms, we have $a \vee b \vee (c \vee d) = a \vee c \vee (b \vee d)$, where $\vee$ represents the `sup` operation.

For any semilattice with sup operation, the supremum of any four elements commutes, i.e., (a ∨ b) ∨ (c ∨ d) = a ∨ c ∨ (b ∨ d).


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.40 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      (-a < -b) = (b < a) :=
  by sorry

This theorem, named `Mathlib.Algebra.Order.Group.Defs._auxLemma.40`, states that for any type `α` that is an additive group and has a less-than relation `<`, and which satisfies the 'CovariantClass' properties for both addition and its swapped variant, it is true that for all elements `a` and `b` of that type, `-a` is less than `-b` if and only if `b` is less than `a`.

In simpler terms, within such an additive group, this theorem establishes a relationship between the ordering of two negated elements and the ordering of those same two elements without negation.

For any additive group with a covariant ordering, the negation of one element is less than the negation of another if and only if the original elements are ordered opposite to each other.


/-- Adding a group element to a point, then subtracting another point,
produces the same result as subtracting the points then adding the
group element.  -/
theorem vadd_vsub_assoc :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (g : G) (p₁ p₂ : P),
      g +ᵥ p₁ -ᵥ p₂ = g + (p₁ -ᵥ p₂) :=
  by sorry

This theorem, `vadd_vsub_assoc`, states that for any additive group `G` and any torsor `P` over `G`, as well as any group element `g` and points `p₁` and `p₂` in `P`, adding `g` to `p₁` and then subtracting `p₂` yields the same result as first subtracting `p₂` from `p₁` and then adding `g`. In other words, it shows that vector addition followed by vector subtraction is associative in this context.

For any additive group G and torsor P over G, for all g in G and p₁, p₂ in P, we have p₁ + g - p₂ = p₁ - p₂ + g.


theorem Finset.erase_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∉ s → Finset.erase (insert a s) a = s := by sorry

The theorem `Finset.erase_insert` states that for all sets `s` of a certain type `α`, and for all elements `a` of the same type `α` such that `a` does not belong to `s`, if you first insert `a` into `s` and then erase `a` from the resulting set, you get back the original set `s`. This is under the condition that the equality of elements of type `α` is decidable, meaning we can determine whether two elements of type `α` are equal or not. Essentially, it's like saying if you add something to a set and then immediately remove it, you are left with the original set.

For any decidably-equated type `α` and set `s` of type `λ (a : α), Finset α a`, if `a ∉ s`, then `Finset.erase (Finset.insert a s) = s`.


/-- If the oriented angle between three points is `π / 2`, so is the unoriented angle.  -/
theorem EuclideanGeometry.angle_eq_pi_div_two_of_oangle_eq_pi_div_two :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]
      [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P},
      EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → EuclideanGeometry.angle p₁ p₂ p₃ = Real.pi / 2 :=
  by sorry

This theorem states that if the oriented angle between three points is `π / 2`, then the unoriented angle between these points is also `π / 2`. Here, the oriented angle is defined in the context of a 2-dimensional vector space over the real numbers, equipped with an orientation and standard Euclidean geometry. The points are taken in a metric space with a normed add torsor structure, which is a space where you can add vectors to points and subtract points to get vectors.

In a 2-dimensional real vector space with orientation and standard Euclidean geometry, the unoriented angle between three points is `π / 2` if and only if their oriented angle is `π / 2`.


theorem Set.eq_of_subset_of_subset : ∀ {α : Type u} {a b : Set α}, a ⊆ b → b ⊆ a → a = b := by sorry

The theorem `Set.eq_of_subset_of_subset` states that for any type `α` and any two sets `a` and `b` of that type, if `a` is a subset of `b` and `b` is a subset of `a`, then `a` and `b` are equal. Here, a set `a` being a subset of another set `b` (denoted as `a ⊆ b`) means that every element of `a` is also an element of `b`. Therefore, this theorem expresses the idea of set equality in terms of subset relationships.

If two sets `α` have the subset relation `a ⊆ b` and `b ⊆ a`, then `a = b`.


theorem BilinForm.smul_left :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {B : BilinForm R M} (a : R) (x y : M), B.bilin (a • x) y = a * B.bilin x y :=
  by sorry

This theorem states that for any commutative semiring `R`, add-commutative monoid `M`, and `M` being a module over `R`, for any bilinear form `B` on `R` and `M`, and any elements `a` in `R`, `x`, `y` in `M`, the bilinear form of the scalar multiplication of `a` and `x`, and `y` is equal to `a` multiplied by the bilinear form of `x` and `y`. This theorem essentially demonstrates the property of scalar multiplication in the context of bilinear forms.

For any commutative semiring `R`, add-commutative `R`-module `M`, bilinear form `B` on `R x M`, and `a` in `R` and `x`, `y` in `M`, we have `B(a, x, y) = a * B(x, y)`.


theorem mul_inv_cancel_left₀ :
    ∀ {G₀ : Type u} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → ∀ (b : G₀), a * (a⁻¹ * b) = b := by sorry

This theorem states that for any type `G₀` that forms a Group with Zero, for any non-zero element `a` of type `G₀`, and for every `b` of type `G₀`, the product of `a` and the product of the inverse of `a` and `b` equals `b`. This is equivalent to cancellation law in the mathematical structure of a group with zero, where if `a` is not zero, then multiplying `a` with the result of multiplying its inverse and another element `b` simplifies back to `b`.

For any group with zero `G₀` and non-zero element `a` in `G₀`, `a * (a⁻¹ * b) = b` holds.


theorem Subgroup.mem_top : ∀ {G : Type u_1} [inst : Group G] (x : G), x ∈ ⊤ := by sorry

This theorem states that for any given type `G` and any instance of a group `G`, every element `x` of `G` belongs to the top subgroup `⊤`. In the context of group theory, the top (or trivial) subgroup of a group is the group itself, hence every element of the group is a member of this subgroup. The theorem is universal, meaning it applies to all elements of all groups.

For any group `G` and all `x` in `G`, `x` belongs to the group `⊤` (i.e., `x ∈ ⊤`).


theorem isGLB_csInf :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α},
      Set.Nonempty s → BddBelow s → IsGLB s (sInf s) :=
  by sorry

The theorem `isGLB_csInf` states that, for any given set `s` of a certain type `α`, if `s` is non-empty (`Set.Nonempty s`) and bounded below (`BddBelow s`), then the infimum (`sInf s`) of `s` is indeed a greatest lower bound of `s` (`IsGLB s`). Here, `α` is assumed to be a conditionally complete lattice, a mathematical structure with order relation where every nonempty, bounded below subset has an infimum. This theorem confirms that the infimum operation always results in a valid greatest lower bound for any non-empty and bounded below set in a conditionally complete lattice.

In a conditionally complete lattice, the infimum of any non-empty and bounded below set is its greatest lower bound.


theorem List.filter_cons_of_pos :
    ∀ {α : Type u_1} {p : α → Bool} {a : α} (l : List α), p a = true → List.filter p (a :: l) = a :: List.filter p l :=
  by sorry

The theorem `List.filter_cons_of_pos` states that for any type `α`, any boolean function `p` on `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, if `p` returns `true` when applied to `a`, then the list obtained by filtering the list that results from prepending `a` to `l` with `p` is the same as the list obtained by prepending `a` to the list that results from filtering `l` with `p`. In other words, if an element satisfies a filter condition, it maintains its position when we apply the filter to the list it belongs to.

If `a` is an element of list `l` such that `p(a)` holds, then `a` : List.filter p (a :: l) = a :: List.filter p l`.


theorem div_lt_iff' : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < c → (b / c < a ↔ b < c * a) :=
  by sorry

This theorem, `div_lt_iff'`, states that for any type `α` that is a LinearOrderedSemifield, and any elements `a`, `b`, `c` of type `α`, if `c` is greater than zero, then `b` divided by `c` is less than `a` if and only if `b` is less than `c` times `a`. In other words, it establishes a particular equivalence relation between division and multiplication in a ordered semifield when the divisor/multiplier is greater than zero.

For any LinearOrderedSemifield type `α` and elements `a`, `b`, `c` of type `α` with `c` being positive, `b / c < a` if and only if `b` is less than `a * c`.


theorem lie_smul :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] (t : R)
      (x : L) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆ :=
  by sorry

This theorem, `lie_smul`, states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative group `M` that is also a module over `R` and a Lie ring module over `L`, and which forms a Lie module over `R` and `L`, the Lie bracket of an element `x` in `L` and the scalar multiplication of a scalar `t` in `R` and an element `m` in `M` is equal to the scalar multiplication of `t` with the Lie bracket of `x` and `m`. In terms of mathematics notation, for all `t` in `R`, `x` in `L`, and `m` in `M`, the theorem states that `[x, t * m] = t * [x, m]`, where `[.,.]` denotes the Lie bracket, and `*` denotes scalar multiplication.

For any commutative ring `R`, Lie ring `L`, and additive commutative group `M` that is both an `R`-module and a Lie ring module, the Lie bracket of an element in `L` with the scalar multiplication of a scalar in `R` and an element in `M` equals the scalar multiplication of the scalar with the Lie bracket of the element in `L` and the element in `M`.