theorem Set.ordConnected_Ici : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.OrdConnected (Set.Ici a) := by sorry

This theorem states that for any type `α` with a preorder relation, and any element `a` of the type `α`, the set of all elements `x` such that `a ≤ x` (represented as `Set.Ici a`) is order-connected. In other words, for any two elements `b` and `c` in the set where `b ≤ c` , all elements `x` between `b` and `c` (inclusive) are also in the set.

For any type `α` with a preorder relation and any element `a` in `α`, the set `{x : α | x ≤ a}` is order-connected.


theorem Ordinal.lt_omega : ∀ {o : Ordinal.{u_1}}, o < Ordinal.omega ↔ ∃ n, o = ↑n := by sorry

The theorem `Ordinal.lt_omega` states that for all ordinals 'o', 'o' is less than the first infinite ordinal (denoted as 'ω' in Lean 4) if and only if there exists a natural number 'n' such that 'o' is equal to the ordinal representation of 'n'. Here, the first infinite ordinal 'ω' is defined as the order type of the set of natural numbers.

For every ordinal 'o', 'o' is strictly less than the first infinite ordinal 'ω' if and only if there exists a natural number 'n' such that 'o' is the ordinal representation of 'n'.


theorem Num.cast_to_nat : ∀ {α : Type u_1} [inst : AddMonoidWithOne α] (n : Num), ↑↑n = ↑n := by sorry

This theorem, `Num.cast_to_nat`, states that for any type `α` which is an additive monoid with a distinct one (i.e., it supports an addition operation and has an element identified as one), the double cast from an instance of the `Num` type to `α` through a natural number (notated as `↑↑n`) is equivalent to a direct cast from `Num` to `α` (notated as `↑n`). Essentially, it assures that the intermediate casting step to a natural number doesn't alter the final result of the cast.

For any additive monoid with a distinct one `α` and instance of `Num`, the double cast from `Num` to `α` through a natural number is equal to a direct cast from `Num` to `α`.


theorem MeasureTheory.Measure.prod_swap :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν]
      [inst_3 : MeasureTheory.SFinite μ],
      MeasureTheory.Measure.map Prod.swap (MeasureTheory.Measure.prod μ ν) = MeasureTheory.Measure.prod ν μ :=
  by sorry

The `MeasureTheory.Measure.prod_swap` theorem states that for any two types `α` and `β`, which are measurable spaces, and two measures `μ` and `ν` on these spaces that are sigma-finite, the measure of the swapped product pair `(b, a)` is the same as the measure of the original product pair `(a, b)`. In other words, the measure of the product space when `μ` is applied to `α` and `ν` is applied to `β` remains the same even if `α` and `β` are swapped, assuming the measure `map` is applied to the swap of the product pair.

For measurable spaces `(α, Σα, μ)` and `(β, Σβ, ν)` with sigma-finite measures, `μ ⊗ ν` on `(α × β, Σα × Σβ)` equals `ν ⊗ μ` on `(β × α, Σβ × Σα)`.


theorem AddCommGroup.modEq_rfl : ∀ {α : Type u_1} [inst : AddCommGroup α] {p a : α}, a ≡ a [PMOD p] := by sorry

This theorem states that, for all elements `a` of an additive commutative group `α`, `a` is congruent to `a` modulo `p`. In mathematical terms, this means that the difference between `a` and `a`, which is zero, is divisible by `p` for any `p` in `α`. This is a fundamental property of modular arithmetic, reflecting the fact that every number is congruent to itself modulo any number.

For all elements `a` in an additive commutative group `α`, `a` is congruent to `a` modulo any `p` in `α` (i.e., `a` is congruent to `a` mod `p`).


theorem subset_exterior : ∀ {α : Type u_3} [inst : TopologicalSpace α] {s : Set α}, s ⊆ exterior s := by sorry

This theorem states that, for any set `s` within a topological space `α`, the set `s` is a subset of its exterior. In other words, every element in `s` is also in the exterior of `s`. This holds for all types `α` that have a topological space structure. In terms of topology, the "exterior" of a set is the intersection of all its neighborhoods, or in an Alexandrov-discrete space, it is the smallest neighborhood of the set. Therefore, this theorem asserts a fundamental property of set's exterior in the context of topology.

In any topological space, every set is a subset of its exterior.


theorem ne_bot_of_le_ne_bot :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, b ≠ ⊥ → b ≤ a → a ≠ ⊥ := by sorry

This theorem states that for any type `α` which has a partial order and a least element (denoted by `⊥`), if `b` is not equal to this least element (`⊥`) and `b` is less than or equal to `a`, then `a` is also not equal to the least element (`⊥`). The theorem essentially says that if `a` is greater than or equal to an element that is not the smallest possible, then `a` cannot be the smallest possible element itself.

If `α` is a type with a partial order and a least element `⊥`, then for all `a` and `b` in `α`, if `b ≤ a` and `b ≠ ⊥`, then `a ≠ ⊥`.


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

The theorem `Filter.map_comap_le` states that for any types `α` and `β`, any filter `g` on `β`, and any function `m` from `α` to `β`, the map of the filter obtained by first co-mapping `g` through `m` and then mapping it through `m` is less than or equal to `g`. In other words, if we first pull `g` back through `m` and then push it forward again, we will get a filter that's a "subset" of (or equal to) our original filter `g`. It represents a fundamental property of filters related to function mappings.

 For any filter \(g\) on type \(\beta\), function \(m : \alpha \to \beta\), and \(F : \Set (\Subset \beta)\), \(F = \downarrow\!\circ m \circ g \uparrow \iff F \subseteq g\).

In other words, the filter obtained by first lifting \(g\) through \(m\) and then pushing it back down is a subset of \(g\).


theorem iInf_subtype'' :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Type u_9} (s : Set ι) (f : ι → α), ⨅ i, f ↑i = ⨅ t ∈ s, f t := by
  sorry

This theorem states that for any complete lattice `α` of some type `u_1`, and for any set `s` of type `ι`, the function `f` mapping elements of `ι` to `α`, the infimum (greatest lower bound) over all `i` of `f` applied to the elements of `ι` in the set `s` is equal to the infimum over all elements `t` in the set `s` of `f` applied to `t`. In other words, it asserts the equality of two different ways of calculating the infimum of a function applied to the elements of a set, one using the direct elements and the other using their subtype representation.

For any complete lattice `α` and set `s` of index type `ι`, the infimum of a function `f` from `ι` to `α` over `s` equals the infimum of the images of elements in `s` under `f`.


theorem Int.ne_of_gt : ∀ {a b : ℤ}, b < a → a ≠ b := by sorry

This theorem states that for any two integers `a` and `b`, if `b` is less than `a`, then `a` is not equal to `b`. The `∀` symbol indicates that this rule applies for all possible integers `a` and `b`. The `→` symbol is an implication, meaning that `b < a` being true directly implies `a ≠ b` is also true.

For all integers `a` and `b`, if `b` is less than `a`, then `a` is not equal to `b`. In mathematical notation: `∀ (a b: ℤ), b < a → a ≠ b`.


/-- A family `𝓕 : ι → β → α` is uniformly equicontinuous iff the function `swap 𝓕 : β → ι → α` is
uniformly continuous *when `ι → α` is equipped with the uniform structure of uniform convergence*.
This is very useful for developping the equicontinuity API, but it should not be used directly
for other purposes.  -/
theorem uniformEquicontinuous_iff_uniformContinuous :
    ∀ {ι : Type u_1} {α : Type u_7} {β : Type u_9} [uα : UniformSpace α] [uβ : UniformSpace β] {F : ι → β → α},
      UniformEquicontinuous F ↔ UniformContinuous (⇑UniformFun.ofFun ∘ Function.swap F) :=
  by sorry

The theorem `uniformEquicontinuous_iff_uniformContinuous` states that a family of functions `𝓕`, mapping from a type `ι` to a function from `β` to `α`, is uniformly equicontinuous if and only if the function obtained by swapping the arguments of `𝓕` (thus mapping from `β` to a function from `ι` to `α`) is uniformly continuous when `ι → α` is equipped with the uniform structure of uniform convergence. This theorem is useful for developing the equicontinuity API in Lean, but it is not recommended to use it directly for other purposes. Here, uniform equicontinuity means that given any entourage (a certain kind of set) `U` in the uniformity of `α`, there exists an entourage `V` in the uniformity of `β` such that if `x` and `y` are `V`-close, then for all `i` in `ι`, `𝓕 i x` is `U`-close to `𝓕 i y`. Uniform continuity of a function `f` from `α` to `β` requires that `(f x, f y)` tends to the diagonal as `(x, y)` tends to the diagonal, i.e., if `x` is sufficiently close to `y`, then `f x` is close to `f y` no matter where `x` and `y` are located in `α`.

A family of functions from a type to functions from another type is uniformly equicontinuous if and only if the function obtained by swapping the arguments is uniformly continuous in the uniform structure of uniform convergence.


theorem MeasureTheory.ae_eq_set_inter :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t s' t' : Set α},
      s =ᶠ[MeasureTheory.Measure.ae μ] t →
        s' =ᶠ[MeasureTheory.Measure.ae μ] t' → s ∩ s' =ᶠ[MeasureTheory.Measure.ae μ] t ∩ t' :=
  by sorry

This theorem is about sets and measure theory in the context of mathematics. It states that for any type `α` equipped with a `MeasurableSpace` structure and a measure `μ` on it, and for any four sets `s`, `t`, `s'`, and `t'` of type `α`, if `s` is almost everywhere equal to `t` with respect to the `μ` measure, and if `s'` is almost everywhere equal to `t'` with respect to the same `μ` measure, then the intersection of `s` and `s'` is almost everywhere equal to the intersection of `t` and `t'` with respect to measure `μ`.

In mathematical terms, this theorem asserts that if two sets are almost everywhere equal under a given measure, the same holds true for their intersections with another two sets that are also almost everywhere equal under the same measure. This property is of significant importance in measure theory, a branch of mathematics that studies notions of the size, length, volume, and generalizations.

If sets `s`, `t`, `s'`, and `t'` in a measurable space with measure `μ` are pairwise almost equal, then their intersections `s ∩ s'` and `t ∩ t'` are almost equal with respect to `μ`.


theorem Complex.exp_ne_zero : ∀ (x : ℂ), Complex.exp x ≠ 0 := by sorry

This theorem states that the complex exponential function is never zero for any complex number. In other words, for all complex numbers `x`, the result of applying the complex exponential function to `x` (`Complex.exp x`) is always non-zero.

The complex exponential function, `Complex.exp`, never returns the zero value for any complex argument.


theorem Sbtw.ne_right :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Sbtw R x y z → y ≠ z :=
  by sorry

The theorem `Sbtw.ne_right` states that for any ordered ring `R`, additive commutative group `V`, and additive torsor `P`, and for any points `x`, `y`, and `z` in `P`, if `y` is strictly between `x` and `z` (in the sense defined by `Sbtw`), then `y` is not equal to `z`.

If `x`, `y`, and `z` are points in an additive torsor `P` over an ordered ring `R`, and `y` is strictly between `x` and `z`, then `y` is not equal to `z`.


theorem Polynomial.ofFinsupp_single :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (r : R), { toFinsupp := fun₀ | n => r } = (Polynomial.monomial n) r := by
  sorry

The theorem `Polynomial.ofFinsupp_single` states that for any semiring `R`, any natural number `n`, and any element `r` of `R`, the polynomial with coefficient function `fun₀ | n => r` (which assigns the value `r` to the `n`th degree and zero otherwise) is equal to the polynomial obtained by applying the monomial operator `Polynomial.monomial n` to the element `r`. This monomial operator creates a polynomial that has `r` as the coefficient of the `n`th degree term, and zero coefficients for all other degrees.

For any semiring R and natural number n, the polynomial with degree n equal to R, and all other coefficients zero, is equal to the monomial polynomial of degree n with coefficient R.


theorem Mathlib.Combinatorics.SimpleGraph.Maps._auxLemma.2 :
    ∀ {V : Type u_1} {W : Type u_2} {u v : V} {G : SimpleGraph W} {f : V → W},
      (SimpleGraph.comap f G).Adj u v = G.Adj (f u) (f v) :=
  by sorry

This theorem states that for any types `V` and `W`, any vertices `u` and `v` of type `V`, any simple graph `G` of type `W`, and any function `f` from `V` to `W`, the adjacency in the graph induced by the function `f` from `G` on the vertices `u` and `v` is the same as the adjacency in the original graph `G` between the images of `u` and `v` under the function `f`. In other words, a function `f` induces a simple graph on `V` from a simple graph on `W` by preserving the adjacency relation.

For any simple graphs G on type W, functions f from type V to W, and vertices u, v of type V, the adjacency relation between u and v in the graph induced by f from G holds if and only if the images of u and v under f are adjacent in G.


ClosureOperator.idempotent

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

This theorem states that for any type `α` that has a partial order, and for any closure operator `c` defined on that type, applying `c` twice to any element `x` of type `α` is the same as applying `c` once. In other words, the closure operator `c` is idempotent: for every `x` in `α`, `c(c(x))` equals `c(x)`. This is a property common to many mathematical operators, such as the closure of a set in topology.

For any partial order type `α` and closure operator `c` on `α`, `c(c(x)) = c(x)` for all `x` in `α`.


theorem AddSemigroup.mem_center_iff :
    ∀ {M : Type u_1} [inst : AddSemigroup M] {z : M}, z ∈ Set.addCenter M ↔ ∀ (g : M), g + z = z + g := by sorry

This theorem states that for any type `M` with an addition operation (forming an additive semigroup), an element `z` of `M` is in the set of central elements (as defined by the `Set.addCenter` function) if and only if it commutes under addition with every element `g` of `M`. In other words, `z` is central if for every `g` in `M`, the equation `g + z = z + g` holds.

For any additive semigroup `M`, an element `z` is in the center of `M` if and only if `z` commutes with every element `g` in `M`, i.e., `g + z = z + g` for all `g` in `M`.


theorem sub_sub_eq_add_sub : ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b c : α), a - (b - c) = a + c - b := by
  sorry

The theorem `sub_sub_eq_add_sub` states that for any type `α` that forms a subtraction monoid (i.e., a set equipped with an associative binary operation and an identity element), and for any three elements `a`, `b`, and `c` of this type, the operation of subtracting `b - c` from `a` is equivalent to adding `c` to `a` and then subtracting `b`. In mathematical notation, this can be written as `a - (b - c) = a + c - b`.

For any type `α` forming a subtraction monoid and any elements `a`, `b`, and `c` of `α`, `a - (b - c)` is equivalent to `a + c - b`.


theorem Real.sign_of_pos : ∀ {r : ℝ}, 0 < r → Real.sign r = 1 := by sorry

This theorem states that for any real number `r`, if `r` is greater than 0, then the sign of `r` (as determined by the `Real.sign` function) is 1. In other words, the sign function returns 1 for all positive real numbers.

For all real numbers `r` greater than 0, `Real.sign r = 1`.


theorem unitInterval.continuous_symm : Continuous unitInterval.symm := by sorry

This theorem states that the function `unitInterval.symm`, which represents the central symmetry on the unit interval (mapping each point to its "mirror image" around the midpoint 0.5), is a continuous function. In more mathematical terms, for any point `t` in the unit interval, the function that maps `t` to `1 - t` is continuous on the entire interval [0,1].

The central symmetry function `unitInterval.symm` (mapping `t` to `1 - t`) is a continuous function on the unit interval [0,1].


theorem Monoid.order_dvd_exponent : ∀ {G : Type u} [inst : Monoid G] (g : G), orderOf g ∣ Monoid.exponent G := by sorry

The theorem `Monoid.order_dvd_exponent` asserts that for any type `G` and its instance of a `Monoid`, for any element `g` of `G`, the order of `g` divides the exponent of the `Monoid`. In other words, if `n` is the smallest positive integer such that `g^n = 1` (the order of `g`) and `m` is the smallest positive integer such that for all `x` in `G`, `x^m = 1` (the exponent of the Monoid), then `n` divides `m`. This means that `m` is a multiple of `n` in the set of natural numbers.

For any Monoid `G` and its identity element `e`, the order of any element `g` in `G` divides the exponent of `G`, i.e., the order of `g` is a divisor of the order of the identity element.


theorem Array.size_toArray : ∀ {α : Type u_1} (as : List α), Array.size (List.toArray as) = List.length as := by sorry

This theorem states that for any list of elements of some type α (denoted as `as`), when we convert this list to an array using the `List.toArray` function, the size of the resulting array (as computed by the `Array.size` function) is equal to the length of the original list (as computed by the `List.length` function). In other words, converting a list to an array preserves its length or size. This theorem is a basic property that helps in understanding the relationship between lists and arrays in Lean 4.

For any list `as : List α`, the size of `Array.toArray as` equals the length of `as`.


theorem Set.singleton_zero : ∀ {α : Type u_2} [inst : Zero α], {0} = 0 := by sorry

This theorem, `Set.singleton_zero`, states that for any type `α` that has a `Zero` instance, the singleton set containing just the `0` element (denoted as `{0}`) is equal to `0`. In other words, it expresses the equivalence between the singleton set of the zero element and the zero element itself in the context of any type that has a zero instance.

For any type `α` with a `Zero` instance, the singleton set `{0}` is equal to the zero element `0`.


Subtype.mk.inj

theorem Subtype.mk.inj :
    ∀ {α : Sort u} {p : α → Prop} {val : α} {property : p val} {val_1 : α} {property_1 : p val_1},
      { val := val, property := property } = { val := val_1, property := property_1 } → val = val_1 :=
  by sorry

The theorem `Subtype.mk.inj` states that for any sort `α`, any predicate `p` on `α`, and any two values `val` and `val_1` of type `α` that satisfy the predicate `p`, if two subtypes created with these pairs of values and proofs are equal, then the original values `val` and `val_1` must also be equal. In other words, the constructor for a subtype is injective, meaning it produces a unique subtype for each unique pair of a value and a proof that the value satisfies the predicate.

If `α` is a sort, `p` is a predicate on `α`, and `val` and `val_1` are values of type `α` satisfying `p`, then the equality of their corresponding subtypes `{x : α | p x} with (val, rfl) = {x : α | p x} with (val_1, rfl)` implies `val = val_1`.


theorem IsPrimitiveRoot.pow_of_coprime :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M},
      IsPrimitiveRoot ζ k → ∀ (i : ℕ), Nat.Coprime i k → IsPrimitiveRoot (ζ ^ i) k :=
  by sorry

This theorem states that for any type `M` with a commutative monoid structure, given any natural number `k` and any element `ζ` of type `M` that is a primitive root of `k`, if `i` is a natural number that is coprime with `k` (i.e., the greatest common divisor of `i` and `k` is 1), then `ζ` to the power `i` is also a primitive root of `k`.

If `M` is a commutative monoid with an element `ζ` that is a primitive root of natural number `k`, and `i` is a natural number coprime to `k`, then `ζ^i` is also a primitive root of `k`.


theorem Finset.sup'_cons :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α) {b : β}
      {hb : b ∉ s}, Finset.sup' (Finset.cons b s hb) ⋯ f = f b ⊔ Finset.sup' s H f :=
  by sorry

The theorem `Finset.sup'_cons` states that for any types `α` and `β` with `α` being a join-semilattice, any nonempty finite set `s` of type `β`, any function `f` from `β` to `α`, and any element `b` of `β` not belonging to `s`, the supremum of the image under `f` of the set created by adding `b` to `s` is the supremum of `f(b)` and the supremum of the image under `f` of `s`. In mathematical terms, if we consider `f` as a function mapping elements of `s` to a join-semilattice `α`, then the supremum of the image of `s ∪ {b}` under `f` is equal to `f(b) ⊔ sup(f(s))`, where `⊔` is the join operation in the semilattice.

For any join-semilattice `α`, function `f` from a nonempty finite set `s` in `β` to `α`, and element `b` not in `s`, the supremum of `f(s ∪ {b})` equals the join of `f(b)` and the supremum of `f(s)`.


theorem mul_lt_mul_of_lt_of_lt :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b c d : α},
      a < b → c < d → a * c < b * d :=
  by sorry

The theorem `mul_lt_mul_of_lt_of_lt` states that for any type `α` equipped with a multiplication, a preorder, and satisfying two covariance conditions, if `a` and `b` are elements of `α` with `a < b`, and `c` and `d` are also elements of `α` with `c < d`, then the product `a * c` is less than the product `b * d`.

The two covariance conditions ensure that multiplication behaves well with the order: the first says that if `x < x_1` then `x * y < x_1 * y` for any `y`, and the second says that if `x < x_1` then `y * x < y * x_1` for any `y`. These conditions, along with the preorder structure, allow us to reason about the order of products in `α`.

For any type `α` with a multiplication operation and a preorder satisfying the covariance conditions `x < x_1 → x * y < x_1 * y` and `x < x_1 → y * x < y * x_1`, if `a < b` and `c < d`, then `a * c < b * d`.


Set.LeftInvOn.injOn

theorem Set.LeftInvOn.injOn :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {f₁' : β → α}, Set.LeftInvOn f₁' f s → Set.InjOn f s := by
  sorry

This theorem states that for any types `α` and `β`, any set `s` of type `α`, and any two functions `f` and `f₁'` from `α` to `β` and `β` to `α` respectively, if `f₁'` is a left inverse to `f` on `s` (meaning that for any `x` in `s`, `f₁'(f(x))` equals `x`), then `f` is injective on `s`. That is, for any two elements `x₁` and `x₂` in `s`, if `f(x₁)` equals `f(x₂)`, then `x₁` must equal `x₂`. This essentially says that if a function `f` has a left inverse on a set, it can't map two different elements of the set to the same value.

If a function `f` from type `α` to type `β` has a left inverse on a set `s` of type `α`, then `f` is injective on `s` (i.e., for any `x₁, x₂` in `s`, `x₁ = x₂` implies `f(x₁) = f(x₂)`).


theorem Int.emod_emod : ∀ (a b : ℤ), a % b % b = a % b := by sorry

This theorem states that for any two integers 'a' and 'b', the modulus of 'a' with respect to 'b', taken modulus 'b' again, is equal to the modulus of 'a' with respect to 'b'. In other words, if you take the remainder of 'a' divided by 'b', and then find the remainder of that result divided by 'b' again, you'll just get the remainder of 'a' divided by 'b'. Mathematically, this can be represented as: `(a mod b) mod b = a mod b`.

For any integers 'a' and 'b', the repeated application of the modulo operation, i.e., `(a mod b) mod b`, is equal to `a mod b`.


theorem norm_add_le_of_le :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {a₁ a₂ : E} {r₁ r₂ : ℝ},
      ‖a₁‖ ≤ r₁ → ‖a₂‖ ≤ r₂ → ‖a₁ + a₂‖ ≤ r₁ + r₂ :=
  by sorry

The theorem `norm_add_le_of_le` states that for any type `E` that has a structure of a seminormed addition group, given two elements `a₁` and `a₂` of `E`, and two real numbers `r₁` and `r₂`, if the norm of `a₁` is less than or equal to `r₁` and the norm of `a₂` is less than or equal to `r₂`, then the norm of the sum `a₁ + a₂` is less than or equal to the sum `r₁ + r₂`. This is essentially a statement about the triangle inequality in the context of seminormed addition groups.

For any seminormed addition group (E, +, ||.||) and elements a₁, a₂ in E, and real numbers r₁, r₂ such that ||a₁|| ≤ r₁ and ||a₂|| ≤ r₂, it holds that ||a₁ + a₂|| ≤ r₁ + r₂.


MeasureTheory.StronglyMeasurable.mul

theorem MeasureTheory.StronglyMeasurable.mul :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Mul β]
      [inst_2 : ContinuousMul β],
      MeasureTheory.StronglyMeasurable f →
        MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable (f * g) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.mul` states that if we have two functions `f` and `g` from a type `α` to a type `β` (where `α` is a measurable space, `β` is a topological space, and `β` also has a multiplication operation that is continuous), and if both of these functions are strongly measurable (i.e., each can be approximated by a sequence of simple functions), then their product function `f * g` is also strongly measurable. In mathematical terms, this theorem states that the set of strongly measurable functions is closed under multiplication, assuming the multiplication operation is continuous.

If `f` and `g` are strongly measurable functions from a measurable space `α` to a topological space `β` with a continuous multiplication operation, then their product `f * g` is also strongly measurable.


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

This theorem, `and_right_comm`, states that for any three propositions `a`, `b`, and `c`, the proposition "(a AND b) AND c" is logically equivalent to the proposition "(a AND c) AND b". That is, within a two-level conjunction (logical AND), the right-side elements can be commutatively swapped without changing the truth value of the overall proposition.

The theorem `and_right_comm` asserts that for all propositions a, b, and c, (a And b) And c is logically equivalent to (a And c) And b.


theorem Derivation.map_one_eq_zero :
    ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
      [inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
      (D : Derivation R A M), D 1 = 0 :=
  by sorry

This theorem states that for any derivation `D` from a commutative semiring `A` to an additive commutative monoid `M`, both with a common scalar field `R`, the derivation of the multiplicative identity (1) in `A` is the additive identity (0) in `M`. This holds under the conditions that `A` is an algebra over `R` and `M` is a module over both `R` and `A`.

For any derivation from a commutative semiring with scalar field, into an additive commutative `R`-module, the multiplicative identity derives to the additive identity. (Assumes the semiring is an `R`-algebra and the module is an `A`-module.)


theorem Homeomorph.symm_apply_apply :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (x : X),
      (Homeomorph.symm h) (h x) = x :=
  by sorry

The theorem `Homeomorph.symm_apply_apply` states that for any two topological spaces `X` and `Y`, and a given homeomorphism `h` from `X` to `Y`, applying the homeomorphism `h` to a point `x` in `X` and then applying the inverse homeomorphism `Homeomorph.symm h` to the result, we recover the original point `x`. In mathematical terms, this theorem asserts that for any homeomorphism and its inverse, the composition of these two maps is the identity on `X`.

For any homeomorphism $h$ between topological spaces $X$ and $Y$, $h \circ \text{Homeomorph.symm } h = \text{id}_X$, where $\text{id}_X$ is the identity map on $X$.


theorem Set.not_infinite : ∀ {α : Type u} {s : Set α}, ¬Set.Infinite s ↔ Set.Finite s := by sorry

This theorem states that for any given set `s` of some type `α`, the set `s` is not infinite if and only if it is finite. In other words, in the context of sets, the property of not being infinite is equivalent to the property of being finite. This is a direct consequence of the definitions of finiteness and infiniteness for sets in Lean 4, where a set is finite if and only if it is not infinite.

A set is finite if and only if it is not infinite.


theorem Ordinal.lt_lsub : ∀ {ι : Type u_4} (f : ι → Ordinal.{max u_5 u_4}) (i : ι), f i < Ordinal.lsub f := by sorry

The theorem `Ordinal.lt_lsub` states that, for any type `ι` and a function `f` from `ι` to the type of well orders `Ordinal` (up to order isomorphism), any value `f i` for a particular `i` in `ι` is less than the least strict upper bound of the family of ordinals defined by `f`. In other words, for any given ordinal in the family, the least strict upper bound of the entire family is always greater.

For any type `ι` and function `f` from `ι` to `Ordinal`, `f i` is strictly less than the least upper bound of the family `{f x | x ∈ ι}`.


theorem Int.emod_eq_of_lt : ∀ {a b : ℤ}, 0 ≤ a → a < b → a % b = a := by sorry

This theorem states that for any two integers `a` and `b`, if `a` is non-negative and less than `b`, then the remainder of `a` divided by `b` is `a` itself. In other words, if you have an integer `a` that is at least zero and less than an integer `b`, when you divide `a` by `b`, the remainder will be `a`. This is a property of the modulo operation.

For any integers `a` and `b` with `a` non-negative and less than `b`, `a` % `b` equals `a`.


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

This theorem, `Mathlib.Order.Lattice._auxLemma.12`, states that for any type `α` that is a semilattice under infimum (denoted `⊓`), and for any two elements `a` and `b` of that type, the infimum of `a` and `b` is always less than or equal to `b`. In mathematical terms, it means that for any semilattice $(α, ⊓)$, for any $a, b ∈ α$, we have $a ⊓ b ≤ b$. This is a basic property of lattices, reflecting that the infimum of two elements is a lower bound of those elements.

For any semilattice `α` and elements `a, b ∈ α`, the infimum `a ⊓ b` is less than or equal to `b`.


theorem vadd_add_assoc :
    ∀ {α : Type u_6} {β : Type u_7} [inst : Add β] [inst_1 : VAdd α β] [inst_2 : VAddAssocClass α β β] (r : α)
      (x y : β), r +ᵥ x + y = r +ᵥ (x + y) :=
  by sorry

This theorem is asserting that for any types `α` and `β`, where `β` is an additive type and `α` and `β` are types that allow for vector addition, the operation of adding a scalar `r` to a vector `x`, and then adding a scalar `y`, is the same as adding `r` to the result of adding `x` and `y`. In mathematical terms, it's asserting that $r +ᵥ x + y = r +ᵥ (x + y)$ for all `r`, `x`, and `y` of appropriate types, where $+ᵥ$ denotes vector addition. This is essentially the associativity property in the context of vector addition.

For any additive types `α` and scalar type `β`, the operation of adding a scalar `r` to the vector sum `x + y` is equivalent to adding the scalars `r` and `r` separately and then adding the vectors `x` and `y`, i.e., `r + (x + y) = r + x + y`.


theorem Rat.cast_mul : ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α] (m n : ℚ), ↑(m * n) = ↑m * ↑n :=
  by sorry

This theorem states that for any type `α` that is a division ring and has property `CharZero`, the casting of the product of two rational numbers `m` and `n` to type `α` is equal to the product of the castings of `m` and `n` to type `α`. In mathematical terms, it asserts that the map from the rationals to `α` preserves multiplication, i.e., for any rational numbers `m` and `n`, `(m * n)` cast to `α` is same as `(m cast to α) * (n cast to α)`.

For any division ring α with CharZero property, the multiplication homomorphism from the rationals to α holds, that is, (m * n) cast to α = (m cast to α) * (n cast to α) for all rational numbers m and n.


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

The theorem `List.filter_sublist` states that, for any given type `α`, any Boolean-valued function `p` on elements from `α`, and any list `l` of type `List α`, the list obtained by applying `List.filter` with `p` on `l` is a sublist of `l`. In other words, filtering a list with any predicate results in a list that is a sublist of the original list.

For any type `α`, if `l` is a list of elements from `α` and `p` is a Boolean-valued function on `α`, then `List.filter p l` is a sublist of `l`.


theorem Subgroup.mem_zpowers : ∀ {G : Type u_1} [inst : Group G] (g : G), g ∈ Subgroup.zpowers g := by sorry

This theorem states that for any group `G` and any element `g` in the group, `g` is a member of the subgroup generated by `g`. Specifically, the `Subgroup.zpowers g` is the subgroup of `G` generated by powers of `g` (i.e., all elements of the form `g^n` for integers `n`). The theorem asserts that `g` itself (which can be considered as `g` to the power of 1) is a member of this subgroup.

For any group `G` and any of its element `g`, `g` is an element of the subgroup generated by `g` (i.e., `Subgroup.zpowers g`).


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

This theorem states that for all natural numbers `a`, `b`, `c`, and `d`, if `a` is less than `b` and `c` is less than `d`, then `a + c` is less than `b + d`. In other words, the sum of two smaller natural numbers is less than the sum of two larger natural numbers.

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


theorem Mathlib.Algebra.Module.Submodule.Ker._auxLemma.1 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_12} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] {f : F}
      {y : M}, (y ∈ LinearMap.ker f) = (f y = 0) :=
  by sorry

This theorem states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, and modules over these semirings, given a ring homomorphism `τ₁₂` from `R` to `R₂`, a type `F` that behaves like a function from `M` to `M₂`, and a semilinear map `f` of type `F`, a vector `y` from `M` is in the kernel of `f` if and only if `f` applied to `y` is equal to zero. Here, the kernel of a linear map `f` is defined as the set of all vectors from `M` that `f` maps to zero. This theorem allows us to check whether a vector is in the kernel of `f` by simply applying `f` to the vector and checking if the result is zero.

For any ring homomorphism τ₁₂ from semirings R and R₂, additive commutative monoids M and M₂, and module homomorphism F : M →ₗ[τ₁₂] M₂ from a type behaving like a function, if y ∈ M then y ∈ ker(F(f)) if and only if F(f)(y) = 0.


theorem div_le_div :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c d : α}, 0 ≤ c → a ≤ c → 0 < d → d ≤ b → a / b ≤ c / d :=
  by sorry

This theorem states that for any linear ordered semifield `α`, given four elements `a`, `b`, `c`, `d` in `α`, if `c` is non-negative, `a` is less than or equal to `c`, `d` is positive, and `d` is less than or equal to `b`, then the ratio `a/b` is less than or equal to the ratio `c/d`. This theorem is a fundamental result about the properties of division in a linear ordered semifield.

In a linear ordered semifield, if $a \leq c$ are elements, $c \geq 0$, and $d > 0$ with $d \leq b$, then $\frac{a}{b} \leq \frac{c}{d}$.


theorem Finset.sum_range_succ_comm :
    ∀ {β : Type u_4} [inst : AddCommMonoid β] (f : ℕ → β) (n : ℕ),
      (Finset.sum (Finset.range (n + 1)) fun x => f x) = f n + Finset.sum (Finset.range n) fun x => f x :=
  by sorry

The theorem `Finset.sum_range_succ_comm` states that for any given type `β` that forms an additive commutative monoid, and any function `f` from natural numbers to `β`, the sum of the function `f` applied to each element in the set of natural numbers less than `n+1` is equal to the value of the function `f` at `n` plus the sum of the function `f` applied to each element in the set of natural numbers less than `n`. In mathematical notation, this can be written as $\sum_{x=0}^{n} f(x) = f(n) + \sum_{x=0}^{n-1} f(x)$.

The sum of a function's values over the set of natural numbers up to `n` is equal to the function value at `n` plus the sum of its values over the set of natural numbers up to `n-1`.


theorem Nat.sqrt_lt : ∀ {m n : ℕ}, Nat.sqrt m < n ↔ m < n * n := by sorry

This theorem is about the relationship between the integer square root function and multiplication in the set of natural numbers. It states that for any two natural numbers `m` and `n`, the square root of `m` is less than `n` if and only if `m` is less than the square of `n`. In mathematical terms, it can be expressed as $\sqrt{m} < n \iff m < n^2$ for all natural numbers `m` and `n`.

The natural square root of a natural number is less than another natural number if and only if the first number is less than the square of the second number. In Lean 4, this is expressed as $\sqrt{m} < n \iff m < n^2$ for all natural numbers $m$ and $n$.


theorem Set.preimage_iInter :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {s : ι → Set β}, f ⁻¹' ⋂ i, s i = ⋂ i, f ⁻¹' s i := by
  sorry

The theorem `Set.preimage_iInter` states that for any types `α` and `β`, any indexing type `ι`, any function `f` from `α` to `β`, and any indexed family of sets `s` of `β`, the preimage (`f⁻¹`) of the intersection of the sets `s i` (for all `i` in `ι`) is equal to the intersection of the preimages of the sets `s i`. In other words, taking the preimage of an intersection of sets under a function coincides with taking the intersection of the preimages of the sets.

For any function `f` from type `α` to type `β` and any indexed family `(S : ∀ i, β → Prop)` of sets of `β`, `f⁻¹ (∧ i in ι, S i) = ∧ i in ι, f⁻¹ S i`.


Measurable.setOf

/-- **Alias** of the reverse direction of `measurableSet_setOf`. -/
theorem Measurable.setOf :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop}, Measurable p → MeasurableSet {a | p a} := by sorry

This theorem, which is an alias of the reverse direction of `measurableSet_setOf`, asserts that for any type `α` equipped with a measurable space structure and any predicate `p` on `α`, if the function `p` is measurable, then the set of elements `a` in `α` such that `p a` holds is a measurable set. In other words, the set of elements satisfying a measurable predicate is itself measurable.

If `α` is a measurable space and `p : α → Prop` is a measurable predicate, then the set `{a : α | p a}` is a measurable subset of `α`.


theorem Nat.cons_self_properDivisors : ∀ {n : ℕ}, n ≠ 0 → Finset.cons n (Nat.properDivisors n) ⋯ = Nat.divisors n := by
  sorry

The theorem `Nat.cons_self_properDivisors` states that for every non-zero natural number `n`, adding `n` (using the `Finset.cons` function) to its own set of proper divisors (which are divisors excluding `n` itself) will yield the full set of its divisors. In other words, if we take the set of proper divisors of `n` and add `n` to this set, we get the same set as if we had started with the set of all divisors of `n`.

For every non-zero natural number `n`, the set of proper divisors of `n` and the set of divisors of `n` including `n` itself are equal.


theorem QuadraticForm.map_smul :
    ∀ {R : Type u_3} {M : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (Q : QuadraticForm R M) (a : R) (x : M), Q (a • x) = a * a * Q x :=
  by sorry

This theorem, `QuadraticForm.map_smul`, states that for any commutative semiring `R`, add commutative monoid `M`, and `M` being a module over `R`, then for any quadratic form `Q` over `M`, scalar `a` from `R` and vector `x` from `M`, scaling the vector `x` by `a` and then applying the quadratic form is equivalent to multiplying the result of the application of `Q` to `x` by the square of `a`. In mathematical notation, this is saying that $Q(a \cdot x) = a^2 \cdot Q(x)$ for a quadratic form $Q$, scalar $a$, and vector $x$.

For any quadratic form $Q$ over a commutative semiring $R$ and an $R$-module $M$, and for any scalar $a$ in $R$ and vector $x$ in $M$, $Q(a \cdot x) = a^2 \cdot Q(x)$.


theorem List.nodup_cons : ∀ {α : Type u} {a : α} {l : List α}, List.Nodup (a :: l) ↔ a ∉ l ∧ List.Nodup l := by sorry

The theorem `List.nodup_cons` states that for any type `α`, and for any element `a` of this type and list `l` of elements of this type, the list `l` has no duplicates (i.e., the proposition `List.Nodup (a :: l)` holds) if and only if `a` is not an element of `l` and `l` itself has no duplicates (expressed as `a ∉ l ∧ List.Nodup l`).

For any type `α` and list `l` of distinct elements of type `α`, `a` not being an element of `l` is equivalent to `l` having no duplicates.


Measurable.fst

theorem Measurable.fst :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β}
      {mγ : MeasurableSpace γ} {f : α → β × γ}, Measurable f → Measurable fun a => (f a).1 :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any measurable spaces over these types denoted by `m`, `mβ`, and `mγ` respectively, if we have a measurable function `f` mapping from `α` to a pair of elements in `β` and `γ`, then the function that maps `α` to the first component of the pair `(f a).1` is also measurable. In mathematical terms, if `f : α → β × γ` is a measurable function, then the function `g : α → β` defined by `g(a) = (f(a)).1` is also measurable.

If `f : α → β × γ` is a measurable function, then the function `g : α → β` defined by `g(a) = (f(a)).1` is measurable.


Array.ext'

theorem Array.ext' : ∀ {α : Type u_1} {as bs : Array α}, as.data = bs.data → as = bs := by sorry

This theorem, named `Array.ext'`, states that for any type α and any two arrays `as` and `bs` of type α, if the data of `as` is equal to the data of `bs`, then the arrays `as` and `bs` are equal themselves. This is essentially a statement about the equality of arrays in Lean 4, stating that two arrays are equal if and only if their contents are equal.

Given arrays `as` and `bs` of type α in Lean 4, if their data are equal, then `as = bs`.


theorem Matrix.one_apply_ne :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α] {i j : n},
      i ≠ j → 1 i j = 0 :=
  by sorry

This theorem states that for any types `n` and `α`, given that `n` has decidable equality, `α` has a zero element, and `α` has a one element, if `i` and `j` are elements of `n` and `i` doesn't equal `j`, then the `i,j`-th entry of the identity matrix (which is represented by `1` in Lean) is `0`. In simpler terms, this is asserting that all non-diagonal entries of an identity matrix are zero.

For any type `n` with decidable equality and types `α` with zero and one elements, the `(i, j)`-entry of the identity matrix of size `n` is `0` when `i ≠ j`.


theorem Polynomial.map_injective :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
      Function.Injective ⇑f → Function.Injective (Polynomial.map f) :=
  by sorry

The theorem `Polynomial.map_injective` states that for any two types `R` and `S`, where `R` and `S` are semirings, if a ring homomorphism `f` from `R` to `S` is injective, then the map of any polynomial from `R` to `S` using `f` is also injective. In other words, if `f` is such that whenever `f(x) = f(y)`, it follows that `x = y`, then for any polynomial `p` and `q`, if the `f`-image of `p` is equal to the `f`-image of `q`, it follows that `p = q`.

If `f` is an injective ring homomorphism from semiring `R` to semiring `S`, then the map taking polynomials over `R` to their images under `f` is an injective homomorphism of `R`-algebras from the polynomial algebra over `R` to that over `S`.


theorem TopologicalSpace.IsTopologicalBasis.isOpen :
    ∀ {α : Type u} [t : TopologicalSpace α] {s : Set α} {b : Set (Set α)},
      TopologicalSpace.IsTopologicalBasis b → s ∈ b → IsOpen s :=
  by sorry

This theorem states that for any type `α` with a given topology `t`, if `b` is a topological basis of the topological space, and `s` is a member of this basis `b`, then `s` is an open set in this topological space. In other words, this theorem asserts that every set in a topological basis is an open set in the corresponding topological space. This is a fundamental property of topological bases in topology.

Given a topological space `(α, t)` and a topological basis `b ⊆ α`, every element `s ∈ b` is an open set in `α`.


theorem add_left_iterate :
    ∀ {G : Type u_3} [inst : AddMonoid G] (a : G) (n : ℕ), (fun x => a + x)^[n] = fun x => n • a + x := by sorry

This theorem states that for any type `G` that has an addition operation and an identity element (i.e., is an additive monoid), any element `a` from `G`, and any natural number `n`, applying the function that adds `a` to its input `n` times is the same as adding `n` times `a` to the input. In mathematical terms, for any `a` in `G` and `n` in ℕ, (a + x) iterated `n` times is the same as `n` • `a` + `x`, where '•' denotes scalar multiplication and 'x' is a variable.

For any additive monoid `G` and its element `a`, natural number `n`, the operation of adding `a` to a value `x` `n` times is equivalent to adding `n` copies of `a` to `x`.


theorem Finset.disjoint_filter :
    ∀ {α : Type u_1} {s : Finset α} {p q : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred q],
      Disjoint (Finset.filter p s) (Finset.filter q s) ↔ ∀ x ∈ s, p x → ¬q x :=
  by sorry

The theorem `Finset.disjoint_filter` states that for any type `α`, any finite set `s` of type `α`, and any two predicates `p` and `q` on `α`, where both `p` and `q` are decidable properties, the set of elements in `s` satisfying `p` is disjoint from the set of elements in `s` satisfying `q` if and only if for all elements `x` in `s`, whenever `x` satisfies `p`, it does not satisfy `q`. In other words, no element in `s` can satisfy both `p` and `q` at the same time.

For any type `α`, finite set `s` of `α`, and decidable properties `p` and `q` on `α`, `s`'s subsets `{x | p x}` and `{x | q x}` are disjoint if and only if for all `x` in `s`, `p x` implies `~q x`.


theorem Multiset.lt_cons_self : ∀ {α : Type u_1} (s : Multiset α) (a : α), s < a ::ₘ s := by sorry

The theorem `Multiset.lt_cons_self` states that for any type `α` and for any multiset `s` of type `α` and any element `a` of type `α`, the multiset `s` is strictly less than the multiset formed by prepending `a` to `s`. Here, `<` is the multiset strict subset relation, and `::ₘ` is the multiset cons operator. This theorem establishes that adding an element to a multiset will always create a multiset that is strictly larger than the original.

For any type `α` and multisets `s` and `t` of type `α` where `t = a ::ₘ s`, we have `s < t`.


theorem Int.cast_id : ∀ {n : ℤ}, ↑n = n := by sorry

This theorem, `Int.cast_id`, states that for every integer `n`, the cast of `n` to an integer is equal to `n` itself. In other words, performing an integer-to-integer cast doesn't change the value, for all integers. This is expressed in Lean 4 using the universal quantifier `∀` and the equality operator `=`.

For all integers n, the cast of n to an integer is equal to n itself. (Or equivalently, the integer conversion operation is the identity function on integers.)


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

The theorem `Filter.NeBot.map₂` states that for any types `α`, `β`, and `γ`, and for any binary function `m : α → β → γ` and filters `f : Filter α` and `g : Filter β`, if the filters `f` and `g` are not bottom filters (meaning that they are not the filter that contains every set), then the image of the binary function `m` under the filters `f` and `g`, denoted as `Filter.map₂ m f g`, is also a non-bottom filter. In essence, the image of two non-bottom filters under a binary function remains a non-bottom filter.

If filters `f` and `g` over types `α` and `β`, respectively, are non-bottom, then the image of their composition under a binary function `m : α → β → γ` is also a non-bottom filter over type `γ`.


theorem Complex.arg_le_pi : ∀ (x : ℂ), Complex.arg x ≤ Real.pi := by sorry

The theorem `Complex.arg_le_pi` states that for every complex number `x`, the argument of `x`, given by the function `Complex.arg x`, is less than or equal to `Real.pi`, the mathematical constant π, approximately 3.14159265. The argument of a complex number is defined such that if the real part of `x` is non-negative, it is the arcsine of the imaginary part divided by the absolute value of `x`; otherwise, if the imaginary part is non-negative, it is the arcsine of the negative `x`'s imaginary part divided by the absolute value of `x` plus π, and if the imaginary part is negative, it is the arcsine of the negative `x`'s imaginary part divided by the absolute value of `x` minus π. The mathematical constant π is defined as twice the real number for which cosine equals zero in the interval [1,2].

For all complex numbers x, the argument of x, as defined, is less than or equal to the mathematical constant π.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.1 :
    ∀ {α : Type u_1} {f : Filter α} {m : α → NNReal} {a : NNReal},
      Filter.Tendsto (fun a => ↑(m a)) f (nhds ↑a) = Filter.Tendsto m f (nhds a) :=
  by sorry

This theorem states that for any type `α`, any filter `f` over `α`, any function `m` from `α` to the nonnegative real numbers (`NNReal`), and any nonnegative real number `a`, the function `m` tends to `a` (i.e., the limit of `m` as it approaches `a` exists) under the filter `f` if and only if the function that takes each element of `α` to the real part of its image under `m` also tends to `a` under the filter `f`. In other words, the limit behaviors of the function `m` and the function that maps each element of `α` to the real part of its image under `m` are the same.

For any type `α`, filter `f` over `α`, function `m` from `α` to `NNReal`, and real number `a`, the function `m` tends to `a` under `f` if and only if the function `x ↦ Re(m x)` tends to `a` under `f`.


theorem continuous_inl :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Sum.inl := by
  sorry

This theorem states that for any two types `X` and `Y`, which have topological space structures (denoted by `inst` and `inst_1`), the injection function `Sum.inl` (which takes an element from `X` and injects it into the left component of the sum type `X + Y`) is continuous. In the context of topology, a function is continuous if the preimage of every open set is open.

For any topological spaces `X` and `Y`, the injection function `Sum.inl : X → X + Y` is a continuous function.


theorem continuous_inr :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Sum.inr := by
  sorry

This theorem states that for any types `X` and `Y` with respective topological spaces, the function `Sum.inr` is continuous. In the context of topology, `Sum.inr` is a function that takes an element of type `Y` and returns that element as part of a disjoint union (also known as a sum type) with `X`. The continuity of this function means that the preimage of any open set in the disjoint union is an open set in `Y`.

The function `Sum.inr`: `Y → X ± Y` is continuous with respect to the subspace topology on `Y`, where `X ± Y` denotes the disjoint union of `X` and `Y`.


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

This theorem, `Finpartition.ne_bot`, states that for any type `α` that forms a lattice and has a least element (`⊥`), given a finite partition `P` of an element `a` of type `α`, any element `b` that is part of the partition `P` cannot be equal to the least element (`⊥`). In other words, no part of a finite partition of an element in a lattice is the bottom element of the lattice.

For any lattice type `α` with a least element `⊥` and finite partition `P` of an element `a` in `α`, no part `b` of `P` equals `⊥`.


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

The theorem `Nat.left_distrib` states that for all natural numbers `n`, `m`, and `k`, the product of `n` and the sum of `m` and `k` is equal to the sum of the product of `n` and `m` and the product of `n` and `k`. This is a formalization of the distributive property of multiplication over addition, which can be written in mathematical notation as n*(m + k) = n*m + n*k.

For all natural numbers n, m, and k, n*(m + k) = n*m + n*k. (Distributive property of multiplication over addition)


theorem Int.lt_of_le_of_lt : ∀ {a b c : ℤ}, a ≤ b → b < c → a < c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is less than or equal to `b`, and `b` is strictly less than `c`, then `a` is strictly less than `c`. It captures the transitivity property of the "less than" relation over integers: being less than or equal to an integer which is in turn less than another integer implies being less than the latter integer.

If `a` is less than or equal to `b` and `b` is strictly less than `c`, then `a` is strictly less than `c`. (In other words, transitivity holds for the strict less than relation on integers.)


theorem Fintype.card_eq_zero_iff : ∀ {α : Type u_1} [inst : Fintype α], Fintype.card α = 0 ↔ IsEmpty α := by sorry

The theorem `Fintype.card_eq_zero_iff` states that for any type `α` which has a finite number of elements (i.e., is a `Fintype`), the number of elements (`Fintype.card α`) is equal to zero if and only if `α` is empty (i.e., `IsEmpty α`). In other words, a finite type has zero elements precisely when it is an empty type.

For any type `α` that is a `Fintype`, `Fintype.card α = 0` if and only if `α` is empty.


theorem Hyperreal.isSt_st' : ∀ {x : ℝ*}, ¬Hyperreal.Infinite x → Hyperreal.IsSt x (Hyperreal.st x) := by sorry

The theorem `Hyperreal.isSt_st'` asserts that for every hyperreal number `x` which is not infinite, the real number `Hyperreal.st x` returned by the standard part function `Hyperreal.st` satisfies the standard part predicate with respect to `x`. In other words, given any real number `δ` greater than zero, `x` lies strictly between `Hyperreal.st x` minus `δ` and `Hyperreal.st x` plus `δ`. This essentially states that `Hyperreal.st x` is the best real number approximation of the hyperreal number `x` within any given positive precision `δ`.

For every non-infinite hyperreal number x, the real number Hyperreal.st x is a real number approximation of x such that x lies between Hyperreal.st x - δ and Hyperreal.st x + δ for any positive real number δ.


theorem Polynomial.degree_C_mul_X_pow :
    ∀ {R : Type u} {a : R} [inst : Semiring R] (n : ℕ),
      a ≠ 0 → Polynomial.degree (Polynomial.C a * Polynomial.X ^ n) = ↑n :=
  by sorry

The theorem `Polynomial.degree_C_mul_X_pow` states that for any semiring `R`, any element `a` of `R` and any natural number `n`, if `a` is not zero, then the degree of the polynomial obtained by multiplying the constant polynomial `a` with the `n`th power of the polynomial variable `X` is `n`. In other words, if we have a non-zero constant times a power of the polynomial variable, the degree of the resulting polynomial is just the exponent of the power.

For any semiring R and natural number n, the degree of the polynomial a * X^n is n, where a is a non-zero element of R.


RelHomClass.wellFounded

theorem RelHomClass.wellFounded :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {F : Type u_5} [inst : FunLike F α β]
      [inst : RelHomClass F r s], F → WellFounded s → WellFounded r :=
  by sorry

The theorem `RelHomClass.wellFounded` states that for any types `α` and `β`, any binary relations `r` on `α` and `s` on `β`, and any type `F` that behaves like a function from `α` to `β`, if `F` is a relational homomorphism from `r` to `s` (meaning it respects the relations `r` and `s`), then if `s` is a well-founded relation (there are no infinite descending chains), `r` must also be a well-founded relation. In other words, the well-foundedness property is preserved through relational homomorphisms.

If `F : α → β` is a function that respects the relational homomorphism between well-founded relations `r` on `α` and `s` on `β`, then `r` is also a well-founded relation.


theorem ENNReal.lt_iff_exists_nnreal_btwn : ∀ {a b : ENNReal}, a < b ↔ ∃ r, a < ↑r ∧ ↑r < b := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, `a` is less than `b` if and only if there exists a nonnegative real number `r` such that `a` is less than `r` and `r` is less than `b`. This means that between any two distinct extended nonnegative real numbers, we can always find a nonnegative real number. This is a formalization of the concept that the real numbers are densely ordered.

For any extended nonnegative real numbers `a` and `b`, `a` < `b` if and only if there exists a nonnegative real number `r` such that `a` < `r` and `r` < `b`.


Equiv.subsingleton

theorem Equiv.subsingleton : ∀ {α : Sort u} {β : Sort v}, α ≃ β → ∀ [inst : Subsingleton β], Subsingleton α := by sorry

This theorem states that, for any types `α` and `β`, if `α` is equivalent to `β` and `β` is a subsingleton (meaning it contains at most one element), then `α` is also a subsingleton. In mathematical terms, it says that the property of being a subsingleton is preserved under equivalence of types.

If `α` is equivalent to a subsingleton `β`, then `α` is a subsingleton.


theorem inv_eq_zero : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, a⁻¹ = 0 ↔ a = 0 := by sorry

This theorem states that for any given type `G₀` that has a structure of a group with zero (i.e., a group that includes a zero element), an element `a` of `G₀` has its inverse equal to zero if and only if `a` itself is zero. In other words, for such types, an element is zero if its inverse is zero, and vice versa. This theorem is a fundamental property in the theory of groups with zero.

In a group with zero, an element is zero if and only if its inverse is zero.


Filter.Tendsto.smul

theorem Filter.Tendsto.smul :
    ∀ {M : Type u_1} {X : Type u_2} {α : Type u_4} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : SMul M X] [inst_3 : ContinuousSMul M X] {f : α → M} {g : α → X} {l : Filter α} {c : M} {a : X},
      Filter.Tendsto f l (nhds c) →
        Filter.Tendsto g l (nhds a) → Filter.Tendsto (fun x => f x • g x) l (nhds (c • a)) :=
  by sorry

The theorem `Filter.Tendsto.smul` states that if for a topological space `M`, another topological space `X`, a scalar multiplication operation (`SMul`) on `M` and `X`, and a continuity condition (`ContinuousSMul`) for this operation, a filter `l` over a type `α`, a scalar `c` of type `M`, and a point `a` of type `X`, if a function `f` from `α` to `M` tends to `c` through the filter `l` and another function `g` from `α` to `X` tends to `a` through the same filter `l`, then the function defined as the scalar multiplication of `f x` and `g x` for each `x` in `α` tends to the scalar multiplication of `c` and `a` through the same filter `l`. In mathematical terms, if $\lim_{x \to l} f(x) = c$ and $\lim_{x \to l} g(x) = a$, then $\lim_{x \to l} (f(x) \cdot g(x)) = c \cdot a$.

If functions $f : \alpha \to M$ and $g : \alpha \to X$ tend to $c \in M$ and $a \in X$, respectively, through filter $l$, then the scalar multiplication $f \cdot g : \alpha \to M \times X$ tends to $(c, a) \in M \times X$ through filter $l$.


LinearIsometryEquiv.isometry

theorem LinearIsometryEquiv.isometry :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂), Isometry ⇑e :=
  by sorry

This theorem states that for any linear isometry equivalence `e` between two semi-normed add-commutative groups `E` and `E₂`, over semirings `R` and `R₂` respectively, and with ring homomorphisms `σ₁₂` and `σ₂₁` between `R` and `R₂` (forming a ring homomorphism inverse pair in both directions), the function `e` preserves the pseudo metric space edistance. In other words, applying `e` to any two points in `E` will not change the edistance between them before and after the mapping, which makes `e` an isometry.

For any linear isometry equivalence between semi-normed add-commutative groups with compatible ring homomorphism inverse pairs, the isometry preserves the group's pseudo-metric distance.


/-- Two additive monoid homomorphisms `f`, `g` from `ℤ` to an additive monoid are equal
if `f 1 = g 1`.  -/
theorem AddMonoidHom.ext_int : ∀ {A : Type u_5} [inst : AddMonoid A] {f g : ℤ →+ A}, f 1 = g 1 → f = g := by sorry

This theorem states that for any type `A` that has an additive monoid structure, if `f` and `g` are two additive monoid homomorphisms from the integers to `A`, and if `f` and `g` map the integer `1` to the same element in `A`, then `f` and `g` are indeed the same homomorphism. In other words, for additive monoid homomorphisms from the integers to any additive monoid, the value of the homomorphism at `1` completely determines the homomorphism.

If `A` is an additive monoid and `f` and `g` are homomorphisms from the integers to `A` with `f(1) = g(1)`, then `f = g`.


/-- For any `p`, the power of `p` in `n^k` is `k` times the power in `n`  -/
theorem Nat.factorization_pow : ∀ (n k : ℕ), Nat.factorization (n ^ k) = k • Nat.factorization n := by sorry

This theorem states that for any natural numbers `n` and `k`, the prime factorization of `n` raised to the power of `k` is the same as `k` times the prime factorization of `n`. In other words, the multiplicity of each prime factor `p` in `n^k` is `k` times the multiplicity of `p` in `n`. This is equivalent to the mathematical statement that for any prime `p`, the power of `p` in the prime factorization of `n^k` is `k` times the power of `p` in the prime factorization of `n`.

For any natural number `n` and `k`, the prime factorization of `n` raised to the power of `k` is `k` times the prime factorization of `n`. Equivalently, the power of each prime `p` in the prime factorization of `n^k` is `k` times its power in the prime factorization of `n`.


/-- If all elements of a `Finset` satisfy the predicate `p`,
`s.subtype p` converts back to `s` with `Embedding.subtype`.  -/
theorem Finset.subtype_map_of_mem :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α},
      (∀ x ∈ s, p x) → Finset.map (Function.Embedding.subtype p) (Finset.subtype p s) = s :=
  by sorry

The theorem `Finset.subtype_map_of_mem` states that for any given type `α` and a predicate `p` that can be decided for elements of `α`, if every element `x` of a given finset `s` satisfies the predicate `p`, then mapping the finset `s` to the subtype of `p` using `Finset.subtype` and then converting it back to the original finset using `Function.Embedding.subtype` will give us back the original finset `s`. This basically means that the process of converting a finset to a subtype and then back to the original finset is a lossless operation when all elements of the finset satisfy the given predicate.

If `s` is a finset of type `α` and `p` is a decidable predicate on `α` such that `p(x)` holds for all `x` in `s`, then `Function.Embedding.subtype (Finset.subtype p s) = s`.


theorem ContinuousLinearMap.isBoundedBilinearMap :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (f : E →L[𝕜] F →L[𝕜] G),
      IsBoundedBilinearMap 𝕜 fun x => (f x.1) x.2 :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, and any normed add commutative groups `E`, `F`, and `G` that are normed spaces over `𝕜`, if you have a continuous linear map `f` that takes an element of `E` and returns a linear map from `F` to `G`, then the map that takes a pair of elements from `E` and `F` respectively and applies the corresponding linear map is a bounded bilinear map over `𝕜`. This means that this map is linear in each argument and there exists a constant such that the norm of the image of a pair of vectors is less than this constant times the product of the norms of the vectors.

Given a non-trivially normed field `𝕜`, and continuous linear maps `f : E → L(F, G)` between normed spaces `E`, `F`, and `G` over `𝕜`, the map `(x, y) ↦ f(x)(y)` is a bounded bilinear map.


theorem deriv_const' :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] (c : F), (deriv fun x => c) = fun x => 0 :=
  by sorry

This theorem states that the derivative of a constant function is zero, regardless of the point at which it is evaluated. More formally, for any non-trivial normed field `𝕜`, normed additive commutative group `F`, and a normed space over `𝕜` and `F`, if `c` is a constant in `F`, then the derivative at any point `x` of the function `f` defined by `f(x) = c` is zero. This is consistent with the standard calculus result that the derivative of a constant function is always zero.

For any constant function `f(x) = c` in a normed vector space, the derivative `df/dx` is the zero function.


theorem Bornology.isBounded_def :
    ∀ {α : Type u_2} {x : Bornology α} {s : Set α}, Bornology.IsBounded s ↔ sᶜ ∈ Bornology.cobounded α := by sorry

The theorem `Bornology.isBounded_def` states that for any type `α` with a bornology `x`, and for any set `s` of type `α`, the set `s` is bounded with respect to the bornology if and only if the complement of `s` belongs to the filter of cobounded sets in the bornology of `α`. In other words, the notion of a set being 'bounded' in a bornology is equivalent to its complement being 'cobounded' within the same bornology.

A set in a bornology is bounded if and only if its complement is cobounded.


theorem HasSum.mul_right :
    ∀ {ι : Type u_1} {α : Type u_4} [inst : NonUnitalNonAssocSemiring α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalSemiring α] {f : ι → α} {a₁ : α} (a₂ : α),
      HasSum f a₁ → HasSum (fun i => f i * a₂) (a₁ * a₂) :=
  by sorry

This theorem, `HasSum.mul_right`, states that for any type `ι` and any non-unital, non-associative semiring `α` that is also a topological space and a topological semiring, if a function `f : ι → α` has a sum `a₁`, then the function `f i * a₂`, where `a₂` is a constant, also has a sum, equal to `a₁ * a₂`. This means that multiplying each term in a series by a constant multiplies the sum of the series by the same constant, a property often assumed in analysis and similar fields.

For any non-unital, non-associative semiring `α` that is also a topological space and a topological semiring, if a function `f : ι → α` from a type `ι` has a sum `a₁`, then `(∑ i, f i) * a₂` has the sum `a₁ * a₂`, where `a₂` is a constant.


/-- For nonzero `a` and `b`, the power of `p` in `a * b` is the sum of the powers in `a` and `b`  -/
theorem Nat.factorization_mul :
    ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → Nat.factorization (a * b) = Nat.factorization a + Nat.factorization b := by sorry

The theorem `Nat.factorization_mul` states that for any two nonzero natural numbers `a` and `b`, the factorization of the product `a * b` is equal to the sum of the factorizations of `a` and `b`. In other words, the multiplicity of a prime `p` in the prime factorization of `a * b` is the sum of the multiplicities of `p` in the prime factorizations of `a` and `b`. This accords with the fundamental theorem of arithmetic, which tells us that the primes in the factorization of `a*b` should exactly match those in `a` and `b`, simply with their multiplicities added together.

For all nonzero natural numbers a and b, the prime factorizations of a * b are equal to the sum of the prime factorizations of a and b.


theorem Cardinal.mk_le_of_surjective :
    ∀ {α β : Type u} {f : α → β}, Function.Surjective f → Cardinal.mk β ≤ Cardinal.mk α := by sorry

The theorem `Cardinal.mk_le_of_surjective` states that for any two types `α` and `β` and a function `f` from `α` to `β`, if `f` is surjective (meaning that for every element of `β`, there exists an element of `α` such that `f` maps this `α` element to the `β` element), then the cardinality of `β` is less than or equal to the cardinality of `α`. This theorem encapsulates the intuitive idea that a surjective function cannot map a type with fewer elements to a type with more elements.

If `f` is a surjective function from a set `α` to a set `β`, then `|α| ≥ |β|`. (The symbol `|.|` represents the cardinality of a set.)


theorem Nat.max_eq_right : ∀ {a b : ℕ}, a ≤ b → max a b = b := by sorry

This theorem, `Nat.max_eq_right`, states that for any two natural numbers `a` and `b`, if `a` is less than or equal to `b`, then the maximum value between `a` and `b` is `b`. Essentially, if `b` is greater than or equal to `a`, then `b` is considered the maximum of the two numbers.

For all natural numbers a and b, if a ≤ b then max a b = b.


theorem TensorProduct.induction_on :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {motive : TensorProduct R M N → Prop}
      (z : TensorProduct R M N),
      motive 0 →
        (∀ (x : M) (y : N), motive (x ⊗ₜ[R] y)) →
          (∀ (x y : TensorProduct R M N), motive x → motive y → motive (x + y)) → motive z :=
  by sorry

This theorem is an induction principle for the tensor product of two modules. In plain English, given two modules `M` and `N` over a commutative semi-ring `R`, it provides a way to prove a property `motive` for any element `z` of the tensor product of `M` and `N`. The principle states that if the property holds for the zero tensor, and if it holds for simple tensors of the form `x ⊗ₜ[R] y` (where `x` is in `M` and `y` is in `N`), and if the property is preserved under addition of tensors (i.e., if it holds for `x` and `y`, it also holds for `x + y`), then it holds for all tensors `z`. This method of proof is often useful when the property `motive` is defined in terms of the structure of the tensor product.

If `M` and `N` are modules over a commutative semi-ring `R`, and `motive` is a property preserved under addition, if `motive` holds for the zero tensor and all simple tensors `x ⊗ₜ[R] y`, then `motive` holds for all tensors in `M ⊗ₜ[R] N`.


theorem QuotientGroup.eq_one_iff :
    ∀ {G : Type u} [inst : Group G] {N : Subgroup G} [nN : Subgroup.Normal N] (x : G), ↑x = 1 ↔ x ∈ N := by sorry

This theorem states that for any group `G` and any subgroup `N` of `G` that is normal, an element `x` of `G` satisfies the property that its canonical projection (or quotient) with respect to `N` is the identity element if and only if `x` belongs to `N`. In terms of group theory, it says that the canonical map from `G` to the quotient group `G/N` sends `x` to the identity if and only if `x` is in the kernel of this map, which is `N` itself.

For any normal subgroup `N` of a group `G`, an element `x` in `G` maps to the identity in the quotient `G/N` if and only if `x` is in `N`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.2 :
    ∀ {S : Type u_5} {G : Type u_6} [inst : InvolutiveNeg G] {x : SetLike S G} [inst_1 : NegMemClass S G] {H : S}
      {x_1 : G}, (-x_1 ∈ H) = (x_1 ∈ H) :=
  by sorry

This theorem states that for any type `S` and `G`, where `G` has an involutive negation operation (i.e., double negation returns the original element), and type `S` is a set-like structure containing elements of type `G`. Moreover, if `S` has an instance of `NegMemClass` (meaning that if an element belongs to a set-like object `S`, its negation also belongs to `S`), then for any set `H` of type `S` and any element `x_1` of type `G`, `x_1` belonging to `H` is equivalent to `-x_1` belonging to `H`. In mathematical terms, for a set `H` and an element `x_1`, `x_1 ∈ H` if and only if `-x_1 ∈ H`.

For any set-like structure `S` over type `G` with an involutive negation operation and an instance of `NegMemClass`, the membership of an element `x_1` in `S` is equivalent to the membership of its negation `-x_1` in `S`.


theorem ENNReal.continuous_ofReal : Continuous ENNReal.ofReal := by sorry

This theorem states that the function `ENNReal.ofReal`, which maps a real number to its nonnegative counterpart (or zero if it's negative), is continuous. In mathematical terms, it implies that for any sequence of real numbers that converges to a limit, their corresponding sequence in the extended nonnegative real number system (obtained through `ENNReal.ofReal`) also converges, and its limit is `ENNReal.ofReal` of the original limit.

The function `ENNReal.ofReal` from real numbers to nonnegative extended real numbers is continuous, meaning that any convergent sequence of real numbers maps to a convergent sequence of nonnegative extended real numbers with the same limit.


theorem Cardinal.natCast_le : ∀ {m n : ℕ}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, the inequality `m ≤ n` holds if and only if the same inequality `↑m ≤ ↑n` holds when both numbers are cast to cardinals, where `↑m` and `↑n` represent the cardinal numbers corresponding to `m` and `n` respectively. In other words, the natural order of the numbers is preserved upon cardinality casting.

For all natural numbers m and n, m <= n if and only if the cardinal numbers of m and n satisfy the inequality ↑m <= ↑n.


theorem IsIntegral.fg_adjoin_singleton :
    ∀ {R : Type u_1} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {x : B},
      IsIntegral R x → Submodule.FG (Subalgebra.toSubmodule (Algebra.adjoin R {x})) :=
  by sorry

The theorem `IsIntegral.fg_adjoin_singleton` states that for any commutative ring `R`, a ring `B`, and an algebra structure over `B` with coefficients in `R`, if an element `x` of `B` is integral over `R`, then the submodule generated by adjoining `x` to `R` is finitely generated. In other words, if `x` is a root of some monic polynomial with coefficients in `R`, then the smallest subalgebra of `B` that contains both `R` and `x` can be written as the span of a finite subset of `B`.

If `x` is an element integral over a commutative ring `R` in an algebra structure over another ring `B`, then the subalgebra of `B` generated by `R` and `x` is finitely generated.


CategoryTheory.Quotient.sound

theorem CategoryTheory.Quotient.sound :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {a b : C} {f₁ f₂ : a ⟶ b},
      r f₁ f₂ → (CategoryTheory.Quotient.functor r).map f₁ = (CategoryTheory.Quotient.functor r).map f₂ :=
  by sorry

The theorem `CategoryTheory.Quotient.sound` states that for any category `C`, and any `HomRel r` on `C` (which is a relation defined on the hom-sets of the category), if for any two morphisms `f₁` and `f₂` from object `a` to object `b` in `C`, if `f₁` and `f₂` are related by `r`, then their images under the quotient functor associated to `r` are equal. In simpler terms, it asserts that the quotient functor respects the relation `r`: if two morphisms are related by `r`, they get mapped to the same morphism in the quotient category.

Given a category `C` and a relation `r` on its hom-sets such that for any morphisms `f₁` and `f₂` from object `a` to object `b`, if `f₁ r f₂`, then the images of `f₁` and `f₂` under the quotient functor associated to `r` are equal.


theorem Bimod.TensorBimod.X.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      [inst_2 : CategoryTheory.Limits.HasCoequalizers C] {R S T : Mon_ C} (P : Bimod R S) (Q : Bimod S T),
      CategoryTheory.Limits.HasColimit
        (CategoryTheory.Limits.parallelPair (CategoryTheory.MonoidalCategory.whiskerRight P.actRight Q.X)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator P.X S.X Q.X).hom
            (CategoryTheory.MonoidalCategory.whiskerLeft P.X Q.actLeft))) :=
  by sorry

This theorem, named `Bimod.TensorBimod.X.proof_1`, states that for a given category `C` that is equipped with a monoidal structure and has coequalizers, and given monoidal objects `R`, `S`, and `T` in `C`, along with bimodules `P` from `R` to `S` and `Q` from `S` to `T`, there is a colimit for the parallel pair of morphisms. The first morphism is derived by applying the right whiskering of `P`'s action with `Q`'s object, and the second morphism is obtained by composing the associator of `P`, `S`, and `Q` with the left whiskering of `P`'s object with `Q`'s action.

Given a monoidal category `C` with coequalizers, there exists a colimit for the parallel pair of morphisms obtained by right whiskering and left whiskering of a bimodule's action between monoidal objects in `C`.


theorem Nat.lt_ceil :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ}, n < ⌈a⌉₊ ↔ ↑n < a :=
  by sorry

This theorem, `Nat.lt_ceil`, states that for any type `α` that is a linear ordered semiring and a floor semiring, and given any `α` value `a` and natural number `n`, `n` is less than the ceiling of `a` if and only if the natural number `n` as a member of `α` is less than `a`. In other words, it links the comparison of a natural number with a real number (through its ceiling function), with the comparison of the same natural number (considered as an `α` number) with the original `α` number.

For any linear ordered semiring and floor semiring type `α`, and for all `α` values `a` and natural numbers `n`, `n < a` if and only if `n < ceiling a`.


theorem MeasureTheory.ae_of_ae_restrict_of_ae_restrict_compl :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (t : Set α) {p : α → Prop},
      (∀ᵐ (x : α) ∂μ.restrict t, p x) → (∀ᵐ (x : α) ∂μ.restrict tᶜ, p x) → ∀ᵐ (x : α) ∂μ, p x :=
  by sorry

The theorem `MeasureTheory.ae_of_ae_restrict_of_ae_restrict_compl` states that for all types `α`, measurable spaces `m0` and measures `μ`, and for any set `t` and property `p` defined on `α`, if almost every element in the restriction of measure `μ` to set `t` satisfies property `p` and also if almost every element in the restriction of measure `μ` to the complement of `t` satisfies property `p`, then almost every element in the entire space under measure `μ` satisfies property `p`. This theorem, in essence, is about the properties of measurable spaces under restrictions and their complements.

If two sets in a measurable space have almost every element satisfying a property with respect to a measure, then almost every element in their union satisfies the property.


theorem lt_sup_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a < b ⊔ c ↔ a < b ∨ a < c := by sorry

This theorem states that for any given type `α` that has a linear ordering, and for any three elements `a`, `b`, and `c` of this type, `a` is less than the supremum (or maximum) of `b` and `c` if and only if `a` is less than `b` or `a` is less than `c`. The theorem is phrased in the form of an "if and only if" statement, expressing a bi-directional implication.

For any linear order type `α`, and elements `a`, `b`, `c` of `α`, `a` is less than the maximum of `b` and `c` if and only if `a` is less than both `b` and `c`.


theorem Filter.mem_lift_sets :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β},
      Monotone g → ∀ {s : Set β}, s ∈ Filter.lift f g ↔ ∃ t ∈ f, s ∈ g t :=
  by sorry

This theorem, `Filter.mem_lift_sets`, states that for any types `α` and `β`, any filter `f` of type `Filter α`, and any function `g` from a set of `α` to a filter of `β` that is monotone, a set `s` of type `β` is a member of the filter produced by lifting `f` using `g` if and only if there exists a set `t`, a member of `f`, such that `s` is a member of the filter produced by applying `g` to `t`. In essence, it provides an equivalence condition for membership in a filter obtained by a lifting operation, in terms of the existence of a set in the original filter that maps to the set in question in the lifted filter via the used function.

For any filters `f` on type `α` and `g : α → Filter β` monotone functions, a set `s` is in the lifted filter `g''(f)` if and only if there exists `t` in `f` such that `s` is in `g(t)`.


Cauchy.map

theorem Cauchy.map :
    ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : UniformSpace β] {f : Filter α} {m : α → β},
      Cauchy f → UniformContinuous m → Cauchy (Filter.map m f) :=
  by sorry

The theorem `Cauchy.map` states that for any two types `α` and `β` equipped with a uniform space structure, a filter `f` on `α`, and a function `m : α → β`, if the filter `f` is Cauchy and the function `m` is uniformly continuous, then the filter obtained by mapping `f` through `m` is also Cauchy. In other words, mapping a Cauchy filter through a uniformly continuous function preserves the property of being Cauchy.

If `f` is a Cauchy filter on type `α` with uniform structure, and `m : α → β` is a uniformly continuous function, then the filter `m``⁻¹````(f)` obtained by mapping `f` through `m` is also Cauchy.


theorem WCovBy.eq_or_eq : ∀ {α : Type u_1} [inst : PartialOrder α] {a b c : α}, a ⩿ b → a ≤ c → c ≤ b → c = a ∨ c = b :=
  by sorry

This theorem, `WCovBy.eq_or_eq`, applies to any type `α` that has a partial order defined on it. It takes three instances of this type, `a`, `b`, and `c`. The theorem states that if `a` is covered by `b` (symbolized as `a ⩿ b`) and `a` is less than or equal to `c` (symbolized as `a ≤ c`) and `c` is less than or equal to `b` (symbolized as `c ≤ b`), then `c` must be equal to either `a` or `b`. In essence, this theorem defines a key property of the relationship between three elements in a partially ordered set.

If `a ⩿ b`, `a ≤ c`, and `c ≤ b` in a partially ordered set, then `c = a` or `c = b`.


Filter.Tendsto.div'

theorem Filter.Tendsto.div' :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Div G] [inst_2 : ContinuousDiv G] {f g : α → G}
      {l : Filter α} {a b : G},
      Filter.Tendsto f l (nhds a) →
        Filter.Tendsto g l (nhds b) → Filter.Tendsto (fun x => f x / g x) l (nhds (a / b)) :=
  by sorry

The theorem `Filter.Tendsto.div'` states that if `f` and `g` are functions from a type `α` to a topological space `G` equipped with a division operation and continuous division, and `l` is a filter on `α`, then if `f` tends towards a point `a` and `g` tends towards a point `b` (i.e., for every neighborhood of `a` and `b`, the preimage under `f` and `g` respectively is a neighborhood of `l`), then the function that sends `x` to `f(x) / g(x)` tends towards the point `a / b`. In other words, the limits of the ratios of the function values at a point is the ratio of the limits of the functions, provided all the limits exist and the limit of the denominator function is not zero.

If functions `f` and `g` from type `α` to topological space `G` with continuous division are such that `f` tends to `a` and `g` tends to a nonzero `b`, then their ratio function `x ↦ f(x) / g(x)` tends to `a / b`.


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

The theorem `MeasureTheory.SimpleFunc.coe_range` states that for any type `α` equipped with a measurable space structure (`inst : MeasurableSpace α`) and any type `β`, the range, as a `Finset`, of a simple function `f : MeasureTheory.SimpleFunc α β` when coerced to a `Set` is equal to the set range of `f` itself. In other words, the set of all outputs of the function `f` (when viewed as a simple function or a regular function) are the same.

For any measurable space `(α, Σ, mu)` and simple function `f : α → β` between measurable sets, the range of `f` as a `Finset` is equal to the set of images of `f`.


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

The theorem `pos_of_mul_pos_right` states that for any type `α` that has a multiplication operation, zero element, and a preordering relation, and such that multiplication by nonnegative elements is strictly reverse monotonic on the left, if the product of two elements `a` and `b` is positive and `a` is nonnegative, then `b` must be positive. In simpler terms, it says that if you multiply a nonnegative number by another number and the result is positive, then the second number must be positive.

If `α` is a type with multiplication, zero, preordering, and left-reverse monotonic multiplication by nonnegative elements, then `a * b > 0` implies `b > 0` when `a ≥ 0`.


theorem Asymptotics.isBigO_norm_left :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {f' : α → E'} {l : Filter α}, (fun x => ‖f' x‖) =O[l] g ↔ f' =O[l] g :=
  by sorry

This theorem, `Asymptotics.isBigO_norm_left`, states that for any types `α`, `F`, and `E'`, given a norm on `F` and `E'` being a semi-normed add commutative group, for any functions `f': α → E'` and `g: α → F`, and any filter `l` on `α`, the norm of `f'` is Big-O of `g` with respect to `l` if and only if `f'` is Big-O of `g` with respect to `l`.

In simpler terms, this theorem is about asymptotic behavior of functions. It says that a function `f'` is dominated by another function `g` (in terms of growth rates for large inputs, according to the Big-O notation) if and only if the norm of `f'` is also dominated by `g`.

For functions `f': α → E'` and `g: α → F` between types `α`, `E'`, and `F` with `E'` being a semi-normed add commutative group, and given a norm on `F` and filter `l` on `α`, `f'` is Big-O of `g` with respect to `l` if and only if the norm of `f'` is Big-O of `g` with respect to `l`.


theorem Mathlib.Order.BoundedOrder._auxLemma.31 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [inst_2 : Nontrivial α], (⊤ = ⊥) = False := by
  sorry

This theorem states that for any type `α` that has a partial order, bounded order, and is nontrivial, the greatest element `⊤` (often read as 'top' and can be seen as the 'maximum') cannot be equal to the least element `⊥` (often read as 'bottom' and can be seen as the 'minimum'). This theorem essentially confirms that in a nontrivial, bounded, and partially ordered set, the maximum and minimum elements are distinct.

In a nontrivial, bounded partially ordered type, the greatest and least elements are distinct.


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

This theorem, `le_not_le_of_lt`, states that for any type `α` that has a preorder structure (denoted by `[inst : Preorder α]`), for any two elements `a` and `b` of this type, if `a` is strictly less than `b` (i.e., `a < b`), then two conditions hold: 1) `a` is less than or equal to `b` (i.e., `a ≤ b`), and 2) it is not the case that `b` is less than or equal to `a` (i.e., `¬b ≤ a`). In other words, the theorem ensures that the strict less than relation (`<`) implies the less than or equal to relation (`≤`), but not the other way around.

If `α` is a preordered type and `a < b`, then `a ≤ b` and `¬b ≤ a`.


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

The theorem `Finset.insert_union` asserts that for any type `α` that has a decidable equality, given an element `a` of type `α` and two finite sets `s` and `t` of type `α`, inserting `a` into the union of `s` and `t` is the same as the union of the set obtained by inserting `a` into `s` and the set `t`. This states a fundamental property of sets: the order of insertion and union operations does not change the resulting set.

For any type `α` with decidable equality, the set `(s ∪ t).insert a` is equal to `(s.insert a ∪ t)`, where `s` and `t` are finite sets of type `α` and `a` is an element of type `α`.


Eq.absolutelyContinuous

/-- **Alias** of `MeasureTheory.Measure.absolutelyContinuous_of_eq`. -/
theorem Eq.absolutelyContinuous :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      μ = ν → MeasureTheory.Measure.AbsolutelyContinuous μ ν :=
  by sorry

The theorem `Eq.absolutelyContinuous` states that for any type `α`, measurable space `m0`, and measures `μ` and `ν`, if `μ` equals `ν`, then `μ` is absolutely continuous with respect to `ν`. In other words, if two measures are equal, then one measure is dominated by the other, meaning that if the second measure assigns zero to a set `s`, then the first measure also assigns zero to that set `s`.

If two measures are equal, then the larger measure is absolutely continuous with respect to the smaller measure.


theorem rank_bot :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R],
      Module.rank R ↥⊥ = 0 :=
  by sorry

This theorem, named `rank_bot`, states that for any ring `R`, type `M` equipped with the structure of an additive commutative group and an `R`-module, and assuming `R` is nontrivial (i.e., not all elements of `R` are the same), the rank of the trivial submodule (denoted `⊥`) is 0. In mathematical terms, if `M` is a module over a nontrivial ring `R`, then the dimension (rank) of the trivial submodule of `M` is zero.

The rank of the trivial submodule of an `R`-module `M` over a nontrivial ring `R` is 0.


theorem ApplicativeTransformation.preserves_pure :
    ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
      (η : ApplicativeTransformation F G) {α : Type u} (x : α), (fun {α} => η.app α) (pure x) = pure x :=
  by sorry

This theorem states that for any two applicative functors `F` and `G`, and any applicative transformation `η` from `F` to `G`, the transformation `η` preserves the "pure" operation. Given any type `α` and any value `x` of type `α`, the result of applying the transformation `η` to `pure x` (where `pure` is a function that embeds a value into a functor) is the same as `pure x`. In other words, the transformation doesn't change the result of the "pure" operation.

Given any applicative functors `F` and `G` and an applicative transformation `η` from `F` to `G`, for all types `α` and values `x` of type `α`, `η (pure x) = pure x`.


theorem Mathlib.Data.Finset.Option._auxLemma.3 :
    ∀ {α : Type u_1} {s : Finset α} {o : Option α}, (o ∈ Finset.insertNone s) = ∀ a ∈ o, a ∈ s := by sorry

This theorem states that for any type `α`, any finite set `s` of elements of type `α`, and any `Option α` (which is either `Some a` for some `a` of type `α` or `None`), `o` belongs to the finite set obtained from `s` by applying `Finset.insertNone` if and only if for every element `a` in `o` (`a` is `None` or `Some value`), `a` belongs to `s`. In other words, an option `o` is in the result of inserting `None` into `s` and lifting `s` to `Option α` if and only if every element in `o` is in `s`.

For any type `α`, a finite set `s` of elements from `α`, and an `Option α`, the option belongs to the finite set obtained by inserting `None` into `s` if and only if all elements in the option are in `s`.


theorem ZNum.cast_add : ∀ {α : Type u_1} [inst : AddGroupWithOne α] (m n : ZNum), ↑(m + n) = ↑m + ↑n := by sorry

This theorem states that for any type `α` that is an `AddGroupWithOne` (that is, a group with addition as operation and one as the identity element), the casting of the sum of any two ZNums `m` and `n` to the type `α` equals the sum of the casts of `m` and `n` to `α`. In other words, addition in ZNums commutes with casting to any additive group with one.

For any `AddGroupWithOne` type `α`, the operation of casting the sum of two ZNumbers to `α` is commutative with the addition of their casts to `α`.


theorem lt_zero_of_zero_gt : ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LT α] {a : α}, 0 > a → a < 0 := by sorry

This theorem, `lt_zero_of_zero_gt`, states that for any type `α` with a defined zero and less than (`LT`) relation, if zero is greater than a given element `a` of type `α` (expressed as `0 > a`), then `a` is less than zero (`a < 0`). Essentially, it asserts the reflexivity of the 'greater than' and 'less than' relationship around zero for any suitable type.

For any type `α` with a defined zero and less than relation, if `0 > a`, then `a < 0`.


theorem Fin.append_right :
    ∀ {m n : ℕ} {α : Type u_1} (u : Fin m → α) (v : Fin n → α) (i : Fin n), Fin.append u v (Fin.natAdd m i) = v i := by
  sorry

This theorem, `Fin.append_right`, states that for any natural numbers `m` and `n`, and any type `α`, given two functions `u` and `v` that map from `Fin m` and `Fin n` to `α` respectively, and an instance `i` of `Fin n`, if we first apply the `Fin.natAdd` function to `i` with `m` as the argument, and then append the function `u` and `v` (using `Fin.append`), the result will be equivalent to applying the function `v` to `i` directly. This can be interpreted as appending `u` and `v` and then adding `m` to `i` on the left doesn't change the fact that `i` still maps to the same element of `α` in `v`.

For any natural numbers `m` and `n`, and any type `α`, if `i : Fin n`, then `(v ∘ Fin.natAdd _ m) (u i) = v i` for functions `u : Fin m → α` and `v : Fin n → α`.


theorem List.findIdx_cons :
    ∀ {α : Type u_1} (p : α → Bool) (b : α) (l : List α),
      List.findIdx p (b :: l) = bif p b then 0 else List.findIdx p l + 1 :=
  by sorry

The theorem `List.findIdx_cons` states that for any type `α`, a boolean function `p` on `α`, an element `b` of type `α`, and a list `l` of elements of type `α`, the index of the first element in the list `b :: l` that satisfies function `p` is either 0 if `b` satisfies `p`, or it is one more than the index of the first element in list `l` that satisfies `p`. In other words, the function `List.findIdx` searches for the first element satisfying `p` in a list, and if the first element of the list `b` satisfies `p`, it returns 0, otherwise it proceeds to the rest of the list `l` and increases the index by 1.

For any list `l` of length `n+1` and any index `i` with `0 ≤ i ≤ n`, if `p(l(i))` holds and `p(l(j))` fails for all `0 ≤ j < i`, then `List.findIdx p l = Some i`. Otherwise, `List.findIdx p l = None` or `List.findIdx p l = Some (i + 1)`.


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

This theorem, `Mathlib.Algebra.Order.Group.Abs._auxLemma.2`, states that for any type `α`, given that `α` is a lattice and an additive group, and the addition operation "`+`" on `α` satisfies the two specified covariant classes, then the absolute value of any element `a` of type `α` is always greater than or equal to zero. The equality `(0 ≤ |a|) = True` in Lean signifies that the non-negativity of the absolute value is a universally true statement.

If `α` is a lattice and an additive group such that the absolute value `|.|` is a non-negative, covariant norm on `α`, then for all `a ∈ α`, we have `0 ≤ |a|`.


theorem CategoryTheory.Limits.BinaryFan.IsLimit.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y},
      CategoryTheory.Limits.IsLimit s →
        ∀ {f g : W ⟶ s.pt},
          CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.BinaryFan.fst s) =
              CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.BinaryFan.fst s) →
            CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.BinaryFan.snd s) =
                CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.BinaryFan.snd s) →
              f = g :=
  by sorry

This theorem is about the uniqueness of morphisms to the apex of a limiting binary fan in a category. Specifically, given a category `C` and objects `W`, `X`, `Y` in `C`, if `s` is a limiting binary fan over objects `X` and `Y`, then for any two morphisms `f` and `g` from `W` to the apex of `s`, if the compositions of `f` and `g` with the first and second projections of the fan are equal, then `f` and `g` must be the same. This expresses the universal property of a limit in categorical terms.

Given a limiting binary fan $s$ in a category $C$ over objects $X$, $Y$, and an object $W$, if for morphisms $f$ and $g$ from $W$ to the apex of $s$, we have $s.p_1 \circ f = s.p_1 \circ g$ and $s.p_2 \circ f = s.p_2 \circ g$, then $f = g$.


theorem Finsupp.embDomain_notin_range :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ↪ β) (v : α →₀ M),
      ∀ a ∉ Set.range ⇑f, (Finsupp.embDomain f v) a = 0 :=
  by sorry

The theorem `Finsupp.embDomain_notin_range` states that for any types `α`, `β`, and `M` with `M` having a zero element, given an injective function `f : α ↪ β` and a finitely supported function `v : α →₀ M`, if an element `a` of type `β` is not in the range of the function `f`, then applying the function `Finsupp.embDomain f v` to `a` yields the zero element of type `M`. In other words, the function `Finsupp.embDomain f v` maps elements of `β` not reachable by `f` to zero.

For any injective function `f : α ↪ β`, finitely supported function `v : α →₀ M`, and `a ∈ β` not in the image of `f`, `Finsupp.embDomain f v a = 0`.