/-- The cosine of an angle in a right-angled triangle as a ratio of sides.  -/
theorem InnerProductGeometry.cos_angle_add_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → Real.cos (InnerProductGeometry.angle x (x + y)) = ‖x‖ / ‖x + y‖ :=
  by sorry

This theorem states that in the context of an inner product space over the reals with a normed add commutative group, given two vectors `x` and `y`, if the inner product of `x` and `y` is zero (which means that they are orthogonal), then the cosine of the angle between `x` and the vector `x + y` is equal to the ratio of the norm of `x` to the norm of `x + y`. This is analogous to the geometric concept from trigonometry that in a right-angled triangle, the cosine of an angle is the ratio of the adjacent side length to the length of the hypotenuse.

In an inner product space over the reals, the cosine of the angle between vectors `x` and `x + y` is equal to the quotient of the norm of `x` by the norm of `x + y`, given that `x` and `y` are orthogonal.


theorem List.mem_dlookup_iff :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)},
      List.NodupKeys l → (b ∈ List.dlookup a l ↔ { fst := a, snd := b } ∈ l) :=
  by sorry

The theorem `List.mem_dlookup_iff` states that for any types `α` and `β` with `β` being a dependent type on `α`, given an instance of decidable equality for type `α`, a value `a` of type `α`, a value `b` of the dependent type `β a`, and a list `l` of `Sigma β` (key-value pairs with keys of type `α` and values dependent on keys), if the list `l` has no duplicate keys, then the value `b` is in the result of looking up the key `a` in `l` if and only if the pair `{ fst := a, snd := b }` is in the list `l`. In other words, this theorem connects the process of looking up a key-value pair in a list with no duplicate keys with the membership of the pair in the list itself.

For lists without duplicate keys, `a` is in the key of the pair `{fst := a, snd := b}` in a list `l` of key-value pairs if and only if that pair is in `l`.


theorem Filter.hasBasis_principal :
    ∀ {α : Type u_1} (t : Set α), Filter.HasBasis (Filter.principal t) (fun x => True) fun x => t := by sorry

The theorem `Filter.hasBasis_principal` states that for any type `α` and any set `t` of that type, the principal filter of `t` has a basis that consists of the set `t` itself. Here, a filter's basis is a collection of sets such that any set in the filter can be written as a union of sets in the basis. In more informal terms, this theorem says that the principal filter of any set can be fully understood by considering the set itself; all other sets in the filter are just supersets of the original set.

The principal filter of a set has that set itself as a basis.


theorem map_prod_eq_map_prod :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : CommMonoid α]
      [inst_2 : CommMonoid β] {A : Set α} {n : ℕ} [inst_3 : FreimanHomClass F A β n] (f : F) {s t : Multiset α},
      (∀ ⦃x : α⦄, x ∈ s → x ∈ A) →
        (∀ ⦃x : α⦄, x ∈ t → x ∈ A) →
          Multiset.card s = n →
            Multiset.card t = n →
              Multiset.prod s = Multiset.prod t →
                Multiset.prod (Multiset.map (⇑f) s) = Multiset.prod (Multiset.map (⇑f) t) :=
  by sorry

The theorem `map_prod_eq_map_prod` states that for any types `F`, `α`, and `β`, given a function-like `F` from `α` to `β`, commutative monoid structures on `α` and `β`, a set `A` of elements of type `α`, an integer `n`, and a Freiman homomorphism from `A` to `β` of size `n`. If there are two multisets `s` and `t` of type `α` such that every element in `s` and `t` belongs to `A`, both `s` and `t` have a cardinality of `n`, and the product of elements in `s` and `t` are equal, then the product of the mapped elements of `s` and `t` under function `f` are also equal. Here, "mapped elements" refers to the elements obtained by applying the function `f` to each element in the respective multisets.

In mathematical terms, if two multisets `s` and `t` have the same cardinality and their products are equal, then the product of their images under a Freiman homomorphism `f` is also equal.

Given commutative monoids `α` and `β`, a function-like `F : α → β`, a set `A ⊆ α` with a Freiman homomorphism of size `n : ℕ`, and multisets `s` and `t` of `A` with equal cardinality `n` and product `∏s = ∏t`, then `∏(F <$> s) = ∏(F <$> t)`.


theorem Polynomial.natDegree_X_pow :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : Nontrivial R] (n : ℕ), Polynomial.natDegree (Polynomial.X ^ n) = n :=
  by sorry

This theorem states that for any natural number `n`, the natural degree of the `n`-th power of the polynomial variable `X` (commonly known as the indeterminate) is equal to `n` itself. This fact holds for any semiring `R` that is nontrivial. In other words, it asserts that the degree (as a natural number) of the polynomial `X^n` is `n`, where `X` is the polynomial variable in the semiring `R`.

For any natural number `n` and semiring `R`, the degree of the `n`-th power of the polynomial variable `X` in `R` is `n`.


theorem isLowerSet_compl : ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet sᶜ ↔ IsUpperSet s := by sorry

This theorem states that for any set `s` in an ordered type `α`, the complement of `s` is a lower set if and only if `s` itself is an upper set. In other words, the complement of an upper set is always a lower set and vice-versa. This is the case regardless of the specific elements in `s` or the specific ordering of the type `α`.

For any set `s` in a type `α` with an ordering, `s` is an upper set if and only if the complement of `s` is a lower set.


theorem Real.log_neg_iff : ∀ {x : ℝ}, 0 < x → (Real.log x < 0 ↔ x < 1) := by sorry

The theorem `Real.log_neg_iff` states that for any real number `x`, if `x` is greater than zero, then the logarithm of `x` is less than zero if and only if `x` is less than 1. This theorem connects the properties of the real logarithm function and the size of a real number in relation to 1.

For any real number `x`, `Log x < 0 <-> x > 0 && x < 1`.


theorem isConnected_connectedComponent :
    ∀ {α : Type u} [inst : TopologicalSpace α] {x : α}, IsConnected (connectedComponent x) := by sorry

The theorem `isConnected_connectedComponent` states that for any type `α` with a given topological space structure and for any point `x` of this type, the connected component of `x` is a connected set. The connected component of a point is defined as the maximal set containing this point that cannot be divided into two nonempty open sets without intersection. A set is defined as connected if it is nonempty and does not allow a non-trivial open partition.

For any topological space `(α, top)` and point `x ∈ α`, the connected component of `x` is a connected subset of `α`.


theorem Polynomial.coeff_restriction :
    ∀ {R : Type u} [inst : Ring R] {p : Polynomial R} {n : ℕ},
      ↑(Polynomial.coeff (Polynomial.restriction p) n) = Polynomial.coeff p n :=
  by sorry

This theorem states that for any given ring `R`, polynomial `p` of `R`, and natural number `n`, the coefficient at position `n` of the restriction of `p` is equal to the coefficient at position `n` of `p`. Here, the restriction of a polynomial is a new polynomial whose coefficients are in the subring generated by the coefficients of the original polynomial. This theorem essentially asserts that the process of restriction does not affect the coefficients of the polynomial at any given position.

For any ring `R`, polynomial `p` over `R`, and natural number `n`, the coefficient of `x^(n)` in the restriction of `p` equals the coefficient of `x^(n)` in `p`.


theorem Polynomial.leadingCoeff_map :
    ∀ {R : Type u} {S : Type v} [inst : DivisionRing R] {p : Polynomial R} [inst_1 : Semiring S] [inst_2 : Nontrivial S]
      (f : R →+* S), Polynomial.leadingCoeff (Polynomial.map f p) = f (Polynomial.leadingCoeff p) :=
  by sorry

The theorem `Polynomial.leadingCoeff_map` states that for any polynomial `p` over a division ring `R` and any ring homomorphism `f` from `R` to a semiring `S` (which is nontrivial), the leading coefficient of the polynomial obtained by mapping `p` across `f` is equal to the image of the leading coefficient of `p` under `f`. In other words, applying the ring homomorphism `f` to `p` does not change the leading coefficient of `p`, but merely transforms it via `f`.

For any polynomial $p$ over a division ring $R$ and ring homomorphism $f$ from $R$ to a semiring $S$, the leading coefficient of $f(p)$ is $f(\text{lc}(p))$, where $\text{lc}(p)$ denotes the leading coefficient of $p$.


theorem Submodule.span_singleton_eq_bot :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
      Submodule.span R {x} = ⊥ ↔ x = 0 :=
  by sorry

The theorem `Submodule.span_singleton_eq_bot` states that for any type `R` with a semiring structure, any type `M` with an additive commutative monoid structure and a module structure over `R`, and any element `x` of type `M`, the span of the singleton set containing `x` (which is the smallest submodule of `M` that contains the set `{x}`) is equal to the bottom element (or zero submodule) if and only if `x` equals to zero. This means that the only way for a singleton set to span a trivial submodule (one that contains only the zero element) is if the singleton set itself only contains the zero element.

The span of a singleton set in an `R`-module `M` is the zero submodule if and only if the element in the set is the zero element of `M`.


/-- **Alias** of the reverse direction of `Int.ofNat_le`. -/
theorem Int.ofNat_le_ofNat_of_le : ∀ {m n : ℕ}, m ≤ n → ↑m ≤ ↑n := by sorry

This is essentially an alias of the reverse direction of the `Int.ofNat_le` theorem. It states that for any two natural numbers `m` and `n`, if `m` is less than or equal to `n`, then the integer representation of `m` is also less than or equal to the integer representation of `n`. In other words, the order of the numbers is maintained when they are converted from natural numbers to integers.

If `m` is a natural number less than or equal to `n`, then `Int.fromNat m` is less than or equal to `Int.fromNat n`.


theorem CochainComplex.prev_nat_succ : ∀ (i : ℕ), ComplexShape.prev (ComplexShape.up ℕ) (i + 1) = i := by sorry

The theorem `CochainComplex.prev_nat_succ` states that for any natural number `i`, the function `ComplexShape.prev` applied to the cohomology-appropriate `ComplexShape.up` of natural numbers and the successor of `i` (i.e., `i + 1`) returns `i`. In other words, given a chain complex with natural number indices and a differential going from `X[i]` to `X[i+1]`, when we try to find the predecessor of an index `i + 1`, we will always get `i`. This aligns with the idea that in cohomology, differentials increase the index by one.

For any chain complex with natural number indices, `ComplexShape.prev (ComplexShape.up i) = i` for all natural numbers `i`.


theorem CategoryTheory.whiskerRight_id' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      {G : CategoryTheory.Functor C D} (F : CategoryTheory.Functor D E),
      CategoryTheory.whiskerRight (CategoryTheory.CategoryStruct.id G) F =
        CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.comp G F) :=
  by sorry

This theorem is stating that in the context of three categories `C`, `D`, and `E`, and two functors `G` from `C` to `D` and `F` from `D` to `E`, the operation of "whiskering" the identity morphism on `G` on the right by `F` is equivalent to the identity morphism on the composition of the functors `G` and `F`. In other words, "whiskering" the identity doesn't change the functorial composition. In mathematical terms, this can be expressed as `CategoryTheory.whiskerRight (CategoryTheory.CategoryStruct.id G) F = CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.comp G F)`.

The operation of whiskering the identity morphism of a functor `G` on the right by another functor `F` is equal to the identity morphism of the composite functor `G ∘ F`.


/-- **Alias** of the reverse direction of `Finset.Ico_eq_empty_iff`. -/
theorem Finset.Ico_eq_empty :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, ¬a < b → Finset.Ico a b = ∅ := by
  sorry

This theorem, titled as an "Alias of the reverse direction of `Finset.Ico_eq_empty_iff`," states that for any type `α` which has a preorder and locally finite order, and for any elements `a` and `b` of `α`, if `a` is not less than `b`, then the finite set of elements `x` such that `a ≤ x` and `x < b` is empty. In mathematical notation, this could be expressed as: if `¬a < b`, then `{x ∈ α | a ≤ x < b} = ∅`.

For any locally finite and preordered type `α` and elements `a, b` of `α` with `a ≠ b` and `a not< b`, the set `{x ∈ α | a ≤ x < b}` is empty.


theorem Codisjoint_comm :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b ↔ Codisjoint b a := by
  sorry

The theorem `Codisjoint_comm` states that for any two elements `a` and `b` of a type `α` that has a partial order and a top element, `a` and `b` are codisjoint if and only if `b` and `a` are codisjoint. In other words, the property of being codisjoint is commutative. Recall that in this context, two elements `a` and `b` are said to be codisjoint if for any element `x` of `α` such that `a` and `b` are both less than or equal to `x`, then the top element of `α` is also less than or equal to `x`.

For any partial order with top element, elements `a` and `b` are codisjoint if and only if `b` and `a` are codisjoint. (i.e. the property of being codisjoint is commutative.)


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

This theorem states that for any four extended nonnegative real numbers (commonly denoted as [0, ∞]), if the first is less than the third and the second is less than the fourth, then the sum of the first and second is less than the sum of the third and fourth. In other words, for all `a`, `b`, `c`, `d` in the set of extended nonnegative real numbers, if `a < c` and `b < d`, then `a + b < c + d`.

For all extended nonnegative real numbers `a`, `b`, `c`, `d`, if `a < c` and `b < d`, then `a + b < c + d`.


theorem add_mem_cancel_right :
    ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_6} {H : S} [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G]
      {x y : G}, x ∈ H → (y + x ∈ H ↔ y ∈ H) :=
  by sorry

This theorem, `add_mem_cancel_right`, states that for any type `G` with an `AddGroup` instance, a type `S`, an element `H` of `S` with `SetLike` and `AddSubgroupClass` instances, and two elements `x` and `y` of `G`, if `x` is an element of `H`, then `y + x` is an element of `H` if and only if `y` is an element of `H`. In other words, in the context of addition groups and additive subgroups, adding an element `x` from the subgroup `H` to another element `y` results in an element that is also in `H` if and only if `y` was already in `H`.

For any additive group `G`, additive subgroup `H`, and elements `x` in `H` and `y` in `G`, if `x` is in `H` then `y + x` is in `H` if and only if `y` is in `H`.


/-- The function `expNegInvGlue` is positive on `(0, +∞)`.  -/
theorem expNegInvGlue.pos_of_pos : ∀ {x : ℝ}, 0 < x → 0 < expNegInvGlue x := by sorry

The theorem `expNegInvGlue.pos_of_pos` states that the function `expNegInvGlue`, which is defined as $e^{-1/x}$ for $x>0$ and $0$ for $x \leq 0$, is positive on the interval $(0, +\infty)$. In other words, for any real number $x$ that is greater than zero, the value of `expNegInvGlue` at $x$ is also greater than zero.

For all $x > 0$, the function `expNegInvGlue` returns a positive real number.


theorem MeasureTheory.aecover_Ioi :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a : ι → α},
      Filter.Tendsto a l Filter.atBot → ∀ [inst_5 : NoMinOrder α], MeasureTheory.AECover μ l fun i => Set.Ioi (a i) :=
  by sorry

The theorem `MeasureTheory.aecover_Ioi` states that for any types `α` and `ι`, given a measurable space over `α` and a measure `μ` on that space, a filter `l` over `ι`, and a function `a` from `ι` to `α`, if `a` tends to negative infinity as per the filter `l`, then under the conditions that `α` has a linear order, a topological space, a closed order topology, and an open measurable space, and that `α` has no minimum order, there will always exist an almost everywhere convergent cover of the measure `μ` with respect to the filter `l`, where the cover is defined as the set of all elements greater than `a i` for all `i` in `ι`. In other words, we can cover almost all of the measurable space with sets of the form `(a i, ∞)` where `a i` is decreasing to negative infinity.

Given a measurable space with a measure, a filter tending to negative infinity, and a decreasing sequence in a linearly ordered, topological space with no minimum, there exists an almost everywhere convergent cover by sets of the form `(a i, ∞)` where `a i` decreases through the filter.


theorem Cardinal.toENatAux_nat : ∀ (n : ℕ), Cardinal.toENatAux ↑n = ↑n := by sorry

This theorem states that for all natural numbers `n`, the function `Cardinal.toENatAux` when applied to `n` (coerced to a cardinal number) returns a value equal to `n` (coerced to a type `ℕ∞`, which represents either a natural number or an infinite value). In essence, it asserts a specific behavior of the function `Cardinal.toENatAux`, namely, that it behaves like the identity function when restricted to natural numbers.

For all natural numbers n, Cardinal.toENatAux (coerce n to cardinal) = coerce n ℕ∞.


theorem ENNReal.coe_eq_zero : ∀ {r : NNReal}, ↑r = 0 ↔ r = 0 := by sorry

This theorem states that for any nonnegative real number `r` (of type `NNReal`), the coercion of `r` to an extended nonnegative real number (`ENNReal`) equals zero if and only if `r` itself equals zero. In mathematical terms, let `r` be a nonnegative real number. This result tells us that `r` maps to zero in the extended nonnegative real numbers exactly when `r` is zero.

For any nonnegative real number `r`, `r` maps to zero in the extended nonnegative real numbers if and only if `r` equals zero.


theorem skewAdjoint.mem_iff :
    ∀ {R : Type u_1} [inst : AddCommGroup R] [inst_1 : StarAddMonoid R] {x : R}, x ∈ skewAdjoint R ↔ star x = -x := by
  sorry

This theorem states that, for any type 'R' equipped with a structure of an additive commutative group and a star additive monoid, an element 'x' of 'R' belongs to the set of skew-adjoint elements if and only if the star of 'x' is equal to the additive inverse of 'x'. In other words, the 'star' of an element is its negative if and only if that element is skew-adjoint.

An element x of an additive commutative group R equipped with a star additive monoid is skew-adjoint if and only if the star of x is the additive inverse of x.


theorem LinearPMap.map_zero :
    ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
      [inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F), ↑f 0 = 0 :=
  by sorry

This theorem states that for any ring `R`, and any two modules `E` and `F` over `R`, if we have a linear map `f` from `E` to `F`, then the image of the zero vector in `E` under `f` is the zero vector in `F`. This property is a characteristic of linear maps in mathematics, where the map of zero always yields zero.

For any ring `R`, and modules `E` and `F` over `R`, if `f` is a linear map from `E` to `F`, then `f(0_E) = 0_F`.


FirstOrder.Language.Hom.ext

theorem FirstOrder.Language.Hom.ext :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] ⦃f g : FirstOrder.Language.Hom L M N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

This theorem states that for any first-order language `L` and any two types `M` and `N` with `FirstOrder.Language.Structure` instances, any two homomorphisms `f` and `g` from `M` to `N` in the language `L` are equal if and only if they are equal at each element of `M`. In other words, if two homomorphisms `f` and `g` map each element of `M` to the same element in `N`, then `f` and `g` are identical.

For any first-order language L and types M and N with structure instances, two homomorphisms f and g from M to N are equal if and only if they agree on every element of M.


AEMeasurable.mul

theorem AEMeasurable.mul :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Mul M] {m : MeasurableSpace α} {f g : α → M}
      {μ : MeasureTheory.Measure α} [inst_2 : MeasurableMul₂ M],
      AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (fun a => f a * g a) μ :=
  by sorry

This theorem, `AEMeasurable.mul`, states that in a measurable space `M` equipped with a binary multiplication operation, given two functions `f` and `g` from some measurable space `α` to `M` which are "almost everywhere measurable" with respect to a given measure `μ`, their pointwise product is also "almost everywhere measurable".

In other words, if `f` and `g` coincide almost everywhere with measurable functions in the measure space defined by `μ`, then the function that maps each element `a` in `α` to the product of `f(a)` and `g(a)` also coincides almost everywhere with a measurable function. This is under the assumption that the multiplication operation on `M` is measurable as a binary function.

Given measurable spaces `(M, Σ)` with a measurable binary multiplication operation, if `f` and `g` are almost everywhere defined measurable functions from a measurable space `(α, Σ′)` to `(M, Σ)` with respect to measures `μ` and `ν`, respectively, then their pointwise product is an almost everywhere defined measurable function from `α` to `M`.


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

This theorem describes the definition of the modulus operation on integers in Lean. For any two integers `a` and `b`, the result of `Int.mod a b` is defined as the difference of `a` and the product of `b` with the integer division of `a` by `b`, denoted as `b * Int.div a b`. In mathematical terms, this can be expressed as `a mod b = a - b*(a div b)`.

The modulus operation of two integers `a` and `b` is equivalent to the difference of `a` and the product of `b` and the quotient of `a` by `b`. In Lean, this is expressed as `a mod b = a - b * (a / b)`.


theorem Ideal.span_singleton_eq_top : ∀ {α : Type u} [inst : CommSemiring α] {x : α}, Ideal.span {x} = ⊤ ↔ IsUnit x :=
  by sorry

This theorem states that for any commutative semiring `α` and any element `x` of `α`, the ideal generated by the singleton set containing `x` is the entire ring (`⊤`) if and only if `x` is a unit. In terms of algebra, a unit is an element that has a multiplicative inverse; the ideal of a unit in a commutative ring is the whole ring. Thus, the theorem is saying that an element generates the entire ring as an ideal if and only if it has a multiplicative inverse.

For a commutative semiring `α`, an element `x` is a unit if and only if the ideal generated by `{x}` equals `α`.


theorem Mathlib.LinearAlgebra.Prod._auxLemma.19 :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [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₂} [inst_6 : RingHomSurjective σ₁₂] {F : Type u_9} [inst_7 : FunLike F M M₂]
      [inst_8 : SemilinearMapClass F σ₁₂ M M₂] {f : F} {p : Submodule R M} {x : M₂},
      (x ∈ Submodule.map f p) = ∃ y ∈ p, f y = x :=
  by sorry

The theorem `Mathlib.LinearAlgebra.Prod._auxLemma.19` in natural language states that:

For any two semirings `R` and `R₂`, two additively commutative monoids `M` and `M₂`, modules `M` and `M₂` over `R` and `R₂` respectively, a surjective ring homomorphism `σ₁₂` from `R` to `R₂`, a function-like `F` from `M` to `M₂`, a semilinear map class `F σ₁₂ M M₂`, a function `f` of type `F`, a submodule `p` of `M`, and an element `x` of `M₂`, the theorem asserts that `x` is in the image of the submodule `p` under the function `f` if and only if there exists an element `y` in `p` such that `f y` equals `x`.

This theorem describes a condition for an element to be in the image of a submodule under a function (which behaves like a semilinear map), and it's fundamental for understanding mappings between different algebraic structures in linear algebra.

For a surjective ring homomorphism σ₁₂ from semirings R to R₂, a semilinear map F from module M over R to module M₂ over R₂, and a submodule p of M, an element x in M₂ is in the image of p under F if and only if there exists y in p such that F(y) = x.


theorem Nat.le_of_eq : ∀ {n m : ℕ}, n = m → n ≤ m := by sorry

This theorem, `Nat.le_of_eq`, asserts that for any two natural numbers `n` and `m`, if `n` equals `m`, then `n` is less than or equal to `m`. This is a fundamental property of the natural numbers, and the inequality relationship, where an equality between two numbers implies a less-than-or-equal-to relationship between the same two numbers.

For all natural numbers n and m, if n = m then n ≤ m.


/-- Rescaling a set by a factor `r` multiplies its measure by `abs (r ^ dim)`.  -/
theorem MeasureTheory.Measure.addHaar_smul :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
      [inst_3 : BorelSpace E] [inst_4 : FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E)
      [inst_5 : MeasureTheory.Measure.IsAddHaarMeasure μ] (r : ℝ) (s : Set E),
      ↑↑μ (r • s) = ENNReal.ofReal |r ^ FiniteDimensional.finrank ℝ E| * ↑↑μ s :=
  by sorry

This theorem states that for a given normed additive commutative group `E` that also has a structure of a real normed space, measurable space, and Borel space, and is of finite dimension over the real numbers, with `μ` as an add-Haar measure on `E`, the measure of the set obtained by scaling a set `s` by a factor `r` is equal to the absolute value of `r` raised to the power of the rank of the finite dimensional space `E` times the measure of the original set `s`. In mathematical terms, if `μ` is a measure and `s` is a set in `E`, then the measure of the scaled set `r•s` is `|r|^dim(E) * μ(s)`, where `dim(E)` is the dimension of the vector space `E`.

For a finite-dimensional, real normed space `E` with Haar measure `μ`, the measure of a set `s` is equal to the absolute value of the scaling factor `r` raised to the power of the space's dimension, multiplied by the measure of the scaled set `r•s`.


theorem Polynomial.aeval_algHom :
    ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (x : A),
      Polynomial.aeval (f x) = AlgHom.comp f (Polynomial.aeval x) :=
  by sorry

The theorem `Polynomial.aeval_algHom` states that for any commutative semiring `R`, semirings `A` and `B`, and any algebra structure over `R` on `A` and `B`, given an algebra homomorphism `f` from `A` to `B` and an element `x` of `A`, the algebra evaluation of `f(x)` is equal to the composition of `f` and the algebra evaluation at `x`. In other words, applying the algebra homomorphism first and then performing the algebra evaluation is the same as performing the algebra evaluation first and then applying the algebra homomorphism.

For any commutative semirings R, semirings A and B, algebra structures on A and B over R, algebra homomorphism f from A to B, and element x in A, we have f(α(x)) = α(f(x)), where α denotes algebra evaluation.


theorem sSup_eq_bot : ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α}, sSup s = ⊥ ↔ ∀ a ∈ s, a = ⊥ := by sorry

This theorem, `sSup_eq_bot`, states that for any given type `α`, which is a complete lattice, and any set `s` of type `α`, the supremum of set `s`, denoted as `sSup s`, is equal to the bottom element of the lattice (represented as `⊥` in Lean 4) if and only if all elements `a` in set `s` are equal to the bottom element of the lattice. In other words, the greatest lower bound of a set in a complete lattice is the lowest element of the lattice if and only if every element in the set is also the lowest element of the lattice.

For any complete lattice `α` and set `s` in `α`, `sSup s = ⊥` if and only if all elements in `s` are `⊥`.


/-- The norm of a function is controlled by the supremum of the pointwise norms.  -/
theorem BoundedContinuousFunction.norm_le :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
      {f : BoundedContinuousFunction α β} {C : ℝ}, 0 ≤ C → (‖f‖ ≤ C ↔ ∀ (x : α), ‖f x‖ ≤ C) :=
  by sorry

This theorem, `BoundedContinuousFunction.norm_le`, states that for any types `α` and `β`, where `α` is a topological space and `β` is a semi-normed additively commutative group, for any bounded continuous function `f` from `α` to `β` and any real number `C` greater than or equal to zero, the norm of `f` is less than or equal to `C` if and only if the norm of `f` at any point `x` in `α` is less than or equal to `C`. In other words, the norm of a function is controlled by the supremum (greatest value) of the pointwise norms.

For any bounded continuous function between a topological space and a semi-normed additively commutative group, the function's norm is equal to the supreme norm of its values at individual points.


theorem Multiset.lcm_cons :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α) (s : Multiset α),
      Multiset.lcm (a ::ₘ s) = lcm a (Multiset.lcm s) :=
  by sorry

The theorem `Multiset.lcm_cons` states that for any type `α` that has a structure of a cancel commutative monoid with zero and a normalized gcd monoid, and given an element `a` of type `α` and a multiset `s` of elements of type `α`, the least common multiple of the multiset obtained by adding `a` to `s` is equal to the least common multiple of `a` and the least common multiple of the multiset `s`. In other words, the least common multiple operation on multisets is compatible with the cons operation.

For any cancel commutative monoid with zero and normalized gcd `α`, the least common multiple of an element `a` and a multiset `s` equals the least common multiple of `a` concatenated with multiset `s`.


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

This theorem states that for any type `α` that forms an additive monoid, for any two additive units `a` and `b` of type `α`, the additive operation of the underlying units of `a` and `b` (i.e., `↑a + ↑b`) is equal to the underlying unit of the additive operation of `a` and `b` (i.e., `↑(a + b)`). In other words, applying the additive operation before or after lifting to the additive units doesn't change the result. This is a statement about the compatibility of the additive operation with the embedding from `α` to the additive units.

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


theorem Complex.cos_arg : ∀ {x : ℂ}, x ≠ 0 → Real.cos (Complex.arg x) = x.re / Complex.abs x := by sorry

This theorem states that for any non-zero complex number `x`, the real part of `x` divided by the absolute value of `x` is equal to the real cosine of the argument of `x`. In mathematical terms, this means that for all complex numbers `x ≠ 0`, we have $\cos(\arg(x)) = \frac{x_{\text{re}}}{|x|}$, where $\arg(x)$ is the argument of `x`, $x_{\text{re}}$ is the real part of `x`, and $|x|$ is the absolute value of `x`.

For any non-zero complex number x, the real part x\_{re} is equal to the absolute value of x times the cosine of its argument, i.e., x\_{re} = |x| * cos(arg(x)).


theorem List.erase_cons_tail :
    ∀ {α : Type u_1} [inst : BEq α] {a b : α} (l : List α),
      ¬(b == a) = true → List.erase (b :: l) a = b :: List.erase l a :=
  by sorry

This theorem, `List.erase_cons_tail`, states that for all types `α`, given an instance of `BEq α` (which allows for equality checks), and for any elements `a` and `b` of type `α` and a list `l` of type `α`, if `b` is not equal to `a` (i.e., `b == a` evaluates to `false`), then erasing `a` from the list that starts with `b` and is followed by `l` (`b :: l`) is equivalent to the list that starts with `b` and is followed by the list resulted from erasing `a` from `l`.

For all types `α` with equality `BEq α`, and for all `a`, `b` in `α` with `b != a`, the list `b :: List.erase a l` equals `b :: l` for any list `l` of type `α`.


theorem mul_lt_mul_of_neg_left :
    ∀ {α : Type u} [inst : StrictOrderedSemiring α] {a b c : α} [inst_1 : ExistsAddOfLE α],
      b < a → c < 0 → c * a < c * b :=
  by sorry

This theorem, `mul_lt_mul_of_neg_left`, is applicable within the context of a `StrictOrderedSemiring` type (a type of algebraic structure that combines the properties of a ring and an ordered set, but without requiring the existence of additive inverses). It states that for any three elements `a`, `b`, and `c` of this type, if `b` is less than `a` and `c` is less than zero, then the product of `c` and `a` is less than the product of `c` and `b`. In simpler terms, it expresses the property that multiplying by a negative number reverses the order of inequality.

For any `StrictOrderedSemiring` `a, b, c`, if `b < a` and `c < 0`, then `c * a < c * b`.


theorem Set.mem_sUnion : ∀ {α : Type u} {x : α} {S : Set (Set α)}, x ∈ ⋃₀ S ↔ ∃ t ∈ S, x ∈ t := by sorry

This theorem, `Set.mem_sUnion`, states that for all types `α`, and for all elements `x` of this type, and for all sets `S` of sets of `α`, the element `x` is a member of the union over all sets in `S` if and only if there exists a set `t` in `S` such that `x` is a member of `t`. This is equivalent to stating that an element belongs to the union of a collection of sets if it belongs to at least one of the sets in the collection.

For any type `α` and sets `S` of sets of `α`, an element `x` is in the union of `S` if and only if it is in some set in `S`.


CauSeq.cauchy

theorem CauSeq.cauchy :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α} (f : CauSeq β abv)
      {ε : α}, 0 < ε → ∃ i, ∀ j ≥ i, abv (↑f j - ↑f i) < ε :=
  by sorry

This theorem states that for any type `α` with a linearly ordered field structure and any type `β` with a ring structure, given an absolute value function `abv` from `β` to `α` and a Cauchy sequence `f` (with respect to the absolute value function `abv`), for any positive `ε` of type `α`, there exists an index `i` such that for all indices `j` greater than or equal to `i`, the absolute value of the difference between the `j`-th and `i`-th terms of the sequence `f` is less than `ε`. In other words, it states that a Cauchy sequence is such that, beyond some point, the elements of the sequence get arbitrarily close to each other.

Given a linearly ordered field `α` and a ring `β` with an absolute value function `abv` from `β` to `α`, any Cauchy sequence in `β` with respect to `abv` converges to a limit in `β`.


theorem Rel.mem_interedges_iff :
    ∀ {α : Type u_4} {β : Type u_5} {r : α → β → Prop} [inst : (a : α) → DecidablePred (r a)] {s : Finset α}
      {t : Finset β} {x : α × β}, x ∈ Rel.interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2 :=
  by sorry

The theorem `Rel.mem_interedges_iff` states that for any types `α` and `β`, any relation `r` from `α` to `β` that is a decidable predicate, any finite sets `s` of type `α` and `t` of type `β`, and any pair `x` of type `α × β`, the pair `x` is an element of the finite set of edges between `s` and `t` (denoted as `Rel.interedges r s t`) if and only if the first element of `x` belongs to `s`, the second element of `x` belongs to `t`, and the relation `r` holds between the first and second elements of `x`.

For any decidable relation $r$ between types $\alpha$ and $\beta$, sets $s$ and $t$ of finite elements from $\alpha$ and $\beta$ respectively, the pair $(x\_1, x\_2)$ is an edge between $s$ and $t$ in $r$ if and only if $x\_1 \in s$, $x\_2 \in t$, and $(x\_1, x\_2) \in r$.


theorem MonoidWithZeroHom.map_zero :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f : α →*₀ β), f 0 = 0 := by
  sorry

This theorem states that for any monoid homomorphism `f` from a type `α` to a type `β`, where both `α` and `β` have structures of `MulZeroOneClass` (meaning they have multiplication operation, and elements zero and one with certain properties), the image of `0` under `f` is `0`. In other words, this homomorphism preserves the zero element while mapping from `α` to `β`.

For any monoid homomorphism `f` from a `MulZeroOneClass` type `α` to a `MulZeroOneClass` type `β`, `f 0 = 0`.


theorem Polynomial.isEquivalent_atTop_div :
    ∀ {𝕜 : Type u_1} [inst : NormedLinearOrderedField 𝕜] (P Q : Polynomial 𝕜) [inst_1 : OrderTopology 𝕜],
      Asymptotics.IsEquivalent Filter.atTop (fun x => Polynomial.eval x P / Polynomial.eval x Q) fun x =>
        Polynomial.leadingCoeff P / Polynomial.leadingCoeff Q *
          x ^ (↑(Polynomial.natDegree P) - ↑(Polynomial.natDegree Q)) :=
  by sorry

This theorem states that for any polynomials `P` and `Q` over a normed linearly ordered field `𝕜`, with an order topology, the function which evaluates `P` divided by `Q` at `x`, is asymptotically equivalent (as `x` approaches infinity) to the function that is the product of the leading coefficient of `P` divided by the leading coefficient of `Q`, and `x` to the power of the difference of the natural degrees of `P` and `Q`. Essentially, this states that as `x` goes to infinity, the ratio of the evaluations of the two polynomials behaves like a power function where the exponent is the difference between the degrees of the two polynomials and the constant is the ratio of their leading coefficients.

For polynomials `P` and `Q` over a normed linearly ordered field with order topology, as `x` approaches infinity, the ratio of `P x / Q x` are asymptotically equivalent to the product of the leading coefficients quotient and `x` raised to the power of the difference of degrees of `P` and `Q`.


theorem NumberField.InfinitePlace.isReal_mk_iff :
    ∀ {K : Type u_2} [inst : Field K] {φ : K →+* ℂ},
      NumberField.InfinitePlace.IsReal (NumberField.InfinitePlace.mk φ) ↔ NumberField.ComplexEmbedding.IsReal φ :=
  by sorry

This theorem asserts that for any field `K` and any complex embedding `φ` from `K` to the complex numbers `ℂ`, the infinite place generated by `φ` is real (as defined by `NumberField.InfinitePlace.IsReal`) if and only if the complex embedding `φ` is real (as defined by `NumberField.ComplexEmbedding.IsReal`). In other words, an infinite place in a number field is real if and only if it is defined by an embedding into the complex numbers that is fixed by complex conjugation.

For any field `K` and complex embedding `φ:` `K` → `ℂ,` the infinite place generated by `φ` is real if and only if `φ` is a real embedding.


theorem tendsto_inverse_atTop_nhds_zero_nat : Filter.Tendsto (fun n => (↑n)⁻¹) Filter.atTop (nhds 0) := by sorry

The theorem `tendsto_inverse_atTop_nhds_zero_nat` states that the function that takes an integer `n` to its inverse `(↑n)⁻¹` (where `↑n` denotes the real number corresponding to the integer `n`), tends to 0 as `n` tends to infinity. In other words, as the input `n` becomes larger and larger, the output `(↑n)⁻¹` comes arbitrarily close to 0. This fits with our intuitive understanding from calculus, where the reciprocal of a large number is a small number close to zero.

The sequence of numbers given by the reciprocal of the real numbers corresponding to natural numbers tends to 0 as the natural numbers approach infinity.


theorem Denumerable.ofNat_encode :
    ∀ {α : Type u_1} [inst : Denumerable α] (a : α), Denumerable.ofNat α (Encodable.encode a) = a := by sorry

This theorem states that for any type `α` that is denumerable, applying the function `Denumerable.ofNat α` to the result of encoding an element `a` of type `α` using `Encodable.encode` will return the original element `a`. In other words, the encoding operation, followed by the decoding operation, is the identity operation for any element of any denumerable type.

For any denumerable type `α` and encodable element `a` of type `α`, `Encodable.encode a = Denumerable.ofNat (α : Type) (Denumerable.ofNat _ a)`.


theorem IsLocalization.comap_map_of_isPrime_disjoint :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (I : Ideal R),
      Ideal.IsPrime I → Disjoint ↑M ↑I → Ideal.comap (algebraMap R S) (Ideal.map (algebraMap R S) I) = I :=
  by sorry

The theorem `IsLocalization.comap_map_of_isPrime_disjoint` states that for any commutative semiring `R`, a submonoid `M` of `R`, a type `S` which is a commutative semiring and a localization of `R` at `M`, and a prime ideal `I` of `R` that is disjoint from `M`, the preimage (`comap`) of the span of the image (`map`) of `I` under the embedding given by the `Algebra` structure (`algebraMap`) is equal to `I` itself.

In simpler terms, this is saying that under specific conditions (the ideal is prime and disjoint from the submonoid), mapping the ideal from `R` to `S` and then mapping it back to `R` gives us the original ideal.

Given a commutative semiring `R`, a submonoid `M` of `R`, a commutative semiring `S` and a localization of `R` at `M`, if `I` is a prime ideal of `R` disjoint from `M`, then the preimage under `algebraMap` of the ideal `map(I)` in `S` is equal to `I` in `R`.


theorem PrincipalSeg.lt_top :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≺i s) (a : α),
      s (f.toRelEmbedding a) f.top :=
  by sorry

This theorem, `PrincipalSeg.lt_top`, states that for all types `α` and `β`, and relations `r` on `α` and `s` on `β`, if we have a principal segment `f` from `r` to `s`, and any element `a` of type `α`, then the relation `s` holds between the image of `a` under the relational embedding of `f` and the top element of `f`. In other words, if `f` is a principal segment from one relation space to another, all elements from the source space are related (via `s`) to the top element of `f` when embedded into the target space.

For any types `α` and `β`, relations `r` on `α` and `s` on `β`, and a principal segment `f` from `r` to `s`, for all `a` in `α`, `s(f a)` holds.


theorem Int.natAbs_eq_natAbs_iff : ∀ {a b : ℤ}, Int.natAbs a = Int.natAbs b ↔ a = b ∨ a = -b := by sorry

The theorem `Int.natAbs_eq_natAbs_iff` states that, for any two integers `a` and `b`, the absolute value of `a` is equal to the absolute value of `b` if and only if `a` is equal to `b` or `a` is equal to the negation of `b`. In other words, two integers have the same absolute value if they are either the same number or each other's opposites.

For integers `a` and `b`, |a| = |b| if and only if a = b or a = -b.


theorem Real.sInf_of_not_bddBelow : ∀ {s : Set ℝ}, ¬BddBelow s → sInf s = 0 := by sorry

This theorem states that for any set of real numbers, if the set is not bounded below (i.e., it doesn't have a minimum value or a lower limit), then the greatest lower bound (infimum) of the set is zero. In other words, if a set of real numbers can extend indefinitely in the negative direction, then its infimum is zero.

If a non-empty set of real numbers has no lowest element, then its infimum is 0.


theorem Finset.fold_empty :
    ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β}
      {b : β}, Finset.fold op b f ∅ = b :=
  by sorry

The `Finset.fold_empty` theorem states that for any types `α` and `β`, any binary operation `op` on `β` that is both commutative and associative, any function `f` from `α` to `β`, and any element `b` of `β`, the fold of the operation `op` over the `f`-image of an empty finset with the initial value `b` is equal to `b`. In mathematical notation, this can be written as `fold(op, b, f, ∅) = b`. In short, applying a fold operation on an empty set always returns the initial value.

For any commutative and associative binary operation `op` on type `β`, function `f` from `α` to `β`, and element `b` of `β`, the fold of `op` over the empty finset `∅` using `f` and `b` as arguments equals `b`. In mathematical notation, `fold(op, b, f, ∅) = b`.


theorem Metric.thickening_of_nonpos :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ}, δ ≤ 0 → ∀ (s : Set α), Metric.thickening δ s = ∅ := by sorry

The theorem `Metric.thickening_of_nonpos` states that in any pseudo emetric space, the δ-thickening of a set is empty if δ is less than or equal to zero. In simpler terms, if we try to create a set of points that are less than or equal to zero distance from a given set (which makes little sense as distances are non-negative), we end up with no points, or an empty set.

In a pseudo metric space, the δ-thickening of a set is empty for δ ≤ 0.


padicNorm.nonarchimedean

/-- The `p`-adic norm is nonarchimedean: the norm of `p + q` is at most the max of the norm of `p`
and the norm of `q`.  -/
theorem padicNorm.nonarchimedean :
    ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r) := by sorry

The theorem `padicNorm.nonarchimedean` asserts that the `p`-adic norm is nonarchimedean. This means for any natural number `p` which is a prime number, and for any two rational numbers `q` and `r`, the `p`-adic norm of the sum of `q` and `r` is less than or equal to the maximum of the `p`-adic norm of `q` and the `p`-adic norm of `r`. In mathematical terms, this can be expressed as $\| q + r \|_p \leq \max(\| q \|_p, \| r \|_p)$, where $p$ is a prime number and $q, r \in \mathbb{Q}$.

For any prime number p and rational numbers q and r, the p-adic norm of q + r is less than or equal to the maximum of the p-adic norms of q and r. (i.e., \| q + r \|p ≤ max(\| q \|p, \| r \|p)).


theorem ContinuousWithinAt.tendsto_nhdsWithin :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {x : α}
      {s : Set α} {t : Set β},
      ContinuousWithinAt f s x → Set.MapsTo f s t → Filter.Tendsto f (nhdsWithin x s) (nhdsWithin (f x) t) :=
  by sorry

The theorem `ContinuousWithinAt.tendsto_nhdsWithin` states that for every topological spaces `α` and `β`, function `f : α → β`, point `x : α`, and sets `s : Set α` and `t : Set β`, if the function `f` is continuous at point `x` within the set `s` and the image of `s` under `f` is contained in `t`, then the limit of function `f` as `x` approaches within `s` equals the limit of `f(x)` as it approaches within `t`. In other words, it asserts the image of a neighborhood within a set under a continuous function is itself a neighborhood within the image of the set.

If a continuous function restricted to a set maps that set's neighborhoods to neighborhoods in the image set, then the limit of the function as the input approaches within the set equals the limit of the function's image as the image approaches within the image set.


theorem exists_or : ∀ {α : Sort u_1} {p q : α → Prop}, (∃ x, p x ∨ q x) ↔ (∃ x, p x) ∨ ∃ x, q x := by sorry

This theorem states that for any type `α` and for any properties `p` and `q` on `α`, the existence of an element in `α` that satisfies either `p` or `q` is logically equivalent to the existence of an element in `α` that satisfies `p` or the existence of an element in `α` that satisfies `q`. In mathematical terms, it means that ∃x (p(x) ∨ q(x)) is equivalent to (∃x p(x)) ∨ (∃x q(x)).

The theorem asserts that for any type `α` and properties `p` and `q` on `α`, the existence of an element in `α` satisfying `p` or `q` is logically equivalent to the existence of an element in `α` satisfying `p` or an independent element satisfying `q`. (Note: In the original statement, "or the existence of an element in `α` that satisfies `q`" seems to be redundant as it is already stated that the property holds for either `p` or `q`.)


theorem Finsupp.filter_apply_pos :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (p : α → Prop) [inst_1 : DecidablePred p] (f : α →₀ M) {a : α},
      p a → (Finsupp.filter p f) a = f a :=
  by sorry

The theorem `Finsupp.filter_apply_pos` states that for any types `α` and `M` with `M` having a zero element, given a decidable predicate `p` over `α` and a finitely supported function `f` from `α` to `M`, for any element `a` in `α`, if the predicate `p` holds true for `a`, then the value of `Finsupp.filter p f` at `a` is the same as the value of `f` at `a`. Essentially, if the predicate is true for a specific input, the filtering function doesn't change the value of the original function at that input.

For any decidable predicate `p` and finitely supported function `f` from a type `α` with zero element, `Finsupp.filter p f a = f a` whenever `p(a)` holds.


theorem Set.mulIndicator_apply_le' :
    ∀ {α : Type u_2} {M : Type u_4} [inst : LE M] [inst_1 : One M] {s : Set α} {f : α → M} {a : α} {y : M},
      (a ∈ s → f a ≤ y) → (a ∉ s → 1 ≤ y) → Set.mulIndicator s f a ≤ y :=
  by sorry

The theorem `Set.mulIndicator_apply_le'` states that for any type `α`, a type `M` that has a less than or equal to operation (`LE M`) and a multiplicative identity (`One M`), a set `s` of `α`, a function `f` from `α` to `M`, an element `a` of `α`, and a `y` of `M`, if `a` is in `s` implies that `f(a)` is less than or equal to `y` and if `a` is not in `s` implies that `1` is less than or equal to `y`, then the result of `Set.mulIndicator s f a` is less than or equal to `y`. In other words, the indicator function of a set and a function (which returns the function value if an element is in the set and `1` otherwise) at a particular point is always less than or equal to `y` given the stated conditions.

For any set `s` of type `α`, function `f` from `α` to a type `M` with `LE M` and `One M`, if `a ∈ s` implies `f(a) ≤ y` and `a ∉ s` implies `1 ≤ y`, then `Set.mulIndicator s f a ≤ y`.


theorem unitary.mem_iff :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, U ∈ unitary R ↔ star U * U = 1 ∧ U * star U = 1 :=
  by sorry

The theorem `unitary.mem_iff` states that for any type `R` with a `Monoid` and `StarMul` structure, and for any element `U` of `R`, `U` is a member of the `unitary` submonoid of `R` if and only if the product of `star U` and `U` equals 1 and the product of `U` and `star U` equals 1. In other words, an element `U` belongs to the set of unitary elements of `R` precisely when `star U * U = 1` and `U * star U = 1`.

An element `U` of a type `R` equipped with `Monoid` and `StarMul` structures belongs to the unitary submonoid if and only if `star U * U = 1` and `U * star U = 1`.


theorem AlgHom.map_sum :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) {ι : Type u_1} (f : ι → A) (s : Finset ι),
      φ (Finset.sum s fun x => f x) = Finset.sum s fun x => φ (f x) :=
  by sorry

The theorem `AlgHom.map_sum` states that for any commutative semiring `R`, semirings `A` and `B`, and algebras `A` and `B` over `R`, given an algebra homomorphism `φ` from `A` to `B`, a function `f` mapping elements of some type `ι` to `A`, and a finite set `s` of type `ι`, the homomorphism of the sum of the function `f` applied to each element in `s` is equal to the sum of the homomorphism of the function `f` applied to each element in `s`. In other words, the algebra homomorphism distributes over the sum of a finite set in `A`. This can be written in LaTeX as follows: for all φ, f and s, φ(∑_{x ∈ s} f(x)) = ∑_{x ∈ s} φ(f(x)).

For any commutative semiring R, algebras A and B over R, algebra homomorphism φ from A to B, function f from some type ι to A, and finite set s of type ι, φ(∑x∈s f(x)) = ∑x∈s φ(f(x)).


theorem measurableEmbedding_const_smul :
    ∀ {G : Type u_1} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace α] [inst_2 : Group G]
      [inst_3 : MulAction G α] [inst : MeasurableSMul G α] (c : G), MeasurableEmbedding fun x => c • x :=
  by sorry

This theorem states that for any given type `G`, and a type `α`, with `G` being a group that acts on `α` via multiplication (`MulAction G α`), assuming that `G` and `α` are measurable spaces and the operation of `G` on `α` is also measurable (`MeasurableSMul G α`), then for any constant `c` of type `G`, the function that maps each element `x` from `α` to the result of `c • x` is a measurable embedding. In other words, scalar multiplication by a constant in a measurable space is a measurable embedding.

For any measurable group action `MulAction G α` and constant `c` in the measurable group `G`, the function `x ↦ c • x` is a measurable embedding from `α` to `α`.


theorem Fin.castSucc_le_castSucc_iff : ∀ {n : ℕ} {a b : Fin n}, Fin.castSucc a ≤ Fin.castSucc b ↔ a ≤ b := by sorry

The theorem `Fin.castSucc_le_castSucc_iff` states that for all natural numbers `n` and for any two elements `a` and `b` of the finite set `Fin n`, the embedding of `a` in `Fin (n+1)` is less than or equal to the embedding of `b` in `Fin (n+1)` if and only if `a` is less than or equal to `b`. In other words, it says that the order of elements in `Fin n` is preserved when they are embedded into `Fin (n+1)` using the `Fin.castSucc` function.

For all natural numbers n and Finite set elements a, b in Fin n, a ≤ b if and only if Fin.castSucc a ≤ Fin.castSucc b in Fin (n+1).


TopologicalSpace.Clopens.isClopen

theorem TopologicalSpace.Clopens.isClopen :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Clopens α), IsClopen ↑s := by sorry

This theorem states that for any topological space `α` and any clopen set `s` in this space, `s` is both closed and open. In more detail, given a topological space, which is a set with a family of subsets satisfying certain properties, there exists a concept of 'clopen' sets. These are sets that are both closed (complements of open sets) and open (part of the given family of subsets). The theorem confirms that if a set is defined as 'clopen' in the space, it indeed possesses both of these properties.

In any topological space, a clopen set is both closed and open.


theorem CategoryTheory.Subobject.factors_of_le :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z : C} {P Q : CategoryTheory.Subobject Y}
      (f : Z ⟶ Y), P ≤ Q → CategoryTheory.Subobject.Factors P f → CategoryTheory.Subobject.Factors Q f :=
  by sorry

This theorem states that in any category `C`, for any two objects `Y` and `Z`, and any two subobjects `P` and `Q` of `Y`, if there is a morphism `f` from `Z` to `Y`, and if `P` is less than or equal to `Q`, then if there exists a factorization of `f` through `P`, there must also exist a factorization of `f` through `Q`. In other words, if `f` can be factored through a smaller subobject `P`, it can also be factored through a larger subobject `Q`.

In any category, given two objects and two subobjects, if a morphism from one object to another factors through a smaller subobject, then it also factors through any larger subobject containing it.


theorem Dioph.add_dioph :
    ∀ {α : Type} {f g : (α → ℕ) → ℕ}, Dioph.DiophFn f → Dioph.DiophFn g → Dioph.DiophFn fun v => f v + g v := by sorry

The theorem `Dioph.add_dioph` states that for any type `α` and any two functions `f` and `g` that map from a function (which itself maps from `α` to natural numbers) to natural numbers, if both `f` and `g` are Diophantine functions, then the function that maps `v` to the sum of `f v` and `g v` is also a Diophantine function. In other words, the sum of two Diophantine functions is also a Diophantine function.

If `f` and `g` are Diophantine functions mapping from a function to natural numbers, then their sum `v => f v + g v` is also a Diophantine function.


LocallyFinite.closure

theorem LocallyFinite.closure :
    ∀ {ι : Type u_1} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X},
      LocallyFinite f → LocallyFinite fun i => closure (f i) :=
  by sorry

This theorem states that for any type `ι` and any topological space `X`, if a family of sets `f : ι → Set X` is locally finite, then the family of closures of these sets is also locally finite. In more detail, the function `f` maps elements of type `ι` to sets in `X`, and `LocallyFinite f` means that for every point in `X`, there is a neighborhood of this point that intersects with only a finite number of sets in the family defined by `f`. The theorem claims that this property still holds if each set in the family is replaced by its closure, where the closure of a set is the smallest closed set that contains it.

If `f : ι → Sets X` is a locally finite family of sets in a topological space `X`, then the family of closures of `f` is also locally finite.


theorem MeasureTheory.Integrable.div_const :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_5} [inst : NormedDivisionRing 𝕜]
      {f : α → 𝕜}, MeasureTheory.Integrable f μ → ∀ (c : 𝕜), MeasureTheory.Integrable (fun x => f x / c) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.div_const` states that for any measurable space `α` with a measure `μ`, a type `𝕜` forming a normed division ring, and a function `f : α → 𝕜` that is integrable with respect to `μ`, the function obtained by dividing `f` by any constant `c : 𝕜` is also integrable with respect to `μ`. Essentially, this theorem assures that the integrability property is preserved when a function is divided by a constant.

If `α` is a measurable space with measure `μ`, `𝕜` is a normed division ring, and `f : α → 𝕜` is an integrable function, then the function `x mapsto (f x) / c` is integrable for any constant `c ∈ 𝕜`.


SchwartzMap.differentiableAt

/-- Every Schwartz function is differentiable at any point.  -/
theorem SchwartzMap.differentiableAt :
    ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (f : SchwartzMap E F) {x : E},
      DifferentiableAt ℝ (⇑f) x :=
  by sorry

The theorem `SchwartzMap.differentiableAt` states that for any Schwartz function `f` mapping from a type `E` to a type `F` (where both `E` and `F` form a normed additive commutative group over the real numbers), the function `f` is differentiable at any point `x` in `E`. In mathematical terms, if `f` is a Schwartz function from a normed space `E` to a normed space `F`, then there exists a derivative of `f` at each point in `E`.

Every Schwartz function from a normed additive commutative group `E` to a normed additive commutative group `F` over the real numbers is differentiable at every point in `E`.


theorem Summable.map_iff_of_leftInverse :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
      [inst_2 : AddCommMonoid γ] [inst_3 : TopologicalSpace γ] {G : Type u_5} {G' : Type u_6} [inst_4 : FunLike G α γ]
      [inst_5 : AddMonoidHomClass G α γ] [inst_6 : FunLike G' γ α] [inst_7 : AddMonoidHomClass G' γ α] (g : G)
      (g' : G'), Continuous ⇑g → Continuous ⇑g' → Function.LeftInverse ⇑g' ⇑g → (Summable (⇑g ∘ f) ↔ Summable f) :=
  by sorry

The theorem `Summable.map_iff_of_leftInverse` states that for any types `α`, `β`, `γ`, if `α` and `γ` are both additively commutative monoids and topological spaces, and for any terms `f` of type `β → α`, `g` of a type `G` that has a function-like behavior from `α` to `γ`, and `g'` of a type `G'` that has a function-like behavior from `γ` to `α`, if both `g` and `g'` are continuous and `g'` is a left inverse to `g` (meaning that applying `g'` after `g` gives the identity on `α`), then `f` is summable if and only if the composition `g ∘ f` is summable.

In simpler terms, this theorem states that if you have a summable function `f` and a pair of continuous functions `g` and `g'` acting like an inverse pair, then the function obtained by applying `g` to `f` is also summable, and vice versa.

If `α`, `β`, `γ` are additively commutative monoids and topological spaces, `f: β -> α`, `g: α -> γ`, `g': γ -> α` are continuous functions with `g'` being a left inverse to `g`, then `Summable f <-> Summable (g ∘ f)`.


theorem Ordinal.sup_lt_ord_lift :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v}} {c : Ordinal.{max u v}},
      Cardinal.lift.{v, u} (Cardinal.mk ι) < Ordinal.cof c → (∀ (i : ι), f i < c) → Ordinal.sup f < c :=
  by sorry

The theorem `Ordinal.sup_lt_ord_lift` states that for any type `ι`, a function `f` from `ι` to ordinals, and an ordinal `c`, if the cardinality of the lift of `ι` is less than the cofinality of `c`, and further every ordinal obtained by applying `f` to a member of `ι` is less than `c`, then the supremum of the ordinals obtained by applying `f` to all members of `ι` is also less than `c`. In simpler terms, under given constraints on cardinality and ordinal magnitudes, this theorem gives a condition under which the supremum of a family of ordinals is less than a given ordinal.

If `ι` is a type, `f : ι → Ordinal`, `c : Ordinal`, the cardinality of the lift of `ι` is less than the cofinality of `c`, and for all `x ∈ ι`, `f x < c`, then `sup (list (map f ι)) < c`.


theorem Sbtw.right_ne :
    ∀ {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 → z ≠ y :=
  by sorry

The theorem `Sbtw.right_ne` states that for any ordered ring `R`, an additive commutative group `V`, a module `R V`, and an additive torsor `V P`, if a point `y` is strictly between points `x` and `z` (as defined by `Sbtw R x y z`), then `z` is not equal to `y`. In other words, the point `y` being strictly between `x` and `z` implies that `z` and `y` are distinct points.

For any ordered ring R, additive commutative group V, R-module R V, and additive torsor V over P, if x, y, z in V satisfy x < y < z in the order on V induced by R, then y ≠ z.


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

The theorem `Finset.insert_nonempty` asserts that for any type `α` with a decidable equality relation, any element `a` of type `α`, and any finite set `s` of type `α`, the set resulting from inserting `a` into `s` is nonempty. In other words, if you add an element to a finite set, the resulting set is guaranteed to have at least one element.

For any type `α` with decidable equality and any finite set `s` of `α` and any `a` in `α`, the set `s.insert a` is nonempty.


IsLUB.union

/-- If `a` is the least upper bound of `s` and `b` is the least upper bound of `t`,
then `a ⊔ b` is the least upper bound of `s ∪ t`.  -/
theorem IsLUB.union :
    ∀ {γ : Type w} [inst : SemilatticeSup γ] {a b : γ} {s t : Set γ}, IsLUB s a → IsLUB t b → IsLUB (s ∪ t) (a ⊔ b) :=
  by sorry

This theorem states that in a semilattice (a structure with a partial order where every two elements have a least upper bound), if 'a' is the least upper bound of a set 's' and 'b' is the least upper bound of another set 't', then the join of 'a' and 'b' (denoted as 'a ⊔ b') is the least upper bound of the union of 's' and 't'. In other words, the least upper bound of the union of two sets is the join of the least upper bounds of the individual sets.

In a semilattice, the least upper bound of the union of two sets is the join of their least upper bounds.


theorem dist_lineMap_lineMap :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] {𝕜 : Type u_6} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V] (p₁ p₂ : P)
      (c₁ c₂ : 𝕜), dist ((AffineMap.lineMap p₁ p₂) c₁) ((AffineMap.lineMap p₁ p₂) c₂) = dist c₁ c₂ * dist p₁ p₂ :=
  by sorry

This theorem states that for any pseudo metric space `P`, seminormed add commutative group `V`, normed add torsor `V P`, normed field `𝕜`, normed space `𝕜 V`, and given points `p₁` and `p₂` in `P`, and scalars `c₁` and `c₂` in `𝕜`, the distance between the points obtained by applying the affine map `AffineMap.lineMap p₁ p₂` to `c₁` and `c₂` is equal to the product of the distance between `c₁` and `c₂` and the distance between `p₁` and `p₂`. In other words, the relative distances along the line between `p₁` and `p₂` created by the affine map are preserved.

For any pseudo metric space `P`, seminormed add commutative group `V`, normed add torsor `V P`, normed field `𝕜`, normed space `𝕜 V`, and points `p₁, p₂ in P` and scalars `c₁, c₂ in 𝕜`, the distance between `AffineMap.lineMap p₁ p₂ c₁` and `AffineMap.lineMap p₁ p₂ c₂` is equal to the product of the distance between `c₁` and `c₂` and the distance between `p₁` and `p₂`.


theorem Set.PartiallyWellOrderedOn.image_of_monotone_on :
    ∀ {α : Type u_2} {β : Type u_3} {r : α → α → Prop} {r' : β → β → Prop} {f : α → β} {s : Set α},
      Set.PartiallyWellOrderedOn s r →
        (∀ a₁ ∈ s, ∀ a₂ ∈ s, r a₁ a₂ → r' (f a₁) (f a₂)) → Set.PartiallyWellOrderedOn (f '' s) r' :=
  by sorry

The theorem `Set.PartiallyWellOrderedOn.image_of_monotone_on` establishes a property of sets that are partially well-ordered by a binary relation. Specifically, for any types `α` and `β`, any relations `r` on `α` and `r'` on `β`, a function `f` from `α` to `β`, and a set `s` of type `α`, if the set `s` is partially well-ordered by `r`, and for any two elements `a₁` and `a₂` in `s` such that `a₁` is related to `a₂` by `r`, `f(a₁)` is related to `f(a₂)` by `r'`, then the image of `s` under `f` is partially well-ordered by `r'`. In other words, this theorem asserts that the partial well-ordering property is preserved under the image of a monotone function.

If `s` is a partially well-ordered set under relation `r`, and `f : α → β` is a monotone function (i.e., `a r b` implies `f a r' f b` for all `a, b` in `α` and relation `r'` on `β`), then the image `{f x | x ∈ s}` is a partially well-ordered set under relation `r'`.


theorem le_of_mul_le_mul_left :
    ∀ {α : Type u_1} {a b c : α} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : PosMulReflectLE α],
      a * b ≤ a * c → 0 < a → b ≤ c :=
  by sorry

The theorem `le_of_mul_le_mul_left` is a statement about the behavior of multiplication in relation to order in certain mathematical structures. Specifically, it applies to any type `α` that has a multiplication operation (`Mul α`), a zero element (`Zero α`), and an order relation that is a preorder (`Preorder α`). Furthermore, this order relation must satisfy the property of reverse monotonicity of multiplication by positive elements on the left (`PosMulReflectLE α`), which basically means that if you multiply a smaller number by a positive number, the result is also smaller. The theorem itself states that for any elements `a`, `b`, and `c` of type `α`, if `a * b` is less than or equal to `a * c` and `a` is positive, then `b` must be less than or equal to `c`. In other words, if multiplying by `a` doesn't change the order of `b` and `c`, then `b` and `c` must have already been in that order.

If `α` is a preordered type with a positive multiplication operation such that `a * b ≤ a * c` implies `b ≤ c`, then `a > 0` implies `b ≤ c`.


theorem finsum_eq_sum_of_support_toFinset_subset :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) (hf : Set.Finite (Function.support f))
      {s : Finset α}, Set.Finite.toFinset hf ⊆ s → (finsum fun i => f i) = Finset.sum s fun i => f i :=
  by sorry

This theorem states that for any type `α` and `M`, where `M` is an additive commutative monoid, and any function `f` from `α` to `M`, if the support of `f` (the set of points `x` where `f(x) ≠ 0`) is a finite set, then for any finite set `s` of type `α`, if the finite set derived from the support of `f` is a subset of `s`, the sum of `f(x)` for all `x` (denoted as `finsum f`) is equal to the sum of `f(x)` for all `x` in `s` (denoted as `Finset.sum s f`). Essentially, the theorem connects the sum of a function over its support to the sum of the function over a finite set that contains the support.

For any additive commutative monoid M, function f from type α to M with finite support, and finite set s of type α containing the support of f, the sum of f over s equals the sum of f over its support. (i.e., Finset.sum s f = finsum f)


theorem Set.PartiallyWellOrderedOn.exists_monotone_subseq :
    ∀ {α : Type u_2} {r : α → α → Prop} {s : Set α} [inst : IsRefl α r] [inst : IsTrans α r],
      Set.PartiallyWellOrderedOn s r →
        ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n)) :=
  by sorry

This theorem states that for any type `α`, relation `r`, and set `s`, if `r` is a reflexive and transitive relation on `α`, and if `s` is partially well-ordered by `r`, then for any sequence `f` from natural numbers to `α` where all elements of the sequence belong to `s`, there exists a subsequence `g` such that for all natural numbers `m` and `n`, if `m` is less than or equal to `n`, then the `m`-th element of the subsequence `g` is related to the `n`-th element of `g` via the relation `r`.

In other words, it guarantees the existence of a monotone subsequence for any sequence that only contains elements from a set that is partially well-ordered by a reflexive and transitive relation.

Given a type `α`, a reflexive and transitive relation `r` on `α`, and a partially well-ordered set `s` (under `r`), any strictly increasing sequence of natural numbers `n` indexing elements in `s` has a monotone subsequence `g` such that `r(g(m), g(n))` holds for all `m ≤ n`.


theorem neg_add_le_iff_le_add :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α}, -b + a ≤ c ↔ a ≤ b + c :=
  by sorry

This theorem, `neg_add_le_iff_le_add`, states that for all types `α` that have an addition operation (`AddGroup`), a less-than-or-equal-to relation (`LE`), and satisfy the `CovariantClass` (which in this case means that addition respects the less-than-or-equal-to relation), the inequality `-b + a ≤ c` is equivalent to `a ≤ b + c`. In other words, given any three elements `a`, `b`, and `c` of such a type `α`, subtracting `b` from `a` and checking if the result is less than or equal to `c` is the same as checking if `a` is less than or equal to the sum of `b` and `c`.

For all types `α` with `AddGroup`, `LE`, and `CovariantClass` structures, `-b + a ≤ c` if and only if `a ≤ b + c`.


theorem List.reverse_perm : ∀ {α : Type u_1} (l : List α), List.Perm (List.reverse l) l := by sorry

The theorem `List.reverse_perm` states that for any list `l` of elements of an arbitrary type `α`, the reversed list is a permutation of the original list `l`. In other words, reversing a list doesn't change the multiset of elements it contains; it simply rearranges them.

The theorem `List.reverse_perm` asserts that reversing the order of elements in a list preserves its multiset.


/-- Corresponds to `dist_triangle`.  -/
theorem hammingDist_triangle :
    ∀ {ι : Type u_2} {β : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)]
      (x y z : (i : ι) → β i), hammingDist x z ≤ hammingDist x y + hammingDist y z :=
  by sorry

This theorem is a version of the triangular inequality for the Hamming distance. Given three functions `x`, `y`, and `z` from an index type `ι` to types `β i` (where `i` is an element of `ι`), the theorem states that the Hamming distance between `x` and `z` is always less than or equal to the sum of the Hamming distances between `x` and `y`, and `y` and `z`. This holds for any `ι` that is a finite type and any `β i` that has decidable equality.

For any finite type `ι` and functions `x, y, z : ι → β i` with decidable equality on `β i`, the Hamming distance between `x` and `z` is less than or equal to the sum of the Hamming distances between `x` and `y`, and `y` and `z`.


theorem Mathlib.Data.Set.Finite._auxLemma.27 : ∀ {α : Type u}, Set.Finite ∅ = True := by sorry

This theorem states that for any type `α`, the empty set of that type is always finite. In other words, regardless of what type you're dealing with, if you have an empty set of that type, it is considered as finite. It is one of the fundamental properties of finite sets in mathematics.

The empty set of any type is a finite set.


theorem Rat.num_div_den : ∀ (r : ℚ), ↑r.num / ↑r.den = r := by sorry

This theorem states that for all rational numbers 'r', when the numerator of 'r' is divided by the denominator of 'r', it equals 'r'. Here, `ℚ` represents the set of all rational numbers, `r.num` represents the numerator of 'r', and `r.den` represents the denominator of 'r'. The ↑ operator is used for type casting, converting the integers `r.num` and `r.den` to rational numbers.

For all rational numbers r, r = r.num / r.den.


theorem Num.add_to_nat : ∀ (m n : Num), ↑(m + n) = ↑m + ↑n := by sorry

This theorem states that for all numbers `m` and `n` of the `Num` type, the coercion of the sum of `m` and `n` to a natural number is equal to the sum of the individual coercions of `m` and `n` to natural numbers. In mathematical terms, this theorem is saying that for any `m` and `n` in `Num`, `(m + n) ⟶ ℕ = m ⟶ ℕ + n ⟶ ℕ`.

The coercion of the sum of two numbers is equal to the sum of their individual coercions to natural numbers. In Lean notation, this is expressed as (m + n) ⟶ ℕ = m ⟶ ℕ + n ⟶ ℕ.


theorem PadicSeq.stationaryPoint_spec :
    ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0) {m n : ℕ},
      PadicSeq.stationaryPoint hf ≤ m → PadicSeq.stationaryPoint hf ≤ n → padicNorm p (↑f n) = padicNorm p (↑f m) :=
  by sorry

The theorem `PadicSeq.stationaryPoint_spec` states that for any prime number `p` and any `p`-adic Cauchy sequence `f` that is not equivalent to zero, if natural numbers `m` and `n` are greater than or equal to the stationary point of `f`, then the `p`-adic norm of `f` at the indices `m` and `n` is the same. In other words, beyond the stationary point of a `p`-adic Cauchy sequence, the `p`-adic norm remains constant.

For any `p`-adic Cauchy sequence `f` that is not equivalent to zero, the `p`-adic norm of `f` at indices greater than or equal to its stationary point is constant.


theorem Subgroup.commutator_mono :
    ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ K₁ K₂ : Subgroup G}, H₁ ≤ K₁ → H₂ ≤ K₂ → ⁅H₁, H₂⁆ ≤ ⁅K₁, K₂⁆ := by sorry

This theorem states that for any type `G` equipped with a group structure, and for any four subgroups `H₁`, `H₂`, `K₁`, and `K₂` of `G`, if `H₁` is a subgroup of `K₁` and `H₂` is a subgroup of `K₂`, then the subgroup generated by the commutators of elements in `H₁` and `H₂` is a subgroup of the subgroup generated by the commutators of elements in `K₁` and `K₂`. In notation, if `H₁ ≤ K₁` and `H₂ ≤ K₂`, then `⁅H₁, H₂⁆ ≤ ⁅K₁, K₂⁆`.

If `H₁` is a subgroup of `K₁` and `H₂` is a subgroup of `K₂` in a group `G`, then the subgroup generated by the commutators of elements in `H₁` and `H₂` is contained in the subgroup generated by the commutators of elements in `K₁` and `K₂`.


theorem Complex.liftAux_apply_I :
    ∀ {A : Type u_1} [inst : Ring A] [inst_1 : Algebra ℝ A] (I' : A) (hI' : I' * I' = -1),
      (Complex.liftAux I' hI') Complex.I = I' :=
  by sorry

The theorem `Complex.liftAux_apply_I` states that for any real algebra type `A` that has both a ring structure and an algebra structure, given any element `I'` in `A` such that the square of `I'` equals `-1`, the application of the `liftAux` function on `I'` and the imaginary unit of complex numbers equals `I'`. In other words, the function `Complex.liftAux` maps the imaginary unit of complex numbers to an element which squares to `-1` in any real algebraic structure.

For any real algebra type `A` with ring and algebra structures, and any element `I'` in `A` satisfying `I'` ^ 2 = -1, Complex.liftAux `I'` equals `I'`.


theorem mul_div : ∀ {G : Type u_3} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c := by sorry

This theorem states that for any type `G` that has a `DivInvMonoid` structure (which is a mathematical structure with division and inverse operations), and for any three elements `a`, `b`, and `c` of `G`, the result of multiplying `a` with the division of `b` by `c` (`a * (b / c)`) is the same as the result of dividing the product of `a` and `b` by `c` (`a * b / c`). This captures the concept of left-distributivity of multiplication over division.

For any type `G` with a `DivInvMonoid` structure and any elements `a`, `b`, and `c` in `G`, we have `(a * (b / c)) = (a * b) / c`.


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

This theorem states that for any type `α` that has a `Preorder` (an algebraic structure that captures the intuitive notion of an ordering that can be "less than", "equal to", or "greater than"), if `b` is less than `a`, then the closed interval from `a` to `b` (inclusive), denoted `Set.Icc a b`, is empty. In other words, there are no elements `x` in `α` such that `a ≤ x ≤ b` when `b < a`.

For any preordered type `α`, the closed interval `Set.Icc a b` is empty when `b` is strictly less than `a`.


theorem CategoryTheory.CommSq.vert_inv :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : C} {f : W ⟶ X} {i : Y ⟶ Z} {g : W ≅ Y}
      {h : X ≅ Z}, CategoryTheory.CommSq f g.hom h.hom i → CategoryTheory.CommSq i g.inv h.inv f :=
  by sorry

The theorem `CategoryTheory.CommSq.vert_inv` states that for any category `C`, and objects `W`, `X`, `Y`, `Z` in `C` with morphisms `f: W ⟶ X`, `i: Y ⟶ Z`, and isomorphisms `g: W ≅ Y` and `h: X ≅ Z`, if a commutative square is formed with `f`, `g.hom`, `h.hom` and `i`, then another commutative square is formed with `i`, `g.inv`, `h.inv` and `f`. In other words, if we have a commutative diagram involving these arrows, we can invert the vertical arrows to get another commutative diagram.

Given any commutative square in a category with isomorphisms as two of its sides, the interchange of these isomorphisms with the other two morphisms results in another commutative square.


theorem MeasureTheory.measurePreserving_add_left :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Add G] [inst_2 : MeasurableAdd G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsAddLeftInvariant μ] (g : G),
      MeasureTheory.MeasurePreserving (fun x => g + x) μ μ :=
  by sorry

This theorem states that for any group `G` equipped with an addition operation and a `MeasureTheory.Measure μ` that is invariant under left addition, the function `(fun x => g + x)` preserves the measure `μ`. In other words, when we shift every element in a set by a fixed amount `g` in the group `G`, the measure of the set remains unchanged.

For any group `G` with invariant measure `μ` under left addition, the function `x ↔ g + x` preserves the measure `μ`, that is, `μ (set.image (fun x => g + x) s) = μ s` for any set `s` in `G`.


theorem Mathlib.Order.Hom.Basic._auxLemma.11 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β) {a b : α},
      (f a ≤ f b) = (a ≤ b) :=
  by sorry

This theorem, named `Mathlib.Order.Hom.Basic._auxLemma.11`, states that for any two types `α` and `β` that have a Preorder relationship, and for any order-embedding `f` from `α` to `β`, if `a` and `b` are elements of type `α`, then `f(a)` is less than or equal to `f(b)` if and only if `a` is less than or equal to `b`. This basically asserts that the order-embedding `f` preserves the order between the elements of `α`.

For any preordered types `α` and `β`, and order-embedding `f` from `α` to `β`, `a ≤ b` in `α` if and only if `f(a) ≤ f(b)` in `β`.


theorem Mathlib.Order.Hom.Basic._auxLemma.13 :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β], (fun f => ⇑f) = DFunLike.coe := by sorry

The theorem `Mathlib.Order.Hom.Basic._auxLemma.13` states that for any type `F` in a certain universe `u_1`, any type `α` in a certain universe `u_2`, and any type function `β` which maps elements of `α` to types in a certain universe `u_3`, if there exists a structure `i` of the typeclass `DFunLike F α β`, then the function which maps each element `f` of the type `F` to its coercion function `⇑f` is exactly the `DFunLike.coe` function. In other words, the coercion operator `⇑` and `DFunLike.coe` act the same way under these conditions.

If `F` is a type in universe `u_1`, `α` is a type in universe `u_2`, and `β` is a type function mapping elements of `α` to types in universe `u_3`, then the function mapping each `f` in `F` to its coercion `⇑f` is equal to the `DFunLike.coe` function for the typeclass `DFunLike F α β`, i.e., `⇑f = DFunLike.coe f`.


theorem IndexedPartition.mem_iff_index_eq :
    ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) {x : α} {i : ι},
      x ∈ s i ↔ hs.index x = i :=
  by sorry

The theorem `IndexedPartition.mem_iff_index_eq` states that for all types `ι` and `α`, for all function `s` mapping elements of `ι` to sets of `α` that forms an indexed partition `hs`, and for any element `x` of `α` and any index `i` of `ι`, `x` is an element of the set `s i` if and only if the index of `x` in the indexed partition `hs` is equal to `i`. In other words, given an indexed partition, an element belongs to a particular set within the partition exactly when its partition index matches the index of that set.

For any indexed partition `hs` of type `ι → set α`, an element `x ∈ α` belongs to `s i` if and only if `i` is the index of `x` in the partition `hs`.


theorem Finset.compls_compls :
    ∀ {α : Type u_2} [inst : BooleanAlgebra α] (s : Finset α), Finset.compls (Finset.compls s) = s := by sorry

This theorem states that for any finite set `s` within a Boolean algebra `α`, applying the `Finset.compls` operation twice on `s` will give us back the original set `s`. In other words, the `Finset.compls` operation is an involution in the context of a Boolean algebra, i.e., it is its own inverse. This operation is essentially taking the complement of each element in the set, so this theorem is asserting that taking the complement twice returns to the original element, a well-known property in Boolean algebra.

In a Boolean algebra, the complement operation on a finite set is idempotent, that is, applying it twice to a set results in the original set.


/-- Symmetric statement to `Filter.map_map₂_right_comm`.  -/
theorem Filter.map_map₂_distrib_right :
    ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {m : α → β → γ} {f : Filter α}
      {g : Filter β} {n : γ → δ} {m' : α → β' → δ} {n' : β → β'},
      (∀ (a : α) (b : β), n (m a b) = m' a (n' b)) →
        Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' f (Filter.map n' g) :=
  by sorry

The theorem `Filter.map_map₂_distrib_right` states that for all types `α`, `β`, `β'`, `γ`, and `δ`, for any filters `f` of type `α` and `g` of type `β`, for any binary function `m : α → β → γ`, any function `n : γ → δ` and `n' : β → β'` and a binary function `m' : α → β' → δ`, if for every `α` and `β`, the function `n` applied to the result of `m` applied to `α` and `β` equals the result of `m'` applied to `α` and `n'` applied to `β`, then the filter obtained by mapping `n` over the filter obtained by applying `m` to filters `f` and `g` is equal to the filter obtained by applying `m'` to filter `f` and the filter obtained by mapping `n'` over filter `g`. In other words, this theorem is about the distributivity of mapping operations over filters in a particular way.

If for all `α`, `β`, `β'`, `γ`, and `δ`, and functions `m : α → β → γ`, `n : γ → δ`, `m' : α → β' → δ`, `n' : β → β'`, the equality `n (m x y) = m' x (n' y)` holds for all `x : α` and `y : β`, then `Filter.map n (Filter.map₂ m f g) = Filter.map₂ m' f (Filter.map n' g)`, where `f` and `g` are filters on types `α` and `β`, respectively.


/-- Gives a recurrence to compute the `n + 1`th value of the sequence of integer and fractional
parts of a value in case of non-termination.
 -/
theorem GeneralizedContinuedFraction.IntFractPair.succ_nth_stream_eq_some_iff :
    ∀ {K : Type u_1} [inst : LinearOrderedField K] [inst_1 : FloorRing K] {v : K} {n : ℕ}
      {ifp_succ_n : GeneralizedContinuedFraction.IntFractPair K},
      GeneralizedContinuedFraction.IntFractPair.stream v (n + 1) = some ifp_succ_n ↔
        ∃ ifp_n,
          GeneralizedContinuedFraction.IntFractPair.stream v n = some ifp_n ∧
            ifp_n.fr ≠ 0 ∧ GeneralizedContinuedFraction.IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n :=
  by sorry

This theorem provides a recurrence to calculate the `n + 1`th element in a sequence of integer and fractional parts of a value in the event of sequence non-termination. Specifically, for any linear ordered field `K`, floor ring `K`, value `v` of type `K`, natural number `n`, and `ifp_succ_n` which is the integer and fractional pair at the `n + 1`th position of the sequence of `v`, it states that `ifp_succ_n` is the `n + 1`th element of the sequence if and only if there exists some `ifp_n` such that `ifp_n` is the `n`th element of the sequence, the fractional part of `ifp_n` is not zero, and the pair created from the reciprocal of the fractional part of `ifp_n` is equal to `ifp_succ_n`.

For any linear ordered field K, given a value v of type K and a natural number n, the integer and fractional pair at position n+1 in the sequence of v is the successor pair if and only if there exists the pair at position n with non-zero fractional part whose reciprocal gives the pair at position n+1.


theorem PartialEquiv.IsImage.image_eq :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
      PartialEquiv.IsImage e s t → ↑e '' (e.source ∩ s) = e.target ∩ t :=
  by sorry

The theorem `PartialEquiv.IsImage.image_eq` establishes that for any set `s` of type `α`, set `t` of type `β`, and a partial equivalence `e` between `α` and `β`, if `t` is an image of `s` under the partial equivalence `e`, then the image of the intersection of the source of `e` and `s` under `e` is equal to the intersection of the target of `e` and `t`. In more mathematical terms, if `t` is an image of `s` under `e`, then `e` maps `(e.source ∩ s)` directly onto `(e.target ∩ t)`.

If `e` is a partial equivalence between sets `α` and `β`, `s ⊆ α`, and `t = e(s)`, then `e(source e ∩ s) = target e ∩ t`.


/-- **Alias** of the forward direction of `antilipschitzWith_iff_le_mul_dist`. -/
theorem AntilipschitzWith.le_mul_dist :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal}
      {f : α → β}, AntilipschitzWith K f → ∀ (x y : α), dist x y ≤ ↑K * dist (f x) (f y) :=
  by sorry

The theorem `AntilipschitzWith.le_mul_dist` states that if a function `f` from a pseudo-metric space `α` to a pseudo-metric space `β` is `AntilipschitzWith` a nonnegative real number `K`, then for any two points `x` and `y` in `α`, the distance between `x` and `y` is less than or equal to `K` times the distance between `f(x)` and `f(y)`. This is essentially saying that the function does not increase distances by more than a factor of `K`.

For any AntilipschitzWith (K > 0) function f from a pseudo-metric space (α, dα) to another pseudo-metric space (β, dβ), it holds that dα(x, y) ≤ K × dβ(f(x), f(y)) for all x, y in α.


theorem Finset.disjoint_iff_ne : ∀ {α : Type u_1} {s t : Finset α}, Disjoint s t ↔ ∀ a ∈ s, ∀ b ∈ t, a ≠ b := by sorry

This theorem states that for any two sets `s` and `t` of any type `α`, the sets are disjoint if and only if for all elements `a` in set `s` and all elements `b` in set `t`, `a` is not equal to `b`. In other words, two sets are disjoint precisely when there is no element that belongs to both sets. Here, disjointness is defined in a general sense, without reference to a specific element-wise operation, extending the concept of disjoint sets in set theory.

Two sets of type `α` are disjoint if and only if they have no common elements.


theorem hasDerivAt_pow :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (n : ℕ) (x : 𝕜),
      HasDerivAt (fun x => x ^ n) (↑n * x ^ (n - 1)) x :=
  by sorry

This theorem states that, for any non-trivially normed field `𝕜` and any natural number `n`, the derivative of the function `f(x) = x^n` at a point `x` in `𝕜` is `n * x^(n - 1)`. In other words, it asserts the power rule of calculus in the context of non-trivially normed fields. The power rule says that the derivative of `x^n` with respect to `x` is `n*x^(n-1)`.

For any non-trivially normed field and natural number, the derivative of the function `x => x^n` is `n * x^(n-1)`.


theorem Polynomial.splits_of_degree_le_one :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) {f : Polynomial K},
      Polynomial.degree f ≤ 1 → Polynomial.Splits i f :=
  by sorry

The theorem `Polynomial.splits_of_degree_le_one` states that for all commutative rings `K` and fields `L`, and a given homomorphism `i` from `K` to `L`, if the degree of a polynomial `f` from `K` is less than or equal to 1, then the polynomial `f` splits over `L`. In other words, if a polynomial has a degree of 1 or less, then it can be factored into linear polynomials in the field `L`.

For any commutative rings K and fields L, and homomorphism i from K to L, polynomials of degree less than or equal to 1 in K split into linear factors in L.


theorem List.nodup_singleton : ∀ {α : Type u} (a : α), List.Nodup [a] := by sorry

The theorem `List.nodup_singleton` states that for any type `α` and for any element `a` of that type, a list consisting of just `a` has no duplicates. This is true by definition, since a list with a single element cannot have duplicate entries.

For any type `α` and element `a` of that type, the list `[a]` has no duplicate elements.


theorem mul_self_inj_of_nonneg :
    ∀ {α : Type u_2} [inst : LinearOrderedField α] {a b : α}, 0 ≤ a → 0 ≤ b → (a * a = b * b ↔ a = b) := by sorry

This theorem, `mul_self_inj_of_nonneg`, states that for any type `α` that has a structure of `LinearOrderedField` (a field in which strict total ordering is defined), given two non-negative (greater than or equal to zero) elements `a` and `b` of `α`, the equality of the squares of `a` and `b` implies the equality of `a` and `b` themselves. That is, if `a * a = b * b` and `a` and `b` are both non-negative, then `a = b`. The reverse is also true: if `a = b`, then `a * a = b * b`. This theorem essentially states that the square function is injective for non-negative numbers.

For any non-negative elements `a` and `b` in a LinearOrderedField, if `a * a = b * b`, then `a = b`.


theorem nnnorm_inv : ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a : α), ‖a⁻¹‖₊ = ‖a‖₊⁻¹ := by sorry

This theorem states that for every element `a` of a normed division ring `α`, the non-negative norm of the inverse of `a` is equal to the inverse of the non-negative norm of `a`. This is often expressed in mathematical notation as ‖a⁻¹‖₊ = ‖a‖₊⁻¹. This theorem holds under the assumption that `α` is a normed division ring, which is a particular kind of structured mathematical set.

In a normed division ring, the non-negative norm of an element's inverse is equal to the reciprocal of its non-negative norm. (‖a⁻¹‖₊ = ‖a‖₊⁻¹)


CliffordAlgebra.reverse.commutes

theorem CliffordAlgebra.reverse.commutes :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} (r : R),
      CliffordAlgebra.reverse ((algebraMap R (CliffordAlgebra Q)) r) = (algebraMap R (CliffordAlgebra Q)) r :=
  by sorry

The theorem `CliffordAlgebra.reverse.commutes` states that for any commutative ring `R`, any additive commutative group `M` which is also a module over `R`, and any quadratic form `Q` on `M`, the reverse operation on the Clifford Algebra of `Q` commutes with the algebra map from `R` to the Clifford Algebra of `Q`. In simpler terms, if we map an element `r` from `R` to the Clifford Algebra, then the order in which we apply the reverse operation and the algebra map doesn't matter.

For any commutative ring R, additive commutative group M as an R-module, and quadratic form Q on M, the reverse operation on the Clifford Algebra of Q and the algebra map from R to the Clifford Algebra of Q commute.


theorem nnnorm_neg : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a : E), ‖-a‖₊ = ‖a‖₊ := by sorry

The theorem `nnnorm_neg` states that for any type `E` which is an instance of the `SemionormedAddGroup`, the non-negative norm of the negation of any element `a` from `E` is equal to the non-negative norm of `a` itself. In mathematical terms, this theorem expresses the property that negation doesn't change the non-negative norm of an element in a seminormed add group, i.e., ‖-a‖₊ = ‖a‖₊ for all `a` in `E`.

For any element `a` in a seminormed add group `E`, the non-negative norm of `-a` is equal to the non-negative norm of `a`, i.e., ‖-a‖₊ = ‖a‖₊.


Asymptotics.IsBigO.mono

theorem Asymptotics.IsBigO.mono :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l l' : Filter α}, f =O[l'] g → l ≤ l' → f =O[l] g :=
  by sorry

This theorem, `Asymptotics.IsBigO.mono`, states that for all types `α`, `E`, and `F`, with `E` and `F` being normed, and for any functions `f : α → E` and `g : α → F`, along with two filters `l` and `l'` on `α`, if `f` is Big O of `g` at filter `l'` and `l` is less than or equal to `l'`, then `f` is also Big O of `g` at filter `l`. In layman's terms, this theorem is about the transitivity property in asymptotic notation: if a function `f` grows no faster than a function `g` at a certain rate (or filter), it will also grow no faster than `g` at any slower rate (or smaller filter).

If `f` is Big O of `g` at filter `l'` and `l` ≤ `l'`, then `f` is also Big O of `g` at filter `l` in the normed types `α`, `E`, and `F`.


/-- The `p`-adic value of an integer `z ≠ 0` is its `p`-adic value as a rational.  -/
theorem padicValRat.of_nat : ∀ {p n : ℕ}, padicValRat p ↑n = ↑(padicValNat p n) := by sorry

The theorem `padicValRat.of_nat` states that for any natural numbers `p` and `n`, the `p`-adic value of `n` when considered as an integer is the same as its `p`-adic value when considered as a rational number. Here, the `p`-adic value of a number is the highest power of `p` that divides the number, with the valuation of `0` or of any number with respect to `1` defined to be `0`. Thus, the `p`-adic valuation of a natural number is preserved under the embedding of the integers into the rationals.

For any natural number `n` and prime number `p`, the `p`-adic valuation of `n` as an integer equals the `p`-adic valuation of the rational number `(from Nat.cast (natToInt n))`.


theorem Mathlib.Topology.Separation._auxLemma.4 : ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) := by sorry

This theorem, located in the Topology.Separation module of the Mathlib library, is stating that for any two propositions 'a' and 'b', the conjunction 'a and b' is equivalent to 'b and a'. In other words, the order in which the propositions are presented in an 'and' statement does not affect the truth of the statement; this is a fundamental property of logical conjunctions.

For all propositions 'a' and 'b', the conjunction 'a ∧ b' is equivalent to 'b ∧ a'.


IsPGroup.map

theorem IsPGroup.map :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {H : Subgroup G},
      IsPGroup p ↥H → ∀ {K : Type u_2} [inst_1 : Group K] (ϕ : G →* K), IsPGroup p ↥(Subgroup.map ϕ H) :=
  by sorry

The theorem `IsPGroup.map` states that if `H` is a p-group in the group `G` for a given prime number `p`, then its image under any group homomorphism `ϕ` from `G` to another group `K` is also a p-group. Here, a p-group is defined as a group in which every element has an order that is a power of the prime `p`. The image of a subgroup under a group homomorphism is defined as another subgroup in the target group.

If `G` is a group, `p` is a prime number, `H` is a p-subgroup of `G`, and `ϕ` is a group homomorphism from `G` to another group `K`, then `ϕ(H)` is a p-subgroup of `K`.


theorem Multiset.mem_singleton : ∀ {α : Type u_1} {a b : α}, b ∈ {a} ↔ b = a := by sorry

This theorem, `Multiset.mem_singleton`, is stating that for any type `α` and any two instances of that type, `a` and `b`, `b` is a member of the singleton multiset containing only `a` if and only if `b` is equal to `a`. In other words, in a multiset with only one element, an element is present if it is equal to the single member of the set.

For any type `α` and any two elements `a` and `b` of type `α`, the element `b` is in the singleton multiset `{a}:` Multiset `α` if and only if `a` is equal to `b`.


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

This theorem states that for any two types `X` and `Y` with respective topological spaces, `Sum.inr` (the function that takes an item of type `Y` and returns an item of the sum type `X + Y`) is an open embedding. An open embedding is a function between topological spaces that is injective (i.e., distinct inputs map to distinct outputs), continuous (i.e., the preimage of an open set is open), and its image is an open subset in the codomain. This means that `Sum.inr` has these properties when considered as a function from `Y` to `X + Y` with the given topologies.

The function `Sum.inr`: `Y → X + Y` is an open embedding between the topological spaces of types `Y` and `X + Y`.


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

This theorem states that for any two types `X` and `Y` each equipped with a topology (i.e., `X` and `Y` are topological spaces), the injection function `Sum.inl` from `X` into the sum type `X + Y` is an open embedding. In the context of topology, an open embedding is a function which is both an embedding and the image of any open set is open. In simpler terms, it preserves the topological structure of the original space, and specifically the openness of sets.

The injection function `Sum.inl` from a topological space `X` into the sum type `X + Y` is a topological embedding.