/-- If `R` is "smaller" ring than `S` then the span by `R` is smaller than the span by `S`.  -/
theorem Submodule.span_le_restrictScalars :
    ∀ (R : Type u_1) {M : Type u_4} (S : Type u_7) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (s : Set M) [inst_3 : Semiring S] [inst_4 : SMul R S] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M],
      Submodule.span R s ≤ Submodule.restrictScalars R (Submodule.span S s) :=
  by sorry

The theorem `Submodule.span_le_restrictScalars` states that for any set `s` of elements in a module `M` over a semiring `R`, and for a larger semiring `S` that acts on the same module `M`, the submodule spanned by `s` with coefficients in `R` is a subset of the submodule spanned by `s` with coefficients in `S`, restricted to `R`. This implies that if `R` is a "smaller" ring than `S` then the span by `R` is smaller than the span by `S`. The theorem relies on the condition that `R` is a scalar tower over `S` and `M`, which means that scalar multiplication in `M` by elements of `R` can be computed via scalar multiplication in `S`.

For any set `s` of elements in a module `M` over a semiring `R`, the submodule of `M` spanned by `s` with coefficients in `R` is contained in the submodule spanned by `s` with coefficients in a larger semiring `S`, when `R` is a scalar tower over `S` and `M`.


/-- The value of the quadratic character at `-1`  -/
theorem quadraticChar_neg_one :
    ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F],
      ringChar F ≠ 2 → (quadraticChar F) (-1) = ZMod.χ₄ ↑(Fintype.card F) :=
  by sorry

This theorem states that for a given field `F` that has a decidable equality and is a finite type, if the unique characteristic of the semiring `F` is not 2, then the value of the quadratic character at `-1` in `F` is equal to the value of the nontrivial quadratic character on `ZMod 4` evaluated at the number of elements in `F`. The theorem essentially provides a connection between the quadratic character of a field and its number of elements under certain conditions.

If `F` is a finite field with decidable equality and characteristic different from 2, then the quadratic character of `-1` in `F` equals the nontrivial quadratic character on `ZMod 4` evaluated at the number of elements in `F`.


SetTheory.PGame.LF.lt

/-- **Alias** of `SetTheory.PGame.lt_of_lf`. -/
theorem SetTheory.PGame.LF.lt :
    ∀ {x y : SetTheory.PGame}, SetTheory.PGame.LF x y → SetTheory.PGame.Numeric x → SetTheory.PGame.Numeric y → x < y :=
  by sorry

The theorem `SetTheory.PGame.LF.lt` establishes that for any two pre-games `x` and `y`, if the less or fuzzy relation holds for `x` and `y` (denoted as `SetTheory.PGame.LF x y`), and both `x` and `y` are numeric pre-games (that is, for all elements in the left set of `x` or `y`, there is an element in the right set that is greater, and all elements of the left and right sets are also numeric), then `x` is less than `y` (denoted as `x < y`). Here, a less or fuzzy relation implies that the second player cannot win the game when the game starts from `y`, assuming optimal play.

If `x` and `y` are numeric pre-games such that the less or fuzzy relation `SetTheory.PGame.LF x y` holds, then `x < y`.


theorem acc_lift₂_iff :
    ∀ {α : Type u_1} [inst : Setoid α] {r : α → α → Prop}
      {H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂} {a : α},
      Acc (Quotient.lift₂ r H) ⟦a⟧ ↔ Acc r a :=
  by sorry

The theorem `acc_lift₂_iff` states that for any type `α` with a setoid structure, and for any binary relation `r` on `α`, if `r` respects the equivalence relation of the setoid in the sense that whenever `a₁` is equivalent to `a₂` and `b₁` is equivalent to `b₂`, `r a₁ b₁` equals `r a₂ b₂`, then for any element `a` in `α`, `a` is accessible under the relation `r` if and only if the equivalence class of `a` under the setoid's equivalence relation is accessible under the relation lifted to the quotient by `Quotient.lift₂`. Here, a value is said to be accessible under a relation if there is no infinite descending chain starting from that value.

For any setoid type `α` and binary relation `r` respecting its equivalence relation, an element `a` is accessible under `r` if and only if its equivalence class is accessible under the relation lifted to the quotient.


theorem tsum_le_of_sum_le :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α} {a₂ : α},
      Summable f → (∀ (s : Finset ι), (Finset.sum s fun i => f i) ≤ a₂) → ∑' (i : ι), f i ≤ a₂ :=
  by sorry

The theorem `tsum_le_of_sum_le` states that for any types `ι` and `α`, given an instance of `OrderedAddCommMonoid α`, `TopologicalSpace α` and `OrderClosedTopology α`, a function `f` from `ι` to `α`, and a value `a₂` of type `α`, if `f` is summable and for all finite sets `s` of `ι`, the sum of `f i` for `i` in `s` is less than or equal to `a₂`, then the infinite sum of `f i` for `i` in `ι` is also less than or equal to `a₂`. In mathematical terms, if we have a function `f: ι → α` such that for any finite subset `s` of `ι`, the sum of `f(i)` over `i` in `s` is less than or equal to `a₂`, and the infinite sum of `f(i)` over all `i` in `ι` exists, then this infinite sum is less than or equal to `a₂`.

If `f: ι → α` is a summable function over an ordered additive commutative monoid `α` in a topological space with an order-closed topology, and the sum of `f i` for all finite sets `s` of `ι` is bounded above by a constant `a₂`, then the infinite sum of `f i` is also less than or equal to `a₂`.


theorem Ordinal.mul_lt_mul_iff_left : ∀ {a b c : Ordinal.{u_4}}, 0 < a → (a * b < a * c ↔ b < c) := by sorry

The theorem `Ordinal.mul_lt_mul_iff_left` states that for any three ordinals `a`, `b` and `c` (in the same universe), if `a` is greater than zero, then the product of `a` and `b` is less than the product of `a` and `c` if and only if `b` is less than `c`. This theorem is an analogue of a similar property in the domain of real numbers, expressing an interaction between multiplication and order in the context of ordinals.

For any ordinals `a > 0`, `b`, and `c`, `a * b < a * c` if and only if `b < c`.


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

This theorem states that for any linear ordered field `α` and any two elements `a` and `b` of `α`, if both `a` and `b` are less than zero, then the reciprocal of `a` is less than or equal to the reciprocal of `b` if and only if `b` is less than or equal to `a`. In mathematical notation, this can be written as: if $a < 0$ and $b < 0$, then $\frac{1}{a} \leq \frac{1}{b}$ if and only if $b \leq a$.

For any linear ordered field `α` and elements `a, b ∈ α` with `a, b < 0`, $\frac{1}{a} \leq \frac{1}{b}$ if and only if `b ≤ a`.


theorem OrderIso.map_sSup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : α ≃o β) (s : Set α),
      f (sSup s) = ⨆ a ∈ s, f a :=
  by sorry

This theorem, `OrderIso.map_sSup`, states that for any types `α` and `β` that are complete lattices, and any order isomorphism `f` from `α` to `β`, and any set `s` of elements of type `α`, the image under `f` of the supremum of `s` (`sSup s`) is equal to the supremum (`⨆ a ∈ s`) of the images under `f` of the elements of `s`. In simpler terms, the order isomorphism preserves the supremum of a set.

For any complete lattices `α` and `β`, and order isomorphism `f: α ≃ β`, if `s ⊆ α` has a supremum `sSup`, then `f(sSup) = ⨆ (f x | x ∈ s)`.


theorem FirstOrder.Language.HomClass.map_constants :
    ∀ {L : FirstOrder.Language} {F : Type u_3} {M : Type u_4} {N : Type u_5} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] [inst_2 : FunLike F M N]
      [inst_3 : FirstOrder.Language.HomClass L F M N] (φ : F) (c : FirstOrder.Language.Constants L), φ ↑c = ↑c :=
  by sorry

The theorem `FirstOrder.Language.HomClass.map_constants` states that for any first-order language `L`, types `F`, `M`, and `N`, and given that `L` has a structure over `M` and `N`, and `F` can be coerced to a function from `M` to `N`. Furthermore, there also exists a homomorphism class for the language `L` with respect to `F`, `M`, and `N`. The theorem then asserts that for any element `φ` of type `F` and any constant `c` of the language `L`, the result of applying `φ` to the coercion of `c` is equal to the coercion of `c` itself. In other words, it ensures that constants are preserved under the application of the function-like term `φ`.

For any first-order language L with a homomorphism class for functions from M to N, and given a function F coercible from M to N and an element φ of F, the application of φ to the constant c of L is equal to the constant c itself, i.e., φ(coercion c) = coercion c.


theorem Set.singleton_mul_singleton : ∀ {α : Type u_2} [inst : Mul α] {a b : α}, {a} * {b} = {a * b} := by sorry

This theorem states that for any two elements `a` and `b` from a multiplication-equipped type `α`, the result of the set multiplication operation on the singleton sets `{a}` and `{b}` is equal to the singleton set `{a * b}`. In other words, it says that the singleton set of the product of `a` and `b` is the same as the product of the singleton sets of `a` and `b`.

For any multiplication-equipped type `α` and elements `a, b` from `α`, the singleton sets `{a}` and `{b}` have product equal to the singleton set of their product, i.e., {a} * {b} = {a * b}.


theorem Mathlib.Algebra.RingQuot._auxLemma.1 :
    ∀ {R : Type uR} [inst : Semiring R] (r : R → R → Prop), 0 = { toQuot := Quot.mk (RingQuot.Rel r) 0 } := by sorry

This theorem, `Mathlib.Algebra.RingQuot._auxLemma.1`, states that for any type `R` equipped with a semiring structure, and any binary relation `r` on `R`, the zero element of `R` is equivalent to the quotient type created by the equivalence class of the zero element under the ring quotient relation derived from `r`. In other words, `0` is equivalent to the set of all elements related to `0` by `r` in the ring quotient.

For any semiring `R` and binary relation `r` on `R`, the zero element of `R` is equivalent to the quotient class of zeros in `R` under the ring quotient relation derived from `r`.


theorem List.sum_take_succ :
    ∀ {M : Type u_5} [inst : AddMonoid M] (L : List M) (i : ℕ) (p : i < List.length L),
      List.sum (List.take (i + 1) L) = List.sum (List.take i L) + List.get L { val := i, isLt := p } :=
  by sorry

This theorem states that for any list `L` of elements of an additive monoid `M` and any natural number `i` which is less than the length of `L`, the sum of the elements of `L` taken up to the `i+1`th position is equal to the sum of the elements of `L` taken up to the `i`th position plus the `i`th element of `L`. In mathematical terms, for a list `L = [a_0, a_1, ..., a_n]` and `i < n`, we have `sum(a_0, a_1, ..., a_i) = sum(a_0, a_1, ..., a_{i-1}) + a_i`.

For any list `L` of additive monoid elements and natural number `i` less than its length, the sum of the first `i+1` elements of `L` equals the sum of the first `i` elements and the `i`-th element of `L`.


theorem Codisjoint.mono_left :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b c : α},
      a ≤ b → Codisjoint a c → Codisjoint b c :=
  by sorry

The theorem `Codisjoint.mono_left` states that for any given type `α` that has a partial order and a top element, if we have three elements `a`, `b`, and `c` of this type such that `a` is less than or equal to `b`, and `a` and `c` are codisjoint, then `b` and `c` are also codisjoint. In other words, codisjointness between `a` and `c` implies codisjointness between `b` and `c`. This property can be referred to as the monotonicity of codisjointness on the left side.

If `α` is a type with a partial order and a top element, and `a` is less than or equal to `b`, and `a` is codisjoint from `c`, then `b` is codisjoint from `c`.


theorem Fin.castSucc_fin_succ : ∀ (n : ℕ) (j : Fin n), Fin.castSucc (Fin.succ j) = Fin.succ (Fin.castSucc j) := by sorry

The theorem `Fin.castSucc_fin_succ` states that for all natural numbers `n` and for every element `j` of the finite set `Fin n`, the operation of embedding `j` (incremented by one) into the finite set `Fin (n+1)` is equivalent to first embedding `j` into `Fin (n+1)` and then incrementing it by one. This asserts a kind of commutative property between the `Fin.castSucc` and `Fin.succ` functions.

For all natural numbers `n` and elements `j` of `Fin n`, `Fin.castSucc (Fin.succ j) = Fin.succ (Fin.castSucc j)` in `Fin (n+1)`.


/-- If `α` is equivalent to `β`, then `IsEmpty α` is equivalent to `IsEmpty β`.  -/
theorem Equiv.isEmpty_congr : ∀ {α : Sort u_1} {β : Sort u_2}, α ≃ β → (IsEmpty α ↔ IsEmpty β) := by sorry

This theorem states that if there is an equivalence between two types `α` and `β`, then `α` is empty if and only if `β` is empty. In other words, the emptiness property is preserved under equivalence between the types. This theorem is applicable to types `α` and `β` located in arbitrary sorts.

If `α` is equivalent to `β`, then `α` is empty if and only if `β` is empty.


theorem eq_tsub_of_add_eq :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α} [inst : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], a + c = b → a = b - c :=
  by sorry

This theorem states that for any type `α` which is a partially ordered set, an additive commutative semigroup, has a subtraction operation, and has an ordered subtraction property, given three elements `a`, `b`, and `c` of type `α` and satisfying the contravariant property, if `a + c` equals `b`, then `a` is equal to `b` subtract `c`. In other words, if the sum of `a` and `c` is `b`, then `a` is what you get when you subtract `c` from `b`.

If `α` is a partially ordered, additive commutative semigroup with subtraction and ordered subtraction property, then for all `a`, `b`, `c` in `α` with `a + c = b`, it follows that `a = b - c`.


/-- A substructure `S` includes `closure L s` if and only if it includes `s`.  -/
theorem FirstOrder.Language.Substructure.closure_le :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      {S : FirstOrder.Language.Substructure L M} {s : Set M},
      (FirstOrder.Language.Substructure.closure L).toFun s ≤ S ↔ s ⊆ ↑S :=
  by sorry

This theorem, `FirstOrder.Language.Substructure.closure_le`, states that for any first-order language `L`, any model `M` of `L`, any substructure `S` of `M`, and any set `s` of elements in `M`, the substructure `S` includes the substructure generated by `s` (denoted as `(FirstOrder.Language.Substructure.closure L).toFun s`) if and only if the substructure `S` includes `s` itself (denoted as `s ⊆ ↑S`). In other words, the closure of a set `s` within a first-order language structure is a subset of a given substructure if and only if the set `s` itself is a subset of that substructure.

In a first-order language, a substructure includes the closure of a set if and only if it includes the set itself.


theorem Equiv.preimage_symm_preimage :
    ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set α), ⇑e ⁻¹' (⇑e.symm ⁻¹' s) = s := by sorry

This theorem, `Equiv.preimage_symm_preimage`, states that for any types `α` and `β`, given an equivalence `e` between `α` and `β`, and a set `s` of type `α`, the preimage of the preimage of `s` under the inverse of `e` is equal to `s` itself. Here, `⇑e` and `⇑e.symm` denote the function corresponding to the equivalence `e` and its inverse respectively, and `⁻¹'` denotes the preimage of a set. In mathematical terms, this means if you take a set in `α`, map it to `β` using the inverse of the equivalence, and then map it back to `α` using the equivalence, you end up with the set you started with.

For any equivalence `e` between types `α` and `β` and any set `s` of type `α`, `s = (e.symm ^-1)' (e ^-1 s)`.


theorem CategoryTheory.IsReflexivePair.common_section :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B)
      [inst_1 : CategoryTheory.IsReflexivePair f g],
      ∃ s,
        CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
          CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B :=
  by sorry

The theorem `CategoryTheory.IsReflexivePair.common_section` states that for any Category `C` and objects `A` and `B` in `C`, given two morphisms `f` and `g` from `A` to `B` that form a reflexive pair (`CategoryTheory.IsReflexivePair f g`), there exists a common section `s` such that composing `s` with `f` or `g` yields the identity morphism on `B`. In other words, both `f` and `g` can be "undone" by `s`, leading back to the original object `B`. This theorem is part of the category theory in mathematics and serves to assert the existence of such a section `s` under the given conditions.

For any category C and objects A, B with reflexive pair morphisms f and g from A to B, there exists a common section s such that fs = g andgs = f.


theorem Real.aemeasurable_of_aemeasurable_exp :
    ∀ {α : Type u_1} {x : MeasurableSpace α} {f : α → ℝ} {μ : MeasureTheory.Measure α},
      AEMeasurable (fun x => Real.exp (f x)) μ → AEMeasurable f μ :=
  by sorry

This theorem states that for any type `α`, any measurable space `x` on `α`, any function `f` from `α` to the real numbers `ℝ`, and any measure `μ` on `α`, if the function obtained by applying the real exponential function to the output of `f` is almost everywhere measurable with respect to the measure `μ`, then the original function `f` is also almost everywhere measurable with respect to the measure `μ`. In other words, the measurability of the composed function, with respect to almost everywhere, implies the measurability of the original function.

If a function composited with the real exponential function is almost everywhere measurable, then the original function is almost everywhere measurable.


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

This theorem states that in the category `C`, given a pullback cone `t` on the morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, and assuming `t` is a limit, if for any object `W` in `C` and any pair of morphisms `k, l : W ⟶ t.pt` (the apex of the pullback cone `t`), the compositions `k ≫ fst t` and `l ≫ fst t` are equal, and the compositions `k ≫ snd t` and `l ≫ snd t` are also equal, then it must be the case that `k = l`. In other words, if two morphisms into the apex of the pullback cone agree on their compositions with both projection maps of the cone, then these two morphisms are equal. This is a form of uniqueness condition for morphisms into the limit object in a pullback situation.

Given a limit pullback cone in a category `C` with morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, if for any `W` and morphisms `k, l : W ⟶ t.pt`, `k ≫ fst t = l ≫ fst t` and `k ≫ snd t = l ≫ snd t`, then `k = l`.


theorem associated_eq_eq : ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Unique αˣ], Associated = Eq := by sorry

The theorem `associated_eq_eq` states that for any type `α` that forms a `Monoid`, and has a property that it is `Unique` (meaning there's exactly one unit element), the relation `Associated` is equivalent to the equality relation. In other words, two elements of the `Monoid` are `Associated` if and only if they are equal. This is because in such a `Monoid`, the only unit is the multiplicative identity, so an element can only be `Associated` (multiplied by a unit to get another) with itself.

In a Monoid with a unique unit, the relation of being Associated coincides with equality.


theorem Quotient.mk_out' : ∀ {α : Sort u_1} {s₁ : Setoid α} (a : α), Setoid.r (Quotient.out' (Quotient.mk'' a)) a := by
  sorry

This theorem states that for any type `α` with an associated Setoid structure `s₁`, and any element `a` of type `α`, the `Setoid.r` relation holds true between `a` and the result of applying `Quotient.out'` to the result of `Quotient.mk''` applied to `a`. Intuitively, this says that when we make a quotient of `a` (using `Quotient.mk''`) and then retrieve a representative from this quotient (using `Quotient.out'`), this representative is related to the original element `a` under the equivalence relation of the Setoid structure.

For any type `α` with a Setoid structure `s₁`, and for any `a` in `α`, `Setoid.r a (Quotient.out' (Quotient.mk'' a))` holds true.


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

The **Equality case of Rearrangement Inequality** theorem states that for a given finite set of indices `s`, scalar multiplication functions `f` and `g` which monovary together, a permutation `σ`, and under certain conditions, the sum of pointwise scalar multiplication of `f` and `g` remains unchanged due to the permutation if and only if the composition of `f` and `σ` and `g` monovary together. The conditions are that the set of indices where the permutation differs from the identity is a subset of `s`, and the scalars are from a linearly ordered ring and the vectors are from a linearly ordered additive commutative group, where scalar multiplication is ordered. In essence, the theorem says that rearranging the entries of `f` does not change the sum if and only if the rearranged `f` and `g` still monovary together.

For a finite set of indices `s`, scalar multiplication functions `f` and `g` monovarying together, a permutation `σ`, and scalars from a linearly ordered ring and vectors from a linearly ordered additive commutative group with ordered scalar multiplication, the sum of pointwise scalar multiplications of `f` and `g` is unchanged under `σ` if and only if `f ∘ σ` and `g` monovary together, provided that the indices where `σ` differs from the identity are in `s`.


theorem Multiset.of_mem_filter :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α}, a ∈ Multiset.filter p s → p a :=
  by sorry

This theorem states that for any type `α`, any decidable predicate `p` on `α`, any element `a` of type `α`, and any multiset `s` of `α`, if `a` is an element of the multiset obtained by filtering `s` with `p`, then `a` must satisfy the predicate `p`. In simpler terms, any element that remains in a multiset after applying a filter must satisfy the condition imposed by the filter.

If `α` is a type, `p` is a decidable predicate on `α`, `a` is an element of `α`, and `s` is a multiset of `α` such that `a` is an element of the multiset obtained by filtering `s` with `p`, then `p(a)` holds.


theorem EMetric.ball_subset_closedBall :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {ε : ENNReal}, EMetric.ball x ε ⊆ EMetric.closedBall x ε := by
  sorry

The theorem `EMetric.ball_subset_closedBall` states that for any type `α` that is a pseudo extended metric space, and for any point `x` of type `α` and extended nonnegative real number `ε`, the set of all points `y` such that the extended distance between `y` and `x` is less than `ε` (denoted as `EMetric.ball x ε`) is a subset of the set of all points `y` such that the extended distance between `y` and `x` is less than or equal to `ε` (denoted as `EMetric.closedBall x ε`). In other words, every point in the open ball (with radius `ε`) is also contained in the closed ball (with the same radius `ε`).

For any pseudo extended metric space (α), and points x : α and y : α, if the extended distance d(x, y) < ε, then y is in the closed ball B.closedBall x ε = {z : α | d(x, z) ≤ ε}.


theorem Int.isCoprime_iff_gcd_eq_one : ∀ {m n : ℤ}, IsCoprime m n ↔ Int.gcd m n = 1 := by sorry

This theorem states that for any two integers `m` and `n`, `m` and `n` are coprime (i.e., there exist integers `a` and `b` such that `a * m + b * n = 1`) if and only if the greatest common divisor of `m` and `n` is 1. In other words, two integers are coprime if their greatest common divisor is 1, and if two integers are coprime, their greatest common divisor must be 1.

Two integers `m` and `n` are coprime if and only if their greatest common divisor equals 1.


theorem ENorm.map_add_le :
    ∀ {𝕜 : Type u_1} {V : Type u_2} [inst : NormedField 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
      (e : ENorm 𝕜 V) (x y : V), ↑e (x + y) ≤ ↑e x + ↑e y :=
  by sorry

This theorem states that for any normed field `𝕜`, an additive commutative group `V`, and a module over `𝕜` and `V`, the extended norm `e` of the sum of two elements `x` and `y` from `V` is less than or equal to the sum of the extended norms of `x` and `y` individually. In other words, the extended norm has the property of subadditivity: `e(x + y) ≤ e(x) + e(y)`.

For any normed field `𝕜` and normed additive commutative group `V` with module `M`, the extended norm `e` on `V` is subadditive, that is, `e(x + y) ≤ e(x) + e(y)` for all `x, y ∈ V`.


theorem le_of_forall_pos_le_add :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] [inst_2 : AddMonoid α] [inst_3 : ExistsAddOfLE α]
      [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_5 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      (∀ (ε : α), 0 < ε → a ≤ b + ε) → a ≤ b :=
  by sorry

This theorem states that for any type `α` that is a linear order, densely ordered, an additive monoid, and satisfies certain covariance and contravariance properties with respect to addition and less-than relation, given any two elements `a` and `b` of type `α`, if for every positive `ε` of type `α`, `a` is less than or equal to `b` plus `ε`, then `a` is less than or equal to `b`.

If `α` is a linear order, densely ordered, additive monoid where `≤` is covariant with respect to addition and `≤` and `<` are contravariant with respect to addition, then for all `a`, `b` in `α`, if `a ≤ b + ε` for all positive `ε`, then `a ≤ b`.


theorem Multiset.dvd_prod :
    ∀ {α : Type u_1} [inst : CommMonoid α] {s : Multiset α} {a : α}, a ∈ s → a ∣ Multiset.prod s := by sorry

The theorem `Multiset.dvd_prod` states that for any type `α` which has a Commutative Monoid structure, for any multiset `s` of type `α`, and for any element `a` of type `α`, if `a` is an element of `s`, then `a` divides the product of all elements in `s`. Here, the product of a multiset is defined as the product of all elements in the multiset, similar to how mathematical product works. For example, the product of the multiset `{a, b, c}` is `a * b * c`.

For any commutative monoid type `α` and multiset `s` of `α`, if `a` is an element of `s`, then `a` divides the product of all elements in `s`.


theorem Subgroup.IsComplement.equiv_snd_eq_inv_mul :
    ∀ {G : Type u_1} [inst : Group G] {S T : Set G} (hST : Subgroup.IsComplement S T) (g : G),
      ↑((Subgroup.IsComplement.equiv hST) g).2 = (↑((Subgroup.IsComplement.equiv hST) g).1)⁻¹ * g :=
  by sorry

This theorem states that for any type `G` that forms a group, and any two sets `S` and `T` of `G` such that `S` and `T` are complements, given a specific element `g` of `G`, the second component of the tuple obtained by applying the equivalence between `G` and the cartesian product of `S` and `T` to `g` (denoted as `((Subgroup.IsComplement.equiv hST) g).2`) is equal to the product of the inverse of the first component of the same tuple (denoted as `((Subgroup.IsComplement.equiv hST) g).1)⁻¹`) and `g`. In simpler terms, if we have an element from a group which can be expressed as a pair of elements from two complementary subsets, then that element times the inverse of the first component of the pair is equal to the second component of the pair.

For any group `G` with complementary subsets `S` and `T`, and for any `g` in `G`, we have `g = (S.complement T).1.inv * (S.complement T).2 g`.


theorem Equiv.Perm.ne_and_ne_of_swap_mul_apply_ne_self :
    ∀ {α : Type u_1} [inst : DecidableEq α] {f : Equiv.Perm α} {x y : α},
      (Equiv.swap x (f x) * f) y ≠ y → f y ≠ y ∧ y ≠ x :=
  by sorry

This theorem states that for any type `α` with decidable equality, any permutation `f` of `α`, and any elements `x` and `y` of `α`, if applying the permutation formed by first swapping `x` and `f x`, and then applying `f`, to `y` does not result in `y` (i.e., `(Equiv.swap x (f x) * f) y ≠ y`), then `f y` is not equal to `y` and `y` is not equal to `x` (i.e., `f y ≠ y ∧ y ≠ x`). In other words, if the combined swap and apply operation changes `y`, then the original permutation must also change `y`, and `y` can't be `x`.

If `α` is a type with decidable equality, `f` is a permutation of `α`, `x` and `y` are elements of `α`, and `(Equiv.swap x (f x) * f) y = y` does not hold, then `f y ≠ y` and `y ≠ x`.


theorem MeasureTheory.withDensity_eq_iff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
      AEMeasurable f μ →
        AEMeasurable g μ →
          ∫⁻ (x : α), f x ∂μ ≠ ⊤ → (μ.withDensity f = μ.withDensity g ↔ f =ᶠ[MeasureTheory.Measure.ae μ] g) :=
  by sorry

This theorem states that for any measurable space `α`, and any measure `μ` over that space, if `f` and `g` are two functions from `α` to the extended nonnegative real numbers that are almost everywhere measurable with respect to `μ`, and the integral of `f` with respect to `μ` is not infinity, then the measure `μ` with density `f` is equal to the measure `μ` with density `g` if and only if `f` is almost everywhere equal to `g` with respect to the measure `μ`. In simpler terms, it says that two measures with the same almost everywhere measurable density functions are equivalent.

For any measurable space `α` and measure `μ`, two almost everywhere measurable functions `f` and `g` from `α` to the extended nonnegative real numbers with finite integral with respect to `μ`, have equivalent measures `μ` with densities `f` and `g` if and only if `f` is almost everywhere equal to `g` with respect to `μ`.


Asymptotics.IsEquivalent.mul

theorem Asymptotics.IsEquivalent.mul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {t u v w : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l t u → Asymptotics.IsEquivalent l v w → Asymptotics.IsEquivalent l (t * v) (u * w) :=
  by sorry

The theorem `Asymptotics.IsEquivalent.mul` states that for any type `α` and any normed field `β`, given any four functions `t`, `u`, `v`, and `w` from `α` to `β` and a filter `l` on `α`, if the function `t` is asymptotically equivalent to the function `u` along the filter `l` and the function `v` is asymptotically equivalent to the function `w` along the filter `l`, then the product of the functions `t` and `v` is asymptotically equivalent to the product of the functions `u` and `w` along the filter `l`. Here, asymptotic equivalence of two functions `f` and `g` along a filter `l` means that `f(x) - g(x) = o(g(x))` as `x` converges along `l`.

If functions `t`, `u`, `v`, `w` from type `α` to normed field `β` are asymptotically equivalent along filter `l` with `t ~ o u` and `v ~ o w`, then their product `tv` is asymptotically equivalent to the product `uw` along filter `l`, i.e., `tv ~ o uw`.


theorem Finset.inf_image₂_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α)
      (t : Finset β) [inst_1 : SemilatticeInf δ] [inst_2 : OrderTop δ] (g : γ → δ),
      Finset.inf (Finset.image₂ f s t) g = Finset.inf t fun y => Finset.inf s fun x => g (f x y) :=
  by sorry

The theorem `Finset.inf_image₂_right` states that for any finite sets `s` of type `α` and `t` of type `β`, a function `f` mapping elements from `α` and `β` to `γ`, and a function `g` mapping elements from `γ` to a structure `δ` with an infimum and a top element, the infimum of the image of `g` applied to the set obtained by `f` acting on the Cartesian product of `s` and `t` is equal to the infimum over `t` of the infimum over `s` of `g` applied to `f` acting on each pair of elements in `s` and `t`. In mathematical terms, the theorem states that $\inf_{(x,y) \in s \times t} g(f(x, y)) = \inf_{y \in t} \inf_{x \in s} g(f(x, y))$.

The infimum of the image of a function `g` over the Cartesian product of sets `s` and `t`, applied to the pairwise applications of a function `f` from `s` to `β` and `t` to `α`, equals the infimum over `t` of the infima over `s` of `g` applied to `f(x, y)` for each `x` in `s` and `y` in `t`.


theorem AffineMap.lineMap_vsub_left :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddTorsor V1 P1] (p₀ p₁ : P1) (c : k), (AffineMap.lineMap p₀ p₁) c -ᵥ p₀ = c • (p₁ -ᵥ p₀) :=
  by sorry

This theorem states that for any three points `p₀`, `p₁`, and `c` in an affine space `P1` over a ring `k`, with `P1` being a module over `k` and an additive torsor for an additive commutative group `V1`, the difference vector from `p₀` to the point on the line from `p₀` to `p₁` determined by `c` (`(AffineMap.lineMap p₀ p₁) c -ᵥ p₀`) is equal to the scalar multiple `c` times the difference vector from `p₀` to `p₁` (`c • (p₁ -ᵥ p₀)`). In other words, it describes the property of affine maps that linearly interpolate between points in an affine space.

For any points `p₀`, `p₁` in an affine space `P1` over a ring `k`, and any scalar `c`, the vector `(AffineMap.lineMap p₀ p₁) c -ᵥ p₀` equals `c • (p₁ -ᵥ p₀)`.


theorem ite_le_sup :
    ∀ {α : Type u} [inst : SemilatticeSup α] (s s' : α) (P : Prop) [inst_1 : Decidable P],
      (if P then s else s') ≤ s ⊔ s' :=
  by sorry

This theorem, `ite_le_sup`, states that for any type `α` that forms a semilattice under a sup operation (denoted by `⊔`), for any propositions `s` and `s'` of type `α`, and for any proposition `P` that is decidable, the result of the `if-then-else` expression (i.e., `s` if `P` is true, `s'` otherwise) is less than or equal to the sup of `s` and `s'`. In other words, in a semilattice, the value of an `if-then-else` expression involving two elements of the semilattice is always less than or equal to the supremum (least upper bound) of those two elements.

For any semilattice `α` with sup operation `⊔`, and propositions `s`, `s' : α` and decidable `P : Prop`, if `s ≤ s' ∨ P` then `(ite P s s') ≤ s ⊔ s'`.


theorem List.mem_append_left : ∀ {α : Type u_1} {a : α} {l₁ : List α} (l₂ : List α), a ∈ l₁ → a ∈ l₁ ++ l₂ := by sorry

This theorem, `List.mem_append_left`, posits that for any element `a` of a certain type `α`, and any list `l₁` of elements of type `α`, if `a` belongs to `l₁`, then `a` will also belong to the list obtained by appending another list `l₂` to `l₁`. In other words, if an element is in a list, it will still be in the list even after we append other elements to the end of the list.

If `a` is an element of list `l₁` and `l₂` is any list, then `a` is an element of the list obtained by appending `l₂` to `l₁` (denoted as `l₁ ++ l₂`).


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

The theorem `uniformity_prod_eq_prod` states that for any two types `α` and `β` which both have `UniformSpace` structures, the uniformity of the product type `(α × β)` is equal to the map of the product of their individual uniformities. In other words, the uniformity over the product space is determined by the individual uniformities over the spaces. The map function takes a pair of pairs and reorders them into a pair of two pairs. This theorem can be seen as a property relating the uniformity structure of a product space to the uniformity structures of its constituent spaces.

The uniformity of a product type of two uniform spaces is equal to the product of their individual uniformities.


theorem symmDiff_self : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a : α), symmDiff a a = ⊥ := by sorry

The theorem `symmDiff_self` states that for any type `α` that forms a Generalized Coheyting Algebra, the symmetric difference of an element `a` with itself always equals the bottom element `⊥`. In other words, given any element from the algebra, the result of performing the symmetric difference operation on it and itself is the lowest or 'null' element in the algebra. This is akin to saying the symmetric difference of a set with itself is the empty set in set theory.

For any type `α` that is a Generalized Coalgebra, `a ⊎ a = ⊥` for all `a : α`.


/-- If one controls the norm of every `A x`, then one controls the norm of `A`.  -/
theorem SchwartzMap.seminormAux_le_bound :
    ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (k n : ℕ) (f : SchwartzMap E F) {M : ℝ},
      0 ≤ M → (∀ (x : E), ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ M) → SchwartzMap.seminormAux k n f ≤ M :=
  by sorry

The theorem `SchwartzMap.seminormAux_le_bound` states that for any normed additive commutative groups `E` and `F` over real numbers, given any Schwartz Map `f` from `E` to `F`, and any nonnegative integers `k` and `n`, if there exists a nonnegative real number `M` such that the norm of `x` raised to the power of `k` multiplied by the norm of the `n`-th iterated Frechet derivative of `f` at `x` is always less than or equal to `M` for every `x` in `E`, then the seminorm of `f` calculated by the auxiliary function `SchwartzMap.seminormAux` with parameters `k` and `n` is also less than or equal to `M`. This means that if we can control the norms of the iterated derivatives of `f` at every point, then we can control the seminorm of `f` itself.

If for all x in a normed additive commutative group E and nonnegative integers k and n, the norm of x raised to the power of k times the norm of the n-th iterated Frechet derivative of a Schwartz Map f from E to another normed additive commutative group F at x is bounded by a constant M, then the seminorm of f using SchwartzMap.seminormAux with parameters k and n is also bounded by M.


/-- **Alias** of the reverse direction of `Nat.modEq_iff_dvd`. -/
theorem Nat.modEq_of_dvd : ∀ {n a b : ℕ}, ↑n ∣ ↑b - ↑a → a ≡ b [MOD n] := by sorry

This theorem, `Nat.modEq_of_dvd`, is an alias for the reverse direction of another theorem `Nat.modEq_iff_dvd`. It states that for any natural numbers `n`, `a`, and `b`, if `n` divides the difference between `b` and `a`, then `a` is congruent to `b` modulo `n`. In mathematical terms, this is saying that if `n` is a divisor of `b - a`, then `a ≡ b (mod n)`.

If `n` divides `b - a`, then `a` is congruent to `b` modulo `n`.


/-- The `sSup` of a non-empty set is its least upper bound for a conditionally
complete lattice with a top.  -/
theorem WithTop.isLUB_sSup' :
    ∀ {β : Type u_5} [inst : ConditionallyCompleteLattice β] {s : Set (WithTop β)}, Set.Nonempty s → IsLUB s (sSup s) :=
  by sorry

The theorem `WithTop.isLUB_sSup'` states that for any non-empty set `s` of an arbitrary type `β` that is structured as a conditionally complete lattice with a top, the supremum (`sSup`) of `s` serves as its least upper bound. This means that the `sSup` of `s` is an upper bound of `s` and any other upper bound of `s` is greater than or equal to this `sSup`.

For any non-empty set `s` in a conditionally complete lattice with a top element, the supremum of `s` is the least upper bound of `s`.


Order.IsSuccLimit.isMax

theorem Order.IsSuccLimit.isMax :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α} [inst_1 : SuccOrder α], Order.IsSuccLimit (Order.succ a) → IsMax a :=
  by sorry

The theorem `Order.IsSuccLimit.isMax` states that for all types `α` that have a pre-order and a successor order, if for any element `a` of `α`, the successor of `a` is a successor limit (which means that it doesn't cover any element smaller than itself), then `a` is a maximal element. Here, `a` is considered a maximal element if there is no element strictly greater than it in the set `α`.

If every successor element in a pre-ordered type with a successor order is a successor limit and has no greater element, then it is a maximal element.


/-- A function is `C^(n + 1)` on a domain with unique derivatives if and only if it is
differentiable there, and its derivative (formulated with `derivWithin`) is `C^n`.  -/
theorem contDiffOn_succ_iff_derivWithin :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f₂ : 𝕜 → F} {s₂ : Set 𝕜} {n : ℕ},
      UniqueDiffOn 𝕜 s₂ →
        (ContDiffOn 𝕜 (↑(n + 1)) f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂) :=
  by sorry

The theorem `contDiffOn_succ_iff_derivWithin` asserts that for any normed field `𝕜`, normed add commutative group `F`, function `f₂` from `𝕜` to `F`, set `s₂` of `𝕜`, and natural number `n`, if the set `s₂` has unique differentials, then the function `f₂` is continuously differentiable `n + 1` times on `s₂` if and only if it is differentiable on `s₂` and its derivative (expressed with `derivWithin`) is continuously differentiable `n` times on `s₂`. In other words, a function has `n + 1` continuous derivatives in a domain with unique derivatives precisely when it is differentiable in that domain, and its derivative is continuously differentiable `n` times.

A function from a normed field to a normed add commutative group is `(n+1)` times continuously differentiable on a set with unique differentials if and only if it is differentiable on that set and its derivative, expressed with `derivWithin`, is `n` times continuously differentiable on that set.


theorem norm_le_norm_add_norm_div' : ∀ {E : Type u_6} [inst : SeminormedGroup E] (u v : E), ‖u‖ ≤ ‖v‖ + ‖u / v‖ := by
  sorry

This theorem, `norm_le_norm_add_norm_div'`, states that for any given type `E` which is a seminormed group, and for any two elements `u` and `v` of that group, the norm of `u` is less than or equal to the sum of the norm of `v` and the norm of the quotient `u / v`. In mathematical notation, this is $\|u\| \leq \|v\| + \|u / v\|$.

For any seminormed group `E` and elements `u` and `v` in `E` with `v ≠ 0`, the norm of `u` is less than or equal to the sum of the norms of `v` and `u / v`. (Mathematically: $\|u\| \leq \|v\| + \|u / v\|$)


theorem Int.toNat_le : ∀ {a : ℤ} {n : ℕ}, Int.toNat a ≤ n ↔ a ≤ ↑n := by sorry

The theorem `Int.toNat_le` states that for any integer `a` and natural number `n`, the function `Int.toNat` applied to `a` is less than or equal to `n` if and only if `a` is less than or equal to `n` when `n` is considered as an integer. In other words, turning `a` into a natural number via `Int.toNat` and comparing it to `n` is equivalent to directly comparing `a` and `n` in the integer domain. This establishes a relationship between integer-to-natural number conversion and inequality comparison in Lean 4.

For any integer `a` and natural number `n`, `Int.toNat a <= n` if and only if `a <= n` in the integer domain.


theorem dvd_gcd_mul_of_dvd_mul :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α},
      k ∣ m * n → k ∣ gcd k m * n :=
  by sorry

This theorem states that for any type `α` that is a cancel commutative monoid with zero and also a GCD monoid, and for any elements `m`, `n`, and `k` of this type, if `k` divides the product of `m` and `n`, then `k` also divides the product of the greatest common divisor of `k` and `m` with `n`. In mathematical terms, given $k$, $m$, $n$ in a GCD monoid, if $k$ divides $m*n$, then $k$ also divides $\gcd(k, m)*n$.

If `α` is a cancel commutative monoid with zero and a GCD monoid, then for any `m`, `n`, and `k` in `α`, if `k` divides `m * n`, then `k` divides `gcd(k, m) * n`.


theorem MvPolynomial.eval₂Hom_map_hom :
    ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      [inst_2 : CommSemiring S₂] (f : R →+* S₁) (g : σ → S₂) (φ : S₁ →+* S₂) (p : MvPolynomial σ R),
      (MvPolynomial.eval₂Hom φ g) ((MvPolynomial.map f) p) = (MvPolynomial.eval₂Hom (RingHom.comp φ f) g) p :=
  by sorry

This theorem states that for all types `R`, `S₁`, `S₂`, and `σ`, commutative semirings `R`, `S₁`, and `S₂`, a ring homomorphism `f` from `R` to `S₁`, a function `g` from `σ` to `S₂`, a ring homomorphism `φ` from `S₁` to `S₂`, and a multivariate polynomial `p` over `σ` and `R`, the evaluation of the polynomial `p` mapped via `f` with `φ` and `g` is equivalent to the evaluation of the polynomial `p` with the composition of `φ` and `f`, and `g`. Essentially, this theorem presents the commutativity of the processes of mapping and evaluation of multivariate polynomials.

For commutative semirings R, S₁, S₂, ring homomorphisms f : R → S₁, φ : S₁ → S₂, function g : σ → S₂, and multivariate polynomial p over σ and R, we have that f(p(x₁, ..., xn)) = φ(p(fx₁, ..., fxn)) + g, where the addition is in S₂.


theorem MonoidAlgebra.sum_single :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] (f : MonoidAlgebra k G), Finsupp.sum f MonoidAlgebra.single = f :=
  by sorry

The theorem `MonoidAlgebra.sum_single` states that for any semiring `k` and any type `G`, and for any monoid algebra `f` over `k` generated by `G`, the sum of the application of the function `MonoidAlgebra.single` to each element in the support of `f` (which is computed via `Finsupp.sum`) is equal to `f` itself. In simpler terms, this result describes an important property of the algebraic structure called a monoid algebra, specifically how summing over its elements using a certain operation gives back the original monoid algebra.

For any semiring `k` and type `G`, the sum of the monoid algebra `f` over `k` generated by `G`, as the application of `MonoidAlgebra.single` to each element in its support, equals `f` itself.


theorem DiscreteValuationRing.associated_pow_irreducible :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DiscreteValuationRing R] {x : R},
      x ≠ 0 → ∀ {ϖ : R}, Irreducible ϖ → ∃ n, Associated x (ϖ ^ n) :=
  by sorry

This theorem states that for any commutative ring `R`, which is also a domain and a discrete valuation ring, and for any given non-zero element `x` of `R`, if `ϖ` is an irreducible element of `R`, then there exists an integer `n` such that `x` is associated with the `n`-th power of `ϖ`. Here, two elements are said to be associated if one can be obtained by multiplying the other by a unit.

For any commutative domain and discrete valuation ring `R` with non-zero element `x` and irreducible element `ϖ`, there exists an integer `n` such that `x` is associated with `ϖ^n`.


IsOpen.smul

theorem IsOpen.smul :
    ∀ {α : Type u_2} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : Group G] [inst_2 : MulAction G α]
      [inst_3 : ContinuousConstSMul G α] {s : Set α}, IsOpen s → ∀ (c : G), IsOpen (c • s) :=
  by sorry

The theorem `IsOpen.smul` states that for any open set `s` in a topological space `α`, if there exists a group `G` that acts on `α` continuously via multiplication (as specified by `[MulAction G α]` and `[ContinuousConstSMul G α]`), then the action of any element `c` from `G` on `s` (denoted as `c • s`) results in a set that is also open in the topological space `α`. This result holds for all such topological spaces `α`, groups `G`, and open sets `s`.

For any topological space α, open set s, and a group G acting continuously on α via multiplication, the set operation c • s (where c is an element of G) results in an open subset of α.


theorem LiouvilleWith.add_rat_iff : ∀ {p x : ℝ} {r : ℚ}, LiouvilleWith p (x + ↑r) ↔ LiouvilleWith p x := by sorry

The theorem `LiouvilleWith.add_rat_iff` states that for any real numbers `p` and `x`, and any rational number `r`, `x` is a Liouville number with exponent `p` if and only if `x + r` is a Liouville number with exponent `p`. In other words, adding a rational number to a Liouville number gives another Liouville number with the same exponent.

For any real numbers `x` being a Liouville number with exponent `p` if and only if `x + r` is a Liouville number with exponent `p`, where `r` is a rational number.


AddSubmonoid.LocalizationMap.ext

theorem AddSubmonoid.LocalizationMap.ext :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {f g : AddSubmonoid.LocalizationMap S N},
      (∀ (x : M), (AddSubmonoid.LocalizationMap.toMap f) x = (AddSubmonoid.LocalizationMap.toMap g) x) → f = g :=
  by sorry

The theorem `AddSubmonoid.LocalizationMap.ext` states that for any two localization maps `f` and `g` from an additive submonoid `S` of an additive commutative monoid `M` to an additive commutative monoid `N`, if the two maps are equal when applied to any element `x` from `M` (i.e., `f(x) = g(x)` for all `x` in `M`), then the two localization maps `f` and `g` are identical. In other words, the theorem provides a criterion for proving the equality of two localization maps based on their action on elements of the monoid `M`.

If two localization maps from an additive submonoid of an additive commutative monoid to an additive commutative monoid agree on all elements of the monoid, then they are equal.


theorem SetTheory.PGame.ofState.proof_1 :
    ∀ {S : Type u_1} [inst : SetTheory.PGame.State S] (s : S),
      SetTheory.PGame.State.turnBound s ≤ SetTheory.PGame.State.turnBound s :=
  by sorry

The theorem `SetTheory.PGame.ofState.proof_1` in Lean 4 states that for any type `S` that has an instance of structure `SetTheory.PGame.State`, and any value `s` of type `S`, the `turnBound` of `s` is less than or equal to the `turnBound` of `s` itself. In other words, it guarantees that the `turnBound` of a state in a positional game (a Set Theory Game) is always less than or equal to its own `turnBound`, which enforces the reflexive property of the less than or equal to relation on the `turnBound` of a game state.

For any positional game state `s`, the reflexive property holds for its turn bound, that is, the turn bound of `s` is less than or equal to itself.


theorem div_le_self : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 ≤ a → 1 ≤ b → a / b ≤ a := by
  sorry

This theorem, `div_le_self`, states that for any type `α` that is a linearly ordered semifield, and any elements `a` and `b` of that type, if `a` is greater than or equal to 0 and `b` is greater than or equal to 1, then the value of `a` divided by `b` is less than or equal to `a`. In other words, in a ordered field, dividing a non-negative number by another number greater than or equal to one will never result in a larger number than the original one.

For any linearly ordered semifield type `α` and elements `a` and `b` of type `α` with `a ≥ 0` and `b ≥ 1`, `a / b ≤ a`.


theorem dist_vadd :
    ∀ {M : Type u} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : VAdd M X] [inst_2 : IsometricVAdd M X] (c : M)
      (x y : X), dist (c +ᵥ x) (c +ᵥ y) = dist x y :=
  by sorry

This theorem states that for any types `M` and `X`, given that `X` is a pseudo metric space and `M` can be added to `X` in an isometric way (i.e., the addition preserves distances), then the distance between any two points `x` and `y` of type `X` will remain the same even after adding a constant `c` of type `M` to both points. In other words, in such a space, translating `x` and `y` by the same vector `c` does not change their distance.

Given a pseudo metric space `X` and type `M` such that `M` can be isometrically added to `X`, the distance between any two points `x` and `y` in `X` is equal to the distance between `x + c` and `y + c` for any constant `c` of type `M`.


theorem LinearIndependent.cardinal_le_rank :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      {ι : Type v} {v : ι → M}, LinearIndependent R v → Cardinal.mk ι ≤ Module.rank R M :=
  by sorry

This theorem states that for any type `R` with a ring structure, a type `M` with an additive commutative group structure and a module structure over `R`, and a nontrivial structure for `R`, given another type `ι` and a function `v` which maps `ι` to `M` such that `v` is linearly independent over `R`, the cardinality of the type `ι` is less than or equal to the rank of the module `M` over `R`. In mathematical terms, if a set of vectors is linearly independent, then the size of this set is less than or equal to the rank of the vector space.

Given a ring `R`, an additive commutative group `M` with a module structure over `R`, and a linearly independent set `v` of elements from `M` with domain `ι`, the cardinality of `ι` is less than or equal to the rank of the `R`-module `M`.


/-- `map` is natural with respect to `cons`.  -/
theorem Vector.map_cons :
    ∀ {α : Type u} {β : Type v} {n : ℕ} (f : α → β) (a : α) (v : Vector α n),
      Vector.map f (a ::ᵥ v) = f a ::ᵥ Vector.map f v :=
  by sorry

The theorem `Vector.map_cons` states that for any types `α` and `β`, any natural number `n`, any function `f` from `α` to `β`, any element `a` of type `α`, and any `n`-length vector `v` of elements of type `α`, applying the function `f` to each element of the vector that results from cons-ing `a` onto `v` (using the vector-specific version of the cons operator `::ᵥ`) results in the same vector as cons-ing `f a` onto the result of mapping `f` over `v`. In other words, for vectors, mapping and cons-ing commute with each other.

For any types α and β, natural number n, function f : α → β, element a : α, and vectors xs : vector α (len n), the application of the function f to the cons-ed element a and the resulting vector obtained by mapping f over xs is equal to the cons of f a to the result of mapping f over xs. In symbols: (∀ i : nat, f (xs.get i) = (map f xs).push (f a)).


StructureGroupoid.symm

theorem StructureGroupoid.symm :
    ∀ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H) {e : PartialHomeomorph H H},
      e ∈ G → PartialHomeomorph.symm e ∈ G :=
  by sorry

This theorem states that for any given topological space `H`, structure groupoid `G` on `H`, and a partial homeomorphism `e` from `H` to `H`, if `e` is an element of the structure groupoid `G`, then the inverse of the partial homeomorphism `e`, denoted by `PartialHomeomorph.symm e`, also belongs to the structure groupoid `G`. This shows the property of the groupoid that it is closed under taking inverses of its elements.

Given a topological space `H`, a structure groupoid `G` on `H`, and a partial homeomorphism `e` in `G`, the inverse `PartialHomeomorph.symm e` is also in `G`.


theorem algebraicIndependent_equiv' :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {A : Type u_5} [inst : CommRing R] [inst_1 : CommRing A]
      [inst_2 : Algebra R A] (e : ι ≃ ι') {f : ι' → A} {g : ι → A},
      f ∘ ⇑e = g → (AlgebraicIndependent R g ↔ AlgebraicIndependent R f) :=
  by sorry

The theorem `algebraicIndependent_equiv'` states that for any types `ι`, `ι'`, `R`, and `A`, with `R` and `A` being commutative rings and `A` being an `R`-algebra, given a bijective function `e` from `ι` to `ι'`, and functions `f` from `ι'` to `A` and `g` from `ι` to `A` such that `f` is the composition of `g` and `e`, then `g` is algebraically independent over `R` if and only if `f` is algebraically independent over `R`. In other words, the algebraic independence of a family of elements in an `R`-algebra is preserved under a change of indexing set by a bijection.

If `e: ι --> ι'` is a bijection, `g: ι --> A` and `f: ι' --> A` are such that `f = g ∘ e`, and `R` is a commutative ring with `A` being an `R`-algebra, then `g` is algebraically independent over `R` if and only if `f` is algebraically independent over `R`.


theorem kstar_mul_le_kstar : ∀ {α : Type u_1} [inst : KleeneAlgebra α] {a : α}, KStar.kstar a * a ≤ KStar.kstar a := by
  sorry

This theorem, `kstar_mul_le_kstar`, states that for any type `α` that is an instance of a Kleene Algebra, and any element `a` of `α`, the result of multiplying the Kleene star of `a` (`KStar.kstar a`) with `a`, is less than or equal to the Kleene star of `a`. In mathematical terms, for any `a` in a Kleene algebra, we have that $KStar(a) * a \leq KStar(a)$.

For any element `a` in a Kleene algebra, $KStar(a) \cdot a \leq KStar(a)$.


theorem nsmul_right_strictMono :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {n : ℕ},
      n ≠ 0 → StrictMono fun x => n • x :=
  by sorry

The theorem `nsmul_right_strictMono` states that, for any type `M` which is an ordered additive monoid, and for any natural number `n` that is not zero, the function that maps `x` to `n` multiplied by `x` (denoted as `n • x`) is strictly monotone. In other words, if `a` and `b` are elements of `M` and `a < b`, then `n • a < n • b`. This implies that multiplying by a non-zero natural number preserves the order in an ordered additive monoid.

For any ordered additive monoid type `M` and non-zero natural number `n`, the function `n • x` mapping `x` to `n` times `x` is a strict order preserving function on `M`.


theorem List.Perm.pairwise_iff :
    ∀ {α : Type u_1} {R : α → α → Prop},
      (∀ {x y : α}, R x y → R y x) → ∀ {l₁ l₂ : List α}, List.Perm l₁ l₂ → (List.Pairwise R l₁ ↔ List.Pairwise R l₂) :=
  by sorry

This theorem states that for any type `α` and a relation `R` on `α` that is symmetric (i.e., if `R x y` holds, then `R y x` also holds for any `x` and `y` of type `α`), if two lists `l₁` and `l₂` of type `α` are permutations of each other, then the property of pairwise `R` relation holds in `l₁` if and only if it also holds in `l₂`. Here, a list is said to satisfy the pairwise `R` relation if every pair of distinct elements in the list are related by `R`.

For any symmetric relation R on type α and permutation l₁, l₂ of lists of elements of α, the property of pairwise relatedness by R holds in l₁ if and only if it holds in l₂.


theorem IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots :
    ∀ {A : Type u} {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain B]
      {ζ : B} {n : ℕ+},
      IsPrimitiveRoot ζ ↑n →
        Algebra.adjoin A (Polynomial.rootSet (Polynomial.cyclotomic (↑n) A) B) =
          Algebra.adjoin A {b | ∃ a ∈ {n}, b ^ ↑a = 1} :=
  by sorry

This theorem states that for any given types `A` and `B` which are commutative rings with an algebra structure from `A` to `B`, and where `B` is a domain, for a given element `ζ` of `B` and a positive integer `n`, if `ζ` is a primitive `n`-th root of unity, then the minimal subalgebra of `B` over `A` that includes all the roots of the `n`-th cyclotomic polynomial in `A` is equal to the minimal subalgebra of `B` over `A` that includes all the `n`-th roots of unity.

For any commutative rings with algebra structures `A` to `B` with `B` being a domain, if `ζ` is a primitive `n`-th root of unity in `B`, then the minimal subalgebras of `B` over `A` containing all `n`-th cyclotomic polynomials and all `n`-th roots of unity are equal.


OrderedSMul.mk'

/-- To prove that a vector space over a linear ordered field is ordered, it suffices to verify only
the first axiom of `OrderedSMul`.  -/
theorem OrderedSMul.mk' :
    ∀ {𝕜 : Type u_5} {M : Type u_7} [inst : LinearOrderedSemifield 𝕜] [inst_1 : OrderedAddCommMonoid M]
      [inst_2 : MulActionWithZero 𝕜 M], (∀ ⦃a b : M⦄ ⦃c : 𝕜⦄, a < b → 0 < c → c • a ≤ c • b) → OrderedSMul 𝕜 M :=
  by sorry

The theorem `OrderedSMul.mk'` states that to establish an ordered scalar multiplication (`OrderedSMul`) structure over a vector space `M` with a linear ordered semifield `𝕜`, it's enough to confirm the first axiom of `OrderedSMul`. This axiom asserts that for all vectors `a` and `b` in `M` and a scalar `c` in `𝕜`, if `a` is less than `b` and `c` is greater than zero, then the scalar multiplication of `c` and `a` is less than or equal to the scalar multiplication of `c` and `b`.

Given a vector space `M` over a linear ordered semifield `𝕜`, the ordered scalar multiplication structure holds if the first axiom (`a < b => c*a <= c*b` for all `a, b in M` and `c in 𝕜` with `c > 0`) is satisfied.


theorem ContinuousOn.restrict_mapsTo :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {t : Set β}, ContinuousOn f s → ∀ (ht : Set.MapsTo f s t), Continuous (Set.MapsTo.restrict f s t ht) :=
  by sorry

The theorem `ContinuousOn.restrict_mapsTo` states that for any types `α` and `β`, both endowed with a topological structure, a function `f` from `α` to `β`, and sets `s` of `α` and `t` of `β`, if `f` is continuous on `s` and the image of `s` under `f` is contained in `t` (expressed as `Set.MapsTo f s t`), then the function `f` restricted to `s` and `t` is continuous. In other words, the continuity of `f` on `s` and the mapping condition between `s` and `t` ensure the continuity of the restricted function.

If a function between topological spaces is continuous on a set and maps that set to another set, then the restriction of the function to that set is continuous.


theorem Nat.coprime_of_dvd : ∀ {m n : ℕ}, (∀ (k : ℕ), Nat.Prime k → k ∣ m → ¬k ∣ n) → Nat.Coprime m n := by sorry

The theorem `Nat.coprime_of_dvd` states that for any natural numbers `m` and `n`, if all prime numbers `k` that divide `m` do not divide `n`, then `m` and `n` are coprime. In other words, if every prime number that is a factor of `m` is not a factor of `n`, then the greatest common divisor (gcd) of `m` and `n` is 1, which by definition means that `m` and `n` are relatively prime.

If all prime divisors of natural numbers `m` and `n` are distinct, then `m` and `n` are coprime.


/-- The head term of the gcf of `v` is `⌊v⌋`.  -/
theorem GeneralizedContinuedFraction.of_h_eq_floor :
    ∀ {K : Type u_1} [inst : LinearOrderedField K] [inst_1 : FloorRing K] {v : K},
      (GeneralizedContinuedFraction.of v).h = ↑⌊v⌋ :=
  by sorry

This theorem states that for any type `K` that is a linear ordered field and has a floor ring structure, the head term of the generalized continued fraction representation of any value `v` of type `K` is equal to the integer part (or floor) of `v`. In mathematical terms, it asserts that the first term of the generalized continued fraction (gcf) of a number `v` is `⌊v⌋`.

For any linear ordered field `K` with a floor ring structure, the first term of the generalized continued fraction representation of a value `v` in `K` equals the integer part of `v`.


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

This theorem states that for any three categories `C`, `D`, and `E`, and any two functors `F` from `C` to `D` and `G` from `D` to `E`, the object `X` in `C` under the composition of the two functors `F` and `G` is the same as the object `X` under functor `F` then under functor `G`. In other words, functor composition respects the mapping of objects.

For any functors F : C -> D and G : D -> E, the composition Functor(G) ∘ Functor(F) equals Functor(F) ∘ Object(X) for any object X in category C.


theorem ENNReal.coe_tsum : ∀ {α : Type u_1} {f : α → NNReal}, Summable f → ↑(tsum f) = ∑' (a : α), ↑(f a) := by sorry

The theorem `ENNReal.coe_tsum` states that for any type `α` and function `f` from `α` to nonnegative real numbers (`NNReal`), if `f` is summable, then the coercive function (denoted as `↑`) applied to the total sum (`tsum`) of `f` is equal to the infinite sum (`∑' (a : α), ↑(f a)`) of the coercive function applied to each `f(a)`. In simpler terms, it states that the sum of the coerced values of the sequence is the same as the coerced value of the sum of the sequence, given that the series represented by the sequence is summable.

For any summable function `f` from type `α` to nonnegative reals, `↑(tsum (map ↑ f) : NNReal) = ∑' (a : α), ↑(f a)`.


theorem ENNReal.add_halves : ∀ (a : ENNReal), a / 2 + a / 2 = a := by sorry

This theorem states that for every extended nonnegative real number `a`, the sum of half of `a` and half of `a` is equal to `a` itself. In other words, it confirms the basic arithmetic property that splitting a number into two equal halves and then adding these halves together results in the original number. This is usually denoted in mathematical notation as: for every $a \in [0, ∞]$, we have $a/2 + a/2 = a$.

For every extended nonnegative real number `a`, the sum of `a` divided by 2 twice is equal to `a` itself. Or, in mathematical notation: ∀ (a : ℝ≥0∞), a / 2 + a / 2 = a.


theorem Mathlib.Data.Sum.Order._auxLemma.7 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inr b ≤ Sum.inl a) = False := by
  sorry

This theorem is stating that for any types `α` and `β` with a less than or equal to (`≤`) relation defined on them, and for any elements `a` of type `α` and `b` of type `β`, the statement "`b` is less than or equal to `a`" is always false when `b` is considered a "right" value (`Sum.inr`) and `a` is considered a "left" value (`Sum.inl`). In other words, a right value is never less than or equal to a left value in the sum type based on `α` and `β`.

For any types `α` and `β` with a defined `≤` relation, and for any `a : α` and `b : β`, `Sum.inr b ≤ Sum.inl a` always falsifies.


theorem Mathlib.Data.Sum.Order._auxLemma.5 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inl b ≤ Sum.inr a) = False := by
  sorry

The theorem `Mathlib.Data.Sum.Order._auxLemma.5` states that for any types `α` and `β` that have a less than or equal to (`≤`) order defined, and any elements `a` from `α` and `b` from `β`, it is not possible for `b` of the left sum (`Sum.inl b`) to be less than or equal to `a` of the right sum (`Sum.inr a`). In other words, an element from the left part of a sum type cannot be less than or equal to an element from the right part of the sum type. This theorem is part of the order properties of sum types in Lean's mathematical library.

For any types `α` and `β` with defined order, and elements `a : α` and `b : β`, `Sum.inl b ≤ Sum.inr a` is false.


theorem Finset.eq_univ_of_forall :
    ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α}, (∀ (x : α), x ∈ s) → s = Finset.univ := by sorry

This theorem states that for any type `α` that is of finite type (`Fintype α`), and any finite set `s` of this type (`Finset α`), if every element `x` of type `α` is an element of `s`, then `s` is equivalent to the universal finite set of type `Finset α` (`Finset.univ`). In other words, if a finite set contains every possible element of a given finite type, it is considered the universal set of that type.

If `α` is a finite type and `s : Finset α` contains every element of `α`, then `s` is equivalent to the universal finite set `Finset.univ` of type `Finset α`.


theorem List.get_singleton : ∀ {α : Type u_1} (a : α) (n : Fin 1), List.get [a] n = a := by sorry

This theorem, `List.get_singleton`, states that for all types `α`, for any element `a` of type `α` and for any `n` of type `Fin 1`, retrieving the `n`th element (using the function `List.get`) from a singleton list that contains only `a` will always yield `a`. In simpler terms, it says that if you have a list with only one element, no matter at which index you look, you'll always get that one element. The `Fin 1` type represents a finite set of size 1, so `n` can only be zero, which is the first and only position in a singleton list.

For any type `α` and element `a` of type `α`, the function `List.get` on a singleton list `[a]` of length 1 returns `a`. In mathematical notation: `List.get (list.singleton a) = a`.


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

The theorem `Sum.Lex.inl_lt_inr` states that for any two types `α` and `β`, given an instance of the "less than" relation for `α` and `β`, and any elements `a` of type `α` and `b` of type `β`, the lex (lexicographic order) of the element `a` injected into the sum type with `Sum.inl` is less than the lex of the element `b` injected with `Sum.inr`. In other words, it claims that in the lexicographic ordering, all elements of the left summand are considered less than all elements of the right summand.

For any types `α` and `β` with a defined less-than relation, and for any elements `a : α` and `b : β`, `Sum.inl a < Sum.inr b` holds in the lexicographic order on the sum type `Sum α β`.


theorem Ordinal.IsNormal.eq_iff_zero_and_succ :
    ∀ {f g : Ordinal.{u} → Ordinal.{u}},
      Ordinal.IsNormal f →
        Ordinal.IsNormal g →
          (f = g ↔ f 0 = g 0 ∧ ∀ (a : Ordinal.{u}), f a = g a → f (Order.succ a) = g (Order.succ a)) :=
  by sorry

This theorem states that for any two normal ordinal functions `f` and `g`, `f` is equal to `g` if and only if `f` and `g` map the ordinal zero to the same ordinal and for all ordinals `a`, if `f` and `g` map `a` to the same ordinal, then `f` and `g` also map the successor of `a` to the same ordinal. Here, a normal ordinal function is a strictly increasing function which is order-continuous, meaning the image of a limit ordinal is the supremum of the function values for all smaller ordinals. The successor of an ordinal is the next ordinal if it exists, or the same ordinal if it is maximal.

Two normal ordinal functions are equal if and only if they map ordinal zero to the same ordinal and agree on all successor ordinals.


HasSum.neg

theorem HasSum.neg :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] {f : β → α} {a : α}, HasSum f a → HasSum (fun b => -f b) (-a) :=
  by sorry

This theorem states that for any two types `α` and `β`, given `α` is an additive commutative group as well as it is a topological space and a topological additive group, if there exists a function `f` from `β` to `α` that has a sum `a`, then the function that negates `f` (i.e., `fun b => -f b`) has a sum of `-a`. Essentially, it says if a certain sum is valid for a function, then the negated sum also holds for the negated function.

If `f` is a function from a topological additive group `β` to an additive commutative group `α` with a sum `a`, then the negated function `fun b => -f b` has a sum of `-a`.


/-- **Alias** of the forward direction of `lipschitzOnWith_iff_restrict`. -/
theorem LipschitzOnWith.to_restrict :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β}
      {s : Set α}, LipschitzOnWith K f s → LipschitzWith K (Set.restrict s f) :=
  by sorry

This theorem states that given two types `α` and `β`, both equipped with a pseudo emetric space structure, a nonnegative real `K`, a function `f` from `α` to `β`, and a set `s` of type `α`, if the function `f` is Lipschitz continuous with constant `K` on the set `s`, then the function `f`, when restricted to the set `s`, is Lipschitz continuous with the same constant `K`. This property is an alias of the forward direction of the theorem `lipschitzOnWith_iff_restrict`. In other words, it guarantees the Lipschitz continuity of a function when its domain is reduced to a specific set.

Given two pseudo metric spaces `(α, dα)` and `(β, dβ)`, a Lipschitz continuous function `f : α → β` with constant `K` on a subset `s ⊆ α`, the restriction of `f` to `s` is also Lipschitz continuous with constant `K`.


theorem CategoryTheory.isIso_unop_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y),
      CategoryTheory.IsIso f.unop ↔ CategoryTheory.IsIso f :=
  by sorry

This theorem states that in the context of category theory, for any category `C` and objects `X` and `Y` in the opposite category `Cᵒᵖ`, a morphism `f` from `X` to `Y` is an isomorphism if and only if its 'unop' (the operation of taking the 'opposite' morphism) is an isomorphism. In more intuitive terms, this theorem captures the idea that reversing the direction of arrows preserves isomorphisms in the category theory sense.

In category theory, an opposite morphism of an isomorphism is an isomorphism in the opposite category.


theorem MeasureTheory.SignedMeasure.toMeasureOfZeroLE_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (s : MeasureTheory.SignedMeasure α) {i j : Set α}
      (hi : MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict s i)
      (hi₁ : MeasurableSet i),
      MeasurableSet j →
        ↑↑(MeasureTheory.SignedMeasure.toMeasureOfZeroLE s i hi₁ hi) j = ↑{ val := ↑s (i ∩ j), property := ⋯ } :=
  by sorry

This theorem states that for any measurable space `α`, any signed measure `s` on `α`, and any two sets `i` and `j` in `α`, if the restriction of the zero vector measure to set `i` is less than or equal to the restriction of measure `s` to set `i` and if set `i` is measurable, then for any measurable set `j`, the measure of set `j` under the measure obtained from the function `toMeasureOfZeroLE` applied to measure `s` and set `i` is equal to the signed measure of the intersection of sets `i` and `j` under measure `s`.

In mathematical terms, for a signed measure `s`, sets `i` and `j` where `i` is measurable and the zero measure restricted to `i` is less than or equal to `s` restricted to `i`, the measure of `j` under `toMeasureOfZeroLE` applied to `s` and `i` is exactly the signed measure of the intersection of `i` and `j` under `s`.

For any measurable spaces `α`, measurable sets `i` and `j`, and signed measure `s` on `α` such that the restriction of the zero measure to `i` is less than or equal to the restriction of `s` to `i`, the measure of `j` under the measure obtained from `s` and `i` via the function `toMeasureOfZeroLE` equals the signed measure of `i ∩ j` under `s`.


theorem Submonoid.LocalizationMap.mul_mk'_eq_mk'_of_mul :
    ∀ {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 : ↥S),
      (Submonoid.LocalizationMap.toMap f) x₁ * Submonoid.LocalizationMap.mk' f x₂ y =
        Submonoid.LocalizationMap.mk' f (x₁ * x₂) y :=
  by sorry

This theorem states that for any commutative monoid `M`, submonoid `S` of `M`, and commutative monoid `N`, given a localization map `f` from `M` to `N`, and elements `x₁`, `x₂` of `M` and `y` of `S`, the image of `x₁` under the localization map `f` multiplied by the image of the pair `(x₂, y)` under the mk' function of the localization map `f` is equal to the image of the pair `(x₁ * x₂, y)` under the mk' function of the localization map `f`. In other words, it asserts that applying the function `mk'` after a multiplication in `M` is the same as applying `mk'` first and then performing the multiplication in `N`.

For any commutative monoids `M`, `N`, commutative monoid homomorphism `f` from `M` to `N`, submonoid `S` of `M`, and elements `x₁`, `x₂` in `M` and `y` in `S`, we have `f(x₁) * f(mk' x₂, y) = f(mk' (x₁ * x₂), y)`.


theorem CategoryTheory.Pretriangulated.Triangle.mor₃_eq_zero_iff_epi₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
      [inst_4 : ∀ (n : ℤ), CategoryTheory.Functor.Additive (CategoryTheory.shiftFunctor C n)]
      [hC : CategoryTheory.Pretriangulated C],
      ∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles, T.mor₃ = 0 ↔ CategoryTheory.Epi T.mor₂ :=
  by sorry

The theorem `CategoryTheory.Pretriangulated.Triangle.mor₃_eq_zero_iff_epi₂` states that for any category `C` with a zero object, a shift by integers, additive structure, and pretriangulated structure, for any triangle `T` which belongs to the distinguished triangle category, the third morphism `T.mor₃` in the triangle is equal to zero if and only if the second morphism `T.mor₂` is an epimorphism. Here, epimorphism refers to a morphism for which any two morphisms from its codomain can be made equal by precomposing with it.

For any pretriangulated category with additive structure and zero object, the third morphism in a distinguished triangle is zero if and only if the second morphism is an epimorphism.


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

The theorem `ApplicativeTransformation.preserves_seq` asserts that for any two types `F` and `G` that are instances of the Applicative typeclass, and for any Applicative Transformation `η` from `F` to `G`, and for any two values `x` of type `F (α → β)` and `y` of type `F α`, applying `η` to the result of performing the `Seq.seq` operation on `x` and `y` is the same as performing `Seq.seq` on the result of applying `η` to `x` and a function that applies `η` to `y`. In other words, it states that the `Seq.seq` operation is preserved under an Applicative Transformation, which is a fundamental property that ensures the behavior of computations remains consistent when transformed from one context (Applicative) to another.

Given Applicative functors F and G, an Applicative transformation η from F to G, and values x : F (α → β) and y : F α, Seq.seq (η <$> x) (η <$ y) is equivalent to η (Seq.seq x y).


TendstoUniformlyOn.prod

theorem TendstoUniformlyOn.prod :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι} {ι' : Type u_1} {β' : Type u_2} [inst_1 : UniformSpace β'] {F' : ι' → α → β'} {f' : α → β'}
      {p' : Filter ι'},
      TendstoUniformlyOn F f p s →
        TendstoUniformlyOn F' f' p' s →
          TendstoUniformlyOn (fun i a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a)) (Filter.prod p p') s :=
  by sorry

The theorem `TendstoUniformlyOn.prod` states that given two sequences of functions, `F` and `F'`, which converge uniformly to limiting functions `f` and `f'` on a set `s` with respect to filters `p` and `p'` respectively, the sequence of functions `(F i.1 a, F' i.2 a)` converges uniformly to the limiting function `(f a, f' a)` on the same set `s` with respect to the product of filters `p` and `p'`. This theorem essentially states that the uniform convergence of a sequence of functions is preserved under the product operation.

Given sequences of functions `F` and `F'` that uniformly converge to `f` and `f'` on set `s` with respect to filters `p` and `p'` respectively, `F.product` (`F i.1 _ _, F' i.2 _ _`) uniformly converges to the product function `f * f'` on `s` with respect to the product filter `p ⊓ p'`.


theorem Polynomial.eval₂_smul :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (g : R →+* S) (p : Polynomial R) (x : S)
      {s : R}, Polynomial.eval₂ g x (s • p) = g s * Polynomial.eval₂ g x p :=
  by sorry

The theorem `Polynomial.eval₂_smul` states that for any semirings `R` and `S`, if there exists a ring homomorphism `g` from `R` to `S`, a polynomial `p` with coefficients in `R`, and an element `x` from `S`, and for any scalar `s` from `R`, the evaluation of the scaled polynomial `s • p` at `x` under the ring homomorphism `g` equals to the product of the image of `s` under `g` and the evaluation of `p` at `x` under the same ring homomorphism. In more precise terms, it asserts that `Polynomial.eval₂ g x (s • p) = g s * Polynomial.eval₂ g x p`.

For any semirings R and S, ring homomorphism g from R to S, polynomial p with coefficients in R, and element x in S, the evaluation of the scaled polynomial s • p at x under homomorphism g equals the product of the image of s under g and the evaluation of p at x under g. That is, g(s) * Polynomial.eval₂ g x p = Polynomial.eval₂ g x (s • p).


theorem IsPrimitiveRoot.minpoly_eq_cyclotomic_of_irreducible :
    ∀ {K : Type u_2} [inst : Field K] {R : Type u_3} [inst_1 : CommRing R] [inst_2 : IsDomain R] {μ : R} {n : ℕ}
      [inst_3 : Algebra K R],
      IsPrimitiveRoot μ n →
        Irreducible (Polynomial.cyclotomic n K) → ∀ [inst_4 : NeZero ↑n], Polynomial.cyclotomic n K = minpoly K μ :=
  by sorry

This theorem states that for any natural number `n`, any field `K`, any commutative ring `R`, and any element `μ` of `R`, if `μ` is a primitive root of `n`, and the `n`-th cyclotomic polynomial with coefficients in `K` is irreducible, then the `n`-th cyclotomic polynomial with coefficients in `K` is equal to the minimal polynomial of `μ` over `K`, provided that `n` is not zero. The statement assumes that `R` is a domain, and that `K` is an algebra over `R`.

For any natural number `n` not equal to zero, if `μ` is a primitive root of unity of order `n` over a field `K`, and the `n`-th cyclotomic polynomial is irreducible over `K`, then it is the minimal polynomial of `μ` over `K`.


theorem OrderIso.preimage_Iio :
    ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (b : β),
      ⇑e ⁻¹' Set.Iio b = Set.Iio ((OrderIso.symm e) b) :=
  by sorry

The theorem `OrderIso.preimage_Iio` states that for any two types `α` and `β` both having preorder relations and any order isomorphism `e` from `α` to `β` and any element `b` of `β`, the preimage of the left-infinite right-open interval less than `b` under the order isomorphism `e` is equal to the left-infinite right-open interval less than the image of `b` under the inverse of the order isomorphism `e`. In other words, the order isomorphism preserves the structure of these intervals under the inverse mapping.

For any order isomorphism between preordered types `α` and `β`, and any `b` in `β`, the preimage under the isomorphism of the left-infinite right-open interval `(-\infty, b)` in `β` is equal to the left-infinite right-open interval `(-\infty, e⁻¹(b))` in `α`.


/-- If matrix A is right invertible, then its inverse equals its right inverse.  -/
theorem Matrix.inv_eq_right_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] {A B : Matrix n n α},
      A * B = 1 → A⁻¹ = B :=
  by sorry

This theorem states that for any type `n` representing the indices of a matrix and any type `α` representing a commutative ring (the set of values of the matrix entries), if we have a matrix `A` and another matrix `B` such that the product of `A` and `B` equals the identity matrix, then the inverse matrix of `A` is equal to `B`. The conditions require that `n` is finite and has decidable equality, and the entries of the matrix belong to a commutative ring.

If matrices `A` and `B` of finite, decidably equal indices over a commutative ring have the product `AB` equal to the identity matrix, then `B` is the inverse of `A`.


MeasureTheory.Martingale.adapted

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

The theorem `MeasureTheory.Martingale.adapted` states that for any given space `Ω` and `E`, any type `ι` with a preorder relation, a measurable space `m0` on `Ω`, a measure `μ` on `Ω`, a sequence of functions `f` from `ι` to `Ω → E`, and a filtration `ℱ` on `m0`, if `f` is a martingale with respect to `ℱ` and the measure `μ`, then `f` is adapted to the filtration `ℱ`. Here, a function sequence is said to be adapted to a filtration if it is strongly measurable for all `ι`. Also, `E` is assumed to be a normed addition commutative group, a normed space over reals, and a complete space.

If `f` is a martingale with respect to filtration `ℱ` and measure `μ` on space `Ω` with values in complete, normed real space `E`, then `f` is an adapted sequence.


theorem Units.continuous_iff :
    ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : Monoid M] [inst_2 : TopologicalSpace X]
      {f : X → Mˣ}, Continuous f ↔ Continuous (Units.val ∘ f) ∧ Continuous fun x => ↑(f x)⁻¹ :=
  by sorry

This theorem, `Units.continuous_iff`, states that for any type `M` equipped with a topological space and monoid structure, and any type `X` also equipped with a topological space, given a function `f` mapping from `X` to the monoid units of `M`, the function `f` is continuous if and only if two conditions are met: 1) the function that maps every element of `X` to the underlying value of the base monoid via `f` is continuous, and 2) the function that maps every element of `X` to the inverse of the underlying value in the base monoid via `f` is also continuous.

A function from a topological space to the units of a monoid equipped with a topology is continuous if and only if the functions mapping each point to the underlying value and its inverse in the monoid are both continuous.


theorem interior_closedBall :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E) {r : ℝ},
      r ≠ 0 → interior (Metric.closedBall x r) = Metric.ball x r :=
  by sorry

This theorem, `interior_closedBall`, states that for any type `E` which is a semi-normed additive commutative group and also a normed space over the real numbers, and for any element `x` of type `E` and real number `r` not equal to zero, the interior of the closed ball centered at `x` with radius `r` is equal to the open ball centered at `x` with radius `r`. Here, the "interior" of a set is defined as the largest open subset of that set. The "closed ball" around a point `x` with radius `r` consists of all points `y` such that the distance from `y` to `x` is less than or equal to `r`. The "open ball" around a point `x` with radius `r` consists of all points `y` such that the distance from `y` to `x` is strictly less than `r`.

For any semi-normed additive commutative group and normed space E over the real numbers, the interior of the closed ball with center x and radius r equals the open ball with center x and radius r for all non-zero r.


theorem Int.natAbs_mul_self : ∀ {a : ℤ}, ↑(Int.natAbs a * Int.natAbs a) = a * a := by sorry

This theorem states that for any integer `a`, the square of the absolute value of `a` (denoted `(Int.natAbs a * Int.natAbs a)`) is equivalent to the square of `a` itself (denoted `a * a`). In other words, it says that the absolute value function (when applied to an integer and then squared) doesn't change the result of squaring the original integer.

For any integer `a`, the square of its absolute value is equal to the square of `a` itself: `(Int.natAbs a) ^ 2 = a ^ 2`.


theorem thickenedIndicatorAux_le_one :
    ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α) (x : α), thickenedIndicatorAux δ E x ≤ 1 := by
  sorry

This theorem states that for every pseudo emetric space `α`, every real number `δ`, every set `E` of elements of `α`, and every element `x` of `α`, the δ-thickened indicator of the set `E` evaluated at `x` is less than or equal to 1. In simpler terms, when we "thicken" a set in a pseudo emetric space and create a continuous function that equals 1 on the set and 0 outside the thickened set, the value of this function at any point in the space will always be less than or equal to 1.

For every pseudo metric space `α`, every real number `δ`, and every set `E` in `α`, the δ-thickened indicator function of `E` is a continuous function with domain `α` that maps each element `x` in `α` to a value less than or equal to 1.


theorem AddSubgroup.zmultiples_le :
    ∀ {G : Type u_1} [inst : AddGroup G] {g : G} {H : AddSubgroup G}, AddSubgroup.zmultiples g ≤ H ↔ g ∈ H := by sorry

The theorem `AddSubgroup.zmultiples_le` states that for any type `G` with an additive group structure (denoted by `AddGroup G`), a particular element `g` of `G`, and a subgroup `H` of `G`, the subgroup generated by `g` (denoted by `AddSubgroup.zmultiples g`) is a subset of `H` if and only if `g` is an element of `H`. This essentially says that the only way for a subgroup generated by a single element to be contained within a larger subgroup is if that original element is already in the larger subgroup.

For any additive group (G, +), element g in G, and subgroup H of G, the subgroup generated by g (AddSubgroup.zmultiples g) is contained in H if and only if g is an element of H.


theorem coe_nat_mem :
    ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : SetLike S R] [hSR : SubsemiringClass S R] (s : S)
      (n : ℕ), ↑n ∈ s :=
  by sorry

This theorem states that for any types `R` and `S` where `R` is a Non-Associative Semiring and `S` is a set-like structure over `R` exhibiting the behavior of a subsemiring, the natural number coercion of any natural number `n` belongs to the set `s` of type `S`. In other words, if you cast a natural number to the semiring `R` and then put it in a subsemiring `s` of `R`, it will always be in `s`.

For any non-associative semiring R and subsemiring s of R as a set-like structure, the natural number coercion of any natural number belongs to s.


theorem Finset.dvd_gcd_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α} {a : α}, a ∣ Finset.gcd s f ↔ ∀ b ∈ s, a ∣ f b :=
  by sorry

The theorem `Finset.dvd_gcd_iff` states that for all sets `s` of type `β` and all functions `f` from `β` to `α`, where `α` is a type with a cancel commutative monoid with zero structure and a normalized gcd monoid structure, a number `a` of type `α` divides the greatest common divisor (gcd) of the set `s` under the function `f` if and only if `a` divides the value of the function `f` for every element `b` in the set `s`.

For a set $s$ of type $\beta$, and a function $f$ from $\beta$ to a type $\alpha$ with cancel commutative monoid and normalized gcd monoid structures, $a$ in $\alpha$ divides the greatest common divisor of $f(s)$ if and only if $a$ divides $f(b)$ for all $b$ in $s$.


theorem Mathlib.GroupTheory.MonoidLocalization._auxAddLemma.12 :
    ∀ {α : Type u_1} [inst : OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s},
      (AddLocalization.mk a₁ a₂ ≤ AddLocalization.mk b₁ b₂) = (↑b₂ + a₁ ≤ ↑a₂ + b₁) :=
  by sorry

This theorem states that for any ordered, cancellative, commutative monoid `α`, a submonoid `s` of `α`, and elements `a₁`, `b₁` from `α` and `a₂`, `b₂` from `s`, the inequality `AddLocalization.mk a₁ a₂ ≤ AddLocalization.mk b₁ b₂` holds if and only if the inequality `↑b₂ + a₁ ≤ ↑a₂ + b₁` holds. Here, `AddLocalization.mk a₁ a₂` and `AddLocalization.mk b₁ b₂` represent the equivalence classes in the localization of `α` at `s` of the pairs `(a₁, a₂)` and `(b₁, b₂)`, respectively, and `↑a₂` and `↑b₂` denote the elements of `α` that `a₂` and `b₂` correspond to.

For any ordered, cancellative, commutative monoid `α`, submonoid `s`, and elements `a₁, a₂, b₁, b₂` in `α` with `(a₂, a₁)` and `(b₂, b₁)` in `s`, the inequality `AddLocalization.mk a₁ a₂ ≤ AddLocalization.mk b₁ b₂` holds if and only if the inequality `↑a₂ + a₁ ≤ ↑b₂ + b₁` holds, where `AddLocalization.mk` denotes the equivalence classes in the localization of `α` at `s`.


theorem List.foldr_permutationsAux2 :
    ∀ {α : Type u_1} (t : α) (ts : List α) (r L : List (List α)),
      List.foldr (fun y r => (List.permutationsAux2 t ts r y id).2) r L =
        (List.bind L fun y => (List.permutationsAux2 t ts [] y id).2) ++ r :=
  by sorry

The theorem `List.foldr_permutationsAux2` states that for any type `α`, and given an element `t` of type `α`, a list `ts` of type `α`, and two lists `r` and `L` of lists of type `α`, the fold operation, which applies the function `(List.permutationsAux2 t ts r y id).2` to all elements `y` of list `L` (from right to left) starting with the initial value `r`, is equal to the concatenation of the list obtained by applying the function `(List.permutationsAux2 t ts [] y id).2` to each element `y` of list `L` (using the list monadic bind operation) and the list `r`. Essentially, this theorem relates the `foldr` operation and the `bind` operation on lists when the function applied generates permutations of the lists.

For any type `α` and lists `ts` and `L` of `α`, the right fold operation of applying `List.permutationsAux2 t ts r` to each element `y` in `L` is equal to the concatenation of the lists obtained by applying `List.permutationsAux2 t ts [] y` to each `y` in `L` using list monadic bind and the list `r`.


theorem Nat.zero_bits : Nat.bits 0 = [] := by sorry

The theorem `Nat.zero_bits` states that when the function `Nat.bits` is applied to the natural number 0, it returns an empty list. This corresponds to the binary representation of 0, which does not have any bits.

The theorem asserts that the binary representation of natural number 0 is the empty list. (or equivalently, Nat.bits 0 = [] in Lean)


/-- An object in the image is in the essential image.  -/
theorem CategoryTheory.Functor.obj_mem_essImage :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor D C) (Y : D),
      F.obj Y ∈ CategoryTheory.Functor.essImage F :=
  by sorry

This theorem states that for any two categories `C` and `D` and a functor `F` from `D` to `C`, any object `Y` in category `D` is also in the essential image of the functor `F`. In the context of category theory, the "essential image" of a functor refers to the collection of objects in the target category that are isomorphic to the image of some object in the source category under the functor.

For any functor F from category D to category C and any object Y in D, Y is in the essential image of F.


theorem Polynomial.aevalTower_X :
    ∀ {R : Type u} {S : Type v} {A' : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A']
      [inst_2 : CommSemiring S] [inst_3 : Algebra S R] [inst_4 : Algebra S A'] (g : R →ₐ[S] A') (y : A'),
      (Polynomial.aevalTower g y) Polynomial.X = y :=
  by sorry

The theorem `Polynomial.aevalTower_X` states that for any commutative semirings `R`, `S`, `A'` and any algebra structure on `R` and `A'` over `S`, and for any algebra homomorphism `g : R →ₐ[S] A'` and any element `y : A'`, the evaluation of the polynomial variable, or indeterminate (which is denoted by `Polynomial.X`), under the `Polynomial.aevalTower` function with parameters `g` and `y`, is equal to `y`. In other words, substituting `y` for `Polynomial.X` in a polynomial over `R` using the algebra homomorphism `g` results in `y`.

For any commutative semirings R, S, and algebra structures on R and A' over S, and for any algebra homomorphism g : R -> A' and any element y : A', the evaluation of the indeterminate X in a polynomial over R using g and y is equivalent to y.


theorem CategoryTheory.Limits.biproduct.ι_toSubtype :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      (p : J → Prop) [inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict p f)] [inst_4 : DecidablePred p]
      (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j)
          (CategoryTheory.Limits.biproduct.toSubtype f p) =
        if h : p j then CategoryTheory.Limits.biproduct.ι (Subtype.restrict p f) { val := j, property := h } else 0 :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.ι_toSubtype`, states that in the context of a category `C` with zero morphisms and a function `f` from type `J` to `C` that forms a biproduct, for a predicate `p` which also forms a biproduct when restricted by function `f`, and that is decidable, for any element `j` of type `J`, the composition of the inclusion morphism into a summand of biproduct `f` at `j` and the function `CategoryTheory.Limits.biproduct.toSubtype f p` is equal to the inclusion into the summand of the biproduct of the restricted function `Subtype.restrict p f` at subtype `{ val := j, property := h }` if `p j` holds, and is the zero morphism otherwise. This theorem essentially describes the relationship between the inclusion into a summand of a biproduct and the restriction of a function to a subtype in the context of category theory.

For a decidable predicate `p` that forms a biproduct with a function `f` in a category `C` with zero morphisms, the inclusion into a summand of the biproduct of `f` at `j` is equal to the inclusion into the summand of the restricted function `Subtype.restrict p f` at `{ val := j, property := true }` if `p(j)` holds, and is the zero morphism otherwise.