theorem measurable_to_countable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Countable α] [inst_2 : MeasurableSpace β]
      {f : β → α}, (∀ (y : β), MeasurableSet (f ⁻¹' {f y})) → Measurable f :=
  by sorry

The theorem `measurable_to_countable` states that for any types `α` and `β` with `α` being countable, and both being measurable spaces, if a function `f` from `β` to `α` has the property that the preimage of each singleton set `{f y}` under `f` is a measurable set for every `y` in `β`, then the function `f` itself is measurable. In other words, if for every `y` in the domain of `f`, the set of all points in `β` mapped to `f(y)` is a measurable set, then `f` is a measurable function. This theorem relates the measurability of a function to the measurability of preimages of singleton sets under it.

If a function between two countable and measurable spaces maps every singleton set to a measurable preimage, then the function itself is measurable.


theorem Finset.mem_sort :
    ∀ {α : Type u_1} (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r] [inst_2 : IsAntisymm α r]
      [inst_3 : IsTotal α r] {s : Finset α} {a : α}, a ∈ Finset.sort r s ↔ a ∈ s :=
  by sorry

The theorem `Finset.mem_sort` states that for any type `α`, any decidable relation `r` on `α` that is transitive, antisymmetric and total, any finite set `s` of type `α`, and any element `a` of type `α`, `a` is an element of the sorted list of `s` (obtained using the relation `r`) if and only if `a` is an element of `s`. This theorem essentially guarantees that the sorting operation does not change the elements of the set, it only rearranges them.

For any type `α`, decidable relation `r` on `α` that is transitive, antisymmetric and total, and finite set `s` of type `α`, the sorted list of `s` using `r` equals `s`.


theorem MeasureTheory.set_lintegral_congr_fun :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal} {s : Set α},
      MeasurableSet s → (∀ᵐ (x : α) ∂μ, x ∈ s → f x = g x) → ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, g x ∂μ :=
  by sorry

The theorem `MeasureTheory.set_lintegral_congr_fun` states that for any measurable space `α` with a measure `μ`, and any two functions `f` and `g` from `α` to the extended nonnegative real numbers `ENNReal`, if we have a measurable set `s` in `α` such that almost everywhere in `s` (with respect to the measure `μ`), `f` and `g` are equal, then the integral over `s` of `f` with respect to `μ` is equal to the integral over `s` of `g` with respect to `μ`. In mathematical terms, this means that if two functions are equal almost everywhere in a measurable set, then their integrals over that set are also equal.

If measurable functions `f` and `g` are equal almost everywhere on a measurable set `s` in a measurable space with measure `μ`, then their integrals over `s` with respect to `μ` are equal: `∫(s, μ, f) = ∫(s, μ, g)`.


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

The theorem `Polynomial.Monic.degree_mul` states that for any semiring `R` and any two polynomials `p` and `q` from that semiring, if `q` is a monic polynomial (meaning its leading coefficient is `1`), then the degree of the product of `p` and `q` is the sum of the degrees of `p` and `q`. The degree of a polynomial is the largest exponent of `X` that appears in the polynomial.

For any semiring R and monic polynomials p and q from R, the degree of their product is the sum of the degrees of p and q.


theorem Nat.eq_of_mul_eq_mul_left : ∀ {m k n : ℕ}, 0 < n → n * m = n * k → m = k := by sorry

This theorem states that for any three natural numbers `m`, `k`, and `n`, if `n` is greater than `0` and the product of `n` and `m` equals the product of `n` and `k`, then `m` equals `k`. In simple terms, it shows that if two products involving the same non-zero natural number are equal, then the other factors in the products are also equal. In terms of mathematical notation, if $0 < n$ and $n \cdot m = n \cdot k$, then $m = k$.

If $0 < n$ and $n \cdot m = n \cdot k$, then $m = k$.


OpenEmbedding.continuous

theorem OpenEmbedding.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      OpenEmbedding f → Continuous f :=
  by sorry

This theorem asserts that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, if `X` and `Y` are equipped with a topological space structure, then if `f` is an open embedding, it is also continuous. In terms of topology, this means that if `f` is a function that preserves the open set structure (i.e., the image of any open set in `X` under `f` is an open set in `Y`), then `f` also preserves the nearbyness relation (i.e., `f` is continuous). Thus, any open embedding between topological spaces is a continuous map.

If `f` is an open embedding between topological spaces `X` and `Y`, then `f` is a continuous function.


theorem LinearMap.toMatrix_apply :
    ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_3} {n : Type u_4} [inst_1 : Fintype n] [inst_2 : Fintype m]
      [inst_3 : DecidableEq n] {M₁ : Type u_5} {M₂ : Type u_6} [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂]
      [inst_6 : Module R M₁] [inst_7 : Module R M₂] (v₁ : Basis n R M₁) (v₂ : Basis m R M₂) (f : M₁ →ₗ[R] M₂) (i : m)
      (j : n), (LinearMap.toMatrix v₁ v₂) f i j = (v₂.repr (f (v₁ j))) i :=
  by sorry

The theorem `LinearMap.toMatrix_apply` states that for any commutative semiring `R`, any types `m` and `n` with finite cardinality, any types `M₁` and `M₂` forming additive commutative monoids and also R-modules, any decidable equality on `n`, any basis `v₁` of `M₁` over `R` indexed by `n`, any basis `v₂` of `M₂` over `R` indexed by `m`, any linear map `f` from `M₁` to `M₂`, and any elements `i` of `m` and `j` of `n`, the `$ij$`-th element of the matrix representation of `f` with respect to the bases `v₁` and `v₂` is the `$i$`-th coordinate of the `v₂`-representation of the image of the `$j$`-th basis vector of `v₁` under `f`.

For any commutative semiring R, finite types m and n, additive commutative monoids and R-modules M₁ and M₂, decidable equality on n, bases v₁ of M₁ and v₂ of M₂, linear map f from M₁ to M₂, and i of m and j of n, the ($ij$)th entry of the matrix representation of f with respect to v₁ and v₂ is equal to the i-th coordinate of the image of the j-th basis vector of v₁ under f.


theorem AffineSubspace.coe_eq_bot_iff :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] (Q : AffineSubspace k P), ↑Q = ∅ ↔ Q = ⊥ :=
  by sorry

This theorem states that for any field `k`, additive commutative group `V`, and `P` with the structure of an `AddTorsor` with respect to `V`, an affine subspace `Q` of `P` is empty if and only if `Q` is equal to the bottom element (i.e., the smallest element in the lattice of subspaces). In simpler words, it asserts that an affine subspace is empty if and only if it is the minimal possible subspace.

A subspace of an additive commutative group carrying the structure of an additive torsor over a field is empty if and only if it is the bottom element in the lattice of subspaces.


theorem Finset.piecewise_eq_of_mem :
    ∀ {ι : Type u_1} {π : ι → Sort u_2} (s : Finset ι) (f g : (i : ι) → π i) [inst : (j : ι) → Decidable (j ∈ s)]
      {i : ι}, i ∈ s → Finset.piecewise s f g i = f i :=
  by sorry

The theorem `Finset.piecewise_eq_of_mem` states that for any given type `ι`, any function `π` mapping `ι` to a sort `u_2`, any finset `s` of `ι`, and any two functions `f` and `g` from `ι` to `π i`, if `i` is an element of the finset `s`, then the `piecewise` function of `s`, `f`, and `g` evaluated at `i` is equal to `f` evaluated at `i`. In other words, the `piecewise` function will select the function `f` for any input which is in the given finset `s`.

For any type `ι`, function `π` from `ι` to a sort `u_2`, finset `s` of `ι`, and functions `f` and `g` from `ι` to `π`, if `i ∈ s`, then `(Finset.piecewise s f g) i = f i`.


theorem ClosureOperator.isClosed_closure :
    ∀ {α : Type u_1} [inst : PartialOrder α] (c : ClosureOperator α) (x : α), c.IsClosed (c x) := by sorry

This theorem states that for any type `α` that has a partial order, and for any closure operator `c` on this type, the closure of any element `x` of type `α` under the operator `c` is a closed element, according to the closure operator `c`. In other words, for any partial order and any closure operator defined on it, applying the closure operator to an element results in a closed element.

For any type `α` with a partial order and any closure operator `c` on `α`, `c(x)` is a closed element under `c` for all `x` in `α`.


theorem Finset.inf_insert :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} {f : β → α}
      [inst_2 : DecidableEq β] {b : β}, Finset.inf (insert b s) f = f b ⊓ Finset.inf s f :=
  by sorry

The theorem `Finset.inf_insert` asserts that for any semilattice with top (`SemilatticeInf` and `OrderTop`), any finite set (`Finset`) `s` of type `β`, any function `f` from `β` to `α`, and any element `b` of `β`, the infimum (greatest lower bound) of the set obtained by applying `f` to each element of the set `s` with `b` inserted (`insert b s`), is equal to the infimum of `f(b)` and the infimum of the set obtained by applying `f` to each element of `s`. This is true when equality for elements of `β` is decidable (`DecidableEq β`). In mathematical terms, this can be written as `inf(f(b ∪ s)) = f(b) ⊓ inf(f(s))`.

For any semilattice with top, finite set, function, and decidable equality, the infimum of the function applied to each element of the set with a new element inserted is equal to the infimum of the function applied to the new element and the infimum of the function applied to each element of the set. (Mathematically: `inf(f(b ∪ s)) = f(b) ∧ inf(f(s))`)


theorem Associates.irreducible_mk :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (a : α), Irreducible (Associates.mk a) ↔ Irreducible a := by sorry

The theorem `Associates.irreducible_mk` states that for all types `α` that are equipped with a `CommMonoidWithZero` structure, a given element `a` of type `α` is irreducible in the associated monoid if and only if `a` itself is irreducible in the original monoid `α`. In simple terms, it's stating that the irreducibility of an element doesn't change when we move from the original monoid to its associated monoid.

For any type `α` with a `CommMonoidWithZero` structure, an element `a` is irreducible in the associated monoid if and only if it is irreducible in the original monoid `α`.


theorem OrderHom.map_lfp :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α), f (OrderHom.lfp f) = OrderHom.lfp f := by sorry

This theorem states that for any type `α` that forms a complete lattice and any order-preserving function `f : α →o α`, the function `f` maps the least fixed point of `f` to itself. In other words, if we apply `f` to the least fixed point of `f`, we still get the least fixed point of `f`. This is essentially asserting that the least fixed point of a monotone function is a fixed point of the function itself. In mathematical terms, for a monotone function `f`, we have `f(lfp(f)) = lfp(f)`, where `lfp(f)` is the least fixed point of `f`.

If `f : α → α` is a monotone function on a complete lattice `α`, then the least fixed point of `f` is a fixed point of `f`. (i.e., `lfp(f) = fixpoint(f)`)


theorem List.map_pmap :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {p : α → Prop} (g : β → γ) (f : (a : α) → p a → β) (l : List α)
      (H : ∀ a ∈ l, p a), List.map g (List.pmap f l H) = List.pmap (fun a h => g (f a h)) l H :=
  by sorry

The theorem `List.map_pmap` states that for any types `α`, `β`, and `γ`, a predicate `p : α → Prop`, a function `g : β → γ`, a function `f : (a : α) → p a → β`, a list `l : List α`, and a proof `H` that the predicate `p` holds for every element in list `l`, the operation of mapping function `g` over the result of partially mapping function `f` over list `l` (given by `List.pmap f l H`) is equivalent to partially mapping the composition of `g` and `f` over list `l` (given by `List.pmap (fun a h => g (f a h)) l H`). In simpler terms, this theorem shows the commutativity of the operations of mapping and partial mapping under certain conditions.

For any types `α`, `β`, and `γ`, and functions `f : α → β → β`, `g : β → γ`, `p : α → Prop`, given a list `l : List α` and a proof `H` that `p` holds for every element in `l`, `List.pmap_map l H (f ∘ g)` is equivalent to `List.pmap (λ a h, g (f a h)) l H`.


theorem Nat.pred_succ : ∀ (n : ℕ), Nat.pred (Nat.succ n) = n := by sorry

This theorem states that for every natural number `n`, the predecessor of the successor of `n` is `n` itself. In other words, if we increment a natural number by 1 and then decrement it by 1, we get back the original number. This mirrors the intuitive understanding of the successor (or "next") and predecessor (or "previous") operations in the natural numbers.

The successor of a natural number is the same number as the predecessor of its successor.


theorem ContinuousMonoidHom.inducing_toContinuousMap :
    ∀ (A : Type u_2) (B : Type u_3) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
      [inst_3 : TopologicalSpace B], Inducing ContinuousMonoidHom.toContinuousMap :=
  by sorry

This theorem states that for any two types `A` and `B`, given that `A` and `B` are both monoids and topological spaces, the function `ContinuousMonoidHom.toContinuousMap`, which transforms a continuous monoid homomorphism between `A` and `B` into a continuous map, is an inducing function. In the context of topology, an inducing function creates a topology on the domain that makes the function continuous.

Given two monoid and topological spaces `A` and `B` and a continuous monoid homomorphism `f : A → B`, the function `ContinuousMonoidHom.toContinuousMap f` is a continuous function.


theorem Polynomial.algHom_ext :
    ∀ {R : Type u} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring B] [inst_2 : Algebra R B]
      {f g : Polynomial R →ₐ[R] B}, f Polynomial.X = g Polynomial.X → f = g :=
  by sorry

The theorem `Polynomial.algHom_ext` states that for any two algebra homomorphisms `f` and `g` from the set of polynomials over a commutative semiring `R` to a semiring `B`, under the condition that `R` is an algebra over `B`, if `f` and `g` map the polynomial indeterminate `X` to the same element, then `f` and `g` are equal. In other words, the behavior of an algebra homomorphism on the polynomial indeterminate completely determines the homomorphism.

If `R` is a commutative semiring where `R` is an algebra over a semiring `B`, and `f` and `g` are algebra homomorphisms from `R[X]` to `B` with `f X = g X`, then `f = g`.


theorem Set.set_smul_subset_iff₀ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ {A B : Set β}, a • A ⊆ B ↔ A ⊆ a⁻¹ • B :=
  by sorry

This theorem is about the interaction between scalar multiplication and subset relations in the context of a group with zero and a multiplicative action. Specifically, for any types `α` and `β` where `α` is a group with zero and `β` has a multiplication action by `α`, and for any non-zero `a` of type `α` and sets `A` and `B` of type `β`, the statement asserts that the set obtained by scalar multiplying `A` by `a` is a subset of `B` if and only if `A` is a subset of the set obtained by scalar multiplying `B` by the inverse of `a`. In mathematical notation, this can be written as: $aA \subseteq B$ if and only if $A \subseteq a^{-1}B$.

For any group with zero `α`, type `β` with a multiplicative action by `α`, non-zero `a` in `α`, and sets `A` and `B` in `β`, $aA \subseteq B$ if and only if $A \subseteq a^{-1}B$.


Equiv.Perm.Disjoint.commute

theorem Equiv.Perm.Disjoint.commute : ∀ {α : Type u_1} {f g : Equiv.Perm α}, Equiv.Perm.Disjoint f g → Commute f g := by
  sorry

The theorem `Equiv.Perm.Disjoint.commute` states that for any type `α` and any two permutations `f` and `g` of that type, if `f` and `g` are disjoint (meaning that for every element of `α`, it is left unchanged by either `f` or `g` but not both), then `f` and `g` commute. In other words, applying `f` and then `g` to any element of `α` yields the same result as applying `g` and then `f`.

If two disjoint permutations on a type commute, then their order can be reversed without changing the result for any element of the type.


HasFPowerSeriesAt.analyticAt

theorem HasFPowerSeriesAt.analyticAt :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {x : E}, HasFPowerSeriesAt f p x → AnalyticAt 𝕜 f x :=
  by sorry

The theorem `HasFPowerSeriesAt.analyticAt` states that for any function `f` from `E` to `F` and any point `x` in `E`, if `f` has a convergent power series expansion represented by a formal multilinear series `p` at the point `x`, then `f` is analytic at the point `x`. Here, `𝕜` is a non-trivial normed field, `E` is a normed additive commutative group that is also a normed space over `𝕜`, and `F` is another normed additive commutative group that is also a normed space over `𝕜`.

If a function `f` from a normed additive commutative group `E` to another normed additive commutative group `F` over a non-trivial normed field `𝕜` has a convergent power series expansion at a point `x` in `E`, then `f` is analytic at `x`.


/-- A continuous surjective open map is a quotient map.  -/
theorem IsOpenMap.to_quotientMap :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → Continuous f → Function.Surjective f → QuotientMap f :=
  by sorry

This theorem states that for any two types `X` and `Y` with a function `f` mapping from `X` to `Y`, if both `X` and `Y` possess a topological structure and `f` is an open map, continuous, and surjective, then `f` is a quotient map. In mathematical terms, this theorem asserts that a continuous function that is both surjective and takes open sets to open sets (an open map) is a quotient map, where a quotient map is a surjective function that preserves the open sets of the domain in the codomain.

A continuous, surjective open map between topological spaces is a quotient map.


theorem isRelPrime_comm : ∀ {α : Type u_1} [inst : CommMonoid α] {x y : α}, IsRelPrime x y ↔ IsRelPrime y x := by sorry

The theorem `isRelPrime_comm` states that for any commutative monoid `α` and any elements `x` and `y` in `α`, `x` and `y` being relatively prime is equivalent to `y` and `x` being relatively prime. In other words, the property of being relatively prime is symmetric. Here, two elements `x` and `y` are defined to be relatively prime if every common divisor of `x` and `y` is a unit (i.e., has a multiplicative inverse).

For any commutative monoid with units, x and y being relatively prime is equivalent to y and x being relatively prime.


theorem SeparationQuotient.continuous_mk :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous SeparationQuotient.mk := by sorry

The theorem `SeparationQuotient.continuous_mk` states that for any type `X` equipped with a topological space structure, the natural map from `X` to its separation quotient, denoted as `SeparationQuotient.mk`, is continuous. Here, continuity refers to the mathematical concept of a function maintaining closeness, which in the context of topological spaces, means that the preimage of any open set is open. The separation quotient of a topological space is a related space where indistinguishable points are identified, and the `SeparationQuotient.mk` function represents the canonical projection map to this quotient space.

The canonical projection map from a topological space to its separation quotient is a continuous function.


/-- A subsemigroup is closed under multiplication.  -/
theorem Subsemigroup.mul_mem :
    ∀ {M : Type u_1} [inst : Mul M] (S : Subsemigroup M) {x y : M}, x ∈ S → y ∈ S → x * y ∈ S := by sorry

This theorem states that for any type `M` which has a multiplication operation defined, and for any subsemigroup `S` of `M`, if elements `x` and `y` are members of `S`, then the product of `x` and `y` (`x * y`) is also a member of `S`. In essence, this theorem proves that a subsemigroup is closed under multiplication, which is a fundamental property of semigroups.

If `S` is a subsemigroup of a type `M` with multiplication, then `x * y` belongs to `S` for all `x, y` in `S`.


theorem contravariant_le_iff_contravariant_lt_and_eq :
    ∀ (M : Type u_1) (N : Type u_2) (μ : M → N → N) [inst : PartialOrder N],
      (Contravariant M N μ fun x x_1 => x ≤ x_1) ↔
        (Contravariant M N μ fun x x_1 => x < x_1) ∧ Contravariant M N μ fun x x_1 => x = x_1 :=
  by sorry

The theorem `contravariant_le_iff_contravariant_lt_and_eq` states that for any two types `M` and `N`, and a function `μ` from `M` and `N` to `N`, under a partial order on `N`, the contravariant property with respect to the "less than or equal to" relation is equivalent to the contravariant property both with respect to the "less than" relation and the "equal to" relation. This means that if the action of any element in `M` preserves the "less than or equal to" ordering of elements in `N`, then it also preserves the "less than" and "equal to" orderings, and vice versa.

For any type `M`, type `N`, and function `μ` from `M` to `N` under a partial order on `N`, the contravariant property with respect to the relation "less than or equal to" on `N` is equivalent to the simultaneous contravariant properties with respect to both "less than" and "equal to" relations on `N`.


Finpartition.le

theorem Finpartition.le :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a) {b : α},
      b ∈ P.parts → b ≤ a :=
  by sorry

This theorem, named `Finpartition.le`, states that for any type `α` where `α` is equipped with a lattice structure and a minimal element (the bottom element), given any element `a` of type `α` and a finite partition `P` of `a`, if `b` is an element of the parts comprising the partition `P`, then `b` is less than or equal to `a`. In other words, every part of a finite partition is less than or equal to the whole.

For any lattice `α` with a bottom element, and for any finite partition `P` of an element `a` in `α`, every part `b` of the partition satisfies `b ≤ a`.


theorem RatFunc.denom_div :
    ∀ {K : Type u} [inst : Field K] (p : Polynomial K) {q : Polynomial K},
      q ≠ 0 →
        RatFunc.denom ((algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) =
          Polynomial.C (Polynomial.leadingCoeff (q / gcd p q))⁻¹ * (q / gcd p q) :=
  by sorry

The theorem `RatFunc.denom_div` states that for any field `K` and for any two polynomials `p` and `q` from `K`, where `q` is not zero, the denominator of the rational function resulting from the division of the algebraic mappings of `p` and `q` into `RatFunc K` is equivalent to the product of the inverse of the leading coefficient of the polynomial `q / gcd(p, q)` and the polynomial `q / gcd(p, q)`. In other words, if you convert the polynomials `p` and `q` into rational functions and divide them, the denominator of the result is determined by the leading coefficient and the greatest common divisor of the original polynomials.

Given a field `K` and two polynomials `p` and `q` in `K` with `q` not zero, the denominator of the rational function `(alg_map p : RatFunc K) / (alg_map q : RatFunc K)` is equivalent to `(lc_coeff q / gcd p q) * q / gcd p q`.


theorem Nat.dvd_of_mul_dvd_mul_left : ∀ {k m n : ℕ}, 0 < k → k * m ∣ k * n → m ∣ n := by sorry

This theorem states that for any three natural numbers, `k`, `m`, and `n`, if `k` is greater than zero and `k` times `m` divides `k` times `n`, then `m` divides `n`. In mathematical notation, if $k > 0$ and $k \cdot m | k \cdot n$, then $m | n$. This theorem is crucial in arithmetic and number theory, as it establishes a relationship between multiplication and divisibility among natural numbers.

If a positive natural number `k` divides the product of two other natural numbers `m` and `n` (i.e., `k * m` = `p * n` for some natural number `p`), then `m` divides `n` (i.e., `m` | `n`).


theorem Convex.segment_subset :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E]
      {s : Set E}, Convex 𝕜 s → ∀ {x y : E}, x ∈ s → y ∈ s → segment 𝕜 x y ⊆ s :=
  by sorry

The theorem `Convex.segment_subset` states that for any ordered semiring `𝕜` and any additive commutative monoid `E` that is also a `𝕜`-module, if `s` is a convex set in `E`, then for any two elements `x` and `y` in `s`, the segment from `x` to `y` (which is defined as the set of all points `z` that can be expressed as `a*x + b*y`, where `a` and `b` are nonnegative and sum to 1) is a subset of `s`. In other words, in a convex set, the entire line segment connecting any two points in the set also lies within the set.

In a convex set of an additive commutative monoid that is a module over an ordered semiring, any segment connecting two elements lies entirely within the set.


MeasurableSet.const

theorem MeasurableSet.const : ∀ {α : Type u_1} {m : MeasurableSpace α} (p : Prop), MeasurableSet {_a | p} := by sorry

The theorem `MeasurableSet.const` states that for any type `α` and any measurable space `m` defined over `α`, any set that is defined by a constant proposition `p` (i.e., a proposition that does not depend on the elements of the set) is a measurable set. This means the measurability criterion is satisfied by such sets, regardless of the actual proposition `p`.

A constant proposition `p` defines a measurable set in a measurable space `m` over type `α`.


theorem Cubic.of_c_eq_zero :
    ∀ {R : Type u_1} {P : Cubic R} [inst : Semiring R],
      P.a = 0 → P.b = 0 → P.c = 0 → Cubic.toPoly P = Polynomial.C P.d :=
  by sorry

The theorem `Cubic.of_c_eq_zero` states that for any type `R` that is a semiring and any cubic polynomial `P` of type `R`, if the coefficients `a`, `b`, and `c` of `P` are all zero, then the conversion of `P` to a regular polynomial using `Cubic.toPoly` is equal to a constant polynomial with coefficient `d`. In other words, a cubic polynomial with all coefficients except the constant term being zero is just a constant polynomial in the semiring `R`.

For any semiring `R` and cubic polynomial `P` over `R` with coefficients `a`, `b`, and `c` such that `a = b = 0`, the conversion of `P` to a regular polynomial using `Cubic.toPoly` is equal to the constant polynomial with coefficient `c`.


/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is maximized when
`f` and `g` monovary together. Stated by permuting the entries of `g`.  -/
theorem MonovaryOn.sum_smul_comp_perm_le_sum_smul :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      MonovaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s → (Finset.sum s fun i => f i • g (σ i)) ≤ Finset.sum s fun i => f i • g i :=
  by sorry

**Rearrangement Inequality Statement**: For any finite set `s` of indices and any two functions `f : ι → α` and `g : ι → β` that monovary together on `s` (meaning if `g i < g j` then `f i ≤ f j` for all `i, j ∈ s`), and any permutation `σ` of the indices such that any index `x` for which `σ x ≠ x` is in `s`, the sum over `s` of `f i • g (σ i)` (the pointwise scalar multiplication of `f` and `σ`-permuted `g`) is less than or equal to the sum over `s` of `f i • g i` (the pointwise scalar multiplication of `f` and `g`). Here, `•` denotes scalar multiplication in the context of a linearly ordered ring `α` and a linearly ordered additive commutative group `β` where `α` acts on `β`. This statement essentially suggests that rearranging the terms of `g` to match the order of `f` maximizes the sum of the pointwise scalar multiplication.

For any finite set `s`, functions `f : ι → α` and `g : ι → β` that monovary together on `s`, and permutation `σ` of `s`, the pointwise scalar multiplication of `f` and `σ`-permuted `g` summed over `s` is less than or equal to the pointwise scalar multiplication of `f` and `g` summed over `s`.


theorem balancedCore_subset :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] (s : Set E), balancedCore 𝕜 s ⊆ s :=
  by sorry

The theorem `balancedCore_subset` states that for any type `𝕜` with a structure of seminormed ring and any type `E` with a structure of scalar multiplication by `𝕜`, for any set `s` of elements of `E`, the balanced core of `s` is always a subset of `s`. In other words, all elements of the balanced core of a set are also elements of the original set.

For any seminormed ring `𝕜` and any scalar multiplication module `E` over `𝕜`, the balanced core of any subset `s` of `E` is contained in `s`.


theorem Profinite.NobelingProof.Products.prop_of_isGood :
    ∀ {I : Type u} [inst : LinearOrder I] (C : Set (I → Bool)) {l : Profinite.NobelingProof.Products I} (J : I → Prop)
      [inst_1 : (j : I) → Decidable (J j)],
      Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C J) l → ∀ a ∈ ↑l, J a :=
  by sorry

The theorem `Profinite.NobelingProof.Products.prop_of_isGood` states that for any type `I` equipped with a linear order, a set `C` of Boolean-valued functions on `I`, a product `l` of `I`, and a property `J` of elements of `I`, if `l` is "good" with respect to the image of `C` under the projection `J`, then every element `a` of `l` satisfies the property `J`. Here, a product is said to be "good" if the evaluation of `C` at `l` is not an integer linear combination of the evaluations of `C` at all products less than `l`. The projection of `C` by `J` is the image of `C` under the projection function `J`.

If a product of a linearly ordered type with respect to a set of Boolean-valued functions is "good" with respect to the image of the functions under a projection, then every element in the product satisfies the property of the projection.


theorem SetTheory.PGame.add_left_neg_le_zero : ∀ (x : SetTheory.PGame), -x + x ≤ 0 := by sorry

This theorem states that for any given game `x` in set theory, the sum of the negative of `x` and `x` itself is less than or equal to zero. In mathematical terms, it's asserting that ∀x (in the space of Games), -x + x ≤ 0. This is analogous to the property in real numbers where the sum of a number and its negative is always zero. However, in the context of games, the inequality is used instead of an equality because there is no total ordering in games.

For all games x, the sum of the negative of x and x is less than or equal to zero: ∀x, -x + x ≤ 0.


/-- If `f g : α → ℝ≥0∞` are two functions and one of them is (a.e.) measurable, then the Lebesgue
integral of `f + g` equals the sum of integrals. This lemma assumes that `f` is integrable, see also
`MeasureTheory.lintegral_add_right` and primed versions of these lemmas.  -/
theorem MeasureTheory.lintegral_add_left :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      Measurable f → ∀ (g : α → ENNReal), ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ :=
  by sorry

The theorem `MeasureTheory.lintegral_add_left` states that given two extended nonnegative real-valued functions `f` and `g` defined on a measurable space `α`, if the function `f` is measurable, then the Lebesgue integral of the sum of `f` and `g` is equal to the sum of the Lebesgue integrals of `f` and `g` individually under measure `μ`. This theorem assumes that `f` is integrable. There are also similar theorems that apply if `g` is measurable or integrable.

If `f` is a measurable, extended nonnegative real-valued function integrable under measure `μ` on a measurable space `α`, then `∫(f + g) dμ = ∫(f) dμ + ∫(g) dμ`.


theorem CategoryTheory.Iso.inv_eq_inv :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ≅ Y), f.inv = g.inv ↔ f.hom = g.hom :=
  by sorry

This theorem states that in any category `C`, for any two objects `X` and `Y` in `C`, and any two isomorphisms `f` and `g` from `X` to `Y`, the inverse of `f` is equal to the inverse of `g` if and only if the morphism represented by `f` is equal to the morphism represented by `g`. This theorem thus provides a condition for the equality of two isomorphisms in a category, in terms of the equality of their inverses.

In any category, two isomorphisms from one object to another have equal inverses if and only if they represent the same morphism.


theorem CategoryTheory.Limits.terminal.comp_from :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasTerminal C] {P Q : C}
      (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.terminal.from Q) =
        CategoryTheory.Limits.terminal.from P :=
  by sorry

This theorem, `CategoryTheory.Limits.terminal.comp_from`, states that for any category `C` that has a terminal object, and any two objects `P` and `Q` in that category, the composition of any morphism `f` from `P` to `Q` with the morphism from `Q` to the terminal object is equal to the morphism from `P` to the terminal object. In simpler terms, it says that in a category with a terminal object, going from any object `P` to any other object `Q` and then to the terminal object is the same as going directly from `P` to the terminal object. This theorem formalizes the intuitive property of terminal objects in category theory.

For any category with a terminal object, the composition of any morphism with the unique morphism to the terminal object is equal to that morphism.


theorem UniformSpace.Completion.map_comp :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
      [inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
      UniformContinuous g →
        UniformContinuous f →
          UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f) :=
  by sorry

The theorem `UniformSpace.Completion.map_comp` states that for all types `α`, `β`, and `γ` equipped with uniform spaces, given two functions `g : β → γ` and `f : α → β`, if both `g` and `f` are uniformly continuous, then the composition of the mappings of `g` and `f` in the completion spaces is equal to the mapping in the completion space of the composition of `g` and `f`. In other words, if we first map from `α` to `β` using `f` and then from `β` to `γ` using `g`, both in the completion spaces, it's the same as if we first compose `g` and `f` and then map from `α` to `γ` in the completion space. This is a property of uniform continuity in the context of completion spaces, which are spaces that include all limits necessary to complete a given space.

Given uniformly continuous functions `f : α → β` and `g : β → γ` between completion spaces, `(g ∘ f) hat = hat(g ∘ f)`, where `hat` denotes the completion mapping.


theorem Real.rpow_le_rpow_iff : ∀ {x y z : ℝ}, 0 ≤ x → 0 ≤ y → 0 < z → (x ^ z ≤ y ^ z ↔ x ≤ y) := by sorry

This theorem states that for any real numbers `x`, `y`, and `z`, given that `x` and `y` are non-negative and `z` is positive, `x` raised to the power of `z` is less than or equal to `y` raised to the power of `z` if and only if `x` is less than or equal to `y`. In mathematical notation, this is expressed as: for all real numbers `x`, `y`, `z` such that `0 ≤ x`, `0 ≤ y` and `0 < z`, we have that `x ^ z ≤ y ^ z` if and only if `x ≤ y`.

For real numbers `x`, `y`, and `z` with `0 ≤ x`, `0 ≤ y`, and `0 < z`, `x ^ z ≤ y ^ z` if and only if `x ≤ y`.


theorem mul_right_inj :
    ∀ {G : Type u_3} [inst : Mul G] [inst_1 : IsLeftCancelMul G] (a : G) {b c : G}, a * b = a * c ↔ b = c := by sorry

This theorem, `mul_right_inj`, states that for any type `G` that supports multiplication (`Mul G`) and has the cancellation property for multiplication on the left (`IsLeftCancelMul G`), for any elements `a`, `b`, and `c` of `G`, the equality `a * b = a * c` implies `b = c`. In other words, if multiplying `a` with `b` and `c` results in the same product, then `b` and `c` must be equal, given that the multiplication operation in `G` is left-cancellable.

If `G` is a type with left-cancellative multiplication, then `a * b = a * c` implies `b = c`.


theorem dist_triangle_right : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y z : α), dist x y ≤ dist x z + dist y z :=
  by sorry

This theorem is a statement of the triangle inequality in the context of pseudometric spaces. Given any pseudometric space `α` and any three points `x`, `y`, `z` within that space, the distance between `x` and `y` is always less than or equal to the sum of the distance between `x` and `z`, and the distance between `y` and `z`. This is a fundamental property of distance in many geometric and algebraic structures.

In a pseudometric space, the distance between any two points is less than or equal to the sum of the distances between each point and a third point.


theorem Function.support_eq_empty_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M}, Function.support f = ∅ ↔ f = 0 := by sorry

This theorem states that for any types `α` and `M`, with `M` being a type with a zero element, and for any function `f` from `α` to `M`, the support of `f` is empty if and only if `f` is the zero function. In other words, if all the values of `f` are zero (i.e., `f` is the zero function), then there are no points `x` in `α` for which `f(x) ≠ 0`, and therefore the support of `f` is an empty set. Conversely, if the support of `f` is an empty set, there are no points `x` in `α` for which `f(x) ≠ 0`, which means `f` is the zero function.

For any type `α` and type `M` with a zero element, a function `f` from `α` to `M` is the zero function if and only if the support of `f` is empty.


/-- `toList` of `cons` of a vector and an element is
the `cons` of the list obtained by `toList` and the element  -/
theorem Vector.toList_cons :
    ∀ {α : Type u} {n : ℕ} (a : α) (v : Vector α n), Vector.toList (a ::ᵥ v) = a :: Vector.toList v := by sorry

The theorem `Vector.toList_cons` states that for any type `α`, any natural number `n`, any element `a` of type `α`, and any vector `v` of length `n` with elements of type `α`, if you construct a new vector by prepending `a` to `v` and then convert this vector to a list, you get the same result as if you first convert `v` to a list and then prepend `a` to this list. In other words, converting a vector to a list preserves the operation of prepending an element.

For any type α, natural number n, element a of α, and vector v of length n in α, the conversion of the vector obtained by prepending a to v to a list is equal to the list obtained by prepending a to the list representation of v.


theorem ValuationSubring.valuation_le_one_iff :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (x : K), (ValuationSubring.valuation A) x ≤ 1 ↔ x ∈ A := by
  sorry

This theorem states that for any field `K` and any valuation subring `A` of `K`, and for any element `x` of `K`, the valuation of `x` with respect to `A` is less than or equal to 1 if and only if `x` belongs to `A`. This provides a way to determine whether an element of `K` belongs to a particular valuation subring based on its valuation.

For any field `K`, valuation subring `A`, and element `x` in `K`, `x` lies in `A` if and only if the valuation of `x` with respect to `A` is less than or equal to 1.


theorem Set.pi_mono :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t₁ t₂ : (i : ι) → Set (α i)},
      (∀ i ∈ s, t₁ i ⊆ t₂ i) → Set.pi s t₁ ⊆ Set.pi s t₂ :=
  by sorry

The theorem `Set.pi_mono` states that for any type `ι`, any function `α` from `ι` to some type, any set `s` of `ι`, and any two families of sets `t₁` and `t₂` (indexed by `ι` and mapping to sets of elements of the type determined by `α`), if every set in the `t₁` family is a subset of the corresponding set in the `t₂` family for each index in `s`, then the set of dependent functions that belongs to every set in the `t₁` family (whenever the index is in `s`) is a subset of the set of dependent functions that belongs to every set in the `t₂` family (whenever the index is in `s`). In other words, it provides a condition under which one can assert that one set of dependent functions is a subset of another.

If for any family of sets `t₁` and `t₂` indexed by a type `ι`, and any set `s ⊆ ι`, every set in `t₁` is a subset of the corresponding set in `t₂` for indices in `s`, then the set of dependent functions belonging to sets in `t₁` for indices in `s` is a subset of the set of dependent functions belonging to sets in `t₂` for indices in `s`.


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

This theorem states that for any boolean value `b`, the logical AND of `b` with itself is always equal to `b`. In other words, if you take a boolean value and AND it with itself, you get the same boolean value back. This is a fundamental property of boolean logic.

For any boolean value `b`, `b` and `b` are equal.


Nat.lt.base

theorem Nat.lt.base : ∀ (n : ℕ), n < Nat.succ n := by sorry

This theorem, `Nat.lt.base`, states that for every natural number `n`, `n` is less than its successor (`n + 1`). In other words, any natural number is always less than the next natural number.


theorem Finsupp.mapRange_comp :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_7} {P : Type u_8} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P]
      (f : N → P) (hf : f 0 = 0) (f₂ : M → N) (hf₂ : f₂ 0 = 0) (h : (f ∘ f₂) 0 = 0) (g : α →₀ M),
      Finsupp.mapRange (f ∘ f₂) h g = Finsupp.mapRange f hf (Finsupp.mapRange f₂ hf₂ g) :=
  by sorry

The theorem `Finsupp.mapRange_comp` states that for any three types `α`, `M`, `N`, and `P`, given two functions `f : N → P` and `f₂ : M → N` that map zero to zero, and a function `g : α →₀ M` (which is a finitely supported function from `α` to `M`), mapping the range of `g` using the composition of `f` and `f₂` is equal to first mapping the range of `g` using `f₂` and then mapping the range of the result using `f`. This theorem illustrates the distributivity of the `mapRange` operation over function composition in the context of finitely supported functions.

For any types `α`, `M`, `N`, and `P`, and finite support functions `g : α →₀ M` and `f : N → P`, `f ∘ f₂ ∘ g = f₂ ∘ g` whenever `f` and `f₂` map zero to zero.


theorem ProbabilityTheory.set_lintegral_preCDF_fst :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (r : ℚ) {s : Set α},
      MeasurableSet s →
        ∀ [inst : MeasureTheory.IsFiniteMeasure ρ],
          ∫⁻ (x : α) in s, ProbabilityTheory.preCDF ρ r x ∂MeasureTheory.Measure.fst ρ =
            ↑↑(MeasureTheory.Measure.IicSnd ρ ↑r) s :=
  by sorry

The theorem `ProbabilityTheory.set_lintegral_preCDF_fst` states that for any type `α` equipped with a measurable space structure `mα`, a measure `ρ` on the product space `α × ℝ`, a rational number `r`, and a measurable set `s` in `α` under the assumption that `ρ` admits a finite measure, the \(\mathbb{N}\)-integral over the set `s` of the function `ProbabilityTheory.preCDF ρ r x`, with respect to the marginal measure `MeasureTheory.Measure.fst ρ` on `α`, is equal to the measure of the set `s` under the measure `MeasureTheory.Measure.IicSnd ρ r`, which is the marginal measure on `α` obtained by restricting `ρ` to the set `Set.univ ×ˢ Set.Iic r`. In other words, this theorem is a property about the connection between a measure and its associated pre-cumulative distribution function.

For any measurable space `(α, mα)`, measure `ρ` on `α × ℝ`, rational number `r`, and measurable set `s` in `α`, under the assumption that `ρ` admits a finite measure, the \(\mathbb{N}\)-integral of `ProbabilityTheory.preCDF ρ r x` over `s` with respect to `MeasureTheory.Measure.fst ρ` equals the measure of `s` under `MeasureTheory.Measure.IicSnd ρ r`.


theorem Mathlib.Data.Set.Basic._auxLemma.31 : ∀ {α : Type u} {s t : Set α}, (s = s ∩ t) = (s ⊆ t) := by sorry

This theorem is stating that for any type `α` and any two sets `s` and `t` of type `α`, the set `s` is equal to the intersection of `s` and `t` if and only if `s` is a subset of `t`. In other words, every element of `s` is also an element of `t`. This can be expressed mathematically as `s = s ∩ t ⇔ s ⊆ t` for all sets `s` and `t`.

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


theorem Mathlib.Data.Set.Basic._auxLemma.46 :
    ∀ {α : Sort u_1} {p q : α → Prop}, (∃ x, p x ∨ q x) = ((∃ x, p x) ∨ ∃ x, q x) := by sorry

This theorem states that for any type `α` and two predicates `p` and `q` on `α`, the existence of an element that satisfies either `p` or `q` is equivalent to either the existence of an element that satisfies `p` or the existence of an element that satisfies `q`. This expresses the distributive property of existential quantification over disjunction.

For any type `α` and predicates `p` and `q` on `α`, the existence of an element satisfying `p` or `q` is equivalent to the existence of an element satisfying `p ∨ q`.


theorem Cardinal.le_aleph0_iff_set_countable :
    ∀ {α : Type u} {s : Set α}, Cardinal.mk ↑s ≤ Cardinal.aleph0 ↔ Set.Countable s := by sorry

This theorem states that for any arbitrary type `α` and a set `s` of this type, the cardinality of the set `s` is less than or equal to the smallest infinite cardinal number (`ℵ₀`) if and only if the set `s` is countable. In other words, it provides a characterization of countable sets in terms of their cardinality, implying that a set is countable if its size does not exceed the size of the set of natural numbers.

A set `s` of type `α` is countable if and only if its cardinality is less than or equal to the first infinite cardinal number `ℵ₀`.


theorem ENNReal.coe_add : ∀ (x y : NNReal), ↑(x + y) = ↑x + ↑y := by sorry

This theorem states that for any two nonnegative real numbers 'x' and 'y', the operation of taking the sum (x + y) and then applying the coercion function (↑) is the same as first applying the coercion to 'x' and 'y' separately and then taking the sum of the results. In other words, the coercion function preserves the operation of addition on nonnegative real numbers.

For any nonnegative real numbers x and y, ↑(x + y) = ↑x + ↑y.


theorem iSup_of_empty' :
    ∀ {α : Type u_9} {ι : Sort u_10} [inst : SupSet α] [inst_1 : IsEmpty ι] (f : ι → α), iSup f = sSup ∅ := by sorry

This theorem, `iSup_of_empty'`, states that for any type `α` that has a supremum operation defined (indicated by `SupSet α`) and for any sort `ι` that is empty (indicated by `IsEmpty ι`), for any function `f` from `ι` to `α`, the indexed supremum of `f` (denoted by `iSup f`) is equal to the supremum of the empty set (denoted by `sSup ∅`). In simple terms, it tells us that the supremum of the image of an empty index set under any function is the same as the supremum of the empty set.

For any type `α` with a supremum operation and any empty index set `ι`, the indexed supremum of the empty function from `ι` to `α` equals the supremum of the empty set in `α`.


theorem Mathlib.Order.Bounds.Basic._auxLemma.21 :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : Nonempty α], BddAbove ∅ = True := by sorry

This theorem states that for any given type `α` and any preorder `inst` on this type, if `α` is nonempty, then the empty set is bounded above. In other words, there exists an upper bound for the empty set under these conditions.

For any nonempty type `α` and preorder `≤` on `α`, the empty set is bounded above.


theorem Mathlib.Algebra.Module.Submodule.Lattice._auxLemma.11 :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
      (p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i :=
  by sorry

This theorem states that for any semiring `R`, any additive commutative monoid `M` and a module structure over `M` and `R`, any indexing type `ι`, and any family of submodules `p` indexed by `ι`, an element `x` of `M` belongs to the intersection of all submodules (⨅ i, p i) if and only if `x` belongs to each submodule `p i` for every `i` in `ι`. This is a characterization of membership in the intersection of a family of submodules in terms of membership in each individual submodule.

For any semiring R, additive commutative monoid M with an R-module structure, indexing type ι, and family of submodules p indexed by ι, an element x of M belongs to the intersection of all p i if and only if x is in each p i for all i in ι.


/-- If `ν` is an s-finite measure, and `s ⊆ α × β` is measurable, then `x ↦ ν { y | (x, y) ∈ s }`
is a measurable function.  -/
theorem measurable_measure_prod_mk_left :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν] {s : Set (α × β)},
      MeasurableSet s → Measurable fun x => ↑↑ν (Prod.mk x ⁻¹' s) :=
  by sorry

The theorem `measurable_measure_prod_mk_left` states that if we have a measure `ν` on a measurable space `β` which is s-finite (i.e., can be decomposed into a countable union of sets with finite measure), and a measurable set `s` in the product space `α × β`, then the function that maps each element `x` of `α` to the measure of the set of `y` in `β` such that `(x, y)` is in `s`, is a measurable function. In other words, for every `x` in `α`, the measure of the set `{ y | (x, y) ∈ s }` is a measurable function of `x`. This theorem is fundamental in the study of product measures and their properties.

If `ν` is an s-finite measure on a measurable space `β`, and `s` is a measurable set in the product space `α × β`, then the function that maps each `x` in `α` to the measure of `{ y | (x, y) ∈ s }` is measurable.


theorem smul_le_smul_iff_of_pos_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero α] [inst_4 : PosSMulMono α β] [inst_5 : PosSMulReflectLE α β],
      0 < a → (a • b₁ ≤ a • b₂ ↔ b₁ ≤ b₂) :=
  by sorry

This theorem states that for any types `α` and `β`, an action `SMul α β`, preorders on `α` and `β`, zero element in `α`, and given that multiplication by a positive number is monotone and reflects less than or equal to for `α` and `β`, if a positive number `a` is less than zero, then `a` multiplied by `b₁` is less than or equal to `a` multiplied by `b₂` if and only if `b₁` is less than or equal to `b₂`. This is a property related to the ordering of elements in a scalar multiplication context. The scalars are from an ordered field and the vectors are from an ordered vector space.

For any ordered vector spaces α and β, and any positive number a in an ordered field, if b₁ ≤ b₂, then a * b₁ ≤ a * b₂.


ContDiffOn.continuousOn

theorem ContDiffOn.continuousOn :
    ∀ {𝕜 : 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] {s : Set E}
      {f : E → F} {n : ℕ∞}, ContDiffOn 𝕜 n f s → ContinuousOn f s :=
  by sorry

The theorem `ContDiffOn.continuousOn` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F` (which are also normed spaces over `𝕜`), a set `s` of elements of type `E`, a function `f` from `E` to `F`, and a natural number or infinity `n`, if the function `f` is continuously differentiable `n` times on the set `s`, then the function `f` is also continuous on the set `s`. The terms involved have the usual meanings from the field of analysis and topology.

If a function between two normed spaces is continuously differentiable at every point in a set, then it is continuous on that set.


theorem sub_le_sub_left :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [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 → ∀ (c : α), c - b ≤ c - a :=
  by sorry

This theorem, named `sub_le_sub_left`, states that for any type `α` which is an additive group and has a less than or equal to (`≤`) relation, if `α` also satisfies two covariant properties involving addition and the `≤` relation, then for any elements `a` and `b` of `α` where `a` is less than or equal to `b`, the difference of any element `c` and `b` is always less than or equal to the difference of `c` and `a`. This is a property related to the order-preserving nature of subtraction in such a mathematical structure.

For any additive group `α` with a `≤` relation, if `a ≤ b` implies `a + c ≤ b + c` for all `c` in `α`, then the difference `(c - b) ≤ (c - a)` for all `c` in `α` when `a leq b`.


theorem Ordinal.succ_one : Order.succ 1 = 2 := by sorry

This theorem asserts that the successor of the number one in any ordered structure, where the successor operation is defined, is the number two. In other words, for any preorder structure that also has a successor order, when the successor operation is applied to the number one, the result will always be the number two.

In any preorder structure with a successor operation, the successor of 1 is equal to 2.


theorem minpolyDiv_spec :
    ∀ (R : Type u_2) {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : S),
      minpolyDiv R x * (Polynomial.X - Polynomial.C x) = Polynomial.map (algebraMap R S) (minpoly R x) :=
  by sorry

This theorem states that for any commutative ring `R`, any commutative ring `S`, and any element `x` of `S`, where `S` is an algebra over `R`, the product of the function `minpolyDiv` applied to `R` and `x` and the polynomial `X - Cx` equals the mapping of the minimal polynomial of `R` and `x` under the algebraic map from `R` to `S`. Here, `minpolyDiv` is defined as the polynomial `minpoly R x / (X - C x)`. The `minpoly` is a polynomial of smallest degree that has `x` as a root. The `algebraMap` is an embedding from `R` to `S` given by the algebra structure. And `Polynomial.X` and `Polynomial.C x` represent the polynomial variable and the constant polynomial `x` respectively.

For any commutative rings R and S, and any element x of S being an algebra element over R, the product of minpoly(R, x) / (X - Cx) and the algebra map from R to S equals the minimal polynomial of x over R.


theorem MeasureTheory.integrable_finset_sum' :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {ι : Type u_5} (s : Finset ι) {f : ι → α → β},
      (∀ i ∈ s, MeasureTheory.Integrable (f i) μ) → MeasureTheory.Integrable (Finset.sum s fun i => f i) μ :=
  by sorry

The theorem `MeasureTheory.integrable_finset_sum'` states that for any measurable space `α`, measure `μ` on `α`, normed additive commutative group `β`, type `ι`, and finite set `s` of type `ι`, if for every element `i` in `s`, the function `(f i)` is integrable with respect to the measure `μ`, then the function which sums up `f i` for every `i` in the finite set `s` is also integrable with respect to the measure `μ`. In other words, the integrability is preserved under taking finite sums in the context of measure theory.

If `μ` is a measure on a measurable space `α`, and `f i` is an integrable function for each `i` in a finite set `s` with respect to `μ`, then the function that sums `f i` for all `i` in `s` is also integrable with respect to `μ`.


theorem MeasureTheory.integrable_map_measure :
    ∀ {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : MeasurableSpace δ] [inst_1 : NormedAddCommGroup β] {f : α → δ} {g : δ → β},
      MeasureTheory.AEStronglyMeasurable g (MeasureTheory.Measure.map f μ) →
        AEMeasurable f μ →
          (MeasureTheory.Integrable g (MeasureTheory.Measure.map f μ) ↔ MeasureTheory.Integrable (g ∘ f) μ) :=
  by sorry

The theorem `MeasureTheory.integrable_map_measure` states that for any types `α`, `β`, `δ`, a measurable space `α` denoted by `m`, and a measure `μ` on `α`, along with the conditions that `δ` is a measurable space and `β` is a normed add commutative group, given two functions `f : α → δ` and `g : δ → β`, if `g` is almost everywhere strongly measurable with respect to the pushforward of the measure `μ` by the function `f`, and `f` is almost everywhere measurable with respect to `μ`, then the integrability of `g` with respect to the pushforward measure is equivalent to the integrability of the composition `(g ∘ f)` with respect to the measure `μ`.

In simpler terms, the theorem describes a condition under which the integrability of a function `g` after a measure is transformed by another function `f` is equivalent to the integrability of the composition of `g` and `f` under the original measure.

If `f : α → δ` and `g : δ → β` are measurable functions, `μ` is a measure on `α`, and `g` is almost everywhere strongly measurable with respect to the pushforward of `μ` by `f`, then `g` is integrable with respect to the pushforward measure if and only if the composition `g ∘ f` is integrable with respect to `μ`.


theorem Set.set_smul_subset_set_smul_iff₀ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ {A B : Set β}, a • A ⊆ a • B ↔ A ⊆ B :=
  by sorry

The theorem `Set.set_smul_subset_set_smul_iff₀` asserts that for any type `α` with a structure of a group with a nonzero element, and any type `β` with an action of `α`, given two sets `A` and `B` of type `β`, scalar multiplication of `A` and `B` by the same nonzero element `a` from `α` preserves the subset relation between `A` and `B`. In other words, if `a` is not zero, then `A` is a subset of `B` if and only if the set obtained by multiplying every element of `A` by `a` is a subset of the set obtained by multiplying every element of `B` by `a`.

For any group `α` with a nonzero element and any `α`-module `β`, if sets `A ⊆ B` in `β`, then for all `a ≠ 0` in `α`, `aA ⊆ aB`.


theorem Order.le_of_pred_lt :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, Order.pred a < b → a ≤ b := by sorry

This theorem states that for any given type `α` that has a preorder and predorder structure, and any two elements `a` and `b` of that type, if the predecessor of `a` is less than `b`, then `a` is less than or equal to `b`. Here, the predecessor of an element is the greatest element less than the given element, unless the element is minimal, in which case the predecessor is the element itself.

For any type `α` with a preorder and a predorder structure, if the predecessor of element `a` is less than or equal to `b`, then `a` is less than or equal to `b`.


theorem eventually_nhdsWithin_iff :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α} {p : α → Prop},
      (∀ᶠ (x : α) in nhdsWithin a s, p x) ↔ ∀ᶠ (x : α) in nhds a, x ∈ s → p x :=
  by sorry

This theorem states that for any topological space `α`, any point `a` in `α`, any set `s` in `α`, and any property `p` mapped from `α`, the statement "eventually in the neighborhood within `s` at `a`, `p` holds for `x`" is equivalent to the statement "eventually in the neighborhood at `a`, if `x` is in `s` then `p` holds for `x`". Here, "eventually" is used in the sense of filters, meaning that the property holds in some neighborhood of `a`. In other words, the property `p` holds at `a` in the intersection of `s` and some open set around `a` if and only if `p` holds at `a` in `s` for some open set around `a`.

For any topological space `α`, point `a` in `α`, set `s` in `α`, and property `p`: the property "eventually in the neighborhood of `a`, `x` in `s` implies `p(x)` holds" is equivalent to "eventually in the neighborhood of `a`, `p` holds at intersecting open sets containing `a` and `s`."


theorem neg_involutive : ∀ {G : Type u_3} [inst : InvolutiveNeg G], Function.Involutive Neg.neg := by sorry

This theorem states that for any type `G` that has the property `InvolutiveNeg` (which usually means that negation operation on elements of `G` is involutive), the negation function `Neg.neg` is an involutive function. In other words, applying the negation function twice on any element from `G` will return the original element. This corresponds to the mathematical property that the negative of the negative of a number is the number itself, i.e., `−(−a) = a` for any number `a` in `G`.

For any type `G` with involutive negation, negation is an involutive function, i.e., `Neg.neg (x : G) = x`.


theorem GaloisConnection.le_iff_le :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {a : α} {b : β}, l a ≤ b ↔ a ≤ u b :=
  by sorry

The theorem `GaloisConnection.le_iff_le` states that for any two types `α` and `β` that have a preorder (a reflexive and transitive binary relation), and any two functions `l : α → β` and `u : β → α`, if a Galois connection is established between `l` and `u`, then for all elements `a` of type `α` and `b` of type `β`, `l a` is less than or equal to `b` if and only if `a` is less than or equal to `u b`. In other words, the condition `l a ≤ b` is equivalent to `a ≤ u b` under the Galois connection between `l` and `u`.

For any preorders (reflexive and transitive relations) on types `α` and `β`, and given functions `l : α → β` and `u : β → α` defining a Galois connection, `l(a) ≤ b` if and only if `a ≤ u(b)` for all `α` elements `a` and `β` elements `b`.


theorem IsMaxFilter.filter_mono :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {l : Filter α} {a : α} {l' : Filter α},
      IsMaxFilter f l a → l' ≤ l → IsMaxFilter f l' a :=
  by sorry

The theorem `IsMaxFilter.filter_mono` states that for any types `α` and `β`, given a preorder (reflexive and transitive binary relation) on `β`, a function `f` from `α` to `β`, two filters `l` and `l'` on `α`, and an element `a` of type `α`, if `f` is maximized at `a` in some `l`-neighborhood (meaning that the value of `f` at any point in this neighborhood is less than or equal to `f(a)`), and if `l'` is a subfilter of `l` (meaning that every set in `l'` is also in `l`), then `f` is also maximized at `a` in every `l'`-neighborhood. In other words, any subfilter of a filter where `f` has a maximum retains this maximum.

Given a preorder, a function, two filters, and an element, if the function is maximized at the element in some neighborhood of the larger filter and the smaller filter is a subfilter, then the function is maximized at the element in every neighborhood of the smaller filter.


theorem IntermediateField.mem_adjoin_simple_self :
    ∀ (F : Type u_1) [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (α : E), α ∈ F⟮α⟯ := by
  sorry

This theorem states that for any field `F` and any field extension `E` of `F` with a specified algebra structure, any element `α` of `E` is an element of the intermediate field generated by adjoining `α` to `F`. In mathematical terms, if we consider `F` as a subfield of `E` and `α` as an element of `E`, then `α` is indeed contained in the field `F(α)`. This is a well-known fact in field theory in algebra.

For any field extension E of field F with an algebra structure, every element α of E is contained in the subfield generated by F and α.


TopologicalSpace.Compacts.isCompact

theorem TopologicalSpace.Compacts.isCompact :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.Compacts α), IsCompact ↑s := by sorry

The theorem `TopologicalSpace.Compacts.isCompact` states that for any type `α` equipped with a topology (i.e., `α` is a topological space) and any compact subset `s` of this topological space, `s` has the property of being compact. Here, a set is defined to be compact if, for every nontrivial filter `f` that contains the set, there exists a point `x` in the set such that all sets in the filter `f` intersect every neighborhood of `x`.

A compact subset of a topological space is a set such that for every nontrivial filter containing it, there exists an element in the set intersecting every neighborhood of that element.


theorem ENNReal.tsum_eq_iSup_sum :
    ∀ {α : Type u_1} {f : α → ENNReal}, ∑' (a : α), f a = ⨆ s, Finset.sum s fun a => f a := by sorry

This theorem states that for any function `f` mapping from an arbitrary type `α` to the extended nonnegative real numbers (represented by `ENNReal`), the sum over all elements of type `α` (notated as `∑' (a : α), f a`) is equal to the supremum (notated as `⨆ s`) of the sum over a finite set `s` of elements of type `α` (notated as `Finset.sum s fun a => f a`). In simpler terms, it says that the total sum of the function `f` applied to all elements of a type is the greatest possible sum we can get by applying `f` to any finite subset of that type.

For any function from a type to extended nonnegative real numbers, the sum over the entire type equals the supremum of the sums over finite subsets.


theorem MeasurableSpace.isPiSystem_measurableSet :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], IsPiSystem {s | MeasurableSet s} := by sorry

This theorem states that for any given type `α` that has a measurable space structure, the set of all measurable subsets of `α` forms a π-system. In other words, if `s` and `t` are both measurable subsets of `α` and their intersection is nonempty, then their intersection is also a measurable subset of `α`. This is a property associated with measure theory where a collection of sets that is closed under the operation of intersection is known as a π-system.

Given a measurable space `(α, Σ)`, the collection `Σ` of measurable subsets of `α` forms a π-system.


theorem IsCompl.inf_eq_bot :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x y : α}, IsCompl x y → x ⊓ y = ⊥ := by sorry

This theorem states that for any type `α` which forms a lattice and has a bounded order, if `x` and `y` are complement of each other (`IsCompl x y`), then the infimum (greatest lower bound or 'meet') of `x` and `y` is the bottom element (`⊥`) of the lattice. In other words, if two elements are complements in a bounded lattice, their intersection equals the smallest element that exists in the lattice.

In a bounded lattice where every element has a complement, the complemented pair forms the greatest lower bound (infimum) of their set.


theorem Ideal.mul_top : ∀ {R : Type u} [inst : CommSemiring R] (I : Ideal R), I * ⊤ = I := by sorry

The theorem `Ideal.mul_top` states that for any commutative semiring `R` and any ideal `I` within `R`, the product of `I` with the top element (denoted by `⊤` and representing the entire set `R`) equals `I` itself. In other words, multiplying an ideal by the whole semiring does not change the ideal.

For any commutative semiring R and its ideal I, I \* ⊤ = I.


theorem PowerSeries.coeff_rescale :
    ∀ {R : Type u_1} [inst : CommSemiring R] (f : PowerSeries R) (a : R) (n : ℕ),
      (PowerSeries.coeff R n) ((PowerSeries.rescale a) f) = a ^ n * (PowerSeries.coeff R n) f :=
  by sorry

This theorem states that for any commutative semiring `R`, any formal power series `f` over `R`, any element `a` of `R`, and any natural number `n`, the `n`-th coefficient of the rescaled power series `f(aX)` is equal to `a` to the power of `n` times the `n`-th coefficient of the original power series `f(X)`. In other words, rescaling a power series by a factor of `a` multiplies each coefficient of the power series by the corresponding power of `a`.

For any commutative semiring `R`, any formal power series `f(X)` over `R`, and any element `a` in `R`, the `n`-th coefficient of the rescaled power series `f(aX)` equals `a^n` times the `n`-th coefficient of `f(X)`.


theorem Subgroup.map_le_iff_le_comap :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N} {K : Subgroup G} {H : Subgroup N},
      Subgroup.map f K ≤ H ↔ K ≤ Subgroup.comap f H :=
  by sorry

The theorem `Subgroup.map_le_iff_le_comap` states that for any groups `G` and `N`, and any monoid homomorphism `f` from `G` to `N`, and for any subgroups `K` of `G` and `H` of `N`, the image of `K` under `f` is a subgroup of `H` if and only if `K` is a subgroup of the preimage of `H` under `f`. This is a fundamental result about the relationship between the image and the preimage of a subgroup under a monoid homomorphism in the context of group theory.

For any groups G and N, monoid homomorphism f from G to N, and subgroups K of G and H of N, the image of K under f is a subgroup of H if and only if K is a subgroup of the preimage of H under f.


/-- So-named because the outer coercion is `Int.cast` into `ZMod`. For `Int.cast` into an arbitrary
ring, see `ZMod.int_cast_cast`.  -/
theorem ZMod.int_cast_zmod_cast : ∀ {n : ℕ} (a : ZMod n), ↑(ZMod.cast a) = a := by sorry

This theorem, referred to as `ZMod.int_cast_zmod_cast`, states that for any natural number `n` and an integer modulo `n`, the value obtained by casting the integer modulo `n` using the `ZMod.cast` function and then coercing it to an integer is equal to the original integer modulo `n` itself. In other words, the process of casting an integer modulo `n` into another semiring and then transforming it back into an integer modulo `n` (using `ZMod.cast` and `Int.cast` functions respectively) preserves the original value. This theorem holds for the case where the outer coercion is `Int.cast` into `ZMod`. For casting an integer into an arbitrary ring, a different theorem `ZMod.int_cast_cast` is used.

The theorem asserts that casting an integer modulo `n` using `ZMod.cast` function and then coercing it back to an integer is equal to the original integer modulo `n`.


/-- For every set there exists a measurable superset of the same measure.  -/
theorem MeasureTheory.exists_measurable_superset :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
      ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.exists_measurable_superset` states that for every set `s` in a measurable space `α`, with a given measure `μ`, there exists a superset `t` of `s` such that `t` is a measurable set and the measure `μ` of `t` is equal to the measure `μ` of `s`. In other words, no matter which set and measure we start with, we can always find a larger or equal measurable set with the same measure.

Given a measurable space `(α, Σ, μ)` and a measurable set `s ∈ Σ`, there exists a measurable set `t ∈ Σ` such that `t supseteq s` and `μ(t) = μ(s)`.


theorem RatFunc.mk_eq_div :
    ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] (p q : Polynomial K),
      RatFunc.mk p q = (algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q :=
  by sorry

This theorem, `RatFunc.mk_eq_div`, states that for any type `K` with a commutative ring structure and domain structure, and for any two polynomials `p` and `q` over `K`, the rational function created by `RatFunc.mk p q` is equal to the division of the algebraic mapping of `p` over the algebraic mapping of `q`. In simpler terms, it states that creating a rational function with `p` and `q` is the same as dividing the algebraic representation of `p` by the algebraic representation of `q`. This theorem relates the construction of rational functions to division in the algebra of rational functions over polynomials.

For any commutative ring and domain `K`, `RatFunc.mk (p : polynomial K) (q : polynomial K) = ( Polandsum.algebraMap K p) / (Polandsum.algebraMap K q)` in the algebra of rational functions over polynomials.


theorem Set.Ico_subset_Ico_right :
    ∀ {α : Type u_1} [inst : Preorder α] {a b₁ b₂ : α}, b₁ ≤ b₂ → Set.Ico a b₁ ⊆ Set.Ico a b₂ := by sorry

This theorem states that for any type `α` that has an established preorder (a binary relation that is reflexive and transitive), and any three elements `a`, `b₁`, and `b₂` from this type, if `b₁` is less than or equal to `b₂`, then the left-closed right-open interval from `a` to `b₁` is a subset of the left-closed right-open interval from `a` to `b₂`. In other words, if we have an interval starting at `a` and ending just before `b₂`, and another interval starting at the same point `a` but ending just before `b₁` which is less than or equal to `b₂`, then every element in the second interval is also in the first interval.

For any type `α` with a preorder and elements `a`, `b₁`, and `b₂` such that `b₁ ≤ b₂`, the left-closed right-open interval `[a, b₁) is a subset of [a, b₂)`.


theorem MeasureTheory.Measure.InnerRegularWRT.measure_eq_iSup :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop} {U : Set α},
      MeasureTheory.Measure.InnerRegularWRT μ p q → q U → ↑↑μ U = ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), ↑↑μ K :=
  by sorry

This theorem states that for any measure `μ` that is inner regular with respect to predicates `p` and `q`, and for any set `U` that satisfies predicate `q`, the measure `μ` of `U` is equal to the supremum of the measures of subsets `K` of `U` that satisfy the predicate `p`. In other words, in this context, the measure of a set is determined by the measures of its 'interesting' subsets as defined by the predicate `p`.

For any inner regular measure `μ` and predicates `p` and `q`, if `U` is a `q`-set, then `μ(U) = ��╗{μ(K) : K ⊆ U, p(K)}` (the supremum of measures of `p`-subsets of `U`).


/-- **Alias** of `Left.one_le_mul`.

---

Assumes left covariance.
The lemma assuming right covariance is `Right.one_le_mul`.  -/
theorem one_le_mul :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α}, 1 ≤ a → 1 ≤ b → 1 ≤ a * b :=
  by sorry

This theorem, named `one_le_mul`, states that for any type `α` that has the characteristics of a `MulOneClass` (a structure with multiplication and a unique 1 element) and a `Preorder` (a structure with a reflexive and transitive binary relation), and that satisfies the `CovariantClass` property (the relation remains invariant when both arguments are transformed by the same function), if `a` and `b` are elements of `α` such that both are greater than or equal to 1, then their product `a * b` is also greater than or equal to 1. The theorem assumes left covariance; there is a parallel theorem `Right.one_le_mul` that assumes right covariance.

For any type `α` with Multiplicative Identity `1` and a Preorder relation that is covariant, if `a` and `b` are elements greater than or equal to `1`, then their product `a * b` is also greater than or equal to `1`.


theorem map_finsupp_prod :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} {P : Type u_11} [inst : Zero M] [inst_1 : CommMonoid N]
      [inst_2 : CommMonoid P] {H : Type u_16} [inst_3 : FunLike H N P] [inst_4 : MonoidHomClass H N P] (h : H)
      (f : α →₀ M) (g : α → M → N), h (Finsupp.prod f g) = Finsupp.prod f fun a b => h (g a b) :=
  by sorry

The theorem `map_finsupp_prod` states that for all types `α`, `M`, `N`, `P`, and `H`, where `M` has a zero element, `N` and `P` are commutative monoids, `H` is a function-like structure from `N` to `P`, and `H` is a monoid homomorphism class from `N` to `P`, then for any such function `h`, function `f` from `α` to `M` with finite support, and function `g` from `α` and `M` to `N`, applying `h` to the product of `g a (f a)` over the support of `f` is equivalent to taking this product with `h (g a b)`. In mathematical terms, it says that $h \big(\prod_{a \in \mathrm{supp}(f)} g(a, f(a))\big) = \prod_{a \in \mathrm{supp}(f)} h(g(a, b))$. This theorem is primarily about the ability to interchange a monoid homomorphism with the operation of taking a product over the support of a function.

For functions `h` from a commutative monoid `N` to another commutative monoid `P` that is a monoid homomorphism, and given functions `f : α → M` with finite support and `g : α → M → N`, the product of `h (g a b)` over `α` is equal to `h (∏_{a ∈ supp(f)} g a (f a))`.


theorem Int.cast_abs : ∀ {α : Type u_3} [inst : LinearOrderedRing α] {a : ℤ}, ↑|a| = |↑a| := by sorry

This theorem, `Int.cast_abs`, states that for any integer `a` and any type `α` that is a linear ordered ring, the absolute value of the casted integer `a` to type `α` is the same as the cast of the absolute value of `a` to type `α`. In other words, the operations of taking the absolute value and casting an integer to another type commute with each other.

For any integer `a` and linear ordered ring `α`, |α(a)| = α( $|$a$|$ ).


CategoryTheory.Arrow.w

theorem CategoryTheory.Arrow.w :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g),
      CategoryTheory.CategoryStruct.comp sq.left g.hom = CategoryTheory.CategoryStruct.comp f.hom sq.right :=
  by sorry

The theorem `CategoryTheory.Arrow.w` states that for any category `T` and any two objects `f` and `g` in the arrow category of `T`, if there exists a morphism `sq` from `f` to `g`, then the composition of `sq.left` and `g.hom` is equal to the composition of `f.hom` and `sq.right`. Here, `CategoryTheory.CategoryStruct.comp` represents the composition of morphisms in the category. In more mathematical terms, this is saying that for any commutative square in a category, the composition of arrows across one diagonal of the square is equal to the composition of arrows across the other diagonal.

For any commutative square in a category, the composition of morphisms along the diagonal from the lower-left to the upper-right is equal to the composition of morphisms along the diagonal from the upper-left to the lower-right.


theorem Nat.bit_val : ∀ (b : Bool) (n : ℕ), Nat.bit b n = 2 * n + bif b then 1 else 0 := by sorry

The theorem `Nat.bit_val` states that for any boolean `b` and natural number `n`, the value of the function `Nat.bit` applied with arguments `b` and `n` is equivalent to twice the value of `n` plus either 1 if `b` is true or 0 if `b` is false. Essentially, this function appends the boolean `b` as a binary digit to the binary representation of `n`, where `true` corresponds to `1` and `false` corresponds to `0`, and this theorem gives the numeric value of the resulting binary number.

For any natural number `n` and boolean `b`, `Nat.bit b n` equals 2*{n} + IEEE.bool_to_int b, where IEEE.bool_to_int is the Lean function mapping boolean values to integers (0 for false and 1 for true).


theorem Mathlib.GroupTheory.GroupAction.ConjAct._auxLemma.1 :
    ∀ {G : Type u_3} [inst : DivInvMonoid G] (p : ConjAct G → Prop),
      (∀ (x : ConjAct G), p x) = ∀ (x : G), p (ConjAct.toConjAct x) :=
  by sorry

This theorem states that for any type `G` with an instance of `DivInvMonoid` (a type of group), and any property `p` defined on the action of the group `G` on itself by conjugation (`ConjAct G`), the property `p` holds for all elements of `ConjAct G` if and only if it holds for all elements `x` of `G` under the `ConjAct.toConjAct` map. This essentially means that the property `p` is preserved under the action of conjugation.

For any `G` with a `DivInvMonoid` structure and any property `p` on `G`'s conjugation action, `p` is invariant under conjugation if and only if `p` holds for all elements in the image of `ConjAct G` under the `toConjAct` map.


theorem Mathlib.Logic.Basic._auxLemma.56 : ∀ {P Q : Prop} [inst : Decidable P], (if P then False else Q) = (¬P ∧ Q) :=
  by sorry

This theorem states that for any two propositions `P` and `Q`, given that `P` is decidable, the statement "if `P` then `False` else `Q`" is equivalent to the statement "`¬P` and `Q`". In other words, "if `P` is true then False, otherwise `Q`" is the same as saying "either `P` is not true and `Q` is true".

If `P` is decidable, then `P → False` is equivalent to `¬P ∧ Q`.


theorem Vector.mapAccumr_snoc :
    ∀ {α : Type u_2} {n : ℕ} (xs : Vector α n) {α_1 : Type} {β : Type u_1} {f : α → α_1 → α_1 × β} {x : α} {s : α_1},
      Vector.mapAccumr f (Vector.snoc xs x) s =
        let q := f x s;
        let r := Vector.mapAccumr f xs q.1;
        (r.1, Vector.snoc r.2 q.2) :=
  by sorry

The theorem `Vector.mapAccumr_snoc` states that for any types `α`, `α_1`, and `β`, any natural number `n`, any vector `xs` of length `n` with elements of type `α`, any function `f` from `α` and `α_1` to a pair of `α_1` and `β`, any element `x` of type `α`, and any element `s` of type `α_1`, the result of mapping function `f` over the vector obtained by appending `x` to the end of `xs` and starting with `s` is equal to a pair. The first element of the pair is the first element of the result of mapping function `f` over `xs` starting with `f(x, s).1`, and the second element of the pair is the result of appending `f(x, s).2` to the end of the second element of the result of mapping function `f` over `xs` starting with `f(x, s).1`.

For any types `α`, `α_1`, and `β`, any natural number `n`, any vector `xs : α^n`, any function `f : α × α_1 → (α_1, β)`, any `x : α`, and any `s : α_1`, `mapAccumr f (xs ++ [x]) s = (foldl f (map f xs) s.1, s.2 ++ foldl f (map f xs) s.1)`.


theorem Polynomial.divX_mul_X_add :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R),
      Polynomial.divX p * Polynomial.X + Polynomial.C (Polynomial.coeff p 0) = p :=
  by sorry

The theorem `Polynomial.divX_mul_X_add` asserts that for any polynomial `p` over a semiring `R`, the polynomial resulting from multiplying the polynomial `divX(p)` (which gives a polynomial `q` such that `q * X + C(p.coeff 0) = p`) with the polynomial variable `X` and then adding the constant polynomial of the coefficient of `X^0` in `p` (`Polynomial.C (Polynomial.coeff p 0)`), is equal to the original polynomial `p`. In mathematical terms, if `p` is a polynomial, `divX(p)` is a polynomial `q` such that `q * X + C(p.coeff 0) = p`, then for all polynomials `p` over a semiring `R`, we have `q * X + C(p.coeff 0) = p`.

For any polynomial `p` over a semiring `R`, the polynomial `q * X + C(p.coeff 0)` equals `p`, where `q` is the polynomial obtained from dividing `p` by `X` using the division-by-x construction and `C` denotes the constant polynomial.


theorem isOpen_coinduced :
    ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsOpen s ↔ IsOpen (f ⁻¹' s) := by
  sorry

The theorem `isOpen_coinduced` states that for any types `α` and `β`, a given topological space `t` on `α`, a set `s` of elements of type `β`, and a function `f` from `α` to `β`, the set `s` is open if and only if the preimage of `s` under `f` is open. In other words, a set in the codomain of a function is open in the topology induced by that function if and only if its preimage is open in the original topology.

For any topological spaces `α` and `β`, function `f` from `α` to `β`, and sets `s` in `β`, the preimage `f⁻¹[s]` is open in `α` if and only if `s` is open in the coinduced topology on `β` by `f`.


OrderMonoidHom.ext

theorem OrderMonoidHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
      [inst_3 : MulOneClass β] {f g : α →*o β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `OrderMonoidHom.ext`, asserts that for any two ordered monoid homomorphisms `f` and `g` from a preordered `mul_one_class` α to another preordered `mul_one_class` β, if for every element `a` in α, `f(a)` equals `g(a)`, then `f` and `g` are the same function. In simpler terms, it states that two monoid homomorphisms are equal if they give the same result for every input.

Two ordered monoid homomorphisms between preordered mul_one_classes are equal if they map each element to the same image.


theorem Cardinal.aleph0_lt_continuum : Cardinal.aleph0 < Cardinal.continuum := by sorry

The theorem `Cardinal.aleph0_lt_continuum` states that the cardinality of the set of natural numbers, denoted as `ℵ₀` or aleph-null, is less than the cardinality of the continuum, denoted as `2^ℵ₀`. In other words, the size of the set of all real numbers is strictly larger than the size of the set of all natural numbers.

The cardinality of the set of natural numbers is strictly less than that of the set of real numbers.


theorem Stream'.Seq.cons_append :
    ∀ {α : Type u} (a : α) (s t : Stream'.Seq α),
      Stream'.Seq.append (Stream'.Seq.cons a s) t = Stream'.Seq.cons a (Stream'.Seq.append s t) :=
  by sorry

The `Stream'.Seq.cons_append` theorem states that for any type `α`, any element `a` of type `α`, and any two sequences `s` and `t` of type `α`, appending sequence `t` to the sequence obtained by prepending `a` to sequence `s` (`Stream'.Seq.append (Stream'.Seq.cons a s) t`) is equivalent to prepending `a` to the sequence obtained by appending `s` and `t` (`Stream'.Seq.cons a (Stream'.Seq.append s t)`). This is a property of sequence concatenation and prepending in potentially infinite lists, which mirrors the traditional property of list concatenation and cons operation in finite lists.

For any type `α` and sequences `s`, `t` of type `α`, `Stream'.Seq.cons_append (Stream'.Seq.cons a s) t` is equal to `Stream'.Seq.cons a (Stream'.Seq.append s t)`.


theorem StrictMono.cmp_map_eq :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β},
      StrictMono f → ∀ (x y : α), cmp (f x) (f y) = cmp x y :=
  by sorry

The theorem `StrictMono.cmp_map_eq` asserts that for any two values `x` and `y` of a type `α`, given that we have a linear ordering defined on `α` and `β` and a strictly monotonic function `f` mapping from `α` to `β`, the comparison of `f(x)` and `f(y)` using the function `cmp` will yield the same result as the comparison of `x` and `y`. In other words, the ordering of `x` and `y` is preserved under the strictly monotonic function `f`.

For any strictly monotonic function `f` between linearly ordered types `α` and `β`, and all `x y` in `α`, we have `x ≤ y` if and only if `f(x) ≤ f(y)`.


theorem CategoryTheory.ShortComplex.RightHomologyData.exact_iff :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S]
      (h : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Limits.IsZero h.H :=
  by sorry

This theorem states that for any type `C` which forms a category with zero morphisms, and any `ShortComplex` `S` that has a homology, a `RightHomologyData` `h` of `S` implies that `S` is exact if and only if `h.H` is a zero object. In simpler terms, in a given short complex of a certain category, a certain right homology data is equivalent to zero if and only if the short complex is exact.

A ShortComplex in a category with zero morphisms has zero right homology if and only if it is exact.


theorem Mathlib.GroupTheory.OrderOfElement._auxAddLemma.3 :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, IsOfFinAddOrder x = ∃ n, 0 < n ∧ n • x = 0 := by sorry

This theorem states that for any type `G` that forms an additive monoid, an element `x` of `G` is of finite additive order if and only if there exists a positive integer `n` such that the `n`-fold sum (or `n` "copies") of `x` equals the additive identity (zero). In other words, an element `x` in an additive monoid `G` is of finite order when it satisfies the property that for some positive `n`, `n • x = 0`, where `•` denotes repeated addition.

An element in an additive monoid has finite order if and only if there exists a positive integer n such that the sum of n copies of the element equals the additive identity.


theorem FirstOrder.Language.BoundedFormula.IsQF.isPrenex :
    ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {φ : FirstOrder.Language.BoundedFormula L α n},
      FirstOrder.Language.BoundedFormula.IsQF φ → FirstOrder.Language.BoundedFormula.IsPrenex φ :=
  by sorry

This theorem states that for any first-order language `L`, any type `α`, any natural number `n`, and any bounded formula `φ` in the language `L` with `α` and `n`, if `φ` is a quantifier-free (QF) formula, then `φ` is in prenex form. Prenex form is a logical form of a formula where all quantifiers are at the front. Hence, this theorem asserts that all quantifier-free formulas in a first-order language are in prenex form.

In a first-order language, all quantifier-free formulas are equivalent to formulas in prenex normal form.


theorem Finsupp.sum_apply :
    ∀ {α : Type u_1} {β : Type u_7} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N]
      {f : α →₀ M} {g : α → M → β →₀ N} {a₂ : β}, (Finsupp.sum f g) a₂ = Finsupp.sum f fun a₁ b => (g a₁ b) a₂ :=
  by sorry

The theorem `Finsupp.sum_apply` states that for all types `α`, `β`, `M`, `N`, where `M` is equipped with a zero and `N` is an additive commutative monoid, given a function `f` from `α` to `M` with finite support, a function `g` from `α` and `M` to `β` with finite support, and an element `a₂` of type `β`, the application of the sum of `g a (f a)` over the support of `f` to `a₂` is equal to the sum over the support of `f` of the function that maps `a₁` and `b` to the application of `g a₁ b` to `a₂`. In mathematical notation, it means that $\sum_{a\in \text{supp}(f)} (g(a, f(a))(a_2)) = \sum_{a\in \text{supp}(f)} g(a, f(a))(a_2)$ for all `a₂` in `β`.

For all types `α`, `β`, `M` (an additive commutative monoid), given functions `f: α → M` and `g: α × M → β` with finite support, and `a₂ ∈ β`, we have $\sum\_{a \in \text{supp}(f)} g(a, f(a))(a\_2) = \sum\_{a \in \text{supp}(f)} g(a, f(a))(a)$.


/-- Given a box `I` in `ℝⁿ`, a function `r : ℝⁿ → (0, ∞)`, and a prepartition `π` of `I`, there
exists a tagged prepartition `π'` of `I` such that

* each box of `π'` is included in some box of `π`;
* `π'` is a Henstock partition;
* `π'` is subordinate to `r`;
* `π'` covers exactly the same part of `I` as `π`;
* the distortion of `π'` is equal to the distortion of `π`.
 -/
theorem BoxIntegral.Prepartition.exists_tagged_le_isHenstock_isSubordinate_iUnion_eq :
    ∀ {ι : Type u_1} [inst : Fintype ι] {I : BoxIntegral.Box ι} (r : (ι → ℝ) → ↑(Set.Ioi 0))
      (π : BoxIntegral.Prepartition I),
      ∃ π',
        π'.toPrepartition ≤ π ∧
          BoxIntegral.TaggedPrepartition.IsHenstock π' ∧
            BoxIntegral.TaggedPrepartition.IsSubordinate π' r ∧
              BoxIntegral.TaggedPrepartition.distortion π' = BoxIntegral.Prepartition.distortion π ∧
                BoxIntegral.TaggedPrepartition.iUnion π' = BoxIntegral.Prepartition.iUnion π :=
  by sorry

This theorem states that, given a box `I` in `ℝⁿ`, a function `r : ℝⁿ → (0, ∞)`, and a prepartition `π` of `I`, there exists a tagged prepartition `π'` of `I` satisfying the following conditions:

* Each box of `π'` is included in some box of `π`.
* `π'` is a Henstock partition, meaning that for each box `J` in `π'`, the tag of `J` belongs to the closed interval corresponding to `J`.
* `π'` is subordinate to `r`, which means that each box `J` in `π'` is included in the closed ball with center at the tag of `J` and radius `r` evaluated at the tag of `J`.
* `π'` covers exactly the same part of `I` as `π`.
* The distortion of `π'` is equal to the distortion of `π`, where distortion refers to the maximum of distortions of its boxes.

Given a box `I` in `ℝⁿ`, a function `r : ℝⁿ → (0, ∞)`, and a partition `π` of `I`, there exists a tagged Henstock partition `π'` of `I` subordinate to `r` that covers the same part of `I` as `π`, is a refinement of `π`, and has the same distortion as `π`.


theorem AddAction.mem_stabilizer_iff :
    ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a : α} {g : G},
      g ∈ AddAction.stabilizer G a ↔ g +ᵥ a = a :=
  by sorry

This theorem states that for any additive group `G`, any set `α` that `G` acts on, any element `a` of `α`, and any element `g` of `G`, the element `g` is in the stabilizer of `a` (i.e., the subgroup of `G` that leaves `a` fixed) if and only if the action of `g` on `a` leaves `a` unchanged. In other words, `g` is in the stabilizer of `a` exactly when `g +ᵥ a = a` (where `+ᵥ` represents the additive action of `G` on `α`).

For any additive group `G` acting on a set `α`, an element `g` of `G` stabilizes `α`'s element `a` if and only if `g + a = a`.


theorem CategoryTheory.Idempotents.Karoubi.HomologicalComplex.p_idem :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {ι : Type u_2} {c : ComplexShape ι} (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c)) (n : ι),
      CategoryTheory.CategoryStruct.comp (P.p.f n) (P.p.f n) = P.p.f n :=
  by sorry

This theorem states that for any category `C` (which is also a preadditive category), any complex shape `c`, any Karoubi envelope `P` of the homological complex of `C` and `c`, and any index `n`, the composition of the morphism `P.p.f n` with itself (denoted by `P.p.f n ≫ P.p.f n` in category theory) is equal to `P.p.f n` itself. This is a property of idempotents, elements that remain unchanged when squared, in the context of categories and homological complexes.

In any preadditive category `C` with homological complex `c` and its Karoubi envelope `P`, the morphism `P.p.f n` is idempotent, that is, `P.p.f n ≫ P.p.f n = P.p.f n`.


theorem Relation.reflTransGen_iff_eq_or_transGen :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b : α}, Relation.ReflTransGen r a b ↔ b = a ∨ Relation.TransGen r a b := by
  sorry

This theorem states that for any type `α` and a binary relation `r` on `α`, and given two elements `a` and `b` of type `α`, the reflexive transitive closure of `r` holds between `a` and `b` if and only if `b` equals `a` or the transitive closure of `r` holds between `a` and `b`. In other words, either `a` and `b` are the same, or there is a chain of `r`-related elements starting from `a` and ending at `b`.

The reflexive transitive closure of a binary relation `r` on type `α` holds between elements `a` and `b` if and only if `b` equals `a` or there exists a chain of `r`-related elements connecting `a` to `b`.


theorem Real.le_coe_toNNReal : ∀ (r : ℝ), r ≤ ↑(Real.toNNReal r) := by sorry

This theorem states that for any real number `r`, `r` is less than or equal to the non-negative real number equivalent of `r`. Specifically, `Real.toNNReal r` is a function that converts a real number `r` into a non-negative real number, and `↑(Real.toNNReal r)` is the coercion of this non-negative real number back to a real number. This theorem guarantees that this process never decreases the value of `r`. If `r` is negative, its non-negative real number equivalent is `0`, and so `r` is less than or equal to `0`. If `r` is non-negative, its non-negative real number equivalent is `r` itself, and so `r` is less than or equal to `r`.

For any real number `r`, `r` is less than or equal to its non-negative real number equivalent `↑(Real.toNNReal r)`.


HasSum.unique

theorem HasSum.unique :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a₁ a₂ : α}
      [inst_2 : T2Space α], HasSum f a₁ → HasSum f a₂ → a₁ = a₂ :=
  by sorry

This theorem states that for any function `f` from a type `β` to a type `α`, if `α` is an additive commutative monoid and a topological space with the Hausdorff property (T2 space), and if `a₁` and `a₂` are two elements of `α` such that `f` has sums `a₁` and `a₂`, then `a₁` and `a₂` must be equal. In other words, the series sum of `f` is unique within a Hausdorff topological space.

If `f` is a function from a type `β` to an additive commutative monoid and Hausdorff topological space `α`, then for all `a₁, a₂ ∈ α` such that `f` has sums `a₁` and `a₂`, it follows that `a₁ = a₂`.


theorem Nat.prime_def_minFac : ∀ {p : ℕ}, Nat.Prime p ↔ 2 ≤ p ∧ Nat.minFac p = p := by sorry

The theorem `Nat.prime_def_minFac` states that for every natural number `p`, `p` is a prime number if and only if `p` is greater than or equal to 2 and the smallest prime factor of `p` is `p` itself. In other words, a natural number `p` is prime exactly when it is not less than 2 and it does not have any prime factor smaller than itself.

A natural number `p` is prime if and only if `p` is greater than or equal to 2 and the smallest prime factor of `p` is `p`.


theorem Multiset.count_add :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s t : Multiset α),
      Multiset.count a (s + t) = Multiset.count a s + Multiset.count a t :=
  by sorry

The theorem `Multiset.count_add` states that for any type `α` that has decidable equality, and for any element `a` of type `α` and any two multisets `s` and `t` of type `α`, the multiplicity of `a` in the multiset obtained by adding `s` and `t` is equal to the sum of the multiplicity of `a` in `s` and the multiplicity of `a` in `t`. In other words, the count of an element in the union of two multisets is the sum of the counts of that element in each of the multisets. This is akin to saying that the number of occurrences of a particular element in the union of two collections is the sum of the number of occurrences of that element in each individual collection.

For multisets `s` and `t` over decidably equal type `α`, the count of an element `a` in the multiset `s ++ t` is equal to the count of `a` in `s` plus the count of `a` in `t`.


theorem Int.emod_zero : ∀ (a : ℤ), a % 0 = a := by sorry

This theorem states that for any integer `a`, the remainder of `a` divided by zero is `a` itself. In other words, the modulus operation `%` when applied with zero as the divisor returns the original integer `a`.


theorem StrictAnti.lt_iff_lt :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      StrictAnti f → ∀ {a b : α}, f a < f b ↔ b < a :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` has a linear order and `β` has a preorder, if a function `f` from `α` to `β` is strictly anti-tonic (i.e., `a < b` implies `f(b) < f(a)`), then for any two elements `a` and `b` of `α`, `f(a) < f(b)` if and only if `b < a`.

For any types `α` with a linear order and `β` with a preorder, a strictly anti-tonic function `f` from `α` to `β` satisfies `a < b` if and only if `f(a) < f(b)` if and only if `b < a`.