theorem mul_nonneg_of_nonpos_of_nonpos :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a b : α} [inst_1 : ExistsAddOfLE α]
      [inst_2 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      a ≤ 0 → b ≤ 0 → 0 ≤ a * b :=
  by sorry

The theorem `mul_nonneg_of_nonpos_of_nonpos` asserts that for any ordered semiring `α`, if elements `a` and `b` of `α` are nonpositive (i.e., `a` and `b` are both less than or equal to zero), then the product of `a` and `b` is nonnegative (i.e., greater than or equal to zero). This is a generalization of the familiar fact from basic algebra that the product of two negative numbers is a nonnegative number. The proof relies on the existence of addition for elements less than or equal to each other and a contravariant class of binary functions on `α` that swaps the order of addition and verifies the inequality.

If `α` is an ordered semiring and `a` and `b` are its elements that are less than or equal to zero, then the product `a * b` is greater than or equal to zero.


theorem continuousOn_snd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set (α × β)},
      ContinuousOn Prod.snd s :=
  by sorry

This theorem states that, for any types `α` and `β` each equipped with a topological space structure, and any set `s` of pairs of elements from `α` and `β`, the second projection function, `Prod.snd`, is continuous on the set `s`. Here, "continuous on a set" means that the function is continuous at each point within that set. In plain terms, this theorem says that picking out the second component of a pair from a set of pairs is a continuous operation.

For any topological spaces `α` and `β` and a set `s` of pairs from `α × β`, the second projection function `Prod.snd` is continuous on `s`.


theorem mul_eq_mul_left_iff :
    ∀ {M₀ : Type u_2} [inst : CancelMonoidWithZero M₀] {a b c : M₀}, a * b = a * c ↔ b = c ∨ a = 0 := by sorry

This theorem states that for any type `M₀` that forms a `CancelMonoidWithZero` (a mathematical structure with a multiplication operation and an element '0' such that multiplication by '0' yields '0'), and for any elements `a`, `b`, `c` of this type, the equality `a * b = a * c` is equivalent to the condition that `b` equals `c` or `a` equals '0'. In other words, if `a` is not '0', `a * b = a * c` implies `b = c`; but if `a` is '0', `a * b = a * c` holds true for any `b` and `c`.

For any `CancelMonoidWithZero` type `M₀` and elements `a` and `b` of `M₀`, if `a ≠ 0`, then `a * b = a * c` implies `b = c`. If `a = 0`, then `a * b = a * c` holds for all `b` and `c`.


theorem PartialHomeomorph.IsImage.toPartialEquiv :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t → PartialEquiv.IsImage e.toPartialEquiv s t :=
  by sorry

This theorem states that for any two topological spaces X and Y, a partial homeomorphism `e` from X to Y, and sets `s` of X and `t` of Y, if `t` is an image of `s` under the partial homeomorphism `e` (i.e., `PartialHomeomorph.IsImage e s t` holds), then `t` is also an image of `s` under the partial equivalence formed by the partial homeomorphism `e` (i.e., `PartialEquiv.IsImage e.toPartialEquiv s t` holds). In other words, the image relationship of a set under a partial homeomorphism is preserved when the homeomorphism is considered as a partial equivalence.

If `e` is a partial homeomorphism from topological spaces X to Y, and s subset of X is the image of t subset of Y under `e` (PartialHomeomorph.IsImage e s t), then t is the image of s under the partial equivalence formed by `e` (PartialEquiv.IsImage e.toPartialEquiv s t).


theorem Rat.mk_eq_divInt :
    ∀ (num : ℤ) (den : ℕ) (nz : den ≠ 0) (c : Nat.Coprime (Int.natAbs num) den),
      { num := num, den := den, den_nz := nz, reduced := c } = Rat.divInt num ↑den :=
  by sorry

This theorem states that for every integer `num` and natural number `den` where `den` is not equal to zero, as well as when `num` and `den` are coprime (i.e., their greatest common divisor is 1), the rational number `{ num := num, den := den, den_nz := nz, reduced := c }` is equal to the result of the division `num / den` in the rational numbers. The coprimeness is calculated with respect to the absolute value of `num`.

For integers `num` and `den` with `den ≠ 0` and `gcd(|num|, |den|) = 1`, the rational number `{num := num, den := den, den_nz := nz, reduced := c}` equals `num / den` in the rational numbers.


/-- The Galois connection between fixing subgroups and fixed points of a group action  -/
theorem fixingSubgroup_fixedPoints_gc :
    ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α],
      GaloisConnection (⇑OrderDual.toDual ∘ fixingSubgroup M)
        ((fun P => MulAction.fixedPoints (↥P) α) ∘ ⇑OrderDual.ofDual) :=
  by sorry

This theorem establishes a Galois connection between the subgroups that fix a set under a group action and the set of points fixed by the whole action. Specifically, for a given group `M` and type `α` with a group action `M` on `α`, there exists a Galois connection between the dual of the function `fixingSubgroup M` (which maps a set to the subgroup that fixes it under the action) and the function that maps a group to the set of fixed points of `α` under the action of that group, after applying the dual of the function. In other words, a subgroup `P` fixes a set `s` if and only if every element of `s` is a fixed point under the action of the group `P`.

The Galois connection exists between the function mapping sets to their fixating subgroups under a group action on type `α`, and the function mapping groups to their fixed point sets on `α`. That is, a subgroup fixes a set if and only if every element in the set is fixed by the group under the action.


Con.refl

/-- Congruence relations are reflexive.  -/
theorem Con.refl : ∀ {M : Type u_1} [inst : Mul M] (c : Con M) (x : M), c x x := by sorry

This theorem states that congruence relations are reflexive for any type `M` equipped with a multiplication operation. More specifically, for any such type `M`, any congruence relation `c` on `M`, and any element `x` of `M`, `x` is congruent to itself under `c`. In other words, for any multiplication-based type and any congruence relation on it, every element is congruent to itself under this relation.

For any type `M` with multiplication and any congruence relation `c` on `M`, the reflexivity property holds, that is, for all `x` in `M`, `x` is congruent to `x` under `c`.


theorem PNat.gcd_comm : ∀ {m n : ℕ+}, PNat.gcd m n = PNat.gcd n m := by sorry

This theorem states that the greatest common divisor (gcd) of two positive natural numbers is commutative. In other words, for any two positive natural numbers `m` and `n`, the gcd of `m` and `n` is the same as the gcd of `n` and `m`. This corresponds to the mathematical principle that the order of the numbers does not influence the outcome when computing the gcd, i.e., $\gcd(m, n) = \gcd(n, m)$.

The theorem asserts that the gcd of two positive natural numbers is commutative, i.e., gcd(m, n) = gcd(n, m) for all positive natural numbers m and n.


/-- The Hausdorff distance satisfies the triangle inequality.  -/
theorem EMetric.hausdorffEdist_triangle :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t u : Set α},
      EMetric.hausdorffEdist s u ≤ EMetric.hausdorffEdist s t + EMetric.hausdorffEdist t u :=
  by sorry

The theorem `EMetric.hausdorffEdist_triangle` states that the Hausdorff distance in a PseudoEMetricSpace satisfies the triangle inequality. In more specific terms, for any three sets of elements `s`, `t`, and `u` in a given PseudoEMetricSpace `α`, the Hausdorff distance (the smallest `r` such that each set is contained in the `r`-neighborhood of the other one) between `s` and `u` is less than or equal to the sum of the Hausdorff distances between `s` and `t`, and `t` and `u`. This is a formal statement of the geometric principle that the direct path between two points is never longer than the path that goes through an intermediate point.

In a PseudoEMetricSpace, the Hausdorff distance between any two sets is less than or equal to the sum of the Hausdorff distances between each pair of adjacent sets.


theorem CategoryTheory.Limits.prod.lift_fst_snd :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y],
      CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd =
        CategoryTheory.CategoryStruct.id (X ⨯ Y) :=
  by sorry

This theorem states that in any category `C` that has a binary product of two objects `X` and `Y`, the morphism obtained by lifting the pair of projection morphisms `CategoryTheory.Limits.prod.fst` and `CategoryTheory.Limits.prod.snd` to a morphism from the product `X ⨯ Y` to itself is actually the identity morphism on `X ⨯ Y`. In simpler words, taking the projection from the product to its constituents and then lifting it back to the product gives you the identity operation. This is a fundamental property of products in category theory.

In any category with binary products, the projection morphisms' lift to the product is equal to the identity morphism on the product.


theorem Set.indicator_le_indicator_of_subset :
    ∀ {α : Type u_2} {M : Type u_4} [inst : Preorder M] [inst_1 : Zero M] {s t : Set α} {f : α → M},
      s ⊆ t → (∀ (a : α), 0 ≤ f a) → ∀ (a : α), Set.indicator s f a ≤ Set.indicator t f a :=
  by sorry

The theorem `Set.indicator_le_indicator_of_subset` states that for any type `α`, any preorder `M` with a zero, any two sets `s` and `t` of type `α`, and any function `f` mapping `α` to `M`, if `s` is a subset of `t` and every value of `f` is nonnegative, then for every element `a` of type `α`, the value of the indicator function of `s` and `f` at `a` is less than or equal to the value of the indicator function of `t` and `f` at `a`. In other words, if `s` is a subset of `t` and `f` is always nonnegative, then the value of the indicator function of `s` is never greater than the value of the indicator function of `t` for any given input.

For any type `α`, preorder `M` with a zero, sets `s` and `t` of type `α`, and function `f : α → M` with nonnegative values, if `s` is a subset of `t`, then `indicator s x ≤ indicator t x` for all `x : α`.


theorem linearIndependent_iff' :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M],
      LinearIndependent R v ↔ ∀ (s : Finset ι) (g : ι → R), (Finset.sum s fun i => g i • v i) = 0 → ∀ i ∈ s, g i = 0 :=
  by sorry

The theorem `linearIndependent_iff'` states that for any semiring `R`, a set `v` of vectors from `ι` to `M`, an additively commutative monoid `M`, and a module `R M`, the set of vectors `v` is linearly independent over `R` if and only if for any finite set `s` of `ι` and any function `g` from `ι` to `R`, if the sum of the scalar multiples `g i • v i` for each `i` in `s` is zero, then `g i` must be zero for each `i` in `s`. In other words, a set of vectors is linearly independent if and only if no non-trivial linear combination of them equals zero.

A set of vectors from a module over a semiring is linearly independent if and only if the sum of scalar multiples of vectors by any function from the set to the semiring is zero only when the function is the zero function.


theorem Sublattice.gc_map_comap :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] (f : LatticeHom α β),
      GaloisConnection (Sublattice.map f) (Sublattice.comap f) :=
  by sorry

This theorem states that for any two types `α` and `β` that are lattices and a given lattice homomorphism `f` from `α` to `β`, there exists a Galois connection between the mapping of a sublattice from `α` to `β` using `f` (denoted as `Sublattice.map f`) and the preimage of a sublattice from `β` to `α` along `f` (denoted as `Sublattice.comap f`). In simpler terms, this means that the mapping of a sublattice from `α` to `β` is less than or equal to a sublattice in `β` if and only if the original sublattice in `α` is less than or equal to the preimage of the sublattice in `β`. The existence of such a Galois connection illustrates a fundamental relationship between the structure of lattices and their sublattices under lattice homomorphisms.

For any lattice homomorphism between lattices `α` and `β`, there exists a Galois connection between the mapping of sublattices using `f` and the preimage of sublattices along `f`.


StrictAntiOn.injOn

theorem StrictAntiOn.injOn :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictAntiOn f s → Set.InjOn f s :=
  by sorry

The theorem `StrictAntiOn.injOn` states that for any two types `α` and `β`, where `α` has a linear order structure and `β` has a preorder structure, and given a function `f` from `α` to `β` and a set `s` of type `α`, if it is the case that the function `f` is strictly antitone on the set `s` (meaning, for all `a, b` in `s`, `a < b` implies `f(b) < f(a)`), then it must also be true that `f` is injective on `s` (that is, for any two elements `x₁, x₂` from `s`, if `f(x₁)` is equal to `f(x₂)`, then `x₁` must be equal to `x₂`). In other words, a strict antitone function on a set is also injective on that set.

If `f` is a strictly antitone function from a linearly ordered type `α` to a preordered type `β`, then `f` is injective on any subset `s` of `α` where `f` is strictly antitone.


theorem Finset.singleton_ne_empty : ∀ {α : Type u_1} (a : α), {a} ≠ ∅ := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, a finite set (`Finset`) that contains only `a` is not equal to the empty set. In mathematical terms, a singleton set (a set containing exactly one element) is never considered to be empty.

For any type `α` and any element `a` of type `α`, the singleton set `{a}` is not equal to the empty set.


theorem LipschitzWith.of_le_add :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {f : α → ℝ}, (∀ (x y : α), f x ≤ f y + dist x y) → LipschitzWith 1 f :=
  by sorry

The theorem `LipschitzWith.of_le_add` states that for any type `α` equipped with a PseudoMetricSpace structure, and any function `f` from `α` to the real numbers (ℝ), if for all `x` and `y` from `α`, the value of `f` at `x` is less than or equal to the value of `f` at `y` plus the distance between `x` and `y`, then `f` is Lipschitz continuous with a constant `1`. In mathematical terms, this asserts that if `f(x) ≤ f(y) + dist(x, y)` for all `x` and `y`, then `f` satisfies the Lipschitz condition `dist(f(x), f(y)) ≤ 1 * dist(x, y)` for all `x` and `y`. This condition is a fundamental one in mathematical analysis, ensuring key properties like stability and robustness of the function.

If a real-valued function on a PseudoMetricSpace satisfies `f(x) ≤ f(y) + dist(x, y)` for all `x` and `y`, then it is Lipschitz continuous with constant 1.


theorem Filter.range_mem_map : ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β}, Set.range m ∈ Filter.map m f :=
  by sorry

This theorem states that for any two types `α` and `β`, any filter `f` of type `α`, and any function `m` from `α` to `β`, the range of the function `m` (i.e., the set of all output values `m` can produce) is an element of the filter obtained by mapping function `m` over the filter `f`. In other words, every value that the function `m` can produce, when applied to the elements of the filter `f`, will exist in the output of the filter mapping operation.

For any filter `f` on type `α` and function `m` from `α` to `type β`, the range of `m` is included in the image of `m` applied to `f`.


theorem Nat.zero_max : ∀ (a : ℕ), max 0 a = a := by sorry

This theorem states that for any natural number `a`, the maximum value between 0 and `a` is `a` itself. In other words, no matter what natural number you choose, it will always be greater than or equal to zero. Therefore, when you use the `max` function to compare zero with any natural number, the result will always be that natural number.

For any natural number `a`, 0 ≤ a holds, thus max 0 a = a.


/-- The predistance on the disjoint union `Σ n, X n` can be computed in any `X k` for large
enough `k`.  -/
theorem Metric.inductiveLimitDist_eq_dist :
    ∀ {X : ℕ → Type u} [inst : (n : ℕ) → MetricSpace (X n)] {f : (n : ℕ) → X n → X (n + 1)},
      (∀ (n : ℕ), Isometry (f n)) →
        ∀ (x y : (n : ℕ) × X n) (m : ℕ) (hx : x.fst ≤ m) (hy : y.fst ≤ m),
          Metric.inductiveLimitDist f x y =
            dist (Nat.leRecOn hx (fun {k} => f k) x.snd) (Nat.leRecOn hy (fun {k} => f k) y.snd) :=
  by sorry

The theorem `Metric.inductiveLimitDist_eq_dist` states that for any sequence of types `X` indexed by natural numbers, where each `X n` is a metric space, and for any function `f` that maps elements of `X n` to `X (n + 1)` and preserves distances (isometry), the pre-distance on the disjoint union of all `X n` (calculated by the `Metric.inductiveLimitDist` function) can be computed in any `X k` for large enough `k`. More specifically, given any two elements `x` and `y` from the disjoint union and any natural number `m` such that the indices of `x` and `y` are less than or equal to `m`, the pre-distance between `x` and `y` is equal to the distance between the images of `x` and `y` under the function `f` recursively applied `m` times.

For any isometry `f` between metric spaces `X n` indexed by natural numbers, the pre-distance in the inductive limit of `X` equals the distance between the images of elements under recursive application of `f`.


theorem uniformity_comap :
    ∀ {α : Type ua} {β : Type ub} {x : UniformSpace β} (f : α → β),
      uniformity α = Filter.comap (Prod.map f f) (uniformity β) :=
  by sorry

The theorem `uniformity_comap` states that for any types `α` and `β`, given a uniform space structure `x` on `β` and a function `f` from `α` to `β`, the uniformity filter on `α` is equivalent to the pre-image of the uniformity filter on `β` under the function `Prod.map f f`. Here, `Prod.map f f` is a function that applies `f` to both elements of a pair from `α × α` and maps it to `β × β`. In essence, this theorem relates the uniform structures of two spaces when a function is known to exist between them.

For any uniform spaces (α, ς\_α) and (β, ς\_β), and any function f : α → β, the pre-image filter of the uniformity filter ς\_β on β under f is equivalent to the uniformity filter ENDOR\_α(f) on α.


theorem orderOf_eq_one_iff : ∀ {G : Type u_1} [inst : Monoid G] {x : G}, orderOf x = 1 ↔ x = 1 := by sorry

The theorem `orderOf_eq_one_iff` asserts that for any type `G` equipped with a monoid structure, and any element `x` of `G`, the order of `x` is equal to `1` if and only if `x` itself is the identity element of the monoid. In other words, in the context of a monoid, an element has order `1` exactly when it is the identity element.

For any monoid `G` and its identity element `e`, the order of `e` is equal to 1 if and only if `e` is the identity element itself.


theorem nhdsSet_union :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (s t : Set X), nhdsSet (s ∪ t) = nhdsSet s ⊔ nhdsSet t := by sorry

This theorem states that for any type `X` that is a topological space and any two sets `s` and `t` of type `X`, the filter of neighborhoods of the union of `s` and `t` is equivalent to the join (supremum) of the filter of neighborhoods of `s` and the filter of neighborhoods of `t`. In other words, the set of all neighborhoods of the union of two sets in a topological space is the same as the combined set of all neighborhoods of both sets.

The filter of neighborhoods of the union of two sets in a topological space is equal to the join (supremum) of the filters of neighborhoods of each set.


theorem zpow_mod_orderOf : ∀ {G : Type u_1} [inst : Group G] (x : G) (z : ℤ), x ^ (z % ↑(orderOf x)) = x ^ z := by sorry

The theorem `zpow_mod_orderOf` states that for any group `G` and any element `x` of `G`, and for any integer `z`, the power of `x` raised to the value of `z` modulo the order of `x` is equal to the power of `x` raised to `z`. This theorem essentially encapsulates the property of periodicity in the powers of an element in a group, reflecting that once we cycle through the order of the element, we return to the beginning of the cycle.

For any group `G`, element `x` of `G`, and integer `z`, `x^(z mod order of x) = x^z` holds.


theorem Real.pi_ne_zero : Real.pi ≠ 0 := by sorry

This theorem states that the number pi, denoted as π in mathematics and defined as twice a zero of the cosine function in the range [1, 2], is not equal to zero. Simply put, it asserts the non-zero nature of the mathematical constant π.

The theorem asserts that the mathematical constant π, defined as a zero of cosine in the range [1, 2], is non-zero.


theorem Finset.erase_eq : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), Finset.erase s a = s \ {a} :=
  by sorry

This theorem states that for any given type `α` that has decidable equality and any finite set `s` of type `α` and any element `a` of type `α`, the operation of erasing `a` from `s` using `Finset.erase` is equivalent to the standard set difference operation of `s` with the singleton set `{a}`. In mathematical terms, `Finset.erase s a` is equivalent to `s \ {a}`.

For any finite type `α` with decidable equality, the operation `Finset.erase` on type `Finset α` erasing an element `a` is equal to the standard set difference `\` between the set and the singleton set `{a}`.


theorem QuadraticForm.pi_apply :
    ∀ {ι : Type u_1} {R : Type u_2} {Mᵢ : ι → Type u_7} [inst : CommSemiring R]
      [inst_1 : (i : ι) → AddCommMonoid (Mᵢ i)] [inst_2 : (i : ι) → Module R (Mᵢ i)] [inst_3 : Fintype ι]
      (Q : (i : ι) → QuadraticForm R (Mᵢ i)) (x : (i : ι) → Mᵢ i),
      (QuadraticForm.pi Q) x = Finset.sum Finset.univ fun i => (Q i) (x i) :=
  by sorry

This theorem states that for a family of quadratic forms `Q : (i : ι) → QuadraticForm R (Mᵢ i)` on a family of modules `Mᵢ : ι → Type u_7` over a commutative semiring `R`, and for any vector `x : (i : ι) → Mᵢ i` (which is indexed by the same type `ι`), the value of the quadratic form constructed via `QuadraticForm.pi` at `x` is equal to the sum, taken over all indices in `ι`, of each `Q i` evaluated at `x i`. In other words, the quadratic form on the entire family of modules evaluates to the sum of the evaluations of the individual quadratic forms.

For a family of quadratic forms `Q : (i : ι) → QuadraticForm R (Mᵢ i)` on modules `Mᵢ : ι → Type u_7` over a commutative semiring `R`, the quadratic form `∏ i, Q i` evaluated at the vector `x : (i : ι) → Mᵢ i` equals the sum `∑ i, Q i x i`.


theorem MeasureTheory.Measure.join_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {m : MeasureTheory.Measure (MeasureTheory.Measure α)} {s : Set α},
      MeasurableSet s → ↑↑(MeasureTheory.Measure.join m) s = ∫⁻ (μ : MeasureTheory.Measure α), ↑↑μ s ∂m :=
  by sorry

The theorem `MeasureTheory.Measure.join_apply` states that for any measurable space `α`, any measure `m` on the space of measures on `α`, and any set `s` of `α`, if `s` is a measurable set, then the measure of `s` under the joined measure `m` is equal to the integral over all measures `μ` in `α` of the measure of `s` under `μ`, with respect to `m`. This essentially provides the rule for computing the measure of a set under a joined measure in terms of the measures it joins.

For any measurable space `α`, measurable set `s` in `α`, measure `m` on the space of measures over `α`, and measurable measure `μ` on `α`, the integral of the measure of `s` under `μ with respect to `m` equals the measure of `s` under the joined measure `m ⊕ μ`.


theorem isUnit_of_mul_isUnit_left : ∀ {M : Type u_1} [inst : CommMonoid M] {x y : M}, IsUnit (x * y) → IsUnit x := by
  sorry

This theorem states that for any type `M` that forms a commutative monoid, if `x` and `y` are elements of `M` and the product `x * y` is a unit (meaning it has a two-sided inverse), then `x` is also a unit. In other words, if `x * y` has a two-sided inverse in the commutative monoid, then `x` must also have a two-sided inverse.

If `M` is a commutative monoid and `x` in `M` has a two-sided inverse when multiplied with `y` in `M`, then `x` is a unit in `M`.


theorem continuous_zsmul :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : TopologicalAddGroup G] (z : ℤ),
      Continuous fun a => z • a :=
  by sorry

This theorem states that for any integer `z`, the operation of multiplying an element `a` from a topological additive group `G` by `z` (denoted as `z • a`) is a continuous function. Here, `G` is a type equipped with a topology (making it a topological space) and an additive group structure, and it's also assumed that the group operation is continuous with respect to the topology (making `G` a topological additive group).

For any topological additive group (G, +) with continuous group operation and any integer z, the function multiplication by z: G -> G, a => z * a, is a continuous function.


/-- In a monoid, an element `a` divides an element `b` iff all associates of `a` divide `b`.  -/
theorem Units.mul_right_dvd : ∀ {α : Type u_1} [inst : Monoid α] {a b : α} {u : αˣ}, a * ↑u ∣ b ↔ a ∣ b := by sorry

This theorem states that in a monoid, an element `a` divides another element `b` if and only if all associates of `a` also divide `b`. Here, an associate of `a` is any element that can be obtained by multiplying `a` by a unit `u` (where units are elements with multiplicative inverses). This theorem is applicable to any type `α` that forms a monoid, a structure with an associative binary operation and an identity element.

In a monoid, an element `a` divides `b` if and only if all units multiplied with `a` also divide `b`.


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

The theorem `normalize_dvd_iff` states that for any type `α` which is a cancel commutative monoid with zero and also a normalization monoid, and for any two elements `a` and `b` of type `α`, `a` divides `b` if and only if the normalized form of `a` divides `b`. Here, "normalizing" an element means multiplying it by the normalized unit of the monoid, which is a process that essentially adjusts its "size" without changing its "shape" or associate class in the monoid.

For any cancel commutative monoid with zero and normalization monoid type `α`, `a` divides `b` if and only if the normalized form of `a` divides the normalized form of `b`.


theorem Ultrafilter.compl_mem_iff_not_mem : ∀ {α : Type u} {f : Ultrafilter α} {s : Set α}, sᶜ ∈ f ↔ s ∉ f := by sorry

This theorem states that for any type `α`, any ultrafilter `f` of `α`, and any set `s` of type `α`, the complement of `s` (`sᶜ`) is an element of `f` if and only if `s` is not an element of `f`. In other words, it captures the idea that in an ultrafilter, a set and its complement cannot both be present.

For any ultrafilter `f` on type `α` and set `s` of type `α`, `s` is not in `f` if and only if its complement `sᶜ` is in `f`.


theorem SimpleGraph.neighborFinset_eq_filter :
    ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] {v : V} [inst_1 : DecidableRel G.Adj],
      SimpleGraph.neighborFinset G v = Finset.filter (G.Adj v) Finset.univ :=
  by sorry

This theorem states that for any simple graph `G` with vertices of a certain type `V`, which has a finite number of elements, and for any vertex `v` from `V`, if the adjacency relation `G.Adj` is decidable, then the finite set of neighbours of `v` in `G` is equal to the set of all vertices in `G` that satisfy the adjacency relation with `v`. In other words, the set of neighbours of `v` is the set of all vertices that are adjacent to `v` in the graph `G`.

If `G` is a finite simple graph with decidable adjacency relation, then for any vertex `v` in `G`, the set of neighbours of `v` equals the set of vertices adjacent to `v` in `G`.


theorem IsFractionRing.mk'_eq_div :
    ∀ {A : Type u_4} [inst : CommRing A] [inst_1 : IsDomain A] {K : Type u_5} [inst_2 : Field K] [inst_3 : Algebra A K]
      [inst_4 : IsFractionRing A K] {r : A} (s : ↥(nonZeroDivisors A)),
      IsLocalization.mk' K r s = (algebraMap A K) r / (algebraMap A K) ↑s :=
  by sorry

The theorem `IsFractionRing.mk'_eq_div` states that for any commutative ring `A` that is an integral domain, and a field `K` such that `K` is the field of fractions of `A`, for any element `r` in `A` and `s` in the non-zero divisors of `A`, the map from `A × (non-zero divisors of A)` to `K` that sends `(r, s)` to `r/s` is equal to the result of applying the ring homomorphism from `A` to `K` to `r` and `s`, and then taking their division in `K`. This theorem essentially states that in the field of fractions of a ring, the fraction `r/s` is equal to the division of the images of `r` and `s` under the canonical map from the ring to its field of fractions.

For any commutative integral domain ring A with field of fractions K, the map sending (r, s) to r/s from A × (non-zero divisors of A) equals the division of the ring homomorphism from A to K applied to r and s, i.e., r/s = (ρ(r) ÷ ρ(s)) in K, where ρ is the canonical homomorphism from A to K.


theorem MeasureTheory.Iio_ae_eq_Iic' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a : α},
      ↑↑μ {a} = 0 → Set.Iio a =ᶠ[MeasureTheory.Measure.ae μ] Set.Iic a :=
  by sorry

This theorem states that for any type `α` equipped with a measurable space structure `m0`, a measure `μ`, and a partial order, and for any element `a` of `α`, if the measure of the singleton set `{a}` is zero, then the left-infinite right-open interval ending at `a` (`Set.Iio a`) is almost everywhere equal (with respect to the measure `μ`) to the left-infinite right-closed interval ending at `a` (`Set.Iic a`).

In other words, if the measure (or "size") of the set containing just the point `a` is zero, then the sets of all points less than `a` and all points less than or equal to `a` are essentially the same except possibly on a set of measure zero (a set that is negligible in terms of the measure `μ`), hence the term "almost everywhere".

Given a measurable space `(α, m0)` with measure `μ`, if the measure of the singleton `{a}` is zero for some `a` in `α`, then the left-infinite right-open interval `Set.Iio a` is almost everywhere equal to the left-infinite right-closed interval `Set.Iic a`.


theorem Ordinal.pred_succ : ∀ (o : Ordinal.{u_4}), Ordinal.pred (Order.succ o) = o := by sorry

The theorem `Ordinal.pred_succ` states that for any ordinal `o`, when you take the successor of `o` and then its predecessor, you get `o` back. In other words, the predecessor function undoes the effect of the successor function on the set of ordinals. This can be thought of as a property of ordinal arithmetic much like the property in basic number theory where subtracting 1 from a number that was just incremented by 1 returns the original number.

For any ordinal number `o`, the predecessor of the successor of `o` equals `o`: `∀ (o : Ordinal), pred (pred (o.successor)) = o`.


theorem CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_inv :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s)
      (Q : CategoryTheory.Limits.IsColimit t) (j : J),
      CategoryTheory.CategoryStruct.comp (t.ι.app j)
          (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso P Q).inv =
        s.ι.app j :=
  by sorry

This theorem states that for any category `J` with objects of type `u₁` and morphisms of type `v₁`, and another category `C` with objects of type `u₃` and morphisms of type `v₃`, given a functor `F` from `J` to `C`, and two cocones `s` and `t` over `F`, if `P` is a colimit of `s` and `Q` is a colimit of `t`, then for any object `j` in `J`, the composition of the morphism from `j` to the vertex of `t` and the inverse of the unique isomorphism between the vertices of `s` and `t` (which is guaranteed to exist by the property of being a colimit) is equal to the morphism from `j` to the vertex of `s`. This theorem can be thought of as a way of comparing the structures of two colimits over the same diagram, and specifically, it's about how the morphisms into the colimit from the diagram are related to each other.

Given functors between categories and two cocones over the same diagram, the inverse of the unique isomorphism between their vertices maps morphisms from any object in the base category to the morphism from that object to the other vertex. In other words, the composition of a morphism with the inverse of the isomorphism between the colimit vertices is equal to the morphism to the first colimit vertex.


theorem WithBot.coe_zero : ∀ {α : Type u} [inst : Zero α], ↑0 = 0 := by sorry

This theorem states that for any type `α` that has an instance of the `Zero` typeclass (meaning it has a defined 'zero' value), the 'coercion' or typecast of the zero value of `α` (`↑0`) results in the zero value in the `WithBot` structure (`0`). In other words, when zero of any type with a defined zero is lifted to the `WithBot` type, it remains zero.

For any type `α` with a `Zero` instance, the coercion of its zero value to the `WithBot` type results in the `WithBot` zero value. In other words, `↑0 : WithBot α = 0 : WithBot`.


theorem CauSeq.const_limZero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {x : β}, CauSeq.LimZero (CauSeq.const abv x) ↔ x = 0 :=
  by sorry

The theorem `CauSeq.const_limZero` states that for any types `α` and `β`, where `α` is a linearly ordered field and `β` is a ring, and for any absolute value function `abv` from `β` to `α`, and any element `x` of `β`, the constant Cauchy sequence `CauSeq.const abv x` approaches zero (i.e., `CauSeq.LimZero (CauSeq.const abv x)`) if and only if the constant value `x` is zero. In other words, a constant Cauchy sequence in a given ring converges to zero under a certain absolute value if and only if the constant of the sequence is zero.

A constant Cauchy sequence in a ring with respect to a given absolute value function converges to zero if and only if the constant term is zero.


theorem Embedding.tendsto_nhds_iff :
    ∀ {Y : Type u_2} {Z : Type u_3} {ι : Type u_4} {g : Y → Z} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z]
      {f : ι → Y} {l : Filter ι} {y : Y},
      Embedding g → (Filter.Tendsto f l (nhds y) ↔ Filter.Tendsto (g ∘ f) l (nhds (g y))) :=
  by sorry

The theorem `Embedding.tendsto_nhds_iff` states that, given two types `Y` and `Z` along with an indexing type `ι`, a function `g` from `Y` to `Z`, both `Y` and `Z` having topological space structures, a function `f` from `ι` to `Y`, a filter `l` on `ι`, and an element `y` of `Y`, if `g` is an embedding, then the function `f` tends towards the neighborhood of `y` under the filter `l` if and only if the composition of `g` and `f` (denoted `g ∘ f`) tends towards the neighborhood of `g(y)` under the filter `l`. In simpler terms, it shows the preservation of limit properties under an embedding.

Given an embedding `g` between topological spaces `Y` and `Z`, if a filter `l` on the indexing type `ι` causes `f` from `ι` to `Y` to tend towards the neighborhood of `y` in `Y`, then it causes `g ∘ f` to tend towards the neighborhood of `g(y)` in `Z`.


theorem MultilinearMap.coe_injective :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂], Function.Injective DFunLike.coe :=
  by sorry

This theorem, `MultilinearMap.coe_injective`, states that for any semiring `R`, any type `ι`, any type function `M₁ : ι → Type v₁`, any type `M₂ : Type v₂`, and given that `M₁ i` and `M₂` are additive commutative monoids and modules over `R` for all `i : ι`, the coercion function `DFunLike.coe` is injective. In other words, if `DFunLike.coe` applied to two objects results in two identical functions, then those two original objects were identical themselves. This is a property of function-like objects, saying that no two different function-like objects can result in the same function when coerced.

For any semiring `R`, given type functions `M₁ : ι → Type v₁` and `M₂ : Type v₂`, if `M₁ i` and `M₂` are additive commutative monoids and modules over `R` for all `i : ι`, then the coercion function `DFunLike.coe` from `M₁ i` to `M₂` is injective.


/-- **Alias** of `starRingEnd_self_apply`. -/
theorem Complex.conj_conj :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : StarRing R] (x : R), (starRingEnd R) ((starRingEnd R) x) = x := by
  sorry

This theorem, named `Complex.conj_conj`, states that for any type `R` that is a commutative semiring and a star ring, applying the `starRingEnd` function twice on any element `x` of type `R` will return the original element `x`. Essentially, this means that the `starRingEnd` function is involutive in this context, i.e., it is its own inverse when applied twice.

For any commutative semiring and star ring `R`, the involution `starRingEnd : R → R` satisfies `starRingEnd (starRingEnd x) = x` for all `x : R`.


OneHom.ext

theorem OneHom.ext :
    ∀ {M : Type u_4} {N : Type u_5} [inst : One M] [inst_1 : One N] ⦃f g : OneHom M N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem states that for any two types `M` and `N` that have a `One` instance (i.e., they have an identity element with respect to a multiplication-like operation), given any two homomorphisms from `M` to `N` (`OneHom M N`), if for every element `x` of type `M`, the result of applying the homomorphisms `f` and `g` to `x` are equal, then the homomorphisms `f` and `g` themselves are equal. This is essentially a statement of function extensionality for homomorphisms between types with a designated "one" element.

If `M` and `N` are types with `One` instances, and `f` and `g` are homomorphisms from `M` to `N` such that `f x = g x` for all `x` in `M`, then `f = g`.


theorem MeasureTheory.IsStoppingTime.measurableSet_inter_eq_iff :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ) (s : Set Ω) (i : ι),
      MeasurableSet (s ∩ {ω | τ ω = i}) ↔ MeasurableSet (s ∩ {ω | τ ω = i}) :=
  by sorry

This theorem states that for any measure space `Ω`, any preordered index set `ι`, any filtration `f` on `Ω` indexed by `ι`, and any stopping time `τ` with respect to this filtration, the set `s` of elements in `Ω`, and an index `i` from `ι`, the intersection of `s` with the set of elements `ω` in `Ω` where `τ ω` equals `i` is measurable if and only if this intersection is measurable. Intuitively, this means that the measurability of the set of outcomes where the stopping time equals a specific time `i` and belong to a certain set `s` is not affected by the specifics of the stopping rule `τ`.

For any measure space `Ω`, preordered index set `ι`, filtration `f` on `Ω` indexed by `ι`, and stopping time `τ` with respect to `f`, the set `{ω ∈ Ω | τ ω = i ∧ ω ∈ s}` is measurable if andωaso is, for all `i` in `ι` and set `s` in `Ω`.


theorem MulOpposite.op_mul :
    ∀ {α : Type u_1} [inst : Mul α] (x y : α), MulOpposite.op (x * y) = MulOpposite.op y * MulOpposite.op x := by sorry

This theorem states that for all elements `x` and `y` of a type `α` that has a multiplication operation, the "opposite multiplication" of the product of `x` and `y` (i.e., `MulOpposite.op (x * y)`) is equal to the product of the "opposite multiplication" of `y` and `x` (i.e., `MulOpposite.op y * MulOpposite.op x`). In other words, the operation `MulOpposite.op` reverses the order of multiplication, reflecting the property of the "opposite" or "reversed" multiplication.

For all types `α` with a multiplication operation and for all elements `x` and `y` of `α`, the opposite multiplication of `x * y` is equal to `MulOpposite.op y * MulOpposite.op x`. In other words, `MulOpposite.op (x * y) = MulOpposite.op y * MulOpposite.op x`.


theorem Set.isCompl_range_some_none : ∀ (α : Type u_6), IsCompl (Set.range some) {none} := by sorry

The theorem `Set.isCompl_range_some_none` states that for any type `α`, the set of all values that can be generated by applying the `some` function (which wraps a value in an `Option` type) is a complement of the set containing only the `none` value (which represents an absence of a value in `Option` type). In other words, the union of these two sets gives the whole set of all `Option α` values, and their intersection is empty.

The sets of `Option.some α` values and `Option.none` form a complementary pair, i.e., their union equals the whole `Option α` type and their intersection is empty.


theorem Finset.fold_insert :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β} {s : Finset α} {a : α} [inst : DecidableEq α],
      a ∉ s → Finset.fold op b f (insert a s) = op (f a) (Finset.fold op b f s) :=
  by sorry

The theorem `Finset.fold_insert` asserts that, for any types `α` and `β`, a binary operation `op` on `β` that is both commutative and associative, a function `f` from `α` to `β`, a base value `b` of type `β`, a finite set `s` of type `α`, and an element `a` of type `α` such that `a` is not in `s`, when we insert `a` into `s` and then fold `op` over the `f`-image of the resulting set starting with `b`, we get the same result as applying `op` to `f(a)` and the result of folding `op` over the `f`-image of `s` starting with `b`. This assumes that the equality for `α` is decidable. In other words, this says the result of the folding operation is not affected by the order of elements in the set.

For any commutative and associative binary operation `op` on type `β`, function `f` from `α` to `β`, base value `b` of type `β`, finite set `s` of type `Finset α`, and element `a` not in `s`, the following equality holds: `(foldl op f b (insert a s)) = op (f a) (foldl op f b s)`.


/-- `C(·, Z)` is a functor.  -/
theorem ContinuousMap.continuous_comp_left :
    ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] (f : C(X, Y)), Continuous fun g => ContinuousMap.comp g f :=
  by sorry

The theorem `ContinuousMap.continuous_comp_left` states that for any topological spaces `X`, `Y`, and `Z`, and for any continuous function `f` from `X` to `Y`, the function that maps any continuous function `g` from `Y` to `Z` to the composition of `g` and `f` (i.e., `ContinuousMap.comp g f`) is also continuous. In other words, the "composition with `f` on the left" operation is continuous. This means that the space of continuous functions `C(·, Z)` behaves as a functor in the category of topological spaces.

The composition of a continuous function with another continuous function, evaluated from the left, is a continuous function.


theorem continuous_prod_mk :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y} {g : X → Z},
      (Continuous fun x => (f x, g x)) ↔ Continuous f ∧ Continuous g :=
  by sorry

This theorem states that for any three types `X`, `Y`, and `Z` where `X`, `Y`, and `Z` are equipped with topological spaces, given two functions `f : X → Y` and `g : X → Z`, the function that maps each element of `X` to the pair `(f(x), g(x))` in `Y × Z` is continuous if and only if both `f` and `g` are continuous. This is a fundamental result in topology which characterizes the continuity of product functions in terms of the continuity of their component functions.

The function that maps each element of a topological space `X` to the pair of its images under continuous functions `f : X → Y` and `g : X → Z` is a continuous function from `X` to `Y × Z`. (If X, Y, Z are topological spaces and f and g are continuous functions.)


theorem Set.surjOn_image : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.SurjOn f s (f '' s) := by sorry

The theorem `Set.surjOn_image` states that for any types `α` and `β`, and any function `f` from `α` to `β`, and any set `s` of type `α`, the function `f` is surjective from the set `s` to its image under the function `f`. In other words, every element in the image of `s` under `f` (denoted as `f '' s`) comes from an element in `s` by applying the function `f`. This is a property of surjectivity restricted to a specific domain (`s`) and codomain (`f '' s`).

For any function `f` from type `α` to type `β` and any set `s` of type `α`, the image `f'' s` is a subset of `{x : β | ∃ (a : α), f a = x}` (the image of `s` under `f` is equal to the set of all images of elements in `s`). In other words, `f` is surjective from `s` to its image.


theorem Prod.mk_add_mk :
    ∀ {M : Type u_5} {N : Type u_6} [inst : Add M] [inst_1 : Add N] (a₁ a₂ : M) (b₁ b₂ : N),
      (a₁, b₁) + (a₂, b₂) = (a₁ + a₂, b₁ + b₂) :=
  by sorry

This theorem, `Prod.mk_add_mk`, states that for any two types `M` and `N` that have an addition operation defined, the sum of pairs of elements from these types behaves as expected. Specifically, the sum of the pair `(a₁, b₁)` and `(a₂, b₂)` is equal to the pair `(a₁ + a₂, b₁ + b₂)`, where `a₁` and `a₂` are elements of type `M`, and `b₁` and `b₂` are elements of type `N`. This means that the addition operation is applied component-wise on the elements of the pairs.

For types `M` and `N` with addition operations, the operation `(+)` on pairs `(a, b)` from `M × N` is defined as `(a + a', b + b')` where `a` and `a'` are from `M` and `b` and `b'` are from `N`.


theorem Finmap.union_toFinmap :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : AList β),
      AList.toFinmap s₁ ∪ AList.toFinmap s₂ = AList.toFinmap (s₁ ∪ s₂) :=
  by sorry

This theorem states that for all types `α` and `β` (where `β` is a type dependent on `α`), and for all instances of decidable equality on `α`, and for all `s₁` and `s₂` which are association lists of type `β`, the union of the `Finmap` representations (i.e., finite maps), obtained from converting `s₁` and `s₂` using `AList.toFinmap`, is equal to the `Finmap` representation of the union of `s₁` and `s₂`. In other words, converting two association lists to finite maps and then taking their union is the same as first taking the union of the association lists and then converting to a finite map.

For all types `α` and instances of decidable equality on `α`, the union of `Finmap.from AList` for two association lists `s₁` and `s₂` of type `β` (where `β` depends on `α`) is equal to `Finmap.union (Finmap.fromAList s₁) (Finmap.fromAList s₂)`.


theorem HasLineDerivWithinAt.lineDifferentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
      {s : Set E} {x v : E}, HasLineDerivWithinAt 𝕜 f f' s x v → LineDifferentiableWithinAt 𝕜 f s x v :=
  by sorry

This theorem, `HasLineDerivWithinAt.lineDifferentiableWithinAt`, states that given a field `𝕜` that is nontrivially normed, a normed add-commutative group `F`, a normed space over `𝕜` and `F`, an add-commutative group `E`, a module over `𝕜` and `E`, a function `f` mapping `E` to `F`, a derivative `f'` of `F`, a set `s` of `E`, and two elements `x` and `v` of `E`, if `f` has a line derivative within `s` at `x` along `v`, then `f` is line differentiable within `s` at `x` along `v`. This theorem establishes a connection between the existence of a line derivative and the line differentiability of a function at a certain point within a given set.

If a function has a line derivative within a set at a point along a vector, then it is line differentiable within that set at that point along that vector.


theorem FirstOrder.Language.Theory.CompleteType.isMaximal :
    ∀ {L : FirstOrder.Language} {T : FirstOrder.Language.Theory L} {α : Type w}
      (p : FirstOrder.Language.Theory.CompleteType T α), FirstOrder.Language.Theory.IsMaximal ↑p :=
  by sorry

This theorem states that for any first-order language `L`, any theory `T` of the language `L`, and any type `α`, if `p` is a complete type of the theory `T` over the type `α`, then `p` is also a maximal theory. A maximal theory is defined as a theory that is satisfiable and includes either any given sentence or its negation.

For any first-order language L, theory T, and type α in L, if type p of theory T over α is complete, then p is a maximal theory.


theorem Real.hasDerivAt_exp : ∀ (x : ℝ), HasDerivAt Real.exp (Real.exp x) x := by sorry

This theorem states that for any real number `x`, the function `Real.exp`, which represents the real exponential function, has a derivative at the point `x`. Furthermore, the derivative of `Real.exp` at `x` is simply `Real.exp x`. In other words, the derivative of the exponential function at any point is the exponential of that point itself.

The real exponential function `Real.exp` has derivative equal to itself at any real number `x`.


theorem List.chain'_nil : ∀ {α : Type u} {R : α → α → Prop}, List.Chain' R [] := by sorry

The theorem `List.chain'_nil` states that for any type `α` and any binary relation `R` over `α`, the property `List.Chain' R` holds for an empty list. In other words, an empty list is considered to satisfy the "chain" condition for any given relation, since there are no pairs of elements to contradict the condition.

For any type α and binary relation R over α, the empty list satisfies the chain condition R. (In Lean, this is expressed as `List.Chain' R []`)


theorem Function.Surjective.range_comp :
    ∀ {α : Type u_3} {ι : Sort u_1} {ι' : Sort u_2} {f : ι → ι'},
      Function.Surjective f → ∀ (g : ι' → α), Set.range (g ∘ f) = Set.range g :=
  by sorry

The theorem `Function.Surjective.range_comp` states that for any types `α`, `ι`, and `ι'`, and for any function `f` from `ι` to `ι'`, if `f` is surjective, then for any function `g` from `ι'` to `α`, the range of the composition of `g` and `f` is equal to the range of `g`. In simpler terms, if every element in `ι'` comes from applying `f` to some element in `ι`, then applying `g` afterwards doesn't lead to any new elements that weren't in the range of `g` alone.

If `f: ι → ι'` is surjective and `g: ι' → α` is any function, then `range (g ∘ f) = range g`.


ContinuousLinearEquiv.ext

theorem ContinuousLinearEquiv.ext :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] {f g : M₁ ≃SL[σ₁₂] M₂}, ⇑f = ⇑g → f = g :=
  by sorry

This theorem states that for any two continuous linear equivalences `f` and `g` between two topological modules `M₁` and `M₂` over semirings `R₁` and `R₂` respectively, with ring homomorphisms `σ₁₂` and `σ₂₁` that form an inverse pair, if the function corresponding to `f` is equal to the function corresponding to `g`, then `f` itself is equal to `g`. Essentially, this emphasizes that a continuous linear equivalence is determined completely by its corresponding function.

If `f` and `g` are continuous linear equivalences between topological modules over semirings with invertible ring homomorphisms forming an inverse pair, and their corresponding functions are equal, then `f` is equal to `g`.


theorem Mathlib.CategoryTheory.NatIso._auxLemma.2 :
    ∀ {α : Sort u} {r : α → α → Prop} [inst : IsRefl α r] (a : α), r a a = True := by sorry

This theorem states that for any type 'α' and a binary relation 'r' over this type, where 'r' is reflexive (meaning that 'r a a' holds for all 'a' in 'α'), then the proposition 'r a a' is always true for any element 'a' of 'α'. Essentially, this theorem is affirming the reflexivity of the relation 'r' in terms of propositional logic by setting 'r a a' equal to 'True' for all 'a'.

For any reflexive binary relation r on type α, we have r a a holds for all a in α.


theorem Filter.mem_lift'_sets :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β},
      Monotone h → ∀ {s : Set β}, s ∈ Filter.lift' f h ↔ ∃ t ∈ f, h t ⊆ s :=
  by sorry

This theorem states that for every filter `f` on a type `α` and a monotone function `h` from sets of `α` to sets of `β`, a set `s` of `β` is a member of the filter obtained by lifting `f` along `h` if and only if there exists a set `t` in `f` such that `h` applied to `t` is a subset of `s`. In other words, the theorem provides a necessary and sufficient condition for a set to be in the filter obtained by the `lift'` operation on a filter using a monotone function.

A set belongs to the filter obtained by lifting a filter through a monotone function if and only if there exists a set in the filter that maps to a subset of the set.


theorem Nat.self_le_factorial : ∀ (n : ℕ), n ≤ Nat.factorial n := by sorry

The theorem `Nat.self_le_factorial` states that for all natural numbers `n`, `n` is less than or equal to the factorial of `n`. In other words, any natural number is always less than or equal to its factorial.

For all natural numbers `n`, `n` is less than or equal to the factorial of `n` (`n ≤ factorial n`).


theorem Set.Iic_diff_right : ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, Set.Iic a \ {a} = Set.Iio a := by sorry

This theorem states that for any partially ordered set, the difference between the left-infinite right-closed interval up to a point "a" and the singleton set containing "a" is equal to the left-infinite right-open interval up to "a". In other words, if you remove the end point "a" from the interval including "a" (denoted as Set.Iic a), you get the interval that does not include "a" (denoted as Set.Iio a). The intervals are defined over any type `α` that has a partial order (not necessarily a total order).

For any partially ordered set, the difference between the left-infinite right-closed interval and the singleton set of a point is equal to the left-infinite right-open interval for that point.


/-- If `f` and `g` are maps with dense range, then `Prod.map f g` has dense range.  -/
theorem DenseRange.prod_map :
    ∀ {Y : Type v} {Z : Type u_1} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z] {ι : Type u_5}
      {κ : Type u_6} {f : ι → Y} {g : κ → Z}, DenseRange f → DenseRange g → DenseRange (Prod.map f g) :=
  by sorry

The theorem `DenseRange.prod_map` states that if `f` and `g` are functions from types `ι` and `κ` to topological spaces `Y` and `Z` respectively, and both these functions have a dense range, then the function `Prod.map f g` also has a dense range. Here, `Prod.map f g` is a function that operates on pairs from `ι × κ` and produces pairs in `Y × Z` by applying `f` to the first component of the input pair and `g` to the second component. A dense range means that the closure of the set of all output values of the function is the entire space. In mathematical terms, if the images of `f` and `g` densely populate their respective spaces, then the pairs formed by `f` and `g` densely populate the product space.

If functions `f : ι → Y` and `g : κ → Z` with dense ranges map `Prod.map f g : ι × κ → Y × Z` also has a dense range.


theorem Polynomial.sum_monomial_index :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : AddCommMonoid S] {n : ℕ} (a : R) (f : ℕ → R → S),
      f n 0 = 0 → Polynomial.sum ((Polynomial.monomial n) a) f = f n a :=
  by sorry

This theorem states that for any semiring `R`, any additive commutative monoid `S`, any natural number `n`, any element `a` of `R`, and any function `f` from pairs of natural numbers and elements of `R` to elements of `S` (where `f(n, 0)` is defined to be `0`), the sum of the function `f` applied to the coefficients of the polynomial that is equal to the monomial `a * X^n` is equal to `f(n, a)`. In simpler terms, when we apply the function `f` to each coefficient of the monomial `a * X^n` and sum the results, we get `f(n, a)`.

For any semiring `R`, additive commutative monoid `S`, natural number `n`, `R` element `a`, and function `f` from pairs of natural numbers and `R` to `S` (with `f(n, 0) = 0`), we have the sum of `f(i, a)` for `i` from `0` to `n` equals `f(n, a)`.


/-- `Real.cosh` is always positive  -/
theorem Real.cosh_pos : ∀ (x : ℝ), 0 < Real.cosh x := by sorry

The theorem `Real.cosh_pos` states that the real hyperbolic cosine function, represented as `Real.cosh`, is always positive for any real number `x`. In other words, for every real number `x`, the value of `Real.cosh x` is greater than 0.

For all real numbers x, Real.cosh x > 0.


theorem Real.hasDerivAt_log : ∀ {x : ℝ}, x ≠ 0 → HasDerivAt Real.log x⁻¹ x := by sorry

The theorem `Real.hasDerivAt_log` states that for any real number `x` that is not equal to zero, the real logarithm function `Real.log` has a derivative at the point `x`, and this derivative is equal to the reciprocal of `x` (expressed as `x⁻¹` in Lean 4). In mathematical terms, if `x` is non-zero, the derivative of `log(x)` is `1/x`.

For any non-zero real number `x`, the derivative of the logarithm function `Real.log` at `x` is equal to `1/x`.


Fin.pos

theorem Fin.pos : ∀ {n : ℕ}, Fin n → 0 < n := by sorry

This theorem, `Fin.pos`, states that for all natural numbers `n`, if there exists a value in the `Fin n` type, then `n` must be greater than zero. In mathematical terms, if `n` is a natural number that can be indexed into a finite set (i.e., `n` is in `Fin n`), then `n` must be positive. The `Fin n` type in Lean represents a finite set of `n` elements, so if `n` were zero, there would be no elements, contradicting the assumption.

For any natural number `n`, if `n` is an element of `Fin n`, then `n` is positive.


/-- Same as limsup_const applied to `⊥` but without the `NeBot f` assumption  -/
theorem Filter.limsup_const_bot :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β}, Filter.limsup (fun x => ⊥) f = ⊥ := by
  sorry

The theorem `Filter.limsup_const_bot` states that for any given type `α` that forms a complete lattice, and for any filter `f` of type `β`, the limit superior (limsup) of a function that always returns the bottom element (`⊥`) with respect to the filter `f` is equal to the bottom element (`⊥`). This is a specific case of the `limsup_const` theorem where we don't need the assumption that `f` is not a minimal filter (`NeBot f`).

For any complete lattice `α` and filter `f` on `α`, the limsup of a constant function mapping to the bottom element is equal to the bottom element.


theorem Ordinal.opow_le_of_limit :
    ∀ {a b c : Ordinal.{u_1}}, a ≠ 0 → Ordinal.IsLimit b → (a ^ b ≤ c ↔ ∀ b' < b, a ^ b' ≤ c) := by sorry

This theorem, `Ordinal.opow_le_of_limit`, states that for any three ordinals `a`, `b`, and `c`, if `a` is not zero and `b` is a limit ordinal (i.e., an ordinal which is not zero and not a successor), then `a` raised to the power `b` is less than or equal to `c` if and only if for every ordinal `b'` less than `b`, `a` raised to the power `b'` is less than or equal to `c`. In other words, it formalizes a property of exponentiation for limit ordinals in the theory of well orders.

For any ordinals `a` non-zero, and `b` a limit ordinal, `a^b ≤ c` if and only if for all `b' < b`, `a^(b') ≤ c`.


theorem SetTheory.PGame.impartial_def :
    ∀ {G : SetTheory.PGame},
      SetTheory.PGame.Impartial G ↔
        G ≈ -G ∧
          (∀ (i : SetTheory.PGame.LeftMoves G), SetTheory.PGame.Impartial (SetTheory.PGame.moveLeft G i)) ∧
            ∀ (j : SetTheory.PGame.RightMoves G), SetTheory.PGame.Impartial (SetTheory.PGame.moveRight G j) :=
  by sorry

The theorem `SetTheory.PGame.impartial_def` states that for any game `G` in set theory, `G` is impartial if and only if `G` is equivalent to the negation of `G` and for every allowable move `i` by the Left player that transitions the game to a new state, the new game is also impartial, and for every allowable move `j` by the Right player that transitions the game to a new state, the new game is also impartial. In other words, an impartial game is one where neither player has a definite advantage from the start, and every possible game state that can be reached by either player's allowable moves is also impartial.

A game in set theory is impartial if and only if it is self-complementary and every allowable move by both players results in an impartial game.


theorem abs_circleMap_zero : ∀ (R θ : ℝ), Complex.abs (circleMap 0 R θ) = |R| := by sorry

The theorem `abs_circleMap_zero` states that for all real numbers `R` and `θ`, the complex absolute value (or modulus) of the result of mapping `θ` to the circle in the complex plane with center at 0 and radius `R` using the `circleMap` function, is equal to the absolute value of `R`. In other words, the distance from the origin to any point on the circle mapped by `circleMap` with center 0 and radius `R` is precisely the absolute value of `R`, regardless of the angle `θ`.

For all real numbers R and angles θ, the absolute value of the complex number obtained by mapping θ to the complex plane with center at 0 and radius R using the `circleMap` function, equals R.


Convex.interior

/-- In a topological vector space, the interior of a convex set is convex.  -/
theorem Convex.interior :
    ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : LinearOrderedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : TopologicalAddGroup E] [inst_5 : ContinuousConstSMul 𝕜 E] {s : Set E},
      Convex 𝕜 s → Convex 𝕜 (interior s) :=
  by sorry

This theorem states that in a topological vector space, if a set is convex, then its interior is also convex. In more detail, given a type 𝕜 which is a linearly ordered field, a type E with a structure of an additive commutative group, a 𝕜-module structure on E, a topology on E which turns it into a topological space, a topological additive group structure, and a continuity of scalar multiplication, then for any set s of elements of type E, if s is convex, then the interior of s (the largest open subset of s) is also convex.

In a topological vector space over a linearly ordered field, the interior of a convex set is convex.


/-- In a metric space, the minimal edistance to a nonempty set is finite.  -/
theorem Metric.infEdist_ne_top :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x : α}, Set.Nonempty s → EMetric.infEdist x s ≠ ⊤ := by
  sorry

This theorem states that in a pseudometric space, the minimal extended distance (infEdist) from a given point to a nonempty set is always finite. In other words, for any type `α` that forms a pseudometric space, any set `s` of type `α`, and any point `x` of type `α`, if the set `s` is not empty, then the infimum of the extended distances from `x` to any point in `s` cannot be infinity.

In a pseudometric space, the infimum of the extended distances from a point to a nonempty set is finite.


MeasurableSet.biInter

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

The theorem `MeasurableSet.biInter` states that for any types `α` and `β`, any measurable space `m` on `α`, any function `f` from `β` to a set of `α`, and any set `s` of `β`, if the set `s` is countable and for every element `b` in `s` the set `f(b)` is measurable, then the intersection of all `f(b)` for `b` in `s` is also a measurable set. In other words, the countable intersection of measurable sets is measurable.

If `m` is a measurable space on `α`, `f` is a function from `β` to `α`, `s` is a countable set in `β`, and for all `b` in `s`, `f(b)` is measurable, then the intersection of all `f(b)` for `b` in `s` is a measurable set.


theorem MeasureTheory.HasPDF.absolutelyContinuous :
    ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {x : MeasurableSpace Ω} {X : Ω → E}
      {ℙ : MeasureTheory.Measure Ω} {μ : MeasureTheory.Measure E} [hX : MeasureTheory.HasPDF X ℙ μ],
      MeasureTheory.Measure.AbsolutelyContinuous (MeasureTheory.Measure.map X ℙ) μ :=
  by sorry

The theorem states that for any measure space `Ω`, any measurable space `E`, any `Ω`-valued random variable `X` in `E`, and any two measures `ℙ` on `Ω` and `μ` on `E`, if `X` has a probability density function with respect to measures `ℙ` and `μ`, then the pushforward measure of `ℙ` under `X` is absolutely continuous with respect to `μ`. In other words, if for any set in `E`, its `μ`-measure is zero, then its pushforward `ℙ`-measure is also zero. This provides a relationship between the distribution of a random variable and the underlying probability measure.

If an Ω-valued random variable X on a measurable space (E, Σ) has a density function with respect to measures ℙ on Ω and μ on E, then the pushforward measure ℙ ∘ X is absolutely continuous with respect to μ.


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

This theorem, `and_iff_right_iff_imp`, states that for any two propositions `a` and `b`, the statement "`a` and `b` is equivalent to `b`" is equivalent to "`b` implies `a`". In other words, if the truth of `b` is enough to guarantee both `a` and `b` are true, then `b` being true implies `a` is true.

The theorem `and_iff_right_iff_imp` in Lean 4 states that for all propositions `a` and `b`, `(a ∧ b) ↔ b ⟹ a`.


theorem List.countP_cons :
    ∀ {α : Type u_1} (p : α → Bool) (a : α) (l : List α),
      List.countP p (a :: l) = List.countP p l + if p a = true then 1 else 0 :=
  by sorry

The given theorem, `List.countP_cons`, states that for any type `α`, any predicate `p` that is a function from type `α` to `Bool`, any element `a` of type `α`, and any list `l` of elements of type `α`, the count of elements satisfying the predicate `p` in the list that results from prepending the element `a` to the list `l` (`a :: l`) is equal to the count of elements satisfying `p` in `l` plus 1 if `a` satisfies `p` (`if p a = true then 1 else 0`). In other words, if `a` is a member of the list that satisfies the predicate `p`, it is counted as 1, otherwise as 0, and this is added to the count of elements in the original list satisfying `p`.

For any type `α`, predicate `p` on `α`, element `a ∈ α`, and list `l ∈ List α`, the number of elements in `l` satisfying `p` is equal to the number of elements in `a :: l` satisfying `p` if `p(a)` is true, otherwise it is one more than the number of elements in `l` satisfying `p`.


theorem Ideal.IsMaximal.ne_top : ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, Ideal.IsMaximal I → I ≠ ⊤ := by sorry

This theorem states that for any type `α` equipped with a semiring structure and any ideal `I` of `α`, if `I` is a maximal ideal, then `I` is not equal to the whole set `α` (denoted by `⊤`). That is, a maximal ideal in a semiring is never the entire semiring itself.

In a semiring, a maximal ideal is proper, that is, it is strictly contained in the entire semiring.


theorem MeasureTheory.aecover_Ioo_of_Ioo :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a b : ι → α} {A B : α},
      Filter.Tendsto a l (nhds A) →
        Filter.Tendsto b l (nhds B) → MeasureTheory.AECover (μ.restrict (Set.Ioo A B)) l fun i => Set.Ioo (a i) (b i) :=
  by sorry

This theorem, `MeasureTheory.aecover_Ioo_of_Ioo`, states that for any types `α` and `ι`, given a measurable space `α`, a measure `μ` on this space, a filter `l` on `ι`, and the fact that `α` has a linear order, a topological space structure, an order-closed topology, and is open and measurable, along with functions `a` and `b` from `ι` to `α`, and elements `A` and `B` of `α`. If the function `a` tends to `A` along the filter `l`, and the function `b` tends to `B` along the same filter `l`, then `μ` restricted to the open interval `(A, B)` ("almost everywhere") covers the set of open intervals `(a i, b i)` for `i` in the filter `l`.

In other words, if we have two sequences `a` and `b` that respectively converge to `A` and `B`, then almost every point in the open interval `(A, B)` can be found in one of the open intervals `(a i, b i)`.

Given a measurable space with a linear order, measure, filter, topology, and measurability properties, if functions `a` and `b` converge to `A` and `B` respectively along the filter, then almost every point in the open interval `(A, B)` lies in some `(a i, b i)` for `i` in the filter.


Continuous.vadd

theorem Continuous.vadd :
    ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : VAdd M X] [inst_4 : ContinuousVAdd M X] {f : Y → M} {g : Y → X},
      Continuous f → Continuous g → Continuous fun x => f x +ᵥ g x :=
  by sorry

This theorem states that for any types `M`, `X`, and `Y`, given topological spaces on `M`, `X`, and `Y`, and given that `M` and `X` form a vector space under vector addition, if `f` and `g` are continuous functions from `Y` to `M` and `Y` to `X` respectively, then the function that takes `x` in `Y` and maps it to the vector sum of `f(x)` and `g(x)` is also continuous. This is essentially a formalization of the basic calculus principle that the sum of two continuous functions is also continuous.

Given topological spaces on types `M`, `X`, and `Y`, if `M` and `X` form a vector space under vector addition, and `f : Y → M` and `g : Y → X` are continuous functions, then the function `h : Y → M × X` defined by `h x = (f x, g x)` is continuous. (This implies that the vector sum `f x + g x` of `f(x)` and `g(x)` is a continuous function from `Y` to `M`.)


theorem IsCoprime.of_mul_left_left :
    ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime (x * y) z → IsCoprime x z := by sorry

This theorem states that for any commutative semiring `R` and any elements `x`, `y`, and `z` of `R`, if `x * y` and `z` are coprime, then `x` and `z` are also coprime. In other words, if there exist two elements `a` and `b` in `R` such that `a * (x * y) + b * z = 1`, then there must also exist two elements `c` and `d` in `R` such that `c * x + d * z = 1`.

If `x`, `y`, and `z` are elements of a commutative semiring `R` such that `x * y` and `z` are coprime, then `x` and `z` are also coprime, i.e., there exist `a`, `b` in `R` with `a * (x * y) + b * z = 1` implies there exist `c`, `d` in `R` with `c * x + d * z = 1`.


theorem IsometryEquiv.apply_symm_apply :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β) (y : β),
      h ((IsometryEquiv.symm h) y) = y :=
  by sorry

The theorem `IsometryEquiv.apply_symm_apply` states that for any two types `α` and `β` which are both `PseudoEMetricSpace`s, for any isometric isomorphism `h` from `α` to `β`, and for any element `y` of type `β`, applying the isomorphism `h` to the result of applying the inverse of `h` (obtained through `IsometryEquiv.symm`) to `y` will yield `y` itself. In other words, it states that the isomorphism and its inverse are indeed inverse operations to each other in the context of isometric isomorphisms between two pseudo-emetric spaces.

For any isometric isomorphism between two pseudo-metric spaces and any element in the image space, applying the isomorphism followed by its symmetric inverse yields the original element.


theorem Mathlib.Algebra.Order.Group.Abs._auxLemma.10 :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], (|a| = 0) = (a = 0) :=
  by sorry

The theorem `Mathlib.Algebra.Order.Group.Abs._auxLemma.10` states that for any type `α` which is an additive group and possesses a linear order and is covariant in both its regular addition operation and its swapped addition operation, the absolute value of an element `a` from `α` is equal to zero if and only if `a` itself is equal to zero. In other words, in this algebraic structure, an element's absolute value is zero exactly when the element is zero.

For any additive group with a linear order covariant under swapped addition, the absolute value of an element is zero if and only if the element itself is zero.


theorem mul_zsmul' : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (m n : ℤ), (m * n) • a = n • m • a := by
  sorry

This theorem, named `mul_zsmul'`, states that for any type `α` that forms a subtraction monoid, and any element `a` of this type `α` and any two integers `m` and `n`, the operation of "scalar multiplication" by the product of `m` and `n` on `a` is the same as first scalar multiplying `a` by `m` and then by `n`. In other words, it says that scalar multiplication is associative with respect to integer multiplication.

For any subtraction monoid type `α` and its elements `a`, and integers `m` and `n`, the operation of scalar multiplication by the product of `m` and `n` on `a` equals the scalar multiplication of `a` by `m` followed by scalar multiplication by `n`.


theorem isMax_iff_eq_top : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, IsMax a ↔ a = ⊤ := by
  sorry

This theorem, `isMax_iff_eq_top`, states that for any type `α` which has a partial ordering and a greatest element (`OrderTop`), an element `a` of `α` is maximal (as defined by `IsMax`) if and only if `a` equals the greatest element of `α` (`⊤`). In other words, the only maximal element in such a type is the greatest element.

For any type `α` with a partial ordering and a greatest element `⊤`, an element `a` is maximal (in terms of the ordering) if and only if `a = ⊤`.


theorem MeasureTheory.VectorMeasure.restrict_le_restrict_of_subset_le :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
      [inst_2 : PartialOrder M] (v w : MeasureTheory.VectorMeasure α M) {i : Set α},
      (∀ ⦃j : Set α⦄, MeasurableSet j → j ⊆ i → ↑v j ≤ ↑w j) →
        MeasureTheory.VectorMeasure.restrict v i ≤ MeasureTheory.VectorMeasure.restrict w i :=
  by sorry

This theorem states that for any measurable space 'α', topological space 'M' and 'i' belonging to the set 'α', if for any measurable subset 'j' of 'i', the measure of 'j' according to vector measure 'v' is less than or equal to the measure of 'j' according to vector measure 'w', then the restriction of vector measure 'v' to the set 'i' is less than or equal to the restriction of vector measure 'w' to the set 'i'. In other words, if 'v' measures all measurable subsets of 'i' to be less than or equal to 'w', then the measure of 'i' itself according to 'v' is also less than or equal to its measure according to 'w'.

If for all measurable subsets j of i in measurable space α, the vector measure v(j) ≤ w(j), then v(i) ≤ w(i).


theorem MonotoneOn.convex_le :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : LinearOrderedAddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : Module 𝕜 E] [inst_4 : OrderedSMul 𝕜 E] {s : Set E} {f : E → β},
      MonotoneOn f s → Convex 𝕜 s → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ f x ≤ r} :=
  by sorry

This theorem, `MonotoneOn.convex_le`, states that for any ordered semiring `𝕜`, any linear ordered additive commutative monoid `E`, any ordered additive commutative monoid `β`, any module `E` over `𝕜`, and any ordered scalar multiplication over `E`, given a set `s` of type `E` and a function `f` from `E` to `β`, if function `f` is monotone on set `s` and set `s` is convex in `𝕜`, then for any real number `r`, the set of all elements `x` in `s` such that `f(x)` is less than or equal to `r` is also convex in `𝕜`. In other words, any sub-level set of a monotone function on a convex set retains the convex property.

If a monotone function maps a convex set to an ordered additive commutative monoid, then the sub-level sets of the function are also convex.


theorem MeasureTheory.sub_ae_eq_zero :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} [inst : AddGroup β]
      (f g : α → β), f - g =ᶠ[MeasureTheory.Measure.ae μ] 0 ↔ f =ᶠ[MeasureTheory.Measure.ae μ] g :=
  by sorry

The theorem `MeasureTheory.sub_ae_eq_zero` states that for any measurable space `α`, measure `μ` on `α`, and functions `f` and `g` from `α` to some additive group `β`, the statement "the difference between `f` and `g` equals zero almost everywhere with respect to the measure `μ`" is equivalent to saying that "`f` and `g` are equal almost everywhere with respect to the measure `μ`". Here, "almost everywhere" refers to the set of points in the space `α` outside of a subset of measure zero.

For any measurable spaces `(α, Σ)`, measures `μ`, and functions `f, g : α → add-monoid β`, the sets `{x ∈ α : f x ≠ g x}` and `{x ∈ α : f x ─ g x ≠ 0}` have zero measure with respect to `μ`. Thus, `f` and `g` are equal almost everywhere if and only if their difference is zero almost everywhere.


theorem Finite.injective_iff_surjective :
    ∀ {α : Type u_1} [inst : Finite α] {f : α → α}, Function.Injective f ↔ Function.Surjective f := by sorry

The theorem `Finite.injective_iff_surjective` states that for any type `α` that is Finite, and any function `f` from `α` to `α`, the function `f` is injective if and only if it is surjective. In mathematical terms, given a set `α` that is finite and a function `f : α → α`, the function `f` is said to be injective (meaning if `f(x) = f(y)`, then `x = y`) if and only if it is surjective (meaning for every element `b` in `α`, there exists an element `a` in `α` such that `f(a) = b`).

A function from a finite type to itself is injective if and only if it is surjective.


theorem Matrix.mul_zero :
    ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalNonAssocSemiring α]
      [inst_1 : Fintype n] (M : Matrix m n α), M * 0 = 0 :=
  by sorry

The theorem `Matrix.mul_zero` states that for any matrix `M` with entries in a type α, where α is a non-unital non-associative semiring, and the rows of `M` are indexed by type m and the columns are indexed by type n, the multiplication of `M` and the zero matrix always equals the zero matrix. Here, `M * 0 = 0` essentially says that when you multiply any matrix by the zero matrix, you get back the zero matrix, which mirrors the principle in mathematics that any number multiplied by zero equals zero. The `Fintype n` constraint expresses that the type n, which indexes the columns of the matrix, is finite.

For any finite-dimensional matrices M and O with entries in a non-unital non-associative semiring, M * O = O.


theorem MeasureTheory.upperCrossingTime_le_lowerCrossingTime :
    ∀ {Ω : Type u_1} {ι : Type u_2} [inst : ConditionallyCompleteLinearOrderBot ι] {a b : ℝ} {f : ι → Ω → ℝ} {N : ι}
      {n : ℕ} {ω : Ω}, MeasureTheory.upperCrossingTime a b f N n ω ≤ MeasureTheory.lowerCrossingTime a b f N n ω :=
  by sorry

The theorem `MeasureTheory.upperCrossingTime_le_lowerCrossingTime` asserts that for any types `Ω` and `ι`, the latter of which has the structure of a conditionally complete linear order bot, and any real numbers `a` and `b`, function `f` mapping from `ι` and `Ω` to the real numbers, any element `N` of `ι`, any natural number `n`, and any element `ω` of `Ω`, the "upper crossing time" of `f` is less than or equal to its "lower crossing time".

In other words, it's saying that the first time `f` reaches above level `b` for the `n`-th time and then dips below level `a` before time `N`, happens on or after the first time `f` reaches above level `b` for the `n`-th time.

For any conditionally complete linear order bot ι, real numbers a < b, function f : ι × Ω → ℝ, natural number n, element N ∈ ι, and ω ∈ Ω, the n-th upper crossing time of f is less than or equal to the n-th lower crossing time.


theorem Subsemiring.gc_map_comap :
    ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S),
      GaloisConnection (Subsemiring.map f) (Subsemiring.comap f) :=
  by sorry

This theorem states that for any two types `R` and `S` that are non-associative semirings, and any ring homomorphism `f` from `R` to `S`, there exists a Galois connection between the operation of mapping a subsemiring of `R` along `f` and the operation of getting the preimage of a subsemiring of `S` along `f`. In other words, if we use `f` to map a subsemiring of `R` to `S`, and then map back to `R` via the preimage, we will maintain a certain order relation. This order relation is defined by the Galois connection: the image of a subsemiring under `f` is less than or equal to a subsemiring in `S` if and only if the original subsemiring is less than or equal to the preimage of the subsemiring in `S` under `f`. This connection is a fundamental property in order theory and category theory.

Given any non-associative semirings `R` and `S` and a ring homomorphism `f` from `R` to `S`, there exists a Galois connection between the mapping of subsemirings of `R` along `f` and the mapping of preimages of subsemirings of `S` along `f`, such that for all subsemirings `X` of `R` and `Y` of `S`, `f(X) ⊆ Y` if and only if `X ⊆ f⁻¹(Y)`.


theorem Finset.noncommSum_lemma :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid β] (s : Finset α) (f : α → β),
      (Set.Pairwise ↑s fun a b => AddCommute (f a) (f b)) → Set.Pairwise {x | x ∈ Multiset.map f s.val} AddCommute :=
  by sorry

This theorem, `Finset.noncommSum_lemma`, states that for any type `α` and `β`, given `β` is an additive monoid and provided a finite set `s` of type `α` and a function `f` mapping elements from type `α` to `β`, if the function `f` applied to any two distinct elements of the set `s` satisfies the additive commutativity property (i.e., `f a + f b = f b + f a`), then the same additive commutativity property holds for any two distinct elements in the multiset obtained by applying the function `f` to each element in the multiset equivalent to set `s`. In other words, the pairwise commutativity under addition of the images under `f` of elements in `s` is preserved when considering `s` as a multiset rather than a set.

If `f : α → β` is a function mapping a finite set `s : Finset α` to an additive monoid `β`, and `f` satisfies `f a + f b = f b + f a` for all distinct `a, b ∈ s`, then the same commutativity property holds for any distinct `a, b` in the multiset obtained from `s` under `f`.


Symmetric.comap

theorem Symmetric.comap :
    ∀ {α : Type u_1} {β : Type u_2} {r : β → β → Prop}, Symmetric r → ∀ (f : α → β), Symmetric (r on f) := by sorry

The theorem `Symmetric.comap` states that for any two types `α` and `β`, and a relation `r` on `β` that is symmetric, for any function `f` from `α` to `β`, the relation `r` composed with `f` (denoted by `r on f`), is also symmetric. In other words, if `x` and `y` are any two elements of `α`, and `r` holds between `f(x)` and `f(y)`, then `r` also holds between `f(y)` and `f(x)`. This theorem extends the symmetric property of a relation to the function's image under this relation.

In mathematical terms, if `r` is a symmetric relation in the sense that whenever `r(x, y)` holds then `r(y, x)` holds, then the image of this relation under any function `f: α → β` is also symmetric.

If `r` is a symmetric relation on `β` and `f` is a function from `α` to `β`, then the relation `r` composed with `f` (denoted `r on f`) is symmetric. That is, if `r(f(x), f(y))` holds, then `r(f(y), f(x))` holds for all `x, y` in `α`.


/-- A map out of a sum type is continuous if its restriction to each summand is.  -/
theorem continuous_sigma :
    ∀ {X : Type u} {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)]
      [inst_1 : TopologicalSpace X] {f : Sigma σ → X},
      (∀ (i : ι), Continuous fun a => f { fst := i, snd := a }) → Continuous f :=
  by sorry

This theorem states that a function `f` from a sum type `Sigma σ` to a type `X` is continuous if its restriction to each component type (or summand) `σ i` is continuous. Here, `X` and each `σ i` are equipped with topological space structures. The sum type `Sigma σ` is a dependent type, which can be thought of as a type of "tagged" or "labeled" elements, with each label coming from the type `ι` and each element being from the corresponding type `σ i`.

A function from a dependent sum type to a topological space is continuous if and only if its restriction to each summand is continuous.


theorem Cardinal.toPartENat_natCast : ∀ (n : ℕ), Cardinal.toPartENat ↑n = ↑n := by sorry

This theorem states that for any natural number `n`, the function `Cardinal.toPartENat` when applied to the cardinal number corresponding to `n` (denoted by `↑n`), yields the partial extended natural number also corresponding to `n` (also denoted by `↑n`). In essence, this theorem asserts that the `Cardinal.toPartENat` function behaves as expected when dealing with finite cardinals that originate from natural numbers, mapping them to their corresponding partial extended natural numbers.

For any natural number `n`, the function `Cardinal.toPartENat (↑n) = ↑n` holds in Lean 4.


List.IsRotated.perm

theorem List.IsRotated.perm : ∀ {α : Type u} {l l' : List α}, l ~r l' → List.Perm l l' := by sorry

This theorem states that for any type `α` and any two lists `l` and `l'` of this type, if `l` is a rotation of `l'` (denoted `l ~r l'`), then `l` is a permutation of `l'` (denoted `List.Perm l l'`). In other words, if one list can be obtained by rotating another list, then the two lists contain the same elements, but possibly in a different order.

If two lists `l` and `l'` of type `α` are rotations of each other, then they are permutations of each other.


/-- All the `P q` coincide with `𝟙 _` in degree 0.  -/
theorem AlgebraicTopology.DoldKan.P_f_0_eq :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} (q : ℕ),
      (AlgebraicTopology.DoldKan.P q).f 0 =
        CategoryTheory.CategoryStruct.id ((AlgebraicTopology.AlternatingFaceMapComplex.obj X).X 0) :=
  by sorry

The theorem `AlgebraicTopology.DoldKan.P_f_0_eq` asserts that for any simplicial object `X` in a category `C` (which is a category and preadditive), the morphism `f` at index 0 of the `P` functor applied to any natural number `q` is equivalent to the identity morphism acting on `X` at index 0 in the alternating face map complex. In other words, all the `P(q)` coincide with the identity morphism when evaluated at degree 0. The alternating face map complex is a chain complex constructed from the simplicial object.

For any simplicial object X in a preadditive category C, the identity morphism at index 0 of the `P` functor's application to X coincides with the alternating face map at index 0 in the complex formed by the `P` functor.


/-- **Alias** of the forward direction of `dense_iff_inter_open`.

---

A set is dense if and only if it has a nonempty intersection with each nonempty open set.  -/
theorem Dense.inter_open_nonempty :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X],
      Dense s → ∀ (U : Set X), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s) :=
  by sorry

The theorem `Dense.inter_open_nonempty` states that for any type `X` and set `s` within a topological space, if `s` is dense, then for any set `U` that is open and nonempty, the intersection of `U` and `s` is also nonempty. In other words, a set is dense in a topological space if it intersects every nonempty open set in a nonempty way.

If `s` is a dense subset of a topological space `X`, then for any open and nonempty set `U` in `X`, the intersection `U ∩ s` is nonempty.


theorem Complex.inv_im : ∀ (z : ℂ), z⁻¹.im = -z.im / Complex.normSq z := by sorry

The theorem `Complex.inv_im` states that for any complex number `z`, the imaginary part of the inverse of `z` is equal to the negation of the imaginary part of `z` divided by the square of the norm of `z`. Here, the norm of a complex number `z` is defined as the sum of the squares of its real and imaginary parts, and the inverse of `z` is the complex number which multiplied by `z` gives the number 1.

The imaginary part of the complex number inverse to `z` is equal to -(imaginary part of `z`) / (norm of `z`)² for any complex number `z`.


theorem BoxIntegral.Box.upper_mem : ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), I.upper ∈ I := by sorry

This theorem states that for any box `I` of any type `ι`, the upper bound of the box `I` is an element of the box `I`. In mathematical terms, if `I` is an interval in a Euclidean space (or more generally, a product of intervals), its "upper" bound (one of its endpoints) is considered a point in `I`.

For any interval `I` in a Euclidean space, the upper bound of `I` is an element of `I`.


theorem pow_lt_pow_iff_right :
    ∀ {R : Type u_3} [inst : StrictOrderedSemiring R] {a : R} {n m : ℕ}, 1 < a → (a ^ n < a ^ m ↔ n < m) := by sorry

This theorem states that for any type `R` which is a Strict Ordered Semiring, given natural numbers `n` and `m` and an element `a` of `R` such that `a` is greater than 1, `a` raised to the power `n` is less than `a` raised to the power `m` if and only if `n` is less than `m`. In other words, in a Strict Ordered Semiring, for a number `a` greater than 1, a lower exponent results in a smaller result when used as a power of `a`.

For any strict ordered semiring R and natural numbers n, m, and element a > 1 in R, a^n < a^m if and only if n < m.


AddCon.refl

/-- Additive congruence relations are reflexive. -/
theorem AddCon.refl : ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) (x : M), c x x := by sorry

This theorem states that additive congruence relations are reflexive for any type `M` with the addition operation. In other words, for any given type `M`, a specified additive congruence relation `c` on `M`, and an element `x` of type `M`, `x` is always congruent to itself under the relation `c`. This is a property of reflexive relations, which assert, in this case, that any element in an additive structure is congruent to itself.

For any additive type M and congruence relation c on M, x ≡x (mod c) holds for all x in M. (Here, ≡ denotes congruence relation.)


theorem uniformity_prod :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β],
      uniformity (α × β) =
        Filter.comap (fun p => (p.1.1, p.2.1)) (uniformity α) ⊓ Filter.comap (fun p => (p.1.2, p.2.2)) (uniformity β) :=
  by sorry

The theorem `uniformity_prod` states that for any two types `α` and `β` that are equipped with a uniform space structure, the uniformity (which is a filter on the product `α × β`) is equal to the infimum (or greatest lower bound) of the filter obtained by composing the uniformity of `α` with the function that projects onto the first coordinate of both components of a pair, and the filter obtained by composing the uniformity of `β` with the function that projects onto the second coordinate of both components of a pair. Essentially, this theorem describes how the uniformity of a product space is related to the uniformities of the component spaces.

The uniformity of a product of uniform spaces is the infimum of the uniformity induced by the projection onto the first coordinate and the uniformity induced by the projection onto the second coordinate.


theorem MeasureTheory.SimpleFunc.mem_range :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {b : β},
      b ∈ MeasureTheory.SimpleFunc.range f ↔ b ∈ Set.range ↑f :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.mem_range` states that for any types `α` and `β`, with `α` being a measurable space, and any simple function `f` from `α` to `β`, and any element `b` of type `β`, `b` is in the range of the simple function `f` (expressed as a finite set) if and only if `b` is in the image of the function `f` over its entire domain (expressed as a set). In other words, it's asserting that the range of a simple function `f` and the set of images of `f` over its entire domain are the same.

For any measurable space (α, Σ), simple function f : α → β, and b ∈ β, b is in the range of f if and only if b is in the image of f.


MeasureTheory.Martingale.integrable

theorem MeasureTheory.Martingale.integrable :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0},
      MeasureTheory.Martingale f ℱ μ → ∀ (i : ι), MeasureTheory.Integrable (f i) μ :=
  by sorry

The theorem `MeasureTheory.Martingale.integrable` states that for any given preorder ι, measurable space Ω, measure μ on Ω, normed addition commutative group E over real numbers, and a complete normed space E, if there exists a function `f` from ι to Ω to E and a filtration `ℱ` on ι such that `f` is a martingale with respect to `ℱ` and μ, then the function `f` at any index `i` from ι is integrable with respect to μ. In other words, `f` at `i` is measurable and the integral of the norm of `f` at `i` with respect to μ is finite.

If `f` is a martingale with respect to filtration `ℱ` and measure `μ` on measurable space `(Ω, Σ)` over complete normed space `E` over real numbers, then each `f(i)` is integrable with respect to `μ`, i.e., both measurable and the integral of the norm of `f(i)` is finite.


theorem Function.update_eq_iff :
    ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {a : α} {b : β a} {f g : (a : α) → β a},
      Function.update f a b = g ↔ b = g a ∧ ∀ (x : α), x ≠ a → f x = g x :=
  by sorry

The `Function.update_eq_iff` theorem states that for any types `α` and `β`, given `α` has decidable equality, for any elements `a` of type `α` and `b` of type `β a`, and for any two functions `f` and `g` from `α` to `β`, the function resulting from updating `f` at `a` with `b` is equal to `g` if and only if `b` is equal to the value of `g` at `a` and for every `x` in `α` not equal to `a`, the values of `f` and `g` at `x` are the same.

For functions `f` and `g` from a decidably equated type `α` to type `βα`, `Function.update f a b = g a ∧ ∀ x ≠ a, f x = g x` if and only if `b = g a`.


theorem MulAction.mem_stabilizer_iff :
    ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {a : α} {g : G},
      g ∈ MulAction.stabilizer G a ↔ g • a = a :=
  by sorry

The theorem `MulAction.mem_stabilizer_iff` states that for any group `G`, any type `α` equipped with a `MulAction` of `G`, any element `a` of `α`, and any group element `g` of `G`, `g` is a member of the stabilizer of `a` under the action of `G` if and only if the action of `g` leaves `a` unchanged, i.e., `g` acting on `a` equals `a`. In other words, it establishes the equivalence between an element being in the stabilizer of `a` and the action of that element on `a` resulting in `a` itself.

For any group `G` acting on a type `α` via a `MulAction`, an element `g` in `G` is in the stabilizer of `α` element `a` if and only if `g` leaves `a` unchanged under the action, i.e., `g * a = a`.


theorem le_of_nhds_le_nhds : ∀ {α : Type u_1} {t₁ t₂ : TopologicalSpace α}, (∀ (x : α), nhds x ≤ nhds x) → t₁ ≤ t₂ := by
  sorry

This theorem states that for any type 'α', and any two topological spaces 't₁' and 't₂' over 'α', if for all elements 'x' of type 'α', the neighborhood of 'x' in 't₁' is a subset of the neighborhood of 'x' in 't₂', then 't₁' is a subset of 't₂'. In mathematical terms, if for every 'x' in 'α', every neighborhood of 'x' in space 't₁' is also a neighborhood in space 't₂', then 't₁' is subsumed by (or is smaller than or equal to) 't₂' in the lattice of topological spaces on 'α'. The neighborhood of a point 'x' is a set that contains an open set around 'x'.

If for all x in α, the neighborhood filter of x in t₁ is contained in the neighborhood filter of x in t₂, then t₁ is a subspace of t₂.


theorem Multiset.zero_le : ∀ {α : Type u_1} (s : Multiset α), 0 ≤ s := by sorry

The theorem `Multiset.zero_le` states that for all multiset `s` of any type `α`, the empty multiset `0` is less than or equal to `s`. In other words, this theorem asserts that any multiset, may it be empty or not, is always greater than or equal to the empty multiset.

For all multisets `s` of type `α`, the empty multiset `0` is less than or equal to `s`. (In mathematical notation: `0 ≤ s` for all multisets `s`.)


theorem Set.kernImage_eq_compl :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Set.kernImage f s = (f '' sᶜ)ᶜ := by sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `α`, the kernel image of `f` and `s` is equal to the double complement of the image of the complement of `s` under `f`. In other words, the set of all `β`-values `y` such that all preimages of `y` under `f` are within `s`, is the same as the set of all `β`-values that are not mapped to by `f` from outside `s`.

The kernel of a function `f` from type `α` to type `β` applied to a set `s` of type `α` is equal to the complement of the image of the complement of `s` under `f`.