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

The theorem `GaloisConnection.lt_iff_lt` states that for any types `α` and `β` with a linear order, given a Galois connection between `α` and `β` defined by functions `l` and `u`, for all elements `a` of type `α` and `b` of type `β`, `b` is less than `l a` if and only if `u b` is less than `a`. This theorem essentially extends the property of a Galois connection to the strict less than relation, in addition to the less than or equal to relation.

For any types with a linear order and a Galois connection between them, the elements are related by strict order in one direction if and only if they are related by the opposite orders in the other direction. (Specifically, `b < l a` if and only if `u b < a`.)


theorem Irrational.rat_add : ∀ (q : ℚ) {x : ℝ}, Irrational x → Irrational (↑q + x) := by sorry

The theorem `Irrational.rat_add` asserts that for any rational number `q` and any real number `x` that is irrational, the sum of `q` and `x` (denoted `↑q + x` in Lean 4, where `↑q` is the real number corresponding to `q`) is also irrational. In other words, adding a rational number to an irrational number results in another irrational number.

The sum of a rational number and an irrational number is irrational.


theorem Sigma.ext_iff :
    ∀ {α : Type u_1} {β : α → Type u_4} {x₀ x₁ : Sigma β}, x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd := by sorry

The theorem `Sigma.ext_iff` states that for any types `α` and `β`, and any two elements `x₀` and `x₁` of the dependent pair type `Sigma β`, `x₀` is equal to `x₁` if and only if the first component of `x₀` is equal to the first component of `x₁` and the second component of `x₀` is heterogeneously equal to the second component of `x₁`. Here, `HEq` denotes heterogeneous equality, which allows for equality between elements of possibly different types.

For any types `α` and `β`, and dependent pair elements `(x\_0, h\_0)` and `(x\_1, h\_1)` of `Sigma β`, `x\_0 = x\_1` if and only if `x\_0.1 = x\_1.1` and `hEq h\_0 h\_1`.


Measurable.sup

theorem Measurable.sup :
    ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {f g : α → M} [inst_1 : Sup M]
      [inst_2 : MeasurableSup₂ M], Measurable f → Measurable g → Measurable fun a => f a ⊔ g a :=
  by sorry

This theorem, `Measurable.sup`, states that for any two functions `f` and `g` from a measurable space `α` to another measurable space `M` (equipped with a sup operation and a `MeasurableSup₂` instance), if both `f` and `g` are measurable, then the function that sends each element of `α` to the sup (or least upper bound) of the images of that element under `f` and `g`, is also measurable. In other words, the sup function preserves measurability.

If `f` and `g` are measurable functions from a measurable space `α` to a measurable space `(M, ⊔)`, then the function that maps each `x ∈ α` to `⊔(f x, g x)` is also measurable.


theorem iInf_iSup_eq :
    ∀ {α : Type u} {ι : Sort w} {κ : ι → Sort w'} [inst : CompletelyDistribLattice α] {f : (a : ι) → κ a → α},
      ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a) :=
  by sorry

This theorem states that for any type `α` that forms a complete distributive lattice, and for any function `f` that takes an element of type `ι` and an element of type dependent on `ι` to `α`, the infimum (greatest lower bound) over `ι` of the supremum (least upper bound) over `κ` of `f` is equal to the supremum over all functions `g` from `ι` to `κ` of the infimum over `ι` of `f`. In simpler terms, it's saying that you can swap the order of taking the infimum and supremum without changing the result. This is a form of "Fubini's theorem" for lattices.

For any complete distributive lattice `α` and any function `f` from `ι × κ` to `α`, the order-theoretic integration of `f` over `κ` with respect to `ι` is equal to the order-theoretic sum of the order-theoretic integrals of `f` over `ι` for each `κ`.


theorem Relation.reflTransGen_iff_eq :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b : α}, (∀ (b : α), ¬r a b) → (Relation.ReflTransGen r a b ↔ b = a) := by
  sorry

This theorem states that for any type `α` and any binary relation `r` defined on `α`, and given any two elements `a` and `b` from `α`, if `a` does not relate to any other element `b` in `α` through `r`, then the reflexive transitive closure of `r` from `a` to `b` is equivalent to `b` being equal to `a`. In other words, if there's no way to get from `a` to any other element `b` through the relation `r`, then the only way for the reflexive transitive closure of `r` to hold between `a` and `b` is if `b` is actually the same as `a`.

If there is no `x` such that `a` `r` `x` and `x` `r` `b` for a binary relation `r` on type `α`, then `a` and `b` are equal.


theorem AddSubgroup.Normal.mem_comm_iff :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
      AddSubgroup.Normal H → ∀ {a b : G}, a + b ∈ H ↔ b + a ∈ H :=
  by sorry

This theorem states that for any additive group `G`, any additive subgroup `H` of `G`, and any two elements `a` and `b` of `G`, if `H` is a normal subgroup (under addition), then `a + b` is in `H` if and only if `b + a` is in `H`. Essentially, this theorem is saying that if `H` is a normal subgroup, then the order in which you add two group elements doesn't matter for membership in `H`.

If `H` is a normal subgroup of an additive group `G`, then for all `a, b` in `G`, `a + b` is in `H` if and only if `b + a` is in `H`.


theorem Function.Injective.of_comp_iff' :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) {g : γ → α},
      Function.Bijective g → (Function.Injective (f ∘ g) ↔ Function.Injective f) :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, and given a function `f` from `α` to `β`, and a bijective function `g` from `γ` to `α`, the composition of `f` and `g` (denoted as `f ∘ g`) is injective if and only if `f` itself is injective. In other words, when `g` is a bijective mapping, the injectiveness of the composed function `f ∘ g` is equivalent to the injectiveness of the original function `f`.

For all types `α`, `β`, and `γ`, if `f: α → β` is injective and `g: γ → α` is bijective, then their composition `f ∘ g: γ → β` is also injective.


theorem essSup_mono_ae :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β]
      {f g : α → β}, f ≤ᶠ[MeasureTheory.Measure.ae μ] g → essSup f μ ≤ essSup g μ :=
  by sorry

The theorem `essSup_mono_ae` states that for any complete lattice `β`, measurable space `α`, measure `μ` on `α`, and two functions `f` and `g` from `α` to `β`, if `f` is less than or equal to `g` almost everywhere (with respect to the measure `μ`), then the essential supremum of `f` with respect to `μ` is less than or equal to the essential supremum of `g` with respect to `μ`.

In simpler terms, it means that if one function is generally smaller than another when you measure "most" of the places (almost everywhere), then the least upper bound or "the highest low point" (essential supremum) of the smaller function is also smaller or equal to the least upper bound of the larger function.

If two functions from a measurable space to a complete lattice are almost everywhere ordered, then the essential supremum of the first function is less than or equal to the essential supremum of the second function.


theorem Matrix.blockDiagonal_apply :
    ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} [inst : DecidableEq o] [inst_1 : Zero α]
      (M : o → Matrix m n α) (ik : m × o) (jk : n × o),
      Matrix.blockDiagonal M ik jk = if ik.2 = jk.2 then M ik.2 ik.1 jk.1 else 0 :=
  by sorry

This theorem, `Matrix.blockDiagonal_apply`, asserts for any types `m`, `n`, `o`, and `α` with `α` being a zero type and `o` having decidable equality, and a function `M` that maps elements of `o` to matrices indexed by `m` and `n` with entries in `α`. Given a pair `ik` of an element from `m` and an element from `o`, and a pair `jk` of an element from `n` and an element from `o`, the value at the `(ik, jk)` position of the block diagonal matrix formed by `M` is equal to the `(ik.1, jk.1)` entry of the `ik.2`-th matrix if `ik.2` equals `jk.2`, otherwise it is zero. In other words, it forms a block diagonal matrix where each block is a matrix given by the function `M`, and the positions outside these blocks are filled with zeros.

Given a function mapping elements of a decidable type `o` to square matrices with entries in a zero type `α`, the block diagonal matrix formed by horizontally and vertically stacking these matrices has entries equal to the corresponding entry of the diagonal matrix if the indices belong to the same diagonal block, otherwise it is the zero entry.


theorem TopologicalSpace.le_generateFrom_iff_subset_isOpen :
    ∀ {α : Type u} {g : Set (Set α)} {t : TopologicalSpace α},
      t ≤ TopologicalSpace.generateFrom g ↔ g ⊆ {s | IsOpen s} :=
  by sorry

This theorem states that for any type `α`, any set `g` of sets of `α`, and any topological space `t` defined on `α`, the topological space `t` is less than or equal to the topological space generated by `g` if and only if `g` is a subset of the set of all sets `s` such that `s` is open in the topological space `t`. In other words, a given topological space is smaller than or equal to the space generated by a collection of sets if and only if all the sets in the collection are open in the original space.

A topological space is equal to or smaller than the topological space generated by a set of opens if and only if that set of opens is a subset of the opens in the original space.


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

This theorem states that for any type `α` with a preorder structure and any two elements `a` and `b` of that type, the left-closed right-closed interval `Set.Icc a b` is order-connected. In mathematical terms, this means that for every two points in the interval, every point in between them is also in the interval. The interval `Set.Icc a b` is defined as the set of all elements `x` which satisfy the condition `a ≤ x ∧ x ≤ b`.

For any type `α` with a preorder structure and any two elements `a` and `b` of that type, the interval `Set.Icc a b` is order-connected, that is, for all `x, y` in `Set.Icc a b` with `x ≤ y`, there exists a sequence `x = z₀, z₁, ..., zₙ = y` in `Set.Icc a b` such that `z₀ ≤ z₁ ≤ ... ≤ zₙ`.


theorem Int.even_or_odd : ∀ (n : ℤ), Even n ∨ Odd n := by sorry

This theorem states that for every integer `n`, `n` is either even or odd. In the context of the defined terms, an integer is even if it can be expressed as twice some integer, i.e., `n = 2*r` for some integer `r`. On the other hand, an integer is odd if it can be expressed in the form `n = 2*k + 1` for some integer `k`. This theorem is a reflection of the fundamental dichotomy of integers into even and odd numbers.

Every integer can be classified as even (being expressible as 2*r for some integer r) or odd (being expressible as 2*k + 1 for some integer k).


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

The theorem `MeasureTheory.lowerCrossingTime_le_upperCrossingTime_succ` states that for all possible types `'Ω` and `'ι`, given a conditionally complete linear order with a least element on type `'ι`, real numbers `a` and `b`, a function `f` mapping from type `'ι` to `'Ω` to real numbers, a value `N` of type `'ι`, a natural number `n` and a value `ω` of type `'Ω`, the lower crossing time of `f` at `N` for the `n`-th time is less than or equal to the upper crossing time of `f` at `N` for the `n+1`-th time. In plain English, this theorem asserts that the first time before `N` when `f` reaches below `a` after reaching above `b` for the `n`-th time is always less than or equal to the time when `f` reaches above `b` for the `n+1`-th time.

For all types 'Ω and 'ι, given a conditionally complete linear order with a least element on type 'ι, real numbers a < b, a function f : 'ι -> 'Ω -> Real, value N : 'ι, natural number n, and value ω : 'Ω, the n-th lower crossing time of f at N is less than or equal to the (n+1)-th upper crossing time of f at N.


theorem le_of_forall_ge_of_dense :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] {a₁ a₂ : α}, (∀ a₃ < a₁, a₃ ≤ a₂) → a₁ ≤ a₂ := by
  sorry

The theorem `le_of_forall_ge_of_dense` states that for any type `α` that has a linear order and is densely ordered, given any two elements `a₁` and `a₂` of this type, if all elements `a₃` that are less than `a₁` are also less than or equal to `a₂`, then `a₁` is less than or equal to `a₂`. This theorem essentially captures the intuitive idea that if all elements less than `a₁` are bounded by `a₂`, then `a₁` must also be bounded by `a₂`.

If `α` is a densely ordered type with a linear order, then `a₁ ≤ a₂` holds if for all `a₃` with `a₃ < a₁`, we have `a₃ ≤ a₂`.


theorem PartENat.get_natCast' : ∀ (x : ℕ) (h : (↑x).Dom), (↑x).get h = x := by sorry

This theorem, `PartENat.get_natCast'`, states that for any natural number `x` and any proof `h` that `x` belongs to the domain of the embedding of natural numbers into partial extended natural numbers, accessing the value of the embedded number using `get` ultimately gives back `x`. Essentially, this theorem says that the process of embedding natural numbers into extended natural numbers and then retrieving them leaves the original number unchanged.

For any natural number `x` and proof `h`, the embedding of `x` as a partial extended natural number and its retrieval using `get` equal `x`.


theorem compactCovering_subset :
    ∀ (X : Type u_1) [inst : TopologicalSpace X] [inst_1 : SigmaCompactSpace X] ⦃m n : ℕ⦄,
      m ≤ n → compactCovering X m ⊆ compactCovering X n :=
  by sorry

The theorem `compactCovering_subset` states that for any type `X` equipped with a topology and a sigma-compact space structure, and for any two natural numbers `m` and `n`, if `m` is less than or equal to `n`, then the `m`th set in the compact covering of `X` is a subset of the `n`th set in the compact covering of `X`. This establishes a form of monotonicity for the compact covering of a sigma-compact space.

For any sigma-compact space `X` with a topology and a compact covering `{C_i | i < n}`, if `m < n`, then `C_m` is a subset of `C_n`.


theorem CategoryTheory.ShortComplex.p_opcyclesMap' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂),
      CategoryTheory.CategoryStruct.comp h₁.p (CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂) =
        CategoryTheory.CategoryStruct.comp φ.τ₂ h₂.p :=
  by sorry

The theorem `CategoryTheory.ShortComplex.p_opcyclesMap'` states that for any type `C` with structure of a category and zero morphisms, and any two short complexes `S₁` and `S₂` in `C`, given a morphism `φ` from `S₁` to `S₂` and right homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, the composition of `h₁.p` and `CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂` is equal to the composition of `φ.τ₂` and `h₂.p`. This theorem describes a property of the mapping between the cycles of two short complexes in the context of category theory.

Given short complexes $S\_1$ and $S\_2$ in a category $C$ with zero morphisms, a morphism $\varphi \colon S\_1 \to S\_2$, and right homology data $h\_1$ and $h\_2$ for $S\_1$ and $S\_2$ respectively, the diagram commutes: $h\_1.p \circ CategoryTheory.ShortComplex.opcyclesMap' (\varphi) h\_1 h\_2 = \varphi.τ\_2 \circ h\_2.p$.


theorem add_sup :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      c + a ⊔ b = (c + a) ⊔ (c + b) :=
  by sorry

This theorem, `add_sup`, states that for all types `α` that are both a lattice and an additive group, with a covariant class defined for addition and order, the supremum (or least upper bound) of `c + a` and `b` is equal to the supremum of `c + a` and `c + b`. In simpler terms, adding a constant to all elements of a lattice before taking the supremum doesn't change the result.

For all types `α` that are both a lattice and an additive group, the supremum of `(a + c)` and `(b + c)` equals `(sup a b) + c`.


theorem CategoryTheory.Preadditive.comp_nsmul :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      (f : P ⟶ Q) (g : Q ⟶ R) (n : ℕ),
      CategoryTheory.CategoryStruct.comp f (n • g) = n • CategoryTheory.CategoryStruct.comp f g :=
  by sorry

The theorem `CategoryTheory.Preadditive.comp_nsmul` states that for any preadditive category `C` and any three objects `P`, `Q`, and `R` in `C`, given a morphism `f` from `P` to `Q` and a morphism `g` from `Q` to `R`, and an integer `n`, the composition of `f` and `n` times `g` (denoted by `CategoryTheory.CategoryStruct.comp f (n • g)`) is equal to `n` times the composition of `f` and `g` (denoted by `n • CategoryTheory.CategoryStruct.comp f g`). Here, composition of morphisms is defined as per the structure of the category and `n • g` denotes scalar multiplication of the morphism `g` by `n` as per the preadditive structure on `C`.

For any preadditive category `C`, for all objects `P`, `Q`, `R`, morphisms `f: P -> Q`, `g: Q -> R`, and integers `n`, the scalar multiplication of the composition `n • (f ∘ g)` is equal to the composition of scalar multiplications `n • f ∘ g`.


theorem div_eq_iff_eq_mul : ∀ {G : Type u_3} [inst : Group G] {a b c : G}, a / b = c ↔ a = c * b := by sorry

This is a theorem about the properties of division and multiplication in a group. Specifically, for any type `G` that forms a group, and for any three elements `a`, `b`, and `c` of this group, the statement `a / b = c` is equivalent to the statement `a = c * b`. In other words, in a group, dividing `a` by `b` to get `c` is the same as multiplying `b` by `c` to get `a`.

In a group, for all elements a, b, and c, the equality a / b = c holds if and only if a = c * b.


theorem IntermediateField.mem_top :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {x : E}, x ∈ ⊤ := by
  sorry

The theorem `IntermediateField.mem_top` states that for any two types `F` and `E` where both are fields and `E` is an algebra over `F`, any element `x` of `E` belongs to the top intermediate field. Here, the top intermediate field (denoted by `⊤`) refers to the intermediate field that contains all elements of `E`.

For any fields `F` and `E` with `E` being an algebra over `F`, every element `x` in `E` lies in the top intermediate field `⊤`.


theorem AntivaryOn.dual_right :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β}
      {s : Set ι}, AntivaryOn f g s → MonovaryOn f (⇑OrderDual.toDual ∘ g) s :=
  by sorry

The theorem `AntivaryOn.dual_right` states that for any types `ι`, `α`, and `β` with preorders on `α` and `β`, and any functions `f : ι → α`, `g : ι → β`, and a set `s : Set ι`, if `f` antivaries with `g` on `s`, then `f` monovaries with the dual order of `g` on `s`. In other words, if for all `i, j` in `s`, `g i < g j` implies `f j ≤ f i`, then applying the identity function to the dual order of `g`, for all `i, j` in `s`, `g i < g j` would imply `f i ≤ f j`. This theorem essentially establishes a connection between the behaviors of a function under the original and dual orders.

If a function `f` antivaries with another function `g` on a set `s`, then `f` monovaries with the dual order of `g` on `s`.


theorem Set.Subsingleton.eq_empty_or_singleton :
    ∀ {α : Type u} {s : Set α}, Set.Subsingleton s → s = ∅ ∨ ∃ x, s = {x} := by sorry

The theorem `Set.Subsingleton.eq_empty_or_singleton` states that for any type `α` and any set `s` of type `α`, if `s` is a subsingleton set (i.e., it has at most one element), then `s` must either be equal to the empty set or there exists an element `x` such that `s` is the singleton set containing only `x`.

If `α` is a type and `s : Set α` is a subsingleton set, then `s = ∅` or `s = {x : α}`.


/-- The inner content of a union of sets is at most the sum of the individual inner contents.
This is the "unbundled" version of `innerContent_iSup_nat`.
It is required for the API of `inducedOuterMeasure`.  -/
theorem MeasureTheory.Content.innerContent_iUnion_nat :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : R1Space G] ⦃U : ℕ → Set G⦄
      (hU : ∀ (i : ℕ), IsOpen (U i)),
      MeasureTheory.Content.innerContent μ { carrier := ⋃ i, U i, is_open' := ⋯ } ≤
        ∑' (i : ℕ), MeasureTheory.Content.innerContent μ { carrier := U i, is_open' := ⋯ } :=
  by sorry

The theorem `MeasureTheory.Content.innerContent_iUnion_nat` asserts that for any topological space `G` and a given measure `μ`, the inner content (defined as the supremum of the content of all compact subsets) of a countable union of sets is less than or equal to the sum of the inner contents of the individual sets. This property holds true for all countable collections of open sets in `G`. This theorem is a key mathematical property ensuring the measure behaves consistently with respect to set union operations. The specific form of the theorem here is required for the implementation of the 'inducedOuterMeasure'.

For any measure μ on a topological space G and countable collection {A_i} of open sets, the inner content of their union is less than or equal to the sum of the inner contents of each set: ∬(i in nat) μ(A_i) ≤ μ(⋃(i in nat) A_i).


CovBy.ofDual

/-- **Alias** of the reverse direction of `ofDual_covBy_ofDual_iff`. -/
theorem CovBy.ofDual : ∀ {α : Type u_1} [inst : LT α] {a b : αᵒᵈ}, b ⋖ a → OrderDual.ofDual a ⋖ OrderDual.ofDual b := by
  sorry

The theorem `CovBy.ofDual` states that for any type `α` under the less-than (`LT`) operation, if `b` is covered by `a` in the order dual, then the undualized `a` is covered by the undualized `b`. Here, "covered by" (`⋖`) is a relation on an ordered set where `b` is said to cover `a` if `b > a` and there is no element `c` such that `b > c > a`. The order dual of a set reverses the order of the elements, and the function `OrderDual.ofDual` is the identity function that maps each element back to itself in the original order.

If `a ⋖ b` holds in an ordered set under the order dual, then `OrderDual.ofDual a ⋖ OrderDual.ofDual b` holds in the original order.


theorem MeasureTheory.JordanDecomposition.neg_negPart :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α), (-j).negPart = j.posPart :=
  by sorry

The theorem `MeasureTheory.JordanDecomposition.neg_negPart` states that for all types `α` that have an instance of the `MeasurableSpace` type class, and for all Jordan decompositions `j` of measures on `α`, the negative part of the negation of `j` is equal to the positive part of `j`. In other words, for any measurable space and any Jordan decomposition of measures on that space, the "negative of the negative part" is equivalent to the "positive part".

For any measurable space with a Jordan decomposition of measures, the negative of the negative measure part is equal to the positive measure part.


theorem Matrix.dotProduct_neg :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocRing α] (v w : m → α),
      Matrix.dotProduct v (-w) = -Matrix.dotProduct v w :=
  by sorry

The theorem `Matrix.dotProduct_neg` states that for any two mathematical objects `v` and `w` that are functions from an arbitrary type `m` to another type `α`, where `m` is a finite type and `α` is a non-unital non-associative ring, the dot product of `v` and the additive inverse of `w` (denoted as `-w`) equals to the additive inverse of the dot product of `v` and `w`. In other words, the dot product operation distributes over negation. In mathematical notation, it can be written as $\langle v, -w \rangle = - \langle v, w \rangle$, where $\langle \cdot, \cdot \rangle$ denotes the dot product.

The dot product of a function from a finite type to a non-unital non-associative ring and the additive inverse of another function equals the additive inverse of their dot product. In other words, $\langle v, -w \rangle = - \langle v, w \rangle$.


Heyting.IsRegular.eq

theorem Heyting.IsRegular.eq : ∀ {α : Type u_1} [inst : HasCompl α] {a : α}, Heyting.IsRegular a → aᶜᶜ = a := by sorry

The theorem states that for any type `α` with a defined complement operation and any element `a` of type `α`, if `a` is regular in the sense of Heyting algebras (i.e., its double complement equals itself), then indeed the double complement of `a` does equal `a`. This is essentially saying that the definition of regularity for elements of a Heyting algebra holds true, namely if an element's double complement is equal to the element itself, then the double complement of the element is indeed equal to the element.

If `α` is a type with a defined complement operation and `a` is a regular element of the Heyting algebra `α` (i.e., `a` equals its double complement), then `a` equals its double complement.


theorem MeasureTheory.lintegral_mono_set :
    ∀ {α : Type u_1} {x : MeasurableSpace α} ⦃μ : MeasureTheory.Measure α⦄ {s t : Set α} {f : α → ENNReal},
      s ⊆ t → ∫⁻ (x : α) in s, f x ∂μ ≤ ∫⁻ (x : α) in t, f x ∂μ :=
  by sorry

The theorem `MeasureTheory.lintegral_mono_set` states that for any type `α`, MeasurableSpace `x` of type `α`, a measure `μ` on `α`, two sets `s` and `t` of type `α`, and a function `f` from `α` to the extended nonnegative real numbers (usually denoted [0, ∞]), if set `s` is a subset of set `t`, then the Lebesgue integral of `f` over set `s` with respect to measure `μ` is less than or equal to the Lebesgue integral of `f` over set `t` with respect to measure `μ`. This theorem is a statement about the monotonicity of the Lebesgue integral with respect to the set of integration.

For any measurable space (α, μ), measurable sets s ⊆ t, and measurable function f: α → [0, ∞], the Lebesgue integral of f over s with respect to μ is less than or equal to the Lebesgue integral of f over t with respect to μ.


theorem Finset.image_subset_image₂_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {b : β}, b ∈ t → Finset.image (fun a => f a b) s ⊆ Finset.image₂ f s t :=
  by sorry

The theorem `Finset.image_subset_image₂_left` states that for any types `α`, `β`, and `γ` with decidable equality on `γ`, and for any binary function `f : α → β → γ`, any finite sets `s : Finset α` and `t : Finset β`, and any element `b : β` in `t`, the image of the set `s` under the function `a => f a b` is a subset of the image of the set `s × t` under the function `f`. In other words, applying the function `f` to each element of `s` and a fixed value `b` from `t` results in a set that is contained within the set obtained by applying `f` to all pairs `(a, b')` where `a` is from `s` and `b'` is from `t`.

For any decidably equal types `α`, `β`, and `γ`, and decidable `β-values` `b`, the image of a finite set `s ∈ Finset α` under the function `f : α × β → γ` is a subset of the image of the product set `s × {b} ∈ Finset (α × β)` under the same function `f`.


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

The theorem `Set.ordConnected_Ioi` states that for any type `α` that has a preorder structure and for any element `a` of type `α`, the left-open right-infinite interval `(a, +∞)` denoted `Set.Ioi a` is order-connected. In the context of order theory, a set is said to be order-connected if for every pair of elements in the set where one is less than the other, all elements that lie between these two are also in the set. In this case, for any two elements in the set `Set.Ioi a` where one is less than the other, all elements that lie between them are also in `Set.Ioi a`.

For any preordered type `α` and element `a` in `α`, the left-open right-infinite interval `(a, +∞)` in `α` is order-connected.


theorem AlgebraicGeometry.PresheafedSpace.restrict.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {U : TopCat}
      (X : AlgebraicGeometry.PresheafedSpace C) {f : U ⟶ ↑X}, OpenEmbedding ⇑f → IsOpenMap ⇑f :=
  by sorry

This theorem states that for any category `C`, topological space `U`, and presheafed space `X` over `C`, if the morphism `f` from `U` to the underlying topological space of `X` is an open embedding, then `f` is an open map. In other words, if a morphism between topological spaces is an open embedding (i.e., it is a continuous, injective map with its image being an open set), then the image of any open set through this morphism is also an open set.

If `f : U -> X` is an open embedding of a morphism from a topological space `U` to a presheafed space `X` over a category `C`, then `f` is an open map, i.e., the image of any open set in `U` is an open set in `X`.


theorem Nat.floor_one : ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α], ⌊1⌋₊ = 1 := by
  sorry

This theorem, `Nat.floor_one`, states that for any type `α` that is a `LinearOrderedSemiring` and a `FloorSemiring`, the floor function applied to the number one (`1`) is equal to one (`1`). In other words, it's saying that the greatest integer less than or equal to one is one itself, which is obviously true as one is an integer.

For any type `α` that is both a LinearOrderedSemiring and a FloorSemiring, the floor function of 1 equals 1.


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

This theorem states that for all integers `a`, `b`, and `c`, the result of `a` multiplied by the difference of `b` and `c` is equal to the result of `a` multiplied by `b` minus `a` multiplied by `c`. In mathematical notation, this can be written as: for all $a$, $b$, $c$ in $\mathbb{Z}$, $a \cdot (b - c) = a \cdot b - a \cdot c$. This theorem essentially confirms the distribution law of multiplication over subtraction for integers.

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


ContinuousOn.prod

theorem ContinuousOn.prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {f : α → β} {g : α → γ} {s : Set α},
      ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => (f x, g x)) s :=
  by sorry

This theorem, `ContinuousOn.prod`, states that for any three types `α`, `β`, and `γ`, each equipped with a topological space structure, and for any two functions `f` from `α` to `β` and `g` from `α` to `γ`, along with a set `s` of type `α`, if `f` and `g` are both continuous on `s`, then the function that maps `x` in `α` to the pair `(f(x), g(x))` in `β x γ` is also continuous on `s`.

In mathematical terms, given two functions `f: α → β` and `g: α → γ` that are continuous on a subset `s` of `α`, the function that maps a point in `s` to a pair consisting of the image of that point under `f` and `g` is also continuous on `s`.

Given topological spaces `α`, `β`, and `γ`, and continuous functions `f: α → β` and `g: α → γ` on a subset `s` of `α`, the function `x mapsto (f(x), g(x))` from `s` to `β × γ` is continuous.


theorem Int.mul_emod : ∀ (a b n : ℤ), a * b % n = a % n * (b % n) % n := by sorry

This theorem states that for any three integers `a`, `b`, and `n`, the remainder of the product of `a` and `b` when divided by `n` is equal to the product of the remainders of `a` and `b` when divided by `n`, which itself is then divided by `n`. In mathematical notation, this is expressing the identity `a * b mod n = ((a mod n) * (b mod n)) mod n`.

The theorem asserts that for any integers `a`, `b`, and `n`, the remainder of their product taken modulo `n` equals the remainder of their individual products taken modulo `n`, also modulo `n`. In other words, `(a * b) mod n = (a mod n) * (b mod n) mod n`.


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

This theorem, named `Rat.cast_sub`, states that for any type `α` which is a division ring with characteristic zero, the action of casting the difference of two rational numbers `m` and `n` to the type `α` is equal to the difference of the castings of `m` and `n` to the type `α`. In more mathematical terms, it says that if `m` and `n` are rational numbers and `α` is a division ring with characteristic zero, then `(m - n)` cast to `α` is equal to `m` cast to `α` minus `n` cast to `α`. This property is often known as the preservation of subtraction under casting.

For any division ring `α` with characteristic zero, the operation of casting the difference of two rational numbers to `α` is equal to the difference of casting each rational number to `α`.


theorem Multiset.inf_cons :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderTop α] (a : α) (s : Multiset α),
      Multiset.inf (a ::ₘ s) = a ⊓ Multiset.inf s :=
  by sorry

The theorem `Multiset.inf_cons` states that for any multiset `s` and any element `a` of type `α`, where `α` is a semilattice with an order top, the infimum of the multiset obtained by consing `a` onto `s` is equal to the infimum of `a` and the infimum of `s`. In mathematical terms, given a multiset `s` and `a` in a semilattice `α`, we have `inf(a ∪ s) = a ⊓ inf(s)`.

For any multiset `s` and element `a` in a semilattice `α` with an order top, the infimum of `a` combined with `s` is equal to the infimum of `a` and the infimum of `s` (i.e., `inf(a ∪ s) = a ∧ inf(s)`).


Set.Finite.prod

theorem Set.Finite.prod :
    ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β}, Set.Finite s → Set.Finite t → Set.Finite (s ×ˢ t) := by sorry

The theorem `Set.Finite.prod` states that for any two types `α` and `β`, and any two sets `s` and `t` where `s` is a set of type `α` and `t` is a set of type `β`, if both `s` and `t` are finite sets, then the Cartesian product of `s` and `t` (denoted as `s ×ˢ t`) is also a finite set. In other words, if we have finite sets from two different types, their Cartesian product will also form a finite set.

If `α` and `β` are types and `s : Set α` and `t : Set β` are finite sets, then `s ×ˢ t` is a finite set.


theorem neg_div' : ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] (a b : K), -(b / a) = -b / a :=
  by sorry

This theorem, `neg_div'`, states that for any type `K` that is a division monoid and has a distributive negation property, for any two elements `a` and `b` of `K`, the negation of the result of dividing `b` by `a` is equal to the result of dividing the negation of `b` by `a`. In mathematical terms, this can be written as: for all `a` and `b` in `K`, `- (b / a) = -b / a`.

For any type `K` with a distributive negation property and division monoid structure, the negation of the quotient of two elements is equal to the quotient of their negations: `- (b / a) = -b / a`.


TopologicalSpace.IsSeparable.mono

theorem TopologicalSpace.IsSeparable.mono :
    ∀ {α : Type u} [t : TopologicalSpace α] {s u : Set α},
      TopologicalSpace.IsSeparable s → u ⊆ s → TopologicalSpace.IsSeparable u :=
  by sorry

The theorem `TopologicalSpace.IsSeparable.mono` states that for any type `α` equipped with a topology `t` and any two sets `s` and `u` of `α`, if `s` is a separable set in the topological space and `u` is a subset of `s`, then `u` is also a separable set in the topological space. In other words, separability is a monotonic property: it is preserved under taking subsets.

In a topological space, if a separable set is contained in another set, then the contained set is also separable.


theorem Sym2.other_spec : ∀ {α : Type u_1} {a : α} {z : Sym2 α} (h : a ∈ z), s(a, Sym2.Mem.other h) = z := by sorry

The theorem `Sym2.other_spec` states that for any type `α`, any element `a` of type `α`, and any unordered pair `z` of type `Sym2 α` (which is the type of unordered pairs of `α`), if `a` is a member of `z`, then the unordered pair created from `a` and the other member of `z` (found using the `Sym2.Mem.other` function) is equal to `z`. Essentially, it says that if we disassemble an unordered pair into its components and then reassemble it, we get the original unordered pair.

For any type `α` and unordered pair `z` of type `Sym2 α` with member `a`, `{a} ⊓ z = z`. Here, `⊓` denotes the "symmetric difference with" operator in Set theory, which returns the elements common to both sets.


theorem MeasureTheory.VectorMeasure.zero_le_restrict_subset :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M]
      [inst_1 : OrderedAddCommMonoid M] (v : MeasureTheory.VectorMeasure α M) {i j : Set α},
      MeasurableSet i →
        j ⊆ i →
          MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict v i →
            MeasureTheory.VectorMeasure.restrict 0 j ≤ MeasureTheory.VectorMeasure.restrict v j :=
  by sorry

This theorem states that for any measurable space `α`, with a given topological space `M` and an ordered additive commutative monoid `M`, for any vector measure `v` on `α` with values in `M`, and for any two sets `i` and `j` of `α` such that `i` is measurable and `j` is a subset of `i`, if the restriction of the zero vector measure to `i` is less than or equal to the restriction of `v` to `i`, then the restriction of the zero vector measure to `j` is also less than or equal to the restriction of `v` to `j`. In simpler terms, if the zero measure on a larger set is dominated by a vector measure, then the same holds for any subset of that larger set.

For any measurable space `α`, if a vector measure `v` on `α` with values in an ordered additive commutative monoid `M` satisfies the restriction of `v` on a measurable set `i` dominates the zero vector measure on `i`, then the restriction of `v` on any subset `j` of `i` also dominates the zero vector measure on `j`.


theorem RingHom.mem_rangeS :
    ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {f : R →+* S} {y : S},
      y ∈ RingHom.rangeS f ↔ ∃ x, f x = y :=
  by sorry

This theorem states that for any types `R` and `S`, which are both non-associative semirings, and any ring homomorphism `f` from `R` to `S`, and any element `y` of `S`, `y` is in the range of the ring homomorphism `f` if and only if there exists an element `x` in `R` such that applying the function `f` to `x` gives `y`.

For any non-associative semirings R and S, and ring homomorphism f from R to S, y ∈ Im(f) if and only if there exists x ∈ R such that f(x) = y.


theorem MeasureTheory.lintegral_const_mul :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (r : ENNReal) {f : α → ENNReal},
      Measurable f → ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ :=
  by sorry

This theorem states that for any measurable space `α`, given a measure `μ` on `α`, a constant `r` of extended nonnegative real numbers (which includes the positive real numbers and positive infinity), and a measurable function `f` from `α` to the extended nonnegative real numbers, the integration of the function `f` multiplied by the constant `r` with respect to the measure `μ` is equal to the constant `r` times the integration of the function `f` with respect to the measure `μ`. In other words, it asserts the property of constant multiplication with respect to the Lebesgue integral, which is a fundamental property of integration in measure theory.

For any measurable space, measure, constant, and measurable function, the integral of the constant times the function with respect to the measure equals the constant times the integral of the function with respect to the measure.


theorem tendsto_const_div_atTop_nhds_zero_nat : ∀ (C : ℝ), Filter.Tendsto (fun n => C / ↑n) Filter.atTop (nhds 0) := by
  sorry

The theorem `tendsto_const_div_atTop_nhds_zero_nat` states that for any real constant `C`, as `n` tends to infinity (represented by `Filter.atTop`), the function defined as `C / n` tends to zero in the neighborhood filter (represented by `(nhds 0)`). In other words, the value of a constant divided by a natural number gets arbitrarily close to zero as that number goes towards infinity.

For any real constant C, the sequence C / n converges to 0 in the neighborhood filter of 0 as n approaches infinity.


theorem Polynomial.aeval_one :
    ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
      (Polynomial.aeval x) 1 = 1 :=
  by sorry

The theorem `Polynomial.aeval_one` states that for any given evaluation `x` of the variable in an `R`-algebra `A`, where `R` is a commutative semiring and `A` is a semiring, the unique `R`-algebra homomorphism from `R[X]` to `A` that sends `X` to `x`, when applied to the polynomial 1, produces 1. In other words, evaluating the polynomial 1 under any valuation in any `R`-algebra always gives back 1.

For any commutative semiring `R`, `R`-algebra `A`, and evaluation `x` in `A`, the unique `R`-algebra homomorphism from `R[X]` to `A` maps the polynomial 1 to 1, i.e., `(�� heal x : R[X] →* A) 1 = 1`.


theorem Filter.prod_map_map_eq' :
    ∀ {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} (f : α₁ → α₂) (g : β₁ → β₂) (F : Filter α₁)
      (G : Filter β₁), Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G) :=
  by sorry

The theorem `Filter.prod_map_map_eq'` states that for any types `α₁`, `α₂`, `β₁`, `β₂`, any functions `f : α₁ → α₂` and `g : β₁ → β₂`, and any filters `F` on `α₁` and `G` on `β₁`, the product filter of mapping `f` on `F` and mapping `g` on `G` is equal to the filter obtained by mapping the function `Prod.map f g` on the product filter of `F` and `G`. In other words, the theorem describes a certain commutative property of filter mapping with respect to the product operation on filters.

For any filters $F$ on type $\alpha\_1$ and $G$ on type $\beta\_1$, and any functions $f : \alpha\_1 \to \alpha\_2$ and $g : \beta\_1 \to \beta\_2$, the filter obtained by applying $f$ to the product filter of $F$ and $G$ is equal to the product filter of $f$ and $g$, i.e., $(f \times g)(F \otimes G) = (\text{Prod.map } f \ g)(F \otimes G)$.


Nat.ModEq.add

theorem Nat.ModEq.add : ∀ {n a b c d : ℕ}, a ≡ b [MOD n] → c ≡ d [MOD n] → a + c ≡ b + d [MOD n] := by sorry

This theorem states that for all natural numbers `n`, `a`, `b`, `c`, and `d`, if `a` is congruent to `b` modulo `n` and `c` is congruent to `d` modulo `n`, then the sum of `a` and `c` is congruent to the sum of `b` and `d` modulo `n`. In other words, congruence modulo `n` is preserved under addition.

For all natural numbers `n`, `a`, `b`, `c`, and `d`, if `a ≡ b (mod n)` and `c ≡ d (mod n)`, then `a + c ≡ b + d (mod n)`.


theorem ENNReal.strictMono_rpow_of_pos : ∀ {z : ℝ}, 0 < z → StrictMono fun x => x ^ z := by sorry

The theorem `ENNReal.strictMono_rpow_of_pos` states that for any real number `z` which is greater than `0`, the function `f(x) = x^z` is strictly increasing. This means that if `a` and `b` are any two numbers and `a < b`, then `a^z` will be less than `b^z`. Essentially, if you have a positive real exponent `z`, raising numbers to the power of `z` is a strictly monotone operation.

For any real number `z > 0`, the function `x => x^z` is strictly increasing on the positive real numbers.


theorem MeasureTheory.Measure.restrict_iUnion_ae :
    ∀ {α : Type u_2} {ι : Type u_6} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Countable ι]
      {s : ι → Set α},
      Pairwise (MeasureTheory.AEDisjoint μ on s) →
        (∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
          μ.restrict (⋃ i, s i) = MeasureTheory.Measure.sum fun i => μ.restrict (s i) :=
  by sorry

The theorem `MeasureTheory.Measure.restrict_iUnion_ae` states that for any type `α`, any countable index set `ι`, any measurable space `m0`, any measure `μ`, and any indexed family of sets `s`, if each pair of sets from `s` is almost everywhere disjoint with respect to measure `μ`, and each set in `s` is a null measurable set with respect to measure `μ`, then the measure `μ` restricted to the union of all sets in `s` is equal to the sum of the measures `μ` restricted to each individual set in `s`. In simpler terms, if we have a family of sets that don't overlap almost everywhere and each set can be approximated by a measurable set up to a set of null measure, then the total measure over the union of these sets is the sum of the measures over each individual set.

If `(ι : Type)` is countable, `(m0 : MeasurableSpace α)`, `(μ : Measure m0)`, and `(s : ι → Set α)` are such that each pair of sets in `s` is almost everywhere disjoint and each set in `s` is null measurable, then `μ.restrict (⋃ i in ι, s i) = Σ i in ι, μ.restrict (s i)`.


theorem isCompl_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {a b : α},
      IsCompl a b ↔ Disjoint a b ∧ Codisjoint a b :=
  by sorry

The theorem `isCompl_iff` states that, for any type `α` that has a partial order and is also a bounded order, two elements `a` and `b` of `α` are complements (as expressed by `IsCompl a b`) if and only if `a` and `b` are both disjoint and codisjoint. In the context of a lattice, two elements are disjoint if their greatest lower bound (infimum) is the least element of the order (`⊥`), while they are codisjoint if their least upper bound (supremum) is the greatest element of the order (`⊤`).

In a bounded order, two elements are complements if and only if they have no common lower bound and no common upper bound.


theorem coinduced_compose :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [tα : TopologicalSpace α] {f : α → β} {g : β → γ},
      TopologicalSpace.coinduced g (TopologicalSpace.coinduced f tα) = TopologicalSpace.coinduced (g ∘ f) tα :=
  by sorry

The theorem named `coinduced_compose` states that for any three types `α`, `β`, and `γ`, given a topological space on `α`, and two functions `f` from `α` to `β` and `g` from `β` to `γ`, the coinduced topology on `γ` by `g` from the coinduced topology on `β` by `f` from the topological space on `α` is equivalent to the coinduced topology on `γ` by the composition of `g` and `f` from the topological space on `α`. In other words, the process of coinducing topologies is compatible with function composition.

The coinduced topologies on `γ` by the composition of `g` and `f` from the topological space on `α` is equivalent to the coinduced topology on `γ` by `g` from the coinduced topology on `β` by `f` from the topological space on `α`.


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

The theorem `Subgroup.comap_mono` states that for any two subgroups `K` and `K'` of a group `N` and a monoid homomorphism `f` from a group `G` to `N`, if `K` is a subset of `K'` (expressed as `K ≤ K'`), then the preimage of `K` under `f` is a subset of the preimage of `K'` under `f` (expressed as `Subgroup.comap f K ≤ Subgroup.comap f K'`). In other words, if we map `G` to `N` using `f`, and `K` is contained in `K'` in `N`, then the elements of `G` that map to `K` are contained within the elements of `G` that map to `K'`.

If `f` is a monoid homomorphism from a group `G` to a group `N`, `K` is a subgroup of `K'` in `N`, then the preimage of `K` under `f` is a subgroup of the preimage of `K'` under `f` in `G`.


theorem Mathlib.Combinatorics.SimpleGraph.Maps._auxLemma.1 :
    ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W) (G : SimpleGraph V) (u v : W),
      (SimpleGraph.map f G).Adj u v = ∃ u' v', G.Adj u' v' ∧ f u' = u ∧ f v' = v :=
  by sorry

This theorem states that for any two types `V` and `W`, given an injective function `f` from `V` to `W` and a simple graph `G` on `V`, for any two elements `u` and `v` from `W`, the adjacency in the graph obtained by applying the function `f` to `G` (`SimpleGraph.map f G`) between `u` and `v` is equivalent to the existence of two elements `u'` and `v'` in `V` such that `u'` and `v'` are adjacent in the original graph `G` and the images of `u'` and `v'` under the function `f` are `u` and `v` respectively. In other words, the mapped graph preserves the adjacency structure of the original graph under the injective function `f`.

For any injective function between types `V` and `W` and simple graph `G` on `V`, elements `u` and `v` in `W` are adjacent in the mapped graph `SimpleGraph.map f G` if and only if there exist adjacent elements `u'` and `v'` in `G` such that `f(u') = u` and `f(v') = v`.


theorem CategoryTheory.Functorial.map_id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [inst_2 : CategoryTheory.Functorial F] {X : C},
      CategoryTheory.map F (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (F X) :=
  by sorry

The theorem `CategoryTheory.Functorial.map_id` states that for any category `C` of type `u₁` with a category structure `inst`, any category `D` of type `u₂` with a category structure `inst_1`, any function `F` from `C` to `D` that has a functorial structure `inst_2`, and an object `X` in `C`, the mapping of the identity morphism of `X` under `F` (denoted `CategoryTheory.map F (CategoryTheory.CategoryStruct.id X)`) is the identity morphism of the object `F X` in `D` (denoted `CategoryTheory.CategoryStruct.id (F X)`). This theorem is essentially asserting that the functor `F` preserves identity morphisms, a crucial property of functors in category theory.

For any functors F from category C to category D, the identity morphism of an object X in C is mapped to the identity morphism of the object F(X) in D.


theorem bot_sdiff : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, ⊥ \ a = ⊥ := by sorry

The theorem `bot_sdiff` states that for any type `α` that is a Generalized Coheyting Algebra, and for any element `a` of `α`, the pseudo-difference (denoted `\`) of the bottom element (denoted `⊥`) and `a` is equal to `⊥`. In simpler terms, subtracting any element from the smallest element of a Generalized Coheyting Algebra results in the smallest element.

For any Generalized Coalgebra `α` and its bottom element `⊥`, we have `⊥ \ a = ⊥` for all `a` in `α`.


theorem Filter.frequently_atTop :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] [inst_1 : Nonempty α] {p : α → Prop},
      (∃ᶠ (x : α) in Filter.atTop, p x) ↔ ∀ (a : α), ∃ b ≥ a, p b :=
  by sorry

The theorem `Filter.frequently_atTop` states that for any type `α` that forms a semilattice under a supremum operation and is nonempty, and for any property `p` from `α` to `Prop`, the property `p` holds "frequently" at the limit towards infinity (`Filter.atTop`) if and only if, for every element `a` of `α`, there exists an element `b` greater than or equal to `a` such that `p` holds for `b`. To put it simply, the property is satisfied somewhere beyond every point in the ordered set.

For any semilattice with supremum `α` and nonempty `p : α -> Prop`, `Filter.atTop p` holds if and only if for all `a : α`, there exists `b : α` with `b >= a` such that `p b` holds.


theorem iSup_of_empty :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] [inst_1 : IsEmpty ι] (f : ι → α), iSup f = ⊥ := by sorry

This theorem, `iSup_of_empty`, states that for any type `α` that forms a complete lattice, and for any type `ι` that is empty (i.e., there are no elements of this type), if we have a function `f` from `ι` to `α`, then the indexed supremum of `f` (`iSup f`) is equal to the bottom element (`⊥`) of the complete lattice `α`. In simpler terms, the supremum of an empty set of elements in a complete lattice is the smallest element in that lattice.

For any complete lattice `α` and empty type `ι`, the indexed supremum of the empty function from `ι` to `α` equals the bottom element of `α`.


theorem ENNReal.mul_left_strictMono : ∀ {a : ENNReal}, a ≠ 0 → a ≠ ⊤ → StrictMono fun x => a * x := by sorry

The theorem `ENNReal.mul_left_strictMono` states that for any extended nonnegative real number `a` which is neither zero nor positive infinity, the function that multiplies `a` to its input is strictly monotonic. In other words, for any two distinct inputs, the one that is larger will have a larger output after multiplication by `a`. This corresponds to the mathematical statement that multiplication by a positive real number preserves the order of real numbers.

For any extended non-zero non-positive infinity real number `a`, the function `x => a * x` is strictly increasing on the set of real numbers.


theorem Matrix.dotProduct_add :
    ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (u v w : m → α),
      Matrix.dotProduct u (v + w) = Matrix.dotProduct u v + Matrix.dotProduct u w :=
  by sorry

The theorem `Matrix.dotProduct_add` states that for any vectors `u`, `v`, and `w` of elements from a type `m` mapping to a type `α`, where `α` forms a non-unital non-associative semiring, the dot product of `u` with the vector sum of `v` and `w` equals the sum of the dot product of `u` and `v` and the dot product of `u` and `w`. In mathematical terms, this is expressing the distributive property of the dot product over vector addition: `u ⋅ (v + w) = u ⋅ v + u ⋅ w`.

For any vectors `u`, `v`, and `w` in a type `m` mapping to a non-unital non-associative semiring `α`, the dot product of `u` with the vector sum of `v` and `w` is equal to the sum of the dot products of `u` with `v` and `w`: `u ⋅ (v + w) = u ⋅ v + u ⋅ w`.


theorem Mathlib.Algebra.Tropical.Basic._auxLemma.3 :
    ∀ {R : Type u} [inst : LE R] {x y : Tropical R}, (Tropical.untrop x ≤ Tropical.untrop y) = (x ≤ y) := by sorry

The theorem `Mathlib.Algebra.Tropical.Basic._auxLemma.3` states that for any type `R` that has an order (`inst : LE R`), and for any `x` and `y` of the tropicalized type `Tropical R`, the inequality `Tropical.untrop x ≤ Tropical.untrop y` is equivalent to the inequality `x ≤ y`. In other words, the process of "untropicalizing" does not change the order of elements.

For any type `R` with an order and any `x, y` in the tropicalized type of `R`, `x ≤ y` if and only if `Tropical.untrop x ≤ Tropical.untrop y`.


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

This theorem, `Int.sub_sub`, states a property about subtraction for all integers. Specifically, it says that for any three integers `a`, `b`, and `c`, subtracting `b` and then `c` from `a` is the same as subtracting the sum of `b` and `c` from `a`. In other words, `a - b - c` equals `a - (b + c)` for all integer values of `a`, `b`, and `c`.

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


List.IsRotated.symm

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

This theorem states that the "isRotated" relation on lists is symmetric. In other words, for any given type `α` and any lists `l` and `l'` of this type, if `l` is a rotation of `l'`, then `l'` is also a rotation of `l`. Here, a list is said to be a rotation of another if it can be obtained by taking a contiguous part from the beginning and moving it to the end.

If `l` is a rotation of `l'`, then `l'` is a rotation of `l` (for all lists `l` and `l` of the same type `α`).


theorem WithBot.preimage_coe_Iic :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithBot.some ⁻¹' Set.Iic ↑a = Set.Iic a := by sorry

This theorem states that for any type `α` with a preorder, and for any `a` in `α`, the preimage of the interval set `Set.Iic ↑a` under the function `WithBot.some` is equal to the interval `Set.Iic a`. In simpler terms, it means that when we map elements from type `α` to the type `WithBot α` and then take elements that are less than or equal to `a` (in `WithBot α`), it's equivalent to directly taking elements that are less than or equal to `a` in type `α`. Here, `WithBot.some` is a function that embeds type `α` into `WithBot α` and `Set.Iic a` is the set of all elements less than or equal to `a`.

For any preordered type `α` and element `a` in `α`, the preimage of the interval `[a, ∞)` under the embedding `WithBot.some` is equal to the interval `[a, ∞)` in `α`.


theorem Finset.Ico_self :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a : α), Finset.Ico a a = ∅ := by sorry

The theorem `Finset.Ico_self` states that for any type `α` which has a preorder relation and a locally finite order, the interval `[a, a)` represented as a finite set (`Finset`) is an empty set. In simpler terms, it says that the set of all elements `x` such that `a ≤ x < a` is empty for any `a` in some ordered set `α`.

For any type `α` with a preorder and locally finite order, the finite set `{x : α | a ≤ x < a}` is empty for all `a` in `α`.


theorem VitaliFamily.FineSubfamilyOn.exists_disjoint_covering_ae :
    ∀ {α : Type u_1} [inst : MetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {v : VitaliFamily μ}
      {f : α → Set (Set α)} {s : Set α},
      VitaliFamily.FineSubfamilyOn v f s →
        ∃ t,
          (∀ p ∈ t, p.1 ∈ s) ∧
            (Set.PairwiseDisjoint t fun p => p.2) ∧
              (∀ p ∈ t, p.2 ∈ v.setsAt p.1 ∩ f p.1) ∧ ↑↑μ (s \ ⋃ p ∈ t, p.2) = 0 :=
  by sorry

The theorem `VitaliFamily.FineSubfamilyOn.exists_disjoint_covering_ae` states that for any type `α` equipped with a metric space structure, a measurable space `m0`, a measure `μ`, a Vitali family `v`, a function `f` mapping from `α` to a set of subsets of `α`, and a set `s` of `α`, if the Vitali family `v` is a fine subfamily on `f` and `s`, then there exists a set `t` such that every pair `(p.1, p.2)` in `t` satisfies the following conditions:

1. `p.1` is an element of `s`.
2. The set `t` is pairwise disjoint under the function `p => p.2`.
3. `p.2` is an element of the intersection between the set `v.setsAt p.1` and `f p.1`.
4. The measure of the set difference between `s` and the union of `p.2` for all `p` in `t` is zero.

In other words, this theorem guarantees the existence of a disjoint covering set `t` for a given set `s` under certain conditions, and the set `s` without this covering set has measure zero.

Given a metric space `α` with a measurable space `m0`, measure `μ`, Vitali family `v`, function `f` mapping from `α` to subsets of `α`, and set `s`, if `v` is a fine subfamily on `f` and `s`, then there exists a disjoint subfamily `t` of `v.setsAt(s)` such that the measure of `s \ (∪{f(x).inter `v.setsAt x | x ∈ t})` is zero.


theorem SemiconjBy.pow_right :
    ∀ {M : Type u_2} [inst : Monoid M] {a x y : M}, SemiconjBy a x y → ∀ (n : ℕ), SemiconjBy a (x ^ n) (y ^ n) := by
  sorry

The theorem `SemiconjBy.pow_right` states that for any type `M` that forms a monoid, and given any three elements `a`, `x`, and `y` from `M`, if `a` is semiconjugate to `x` by `y` (i.e., `a * x = y * a`), then for any natural number `n`, `a` is also semiconjugate to `x^n` by `y^n` (i.e., `a * x^n = y^n * a`). In other words, the property of being semiconjugate is preserved under exponentiation.

If `a`, `x`, and `y` are in a monoid `M` with `a` semiconjugate to `x` by `y` (i.e., `a * x = y * a`), then for any natural number `n`, `a` is semiconjugate to `x^n` by `y^n` (i.e., `a * x^n = y^n * a`).


theorem MvPolynomial.rename_rename :
    ∀ {σ : Type u_1} {τ : Type u_2} {α : Type u_3} {R : Type u_4} [inst : CommSemiring R] (f : σ → τ) (g : τ → α)
      (p : MvPolynomial σ R), (MvPolynomial.rename g) ((MvPolynomial.rename f) p) = (MvPolynomial.rename (g ∘ f)) p :=
  by sorry

The theorem `MvPolynomial.rename_rename` states that for every commutative semiring `R` and types `σ`, `τ`, and `α`, if you have two renaming functions `f: σ → τ` and `g: τ → α`, and a multivariate polynomial `p` over `σ` and `R`, then applying the renaming function `f` to the polynomial `p` and then applying the renaming function `g` to the result is the same as first composing the functions `g` and `f` to create a new renaming function and then applying this new function to the polynomial `p`. In other words, the process of renaming variables in a multivariate polynomial is associative with respect to function composition.

For every commutative semiring `R` and types `σ`, `τ`, and `α`, and given renaming functions `f: σ → τ` and `g: τ → α`, the renaming of a multivariate polynomial `p` over `σ` and `R` via `f` and then via `g` equals the renaming via the composite function `g ∘ f`.


theorem Finset.image_inter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} [inst_1 : DecidableEq α] (s₁ s₂ : Finset α),
      Function.Injective f → Finset.image f (s₁ ∩ s₂) = Finset.image f s₁ ∩ Finset.image f s₂ :=
  by sorry

The theorem `Finset.image_inter` states that for any two sets `s₁` and `s₂` of an arbitrary type `α`, and a function `f` from `α` to another type `β`, provided that `f` is injective and the equality in `β` is decidable, the image of the intersection of `s₁` and `s₂` under `f` is the same as the intersection of the images of `s₁` and `s₂` under `f`. In other words, if `f` is an injective function, it preserves the intersection operation when it is applied to sets. This theorem is a formal statement of the property in set theory that the image of the intersection is the intersection of the images for an injective function.

If `f` is an injective function between sets `α` with decidable equality, then `f` preserves the intersection operation, i.e., `f(s₁ ∩ s₂) = f(s₁) ∩ f(s₂)` for any sets `s₁, s₂ ⊆ α`.


theorem ENNReal.tsum_coe_ne_top_iff_summable : ∀ {β : Type u_2} {f : β → NNReal}, ∑' (b : β), ↑(f b) ≠ ⊤ ↔ Summable f :=
  by sorry

This theorem, `ENNReal.tsum_coe_ne_top_iff_summable`, states that for all types `β` and all functions `f` from `β` to nonnegative real numbers (`NNReal`), the infinite sum of the values of `f` (the sum of the real number representations of `f(b)` for all `b` in `β`) is not equal to positive infinity if and only if `f` is summable. Here, a function `f` is said to be summable if there exists some value such that `f` has a convergent infinite sum to that value.

A function from a type to nonnegative real numbers has a finite sum if and only if it is summable.


theorem Ordinal.deriv_isNormal : ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}), Ordinal.IsNormal (Ordinal.deriv f) := by sorry

The theorem `Ordinal.deriv_isNormal` states that for every ordinal function `f`, the derivative of `f` is a normal function. In other words, the derivative of any ordinal function is a strictly increasing function that is order-continuous. In mathematical terms, if `f` is an ordinal function, then its derivative `f'` satisfies the conditions: `f'(o) < f'(o+1)` for all ordinals `o`, and for any limit ordinal `o` and any ordinal `a`, `f'(o) ≤ a` if and only if `f'(b) ≤ a` for all `b < o`.

The derivative of every ordinal function is a strictly increasing and order-continuous function.


theorem SymAlg.unsym_zero : ∀ {α : Type u_1} [inst : Zero α], SymAlg.unsym 0 = 0 := by sorry

This theorem states that for any type `α` that has a zero element (i.e., for any type `α` equipped with a zero structure), the unsym operation (which retrieves the element of `α` represented by an element in the symmetric algebra `αˢʸᵐ`) applied to the zero element of the symmetric algebra results in the zero element of `α`. In other words, unsym maps the zero of the symmetric algebra to the zero of the original type `α`.

For any type `α` with a zero element, the unsym operation in the symmetric algebra maps the zero of the symmetric algebra to the zero of `α`.


theorem Set.Iic_disjoint_Ioi : ∀ {α : Type v} [inst : Preorder α] {a b : α}, a ≤ b → Disjoint (Set.Iic a) (Set.Ioi b) :=
  by sorry

This theorem states that for any type `α` that has a preorder, and for any two elements `a` and `b` of this type, if `a` is less than or equal to `b`, then the left-infinite right-closed interval ending at `a` (denoted as `Set.Iic a`) is disjoint with the left-open right-infinite interval starting after `b` (denoted as `Set.Ioi b`). In the context of this theorem, two sets are considered disjoint if their greatest lower bound (infimum) is the least element possible in the structure (`⊥`).

For any preordered type `α`, elements `a` and `b` in `α` with `a ≤ b` imply `Set.Iic a` and `Set.Ioi b` are disjoint, that is, their infimum is the bottom element `⊥`.


theorem Submodule.map_sup :
    ∀ {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₂} (p p' : Submodule R M) {F : Type u_9} [inst_6 : FunLike F M M₂]
      [inst_7 : SemilinearMapClass F σ₁₂ M M₂] [inst_8 : RingHomSurjective σ₁₂] (f : F),
      Submodule.map f (p ⊔ p') = Submodule.map f p ⊔ Submodule.map f p' :=
  by sorry

The theorem `Submodule.map_sup` asserts that for any two submodules `p` and `p'` of a module `M` over a semiring `R`, and a function `f` of type `F`, which is a semilinear map from `M` to a module `M₂` over another semiring `R₂` (via a ring homomorphism `σ₁₂` from `R` to `R₂`), the image under `f` of the sup (join) of `p` and `p'` is equal to the sup of the images of `p` and `p'` under `f`. This statement holds under the condition that the ring homomorphism `σ₁₂` is surjective and the function `f` respects the module structure. It roughly corresponds to the distributive property in a lattice structure.

For any surjective ring homomorphism σ₁₂ from a semiring R to another semiring R₂, and any semilinear map f : M → M₂ between modules M and M₂ over R and R₂ respectively, the image of the sup of two submodules p and p' of M under f is equal to the sup of the images of p and p' under f.


List.IsPrefix.isInfix

theorem List.IsPrefix.isInfix : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁ <:+: l₂ := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a prefix of `l₂` (`l₁ <+: l₂`), then `l₁` is also an infix of `l₂` (`l₁ <:+: l₂`). In other words, if all elements of `l₁` appear at the beginning of `l₂` in the same order, then `l₁` must be a sublist of `l₂`, possibly appearing somewhere in the middle as well.

If `l₁` is a prefix of `list l₂` of type `α`, then `l₁` is a sublist (infix) of `l₂`.


Primrec.beq

theorem Primrec.beq : ∀ {α : Type u_1} [inst : Primcodable α] [inst_1 : DecidableEq α], Primrec₂ BEq.beq := by sorry

The theorem `Primrec.beq` asserts that for any type `α` that is both Primcodable and has Decidable Equality, the boolean equality function `BEq.beq` is a binary primitive recursive function. In other words, given two elements of type `α`, it is possible to decide their equality in a primitive recursive manner using boolean logic. This means that `BEq.beq` can be computed by a primitive recursive function, which is a fundamental concept in computability theory.

For any Primcodable and equalitable type `α`, the boolean equality function `BEq.beq` on `α` is primitive recursive.


theorem Filter.Eventually.self_of_nhdsWithin :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {p : α → Prop} {s : Set α} {x : α},
      (∀ᶠ (y : α) in nhdsWithin x s, p y) → x ∈ s → p x :=
  by sorry

This theorem states that for any type `α` with a topological space structure, and for any property `p` on `α`, a set `s` of `α`, and an element `x` of `α`, if it is true that every point `y` in the neighborhood within `s` around `x` eventually satisfies the property `p`, and if `x` is in the set `s`, then `x` itself also satisfies the property `p`. In other words, under these conditions, the property `p` is satisfied not only in the neighborhood of `x` within `s` but also at `x` itself.

If `α` is a topological space, `p` is a property on `α`, `s` is a set of `α` containing `x`, and for all `y` in `s` near `x`, `p(y)` holds, then `p(x)` holds.


theorem Nat.choose_eq_factorial_div_factorial :
    ∀ {n k : ℕ}, k ≤ n → Nat.choose n k = Nat.factorial n / (Nat.factorial k * Nat.factorial (n - k)) := by sorry

This theorem states that for any two natural numbers `n` and `k`, where `k` is less than or equal to `n`, the binomial coefficient `n choose k` is equal to the division of the factorial of `n` by the product of the factorial of `k` and the factorial of `n - k`. This result is often used in combinatorics and probability theory. It is mathematically expressed as $\binom{n}{k} = \frac{n!}{k!(n-k)!}$.

The binomial coefficient `n choose k` is equal to the ratio of `n!` to the product of `k!` and `(n-k)!`.


theorem Mathlib.Geometry.Manifold.ChartedSpace._auxLemma.5 :
    ∀ (H : Type u_5) {M : Type u_6} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] (x : M), (x ∈ (chartAt H x).source) = True :=
  by sorry

This theorem states that for any types `H` and `M`, where `H` is a topological space and `M` is a charted space over `H`, and for any point `x` in `M`, it is always true that `x` is contained in the source of the preferred chart at `x`. In other words, in the context of differential geometry, every point in a manifold is always contained in the domain of its associated chart.

For every point `x` in a charted space `M` over a topological space `H`, `x` lies in the domain of its preferred chart at `x`.


theorem Mathlib.Geometry.Manifold.ChartedSpace._auxLemma.1 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i := by sorry

This theorem states that for any type `α`, an indexing type `ι`, an element `x` of type `α`, and a function `s` that maps each index to a set of elements of type `α`, the membership of `x` in the intersection of all sets indexed by `ι` (denoted as `⋂ i, s i`) is equivalent to `x` being a member of each set `s i` for all `i` in `ι`. In mathematical terms, an element `x` belongs to the intersection of a collection of sets `(s i)` if and only if `x` belongs to each set `s i` for all `i`.

For any type `α`, indexing type `ι`, element `x` of type `α`, and function `s : ι → set α`, `x` lies in the intersection of `(s i)` for all `i` in `ι` if and only if `x` is an element of each `s i`.


theorem Equiv.subtypeEquivProp.proof_1 :
    ∀ {α : Sort u_1} {p q : α → Prop}, p = q → ∀ (x : α), p x ↔ q ((Equiv.refl α) x) := by sorry

This theorem states that for any type `α` and for any two properties `p` and `q` of `α`, if `p` is equal to `q`, then for any element `x` of `α`, `x` satisfies `p` if and only if `x` satisfies `q` under the identity equivalence (`Equiv.refl α`). Essentially, it shows that if two properties are the same, then their satisfaction by a particular element remains unchanged even when considered under the identity mapping.

For any type `α` and properties `p` and `q` of `α`, if `p` equals `q`, then `x` has property `p` if and only if `x` has property `q` for all `x` in `α` (under the identity equivalence).


theorem AbstractCompletion.uniformContinuous_extend :
    ∀ {α : Type u_1} [inst : UniformSpace α] (pkg : AbstractCompletion α) {β : Type u_2} [inst_1 : UniformSpace β]
      {f : α → β} [inst_2 : CompleteSpace β], UniformContinuous (AbstractCompletion.extend pkg f) :=
  by sorry

The theorem `AbstractCompletion.uniformContinuous_extend` asserts that for any types `α` and `β` equipped with a uniform space structure, any abstract completion `pkg` of `α`, and any function `f : α → β`, if `β` is a complete space, then the extension of the function `f` to the completion `pkg.space` is uniformly continuous. That is, regardless of where two points in `pkg.space` are located, if they are sufficiently close to each other, then their images under the extension of `f` are also close to each other.

Given types `α` and `β` with uniform structures, an abstract completion `pkg` of `α`, and a function `f : α → β` with complete domain `β`, the extension of `f` to `pkg.space` is uniformly continuous.


theorem Mathlib.Algebra.ModEq._auxLemma.2 : ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (a = -b) = (-a = b) :=
  by sorry

This theorem, `Mathlib.Algebra.ModEq._auxLemma.2`, states that for any type `G` that has an involutive negation operation (i.e., negating twice gives the original element), and any two elements `a` and `b` of this type, `a` being equal to the negation of `b` is the same as the negation of `a` being equal to `b`. In other words, it specifies a symmetry property of the negation operation in such algebraic structures.

For any type `G` with an involutive negation operation, the equality of `a` and the negation of `b` is equivalent to the equality of the negation of `a` and `b`.


theorem nhds_nil : ∀ {α : Type u_1} [inst : TopologicalSpace α], nhds [] = pure [] := by sorry

The theorem `nhds_nil` states that for any type `α` equipped with a topology, the neighborhood filter of an empty list is equal to a filter that only contains the empty list itself. In other words, in any topological space, the only neighborhood of the empty list is the empty list itself.

In any topological space, the neighborhood filter of the empty list is equal to the filter containing only the empty list.


theorem Submonoid.LocalizationMap.mk'_eq_iff_eq :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) {x₁ x₂ : M} {y₁ y₂ : ↥S},
      Submonoid.LocalizationMap.mk' f x₁ y₁ = Submonoid.LocalizationMap.mk' f x₂ y₂ ↔
        (Submonoid.LocalizationMap.toMap f) (↑y₂ * x₁) = (Submonoid.LocalizationMap.toMap f) (↑y₁ * x₂) :=
  by sorry

The theorem `Submonoid.LocalizationMap.mk'_eq_iff_eq` states that for any given localization map `f` of a commutative monoid `M` into a commutative monoid `N` with respect to a submonoid `S` of `M`, and any elements `x₁, x₂` of `M` and `y₁, y₂` of `S`, the equality of the images of `(x₁, y₁)` and `(x₂, y₂)` under the map `Submonoid.LocalizationMap.mk' f` is equivalent to the equality of the images of `y₂ * x₁` and `y₁ * x₂` under the map `Submonoid.LocalizationMap.toMap f`. This captures a key property of the localization construction in algebra, providing a criterion for equality in the localized monoid `N`.

For any commutative monoid homomorphism `f` from `M` to `N` with respect to a submonoid `S` of `M`, the images of `(y₁ * x₁)` and `(y₂ * x₂)` under `Submonoid.LocalizationMap.toMap f` are equal if and only if the images of `(x₁, y₁)` and `(x₂, y₂)` under `Submonoid.LocalizationMap.mk' f` are equal.


theorem PosNum.pred'_to_nat : ∀ (n : PosNum), ↑(PosNum.pred' n) = Nat.pred ↑n := by sorry

This theorem, `PosNum.pred'_to_nat`, establishes a relationship between the predecessor function on positive numbers (`PosNum.pred'`) and the predecessor function on natural numbers (`Nat.pred`). It states that for any positive number `n`, the natural number corresponding to the predecessor of `n` (denoted as `↑(PosNum.pred' n)`) is equal to the predecessor of the natural number corresponding to `n` (denoted as `Nat.pred ↑n`). In other words, applying `PosNum.pred'` to a positive number and then converting to a natural number gives the same result as first converting the positive number to a natural number and then applying `Nat.pred`.

For any positive number `n`, `Nat.pred (↑n)` equals `↑(PosNum.pred' n)`.


theorem Nat.lt_le_asymm : ∀ {a b : ℕ}, a < b → ¬b ≤ a := by sorry

This theorem states that for all natural numbers `a` and `b`, if `a` is less than `b`, then it is not true that `b` is less than or equal to `a`. In other words, if a natural number `a` is strictly less than another natural number `b`, then `b` cannot be less than or equal to `a`, which enforces the asymmetry of the less than relationship among natural numbers.

For all natural numbers `a` and `b`, if `a` < `b`, then it is false that `b` <= `a`.


theorem Bool.or_false : ∀ (b : Bool), (b || false) = b := by sorry

This theorem states that for all boolean values `b`, the boolean OR operation (`||`) of `b` and `false` is equal to `b`. In other words, it asserts that the identity element for the boolean OR operation is `false`, since combining any boolean value with `false` using boolean OR yields the original boolean value.

For all boolean values `b`, `b || false = b`.


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

This theorem states that for any right-angled triangle in a real inner product space, if the inner product of two of its vectors, `x` and `y`, is zero (which indicates they are orthogonal), then the tangent of the angle between vector `x` and the sum of vectors `x` and `y` is equal to the ratio of the norm (length) of vector `y` to the norm of vector `x`. This can be interpreted as the trigonometric relation in a right-angled triangle where the tangent of an angle is the ratio of the length of the side opposite the angle to the length of the side adjacent to the angle.

For any right-angled triangle in a real inner product space, the tangent of the angle between two orthogonal vectors `x` and `y` is equal to the norm of `y` divided by the norm of `x`.


theorem PNat.mul_coe : ∀ (m n : ℕ+), ↑(m * n) = ↑m * ↑n := by sorry

This theorem states that for any two positive natural numbers `m` and `n`, the positive natural number obtained by multiplying `m` and `n` (denoted by `m * n`) is the same as the integer obtained by first converting `m` and `n` to integers (denoted by `↑m` and `↑n`) and then multiplying them. Essentially, multiplying the positive natural numbers first and then converting to an integer gives the same result as converting to integers first and then multiplying.

For any natural numbers m and n, (m * n) = (↑m * ↑n).


theorem Set.biUnion_range :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → α} {g : α → Set β}, ⋃ x ∈ Set.range f, g x = ⋃ y, g (f y) :=
  by sorry

This theorem states that for all types `α`, `β`, and `ι`, and for all functions `f : ι → α` and `g : α → Set β`, the union over all elements `x` in the range of `f` of the set `g(x)` is equal to the union over all `y` of the set `g(f(y))`. In other words, it says that the union of the image of the function `g` applied to the range of the function `f` is the same as the union of the image of the function `g` applied to the image of the function `f`. This theorem captures an important property of function composition and union operations in the world of set theory.

For all functions `f : ι → α` and `g : α → Set β`, the union of `{g(x) | x ∈ range f}` equals the union of `{g(f(y)) | y ∈ ι}`.


theorem Nat.mul_mod : ∀ (a b n : ℕ), a * b % n = a % n * (b % n) % n := by sorry

This theorem is stating a property of multiplication and modulus in the context of natural numbers. Specifically, for any three natural numbers `a`, `b`, and `n`, the result of multiplying `a` and `b`, and then taking the modulus of the result with respect to `n`, is equivalent to first taking the modulus of `a` and `b` with respect to `n`, multiplying these results, and then taking the modulus of this result with respect to `n` once again. This can be mathematically represented as `(a * b) mod n = ((a mod n) * (b mod n)) mod n`.

For any natural numbers `a`, `b`, and `n`, `(a * b) mod n` equals `((a mod n) * (b mod n)) mod n`.


/-- If an element `a` divides another element `c` in a ring, `a` divides the sum of another element
`b` with `c` iff `a` divides `b`.  -/
theorem dvd_add_left : ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ c → (a ∣ b + c ↔ a ∣ b) := by sorry

The theorem `dvd_add_left` states that for any type `α` that forms a non-unital ring, for any elements `a`, `b`, and `c` of `α`, if `a` divides `c`, then `a` divides the sum of `b` and `c` if and only if `a` divides `b`. In other words, in a non-unital ring, if one element is a divisor of a second element, then it also divides the sum of the second element and a third element if and only if it divides the third element.

In a non-unital ring, if `a` divides `c`, then `a` divides `b` if and only if `a` divides `b + c`.


MeasureTheory.StronglyMeasurable.neg

theorem MeasureTheory.StronglyMeasurable.neg :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Neg β]
      [inst_2 : ContinuousNeg β], MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable (-f) :=
  by sorry

This theorem states that for any types `α` and `β`, if `β` is a topological space with a negation operation that is continuous, and `f` is a function from `α` to `β`, then if `f` is strongly measurable (i.e., it is the limit of simple functions), the function `-f` (obtained by negating the output of `f` for each input) is also strongly measurable. In other words, the strong measurability property is preserved under the operation of negation for functions on topological spaces with a continuous negation operation.

If `f` is a strongly measurable function from a topological space `α` to a topological space `β` with a continuous negation operation, then the negation of `f` is also strongly measurable.


theorem Multiset.le_union_right : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), t ≤ s ∪ t := by sorry

The theorem `Multiset.le_union_right` states that for any type `α` that has decidable equality and for any two multisets `s` and `t` of type `α`, `t` is less than or equal to the union of `s` and `t`. Here, "less than or equal to" is defined in terms of the subset relation: a multiset `a` is less than or equal to a multiset `b` if `a` is a subset of `b`. This theorem essentially formalizes the intuitive idea that any set (or multiset, in this case) is always a subset of its union with any other set.

For any type `α` with decidable equality and multisets `s` and `t` of type `α`, `t` is a subset of `s ∪ t`.


/-- A more workable definition for `enumOrd`.  -/
theorem Ordinal.enumOrd_def :
    ∀ {S : Set Ordinal.{u}} (o : Ordinal.{u}),
      Ordinal.enumOrd S o = sInf (S ∩ {b | ∀ c < o, Ordinal.enumOrd S c < b}) :=
  by sorry

The theorem `Ordinal.enumOrd_def` provides a more practical definition for the function `Ordinal.enumOrd`. For any set `S` of ordinals and any ordinal `o`, it states that the enumerator function `Ordinal.enumOrd` applied to `S` and `o` is equal to the infimum (or greatest lower bound) of the intersection of `S` and the set of all ordinals `b` such that for all ordinals `c` less than `o`, `Ordinal.enumOrd S c` is less than `b`. This means `Ordinal.enumOrd` picks out the lowest ordinal in `S` that's greater than all the previously enumerated ordinals.

The theorem `Ordinal.enumOrd_def` asserts that for any set `S` of ordinals and any ordinal `o`, `Ordinal.enumOrd S o` is the greatest ordinal `b` in `S` that is greater than every `Ordinal.enumOrd S c` for `c < o`.


theorem List.IsRotated.mem_iff : ∀ {α : Type u} {l l' : List α}, l ~r l' → ∀ {a : α}, a ∈ l ↔ a ∈ l' := by sorry

The theorem `List.IsRotated.mem_iff` states that for any type `α`, and any lists `l` and `l'` of that type, if `l` is a rotation of `l'`, then an element `a` of type `α` is a member of `l` if and only if `a` is a member of `l'`. In other words, a list and its rotation contain exactly the same elements.

For any type `α` and lists `l` and `l'` of type `List α`, `l` is a rotation of `l'` if and only if they have the same elements.


theorem Mathlib.Data.Real.Basic._auxLemma.8 : ∀ {f g : CauSeq ℚ abs}, (Real.mk f ≤ Real.mk g) = (f ≤ g) := by sorry

The theorem `Mathlib.Data.Real.Basic._auxLemma.8` states that for any two Cauchy sequences of rational numbers `f` and `g`, the real number created from the Cauchy sequence `f` is less than or equal to the real number created from the Cauchy sequence `g` if and only if the Cauchy sequence `f` is less than or equal to the Cauchy sequence `g`. In other words, the process of creating a real number from a Cauchy sequence of rational numbers preserves the order of the sequences.

The real number obtained from a Cauchy sequence of rational numbers is less than or equal to the real number obtained from another Cauchy sequence if and only if the former sequence is less than or equal to the latter in terms of their convergence.


theorem inf_sdiff_self_right : ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], x ⊓ y \ x = ⊥ := by sorry

This theorem states that for any generalized boolean algebra (a mathematical structure that can behave like a set of subsets of a base set), the infimum (or greatest lower bound) of y and the symmetric difference of x and y is the bottom element of the algebra. In other words, the intersection of any element `y` with the set difference between `y` and `x` (i.e., elements in `y` but not in `x`) always results in the bottom element, which represents an empty set in this context. Thus, the theorem captures the intuitive notion that the intersection of a set with its complement relative to another set is always empty.

For any generalized boolean algebra, the infimum of an element and the symmetric difference between that element and another element is the bottom element.


theorem IsUnit.mul_iff : ∀ {M : Type u_1} [inst : CommMonoid M] {x y : M}, IsUnit (x * y) ↔ IsUnit x ∧ IsUnit y := by
  sorry

This theorem, `IsUnit.mul_iff`, states that for any commutative monoid `M` and any elements `x` and `y` of `M`, the statement that the product of `x` and `y` is a unit is equivalent to the conjunction of the statements that `x` is a unit and `y` is a unit. In simpler terms, it says that in a commutative monoid, a product is a unit if and only if both factors are units.

In a commutative monoid, the product of two elements is a unit if and only if both elements are units.


theorem Nat.size_bit : ∀ {b : Bool} {n : ℕ}, Nat.bit b n ≠ 0 → Nat.size (Nat.bit b n) = Nat.succ (Nat.size n) := by
  sorry

The theorem `Nat.size_bit` states that for any boolean `b` and natural number `n`, if the binary representation of `n` appended with the digit `b` (as performed by the function `Nat.bit b n`) is not zero, then the size (in bits) of this new number is exactly one more than the size of `n`. Here, the size of a number is defined as the length of its binary representation. This essentially means that appending a bit to the binary representation of a number increases its size by one, given that the resulting number is not zero.

If the binary representation of a natural number `n` is appended with a bit `b`, resulting in a non-zero number, then the number of bits in the binary representation of the new number is one more than the number of bits in the binary representation of `n`.


theorem Mathlib.Data.PFun._auxLemma.6 :
    ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s : Set β) (x : α), (x ∈ PFun.preimage f s) = ∃ y ∈ s, y ∈ f x := by
  sorry

The theorem `Mathlib.Data.PFun._auxLemma.6` states that for all types `α` and `β`, a partial function `f` from `α` to `β`, a set `s` of `β`, and an element `x` of `α`, the fact that `x` belongs to the preimage of `s` under `f` (i.e., `x ∈ PFun.preimage f s`) is equivalent to the existence of an element `y` in `s` such that `y` belongs to the function `f` at `x` (i.e., `∃ y ∈ s, y ∈ f x`). In simple terms, an element is in the preimage of a set under a partial function if and only if there exists an element in the original set that is mapped to by the function from the given element.

For all types `α` and `β`, a partial function `f` from `α` to `β`, and an element `x` in `α` and a set `s` in `β`, `x` is in the preimage of `s` under `f` if and only if there exists `y` in `s` such that `f x = y`.


theorem Multiset.toFinset_eq :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α} (n : Multiset.Nodup s),
      { val := s, nodup := n } = Multiset.toFinset s :=
  by sorry

This theorem states that for any type `α` which has a decidable equality and for any multiset `s` of type `α` which contains no duplicate elements, the finset created by the `{ val := s, nodup := n }` expression is equivalent to the finset obtained by applying the `Multiset.toFinset` function to `s`. Here, `n` is the stated property that `s` contains no duplicates. Hence, if a multiset has no duplicates, explicitly creating a finset from it or using `Multiset.toFinset` function yields the same result.

For any decidably equated type `α` and multiset `s` of `α` without duplicates, the finset constructed from `s` using the `{ val := s, nodup := true }` expression is equal to the finset obtained by applying `Multiset.toFinset` to `s`.


HasFDerivWithinAt.continuousWithinAt

theorem HasFDerivWithinAt.continuousWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s : Set E}, HasFDerivWithinAt f f' s x → ContinuousWithinAt f s x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜` and normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, if a function `f` from `E` to `F` has a Frechet derivative `f'` within a subset `s` of `E` at a point `x` in `E` (denoted by `HasFDerivWithinAt f f' s x`), then `f` is continuous at `x` within `s`. This means that as points in `s` get arbitrarily close to `x`, the function values `f` of these points get arbitrarily close to `f(x)`.

If a function `f` between two normed spaces `E` and `F` over a non-trivially normed field `𝕜` has a Frechet derivative `f'` within a subset `s` of `E` at a point `x` in `E`, then `f` is continuous at `x` within `s`. In other words, for all `ε > 0`, there exists `δ > 0` such that for all `y` in `s` with `‖y - x‖ < δ`, we have `‖f(y) - f(x) - f'(x)(y - x)‖ < ε`.


theorem exists_prop : ∀ {b a : Prop}, (∃ (_ : a), b) ↔ a ∧ b := by sorry

This theorem, `exists_prop`, states that for all propositions `a` and `b`, the existence of an instance of `b` given `a` is equivalent to the conjunction of `a` and `b`. In other words, it asserts that there exists a `b` such that `a` is true if and only if both `a` and `b` are true. This theorem is essentially a formalization of the logical rule of simplification in propositional logic.

The theorem asserts that for all propositions `a` and `b`, `exists.prop a (exists.prop b) ↔ a ∧ b`.


theorem map_rat_smul :
    ∀ {M : Type u_5} {M₂ : Type u_6} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] [_instM : Module ℚ M]
      [_instM₂ : Module ℚ M₂] {F : Type u_9} [inst_2 : FunLike F M M₂] [inst_3 : AddMonoidHomClass F M M₂] (f : F)
      (c : ℚ) (x : M), f (c • x) = c • f x :=
  by sorry

The theorem `map_rat_smul` states that for any rational number `c`, any element `x` of a module `M` over the rational numbers, and any function `f` that is an additively commutative group homomorphism from `M` to another module `M₂` over the rational numbers, the result of applying `f` to the result of scaling `x` by `c` (`f (c • x)`) is the same as the result of scaling the result of applying `f` to `x` by `c` (`c • f x`). This property holds for all types `M`, `M₂`, and `F` where `M` and `M₂` are additively commutative groups and `F` is a function type such that functions of type `F` can be treated as functions from `M` to `M₂`, and `F` forms an additively commutative group homomorphism class from `M` to `M₂`.

For any additively commutative group homomorphism `f` and rational number `c`, the application of `f` to the scalar multiplication `c • x` of an element `x` in an additively commutative group `M` is equal to the scalar multiplication `c • f x` of the image `f x` in another additively commutative group `M₂`.


theorem Sum.Lex.inl_le_inr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (a : α) (b : β),
      toLex (Sum.inl a) ≤ toLex (Sum.inr b) :=
  by sorry

The theorem `Sum.Lex.inl_le_inr` states that for any two types `α` and `β` that have a less than or equal to (`LE`) relation defined on them, for any element `a` of type `α` and any element `b` of type `β`, the Lex (lexicographic order) of the sum type element formed by injecting `a` into the left (`Sum.inl a`) is always less than or equal to the Lex of the sum type element formed by injecting `b` into the right (`Sum.inr b`). This essentially captures the idea that in a lexicographic ordering, elements from the left component of a sum type are considered 'smaller' than elements from the right component.

For any types `α` and `β` with a defined LE relation, and for all `a : α` and `b : β`, `Sum.inl a ≤ Sum.inr b` holds in the lexicographic order on the sum type `α + β`.


theorem AlgHom.map_smul :
    ∀ {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) (r : R) (x : A), φ (r • x) = r • φ x :=
  by sorry

This theorem states that for any commutative semiring `R`, semirings `A` and `B`, along with the algebra structures of `R` over `A` and `B`, a given algebra homomorphism `φ` from `A` to `B` preserves the action of scalars. Specifically, for any element `r` from `R` and `x` from `A`, applying the homomorphism `φ` to the scalar multiplication of `r` and `x` (`r • x`) is the same as first applying the homomorphism `φ` to `x` and then scaling by `r` (`r • φ x`). In other words, the algebra homomorphism `φ` commutes with the scalar multiplication operation.

Given commutative semirings `R`, semirings `A` and `B`, algebra structures over `R` on `A` and `B`, and an algebra homomorphism `φ` from `A` to `B`, the scalar multiplication of `r` in `R` with `x` in `A` equals the scalar multiplication of `r` with `φ(x)` in `B`, for all `r` in `R` and `x` in `A`.


theorem CategoryTheory.Functor.const_obj_map :
    ∀ (J : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} C] (X : C) {X_1 Y : J} (x : X_1 ⟶ Y),
      ((CategoryTheory.Functor.const J).obj X).map x = CategoryTheory.CategoryStruct.id X :=
  by sorry

The theorem `CategoryTheory.Functor.const_obj_map` states that for any type `J` with a category structure, any type `C` with a category structure, and any object `X` of type `C`, for any two objects `X_1` and `Y` of type `J` and a morphism `x` from `X_1` to `Y`, the map induced by the constant functor at `X` applied to the morphism `x` is equal to the identity morphism on `X`. In other words, the constant functor sends every morphism in the domain category to the identity morphism in the codomain category.

For any category structures on types J and C, and any object X of C, the constant functor from J to C maps every morphism from an object X1 to an object Y in J to the identity morphism on X in C.


theorem isometry_add_right :
    ∀ {M : Type u} [inst : Add M] [inst_1 : PseudoEMetricSpace M] [inst_2 : IsometricVAdd Mᵃᵒᵖ M] (a : M),
      Isometry fun x => x + a :=
  by sorry

This theorem states that for any type `M` that has an addition operation, is a pseudoemetric space, and satisfies the property of being an isometric vector addition space on the opposite side (`Mᵃᵒᵖ`), for any element `a` of `M`, the transformation that adds `a` to every element in the space is an isometry. In other words, adding a fixed value to every point in the space preserves the pseudoemetric (the "distance" between two points in the space), i.e., the distance between any two points remains unchanged when the same value is added to both of them.

For any isometric vector addition space `M` with pseudometric `d` and element `a`, the translation function `x ↦ x + a` is an isometry with respect to `d`.


theorem AddSubgroup.relindex_bot_left :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), AddSubgroup.relindex ⊥ H = Nat.card ↥H := by sorry

This theorem states that for any given additive group `G` and any subgroup `H` of `G`, the relative index of the trivial subgroup (denoted as `⊥`) with respect to `H` is equal to the cardinality (or the number of elements) of `H`. In other words, the number of distinct cosets formed by partitioning `H` with the trivial subgroup is the same as the number of elements in `H`, when we consider the cardinality of an infinite set as zero.

The relative index of the trivial subgroup in an additive group `G` with respect to a subgroup `H` equals the cardinality of `H`.


LaurentPolynomial.ext

theorem LaurentPolynomial.ext :
    ∀ {R : Type u_1} [inst : Semiring R] {p q : LaurentPolynomial R}, (∀ (a : ℤ), p a = q a) → p = q := by sorry

The theorem named `LaurentPolynomial.ext` states that, for every type `R` that is equipped with a semiring structure, any two Laurent polynomials `p` and `q` over `R` are equal if and only if their coefficients are equal at every integer `a`. In other words, two Laurent polynomials are identical when their corresponding coefficients for all integer powers of the indeterminate are identical.

Two Laurent polynomials over a semiring are equal if and only if their coefficients at every integer power of the indeterminate are equal.


theorem inf_right_idem : ∀ {α : Type u} [inst : SemilatticeInf α] (a b : α), a ⊓ b ⊓ b = a ⊓ b := by sorry

This theorem, named `inf_right_idem`, asserts that for all types `α` that is a semilattice under an infimum operation (`SemilatticeInf α`), the infimum of any `a` and `b` (`a` and `b` being elements of the type `α`) with `b` infimum `b` is the same as the infimum of `a` and `b`. In other words, it states that taking the infimum operation on `b` with itself doesn't change the result when taking the infimum with `a`. This can be written in mathematical terms as: for all `a` and `b` in a semilattice, `a ⊓ b ⊓ b = a ⊓ b`.

For all semilattices `α` and elements `a, b` in `α`, `a ⊓ b ⊓ b equals a ⊓ b`. In other words, the infimum of an element with itself is equal to the infimum of that element with another element.