theorem Finset.coe_eq_singleton : ∀ {α : Type u_1} {s : Finset α} {a : α}, ↑s = {a} ↔ s = {a} := by sorry

This theorem states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, the coercion of the finite set `s` to a set is equal to the singleton set that only contains the element `a` if and only if the finite set `s` itself is equal to that singleton set. In other words, it describes the equivalence between a finite set being a singleton and its coerced set being a singleton in Lean 4.

For any type `α` and any finite set `s` of type `α` with exactly one element `a`, the coercion of `s` to a set is equal to the singleton set `{a}` if and only if `s` itself is equal to `{a}`.


theorem Ideal.zero_eq_bot : ∀ {R : Type u} [inst : Semiring R], 0 = ⊥ := by sorry

This theorem states that, for any semiring `R` (a type `R` equipped with operations that make it a semiring), the zero ideal (denoted by `0`) is equivalent to the bottom element of the lattice of ideals (denoted by `⊥`). In mathematical terms, it means that the set of all multiples of 0 (which is just 0 itself) is the smallest ideal in the semiring `R`.

For any semiring R, the zero ideal equals the bottom element of the lattice of ideals.


Function.Injective.iterate

theorem Function.Injective.iterate :
    ∀ {α : Type u} {f : α → α}, Function.Injective f → ∀ (n : ℕ), Function.Injective f^[n] := by sorry

The theorem states that for any type `α` and any function `f` from `α` to `α`, if `f` is injective (that is, it never maps different inputs to the same output) then for any natural number `n`, the `n`-th iteration of `f` (denoted by `f^[n]`) is also injective. In other words, repeatedly applying an injective function still results in an injective function, no matter how many times you apply it.

If `f` is an injective function from type `α` to itself, then for any natural number `n`, the `n`-th power of `f` is also an injective function.


theorem AEMeasurable.const_smul :
    ∀ {M : Type u_2} {β : Type u_3} {α : Type u_4} [inst : MeasurableSpace M] [inst_1 : MeasurableSpace β]
      [inst_2 : SMul M β] {m : MeasurableSpace α} {g : α → β} [inst : MeasurableSMul M β] {μ : MeasureTheory.Measure α},
      AEMeasurable g μ → ∀ (c : M), AEMeasurable (c • g) μ :=
  by sorry

The theorem `AEMeasurable.const_smul` states that for any given types `M`, `β`, and `α`, with `M` and `β` being measurable spaces and `M` and `β` having a scalar multiplication (`SMul`), and given a measurable space `m` on `α`, a function `g: α → β`, a scalar multiplication measurability instance `inst` for `M` and `β`, and a measure `μ` on `α`, if `g` is almost everywhere measurable with respect to measure `μ`, then for any constant `c` from `M`, the function obtained by scalar multiplication of `c` and `g` (i.e., `c • g`) is also almost everywhere measurable with respect to the same measure `μ`.

If `M` and `β` are measurable spaces with scalar multiplication, `m` is a measurable space on `α`, `g: α → β` is almost everywhere measurable with respect to measure `μ` on `α`, and `c` is a constant from `M`, then `c • g` is almost everywhere measurable with respect to `μ`.


theorem finsum_mem_eq_sum_of_inter_support_eq :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) {s : Set α} {t : Finset α},
      s ∩ Function.support f = ↑t ∩ Function.support f →
        (finsum fun i => finsum fun h => f i) = Finset.sum t fun i => f i :=
  by sorry

The theorem `finsum_mem_eq_sum_of_inter_support_eq` states that for any type `α`, `M`, any function `f` mapping from `α` to `M`, a set `s` of type `α`, and a finset `t` of type `α`, given that the intersection of `s` and the support of `f` is equal to the intersection of `t` and the support of `f`, the sum of `f(i)` for each `i` in the domain (calculated using the `finsum` function) is equal to the sum of `f(i)` for each `i` in the finset `t` (calculated using the `Finset.sum` function). Here, the support of a function `f` is the set of elements `x` such that `f(x)` is not zero. The `finsum` function calculates the sum over the support of `f` if it's finite and gives zero otherwise, while the `Finset.sum` function calculates the sum over a finite set.

For any function `f` from type `α` to `M` and finite sets `s` and `t` of type `α` with `s ∩ supp(f) = t ∩ supp(f)`, we have `finsum f = Finset.sum (map f t)`, where `supp(f)` denotes the support of `f`.


theorem ite_smul :
    ∀ {α : Type u_4} {β : Type u_5} [inst : SMul β α] (p : Prop) [inst_1 : Decidable p] (a : α) (b c : β),
      (if p then b else c) • a = if p then b • a else c • a :=
  by sorry

This theorem, named `ite_smul`, is a property of the scalar multiplication operation in some arbitrary types `α` and `β`. Given a proposition `p` that can be decided, and elements `a` of type `α`, `b` of type `β`, and `c` of type `β`, the theorem states that the scalar multiplication of the conditional value (if `p` then `b` else `c`) with `a` is the same as the conditional value of the scalar multiplication (if `p` then `b • a` else `c • a`). In other words, the scalar multiplication operation can be "distributed" over a conditional statement.

For all propositions `p`, types `α` and `β`, and elements `a` of type `α` and `b`, `c` of type `β`, if `p` can be decided, then `(if p then b else c) • a = if p then (b • a) else (c • a)`.


theorem MeasureTheory.Integrable.toL1.proof_1 :
    ∀ {α : Type u_2} {β : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      (f : α → β), MeasureTheory.Integrable f μ → MeasureTheory.Memℒp f 1 μ :=
  by sorry

The theorem `MeasureTheory.Integrable.toL1.proof_1` states that for any measurable space `α`, type `β` in a normed add commutative group, a measure `μ` on `α`, and a function `f` from `α` to `β`, if `f` satisfies the condition of `Integrable` under measure `μ`, then `f` also satisfies the condition of `Memℒp` with `p` equal to 1 under the same measure `μ`. That is, if `f` is measurable and has finite integral under measure `μ`, then `f` is almost everywhere strongly measurable and the $L^1$ norm of `f` (which is the integral of the absolute value of `f`) is finite under measure `μ`.

If a measurable function `f` from a measurable space `(α, μ)` to a normed add commutative group `β` is integrable with respect to `μ`, then `f` is almost everywhere strongly measurable and its $L^1$ norm is finite under `μ`.


theorem CategoryTheory.IsPullback.of_horiz_isIso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z}
      {g : Y ⟶ Z} [inst_1 : CategoryTheory.IsIso fst] [inst_2 : CategoryTheory.IsIso g],
      CategoryTheory.CommSq fst snd f g → CategoryTheory.IsPullback fst snd f g :=
  by sorry

This theorem states that in any category `C`, given objects `P`, `X`, `Y`, and `Z`, and morphisms `fst: P -> X`, `snd: P -> Y`, `f: X -> Z`, and `g: Y -> Z`, if `fst` and `g` are isomorphisms and the diagram formed by these morphisms is a commutative square, then the square is a pullback square. In the language of category theory, a pullback square is a way of defining the product of two morphisms in a category, and commutative squares are diagrams in which all paths through the diagram result in the same morphism when composed.

In any category, if the diagonal morphisms and two given morphisms form a commutative square and are isomorphisms, then the square is a pullback square.


theorem Polynomial.eval_eq_sum :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {x : R},
      Polynomial.eval x p = Polynomial.sum p fun e a => a * x ^ e :=
  by sorry

This theorem, `Polynomial.eval_eq_sum`, states that for any semiring `R`, any polynomial `p` of `R`, and any element `x` of `R`, the evaluation of the polynomial `p` at `x` is equal to the sum of each term of `p`, where each term is the product of its coefficient `a` and `x` raised to the power of its exponent `e`. In other words, if you want to evaluate a polynomial at a particular point, you can do so by summing up the results of multiplying each coefficient by the value at which you are evaluating the polynomial, raised to the appropriate power. This corresponds to the standard procedure for evaluating polynomials in mathematics.

For any semiring `R`, polynomial `p` of `R`, and `x` in `R`, `Polynomial.eval p x = sum (map (λ (a, e), a * x ^ e) p.terms)`.


theorem MeasureTheory.FinStronglyMeasurable.tendsto_approx :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → β} [inst : Zero β]
      [inst_1 : TopologicalSpace β] (hf : MeasureTheory.FinStronglyMeasurable f μ) (x : α),
      Filter.Tendsto (fun n => ↑(MeasureTheory.FinStronglyMeasurable.approx hf n) x) Filter.atTop (nhds (f x)) :=
  by sorry

The theorem `MeasureTheory.FinStronglyMeasurable.tendsto_approx` states that for any function `f` from type `α` to `β`, where `β` is a topological space and has a zero, and `f` is `FinStronglyMeasurable` with respect to a measurable space `m0` and a measure `μ`, for any `x` in `α`, the sequence of approximations of `f` at `x` given by `MeasureTheory.FinStronglyMeasurable.approx` tends towards the value of `f` at `x` as `n` goes to infinity. This is to say, for every neighborhood of `f(x)`, there exists some natural number `N` such that for all `n > N`, `MeasureTheory.FinStronglyMeasurable.approx hf n x` is in that neighborhood. The `FinStronglyMeasurable` property means that `f` can be approximated by a sequence of simple functions with finite measure support.

For any FinStronglyMeasurable function `f` from `α` to a topological space `β` with a zero, and for all `x` in `α`, the sequence of approximations `MeasureTheory.FinStronglyMeasurable.approx hf n x` converges to `f(x)` as `n` goes to infinity.


theorem Asymptotics.IsLittleO.tendsto_div_nhds_zero :
    ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {l : Filter α} {f g : α → 𝕜},
      f =o[l] g → Filter.Tendsto (fun x => f x / g x) l (nhds 0) :=
  by sorry

The theorem `Asymptotics.IsLittleO.tendsto_div_nhds_zero` states that for any type `α`, a normed division ring `𝕜`, a filter `l` on `α`, and functions `f` and `g` from `α` to `𝕜`, if `f` is little-o of `g` at filter `l` (which means the ratio of `f` to `g` tends to zero when values are taken close to the points specified by the filter `l`), then the function that takes `x` to `f(x)/g(x)` tends to zero in the neighborhood filter at zero. This theorem essentially says that if `f` is much smaller than `g` near the points defined by `l`, then the ratio `f/g` tends to zero in the neighborhood of zero.

If a function `f` is little-o of `g` at filter `l` on type `α`, then the quotient function `x ⟩‐⟩ 0 => f x / g x` tends to zero in the neighborhood filter at zero in a normed division ring `𝕜`.


theorem Nat.minFac_le_of_dvd : ∀ {n m : ℕ}, 2 ≤ m → m ∣ n → Nat.minFac n ≤ m := by sorry

The theorem `Nat.minFac_le_of_dvd` states that for any two natural numbers `n` and `m`, where `m` is greater than or equal to 2, if `m` divides `n`, then the smallest prime factor of `n` is less than or equal to `m`. In other words, no divisor of `n` that is greater than or equal to 2 can be smaller than the smallest prime factor of `n`.

If `m` divides `n` and `m` is greater than or equal to 2, then the smallest prime factor of `n` is less than or equal to `m`.


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

This theorem states that for any type `G` that is a group, given two elements `g₁` and `g₂` of `G` and two subgroups `H₁` and `H₂` of `G`, if `g₁` is in `H₁` and `g₂` is in `H₂`, then the commutator (denoted by `⁅ , ⁆`) of `g₁` and `g₂` is in the commutator subgroup of `H₁` and `H₂`. In more mathematical terms: for all groups G, all elements g₁, g₂ in G, and all subgroups H₁, H₂ of G, if g₁ is in H₁ and g₂ is in H₂, then the element resulting from the group commutator operation with g₁ and g₂ is an element of the subgroup resulting from the commutator operation with H₁ and H₂.

For any groups G, subgroups H₁ and H₂, and elements g₁ in H₁ and g₂ in H₂, the commutator [g₁, g₂] lies in the subgroup generated by the commutators of elements from H₁ and H₂.


/-- Closure of a submonoid `S` equals `S`.  -/
theorem Submonoid.closure_eq : ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M), Submonoid.closure ↑S = S := by
  sorry

The theorem `Submonoid.closure_eq` asserts that for any type `M` equipped with a multiplicative identity and a multiplication operation (the `MulOneClass M` instance), and any submonoid `S` of `M`, the closure of `S` (i.e., the smallest submonoid of `M` that contains `S`) is equal to `S` itself. This means that the submonoid `S` is already closed under the operations of the `MulOneClass`, and no additional elements from `M` are needed to complete it.

For any submonoid `S` of a multiplicative monoid `M`, the submonoid generated by `S` (i.e., the smallest submonoid containing `S`) is equal to `S` itself.


theorem Option.pmap.proof_1 : ∀ {α : Type u_1} {p : α → Prop} (a : α), (∀ a_1 ∈ some a, p a_1) → p a := by sorry

This theorem states that for any type `α` and for any predicate `p` over `α`, if `p` holds for all elements `a_1` contained in the option `some a`, then it also holds for the element `a` itself. In other words, if a predicate applies to all members of an option, then it also applies to any individual member of that option.

If a predicate `p` holds for all elements in an option `some a`, then `p` holds for the contained element `a`.


theorem List.nodup_range : ∀ (n : ℕ), List.Nodup (List.range n) := by sorry

The theorem `List.nodup_range` states that for all natural numbers `n`, the list obtained by the function `List.range n`, which contains the numbers from `0` to `n` exclusive in increasing order, does not contain any duplicate elements. In other words, every element in the list `List.range n` appears at most once.

The list generated by `List.range n` is a strictly increasing sequence of length `n+1` without repetitions.


theorem Computable.of_eq :
    ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] {f g : α → σ},
      Computable f → (∀ (n : α), f n = g n) → Computable g :=
  by sorry

The theorem `Computable.of_eq` states that for any two functions `f` and `g` from a type `α` to a type `σ`, where `α` and `σ` are primcodable (meaning, they can be encoded as natural numbers), if `f` is computable and `f` and `g` are equal for every `α`, then `g` is also computable. This theorem therefore shows that computability is preserved under function equality.

If `f` and `g` are equal computable functions from a primcodable type `α` to a type `σ`, then `g` is computable.


theorem sub_lt_self_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α}, a - b < a ↔ 0 < b :=
  by sorry

This theorem, `sub_lt_self_iff`, states that for any type `α` that has an addition operation (`AddGroup`), a less-than operation (`LT`), and satisfies the CovariantClass property with respect to addition and less-than operation, for any two elements of this type `a` and `b`, the statement "a minus b is less than a" is equivalent to "0 is less than b". This theorem is a useful property in the domain of ordered groups, where subtraction, addition, and comparison interact.

For any additive group `α` with `LT`, we have `a - b < a iff 0 < b`.


theorem leibniz_lie :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x y : L)
      (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆ :=
  by sorry

The theorem `leibniz_lie` states that for any Lie ring `L`, additive commutative group `M`, and a Lie ring module `M` over `L`, given any elements `x` and `y` in `L` and an element `m` in `M`, the nested Lie bracket of `x` with the Lie bracket of `y` and `m` equals the sum of the Lie bracket of `x` with `y` acted on `m` and the Lie bracket of `y` with the Lie bracket of `x` and `m`. It is a formulation of the Leibniz identity in the context of Lie algebras.

For any Lie ring `L`, additive commutative group `M`, and Lie module `M` over `L`, the Lie bracket of `x` and the Lie bracket of `y` with `m` in `L x M` satisfies the Leibniz identity: `[x, [y, m]] = [x, y] . m + [y, x] . m`.


theorem Submodule.eq_bot_iff :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), p = ⊥ ↔ ∀ x ∈ p, x = 0 :=
  by sorry

This theorem states that for any given set of objects `p` considered as a submodule of a `Module` M over a `Semiring` R, `p` is equal to the zero submodule (denoted by `⊥`) if and only if every element `x` within `p` is equal to zero. Here, `Module` and `Semiring` are algebraic structures in mathematics. `Module` is a generalization of vector spaces and `Semiring` is a set with two binary operations that generalize the arithmetic operations of addition and multiplication.

A submodule `p` of a Module M over a Semiring R is the zero submodule if and only if every element in `p` is the additive identity (zero).


theorem TruncatedWittVector.out_injective :
    ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R], Function.Injective TruncatedWittVector.out := by sorry

The theorem `TruncatedWittVector.out_injective` states that for all natural numbers `p` and `n`, and for any type `R` with a commutative ring structure, the function `TruncatedWittVector.out` is injective. In other words, if we have two truncated Witt vectors and applying the `out` function to both of them gives the same Witt vector, then the original truncated Witt vectors must have been the same. This function `out` turns a truncated Witt vector into a Witt vector by setting all coefficients after the vector to be 0.

For all natural numbers `p` and `n` and commutative rings `R`, the function `TruncatedWittVector.out` maps distinct truncated Witt vectors of length `n` in `R` to distinct Witt vectors.


theorem hnot_anti : ∀ {α : Type u_2} [inst : CoheytingAlgebra α], Antitone hnot := by sorry

The theorem `hnot_anti` states that for every type `α` that forms a co-Heyting algebra, the Heyting algebra negation function `hnot` is antitone. In other words, if `α` is a type that forms a co-Heyting algebra (a lattice with certain additional properties), and `a` and `b` are elements of `α` such that `a ≤ b`, then `hnot(b) ≤ hnot(a)`.

For every co-Heyting algebra type `α`, the Heyting algebra negation function `hnot` is monotonic, that is, `hnot(a) ≤ hnot(b)` whenever `a ≤ b`.


Set.Nonempty.prod

theorem Set.Nonempty.prod :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Set.Nonempty s → Set.Nonempty t → Set.Nonempty (s ×ˢ t) :=
  by sorry

The theorem `Set.Nonempty.prod` asserts that for any two types `α` and `β`, and sets `s` of type `α` and `t` of type `β`, if `s` and `t` are both nonempty (i.e., each contains at least one element), then the Cartesian product of `s` and `t`, denoted `s ×ˢ t`, is also nonempty. In other words, it's not possible to create a Cartesian product from two sets where one or both of them are empty.

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


theorem NNReal.coe_mul : ∀ (r₁ r₂ : NNReal), ↑(r₁ * r₂) = ↑r₁ * ↑r₂ := by sorry

This theorem states that for any two nonnegative real numbers (`NNReal`), the operation of multiplying them together and then taking the underlying real number (as denoted by `↑`) is the same as first taking their underlying real numbers and then multiplying those. In other words, if `r₁` and `r₂` are nonnegative real numbers, then the real number associated with the product `r₁ * r₂` is the same as the product of the real numbers associated with `r₁` and `r₂` respectively. This is a property of multiplication in the context of nonnegative real numbers in Lean 4.

For any nonnegative real numbers `r₁` and `r₂`, `↑(r₁ * r₂) = ↑r₁ * ↑r₂`.


theorem pow_le_one : ∀ {R : Type u_3} [inst : OrderedSemiring R] {a : R} (n : ℕ), 0 ≤ a → a ≤ 1 → a ^ n ≤ 1 := by sorry

This theorem, `pow_le_one`, states that for any type `R` that has an ordered semiring structure, and for any element `a` of `R` and any natural number `n`, if `a` is non-negative and less than or equal to 1, then `a` to the power of `n` is also less than or equal to 1. In mathematical terms, it states that for all $a \in R$ and $n \in \mathbb{N}$, if $0 \leq a \leq 1$, then $a^n \leq 1$.

For any ordered semiring type $R$ and all $a \in R$ with $0 \leq a \leq 1$ and natural number $n$, $a^n \leq 1$.


/-- **Alias** of `Polynomial.modByMonic_eq_zero_iff_dvd`. -/
theorem Polynomial.dvd_iff_modByMonic_eq_zero :
    ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R}, Polynomial.Monic q → (p %ₘ q = 0 ↔ q ∣ p) := by sorry

This theorem, named `Polynomial.dvd_iff_modByMonic_eq_zero`, states that for any type `R` that is a ring, and for any polynomials `p` and `q` over `R`, if `q` is a monic polynomial, then `p` mod `q` equals to zero if and only if `q` divides `p`. Here, a polynomial is considered monic if its leading coefficient is 1 (`Polynomial.Monic`). The symbol `%ₘ` represents the modulo operation in the context of polynomials, and `∣` denotes polynomial division.

For any ring `R`, polynomial `p`, and monic polynomial `q` over `R`, `p %ₘ q = 0` if and only if `q` divides `p`.


theorem Filter.tendsto_pure_pure :
    ∀ {α : Type u} {β : Type v} (f : α → β) (a : α), Filter.Tendsto f (pure a) (pure (f a)) := by sorry

The theorem `Filter.tendsto_pure_pure` asserts that for any function `f` from type `α` to type `β` and any element `a` of type `α`, the function `f` tends to the filter `pure (f a)` when applied to the filter `pure a`. In other words, for every neighborhood of `f a`, the preimage under `f` of this neighborhood contains `a`, which is the essence of the definition of 'tending to' in the context of filters.

For any function `f: α → β` and `a ∈ α`, the filter `{x : α | ∃ ε > 0, ∀ x' ∈ β, 0 < d(x, f x') < ε ⇒ x ∈ filter.pure a}` tends to `f a`.


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

The theorem `Filter.map₂_mono` states that for all types `α`, `β`, and `γ`, for all binary functions `m : α → β → γ`, for all filters `f₁`, `f₂` on `α` and `g₁`, `g₂` on `β`, if `f₁` is a subfilter of `f₂` and `g₁` is a subfilter of `g₂` (meaning every set in `f₁` is also in `f₂` and every set in `g₁` is also in `g₂`), then the image of `m` under the filters `f₁` and `g₁` is a subfilter of the image of `m` under the filters `f₂` and `g₂`. In mathematical terms, this can be expressed as if $f_1 \subseteq f_2$ and $g_1 \subseteq g_2$ then $m(f_1, g_1) \subseteq m(f_2, g_2)$ where $m$ is the map function, $f_1, f_2$ are filters on $\alpha$ and $g_1, g_2$ are filters on $\beta$.

If filters $f\_1 \subseteq f\_2$ on type $\alpha$ and filters $g\_1 \subseteq g\_2$ on type $\beta$, then the image of the binary function $m : \alpha \times \beta \rightarrow \gamma$ under filters $f\_1 \times g\_1$ is a subfilter of the image under filters $f\_2 \times g\_2$.


theorem Set.pairwise_univ : ∀ {α : Type u_1} {r : α → α → Prop}, Set.Pairwise Set.univ r ↔ Pairwise r := by sorry

The theorem `Set.pairwise_univ` states that, for any type `α` and any relation `r` on `α`, the relation `r` is pairwise on the universal set of `α` if and only if the relation `r` is pairwise on `α`. Here, a relation `r` is said to be pairwise on a set if `r x y` holds for all distinct `x` and `y` in the set, and it is said to be pairwise on a type if `r i j` holds for all distinct `i` and `j` of the type. The universal set of a type `α` is the set containing all elements of `α`.

A relation on a type is pairwise with respect to the universal set if and only if it is pairwise on the type itself.


/-- If we start with a multiset of primes, take the product and
then factor it, we get back the original multiset.  -/
theorem PrimeMultiset.factorMultiset_prod : ∀ (v : PrimeMultiset), PNat.factorMultiset (PrimeMultiset.prod v) = v := by
  sorry

This theorem states that for any multiset of prime numbers, if we compute the product of these prime numbers into a positive natural number and then factorize this product back into its prime factors, we will retrieve the original multiset of prime numbers. In essence, this process demonstrates a round-trip property of prime factorization and product, which is the fundamental principle of the unique factorization theorem in number theory.

Given any multiset of prime numbers, the product of these primes and the prime factorization of the result are equal.


theorem Int.ceil_add_int :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α) (z : ℤ), ⌈a + ↑z⌉ = ⌈a⌉ + z := by sorry

This theorem states that for any type `α` that has the structure of a `LinearOrderedRing` and a `FloorRing`, and given any element `a` of this type and an integer `z`, the ceiling function of the sum of `a` and `z` (where `z` is treated as an element of `α`) is equal to the sum of the ceiling of `a` and `z`. In mathematical notation, this reads: for all `a` in `α` and `z` in integers (`ℤ`), `⌈a + z⌉ = ⌈a⌉ + z`.

For any `LinearOrderedRing` and `FloorRing` type `α`, and for all `a` in `α` and `z` in integers, the ceiling function of `a + z` equals the sum of the ceiling of `a` and `z`. (i.e., `⌈a + z⌉ = ⌈a⌉ + z`)


theorem Computation.think_bind :
    ∀ {α : Type u} {β : Type v} (c : Computation α) (f : α → Computation β),
      Computation.bind (Computation.think c) f = Computation.think (Computation.bind c f) :=
  by sorry

The theorem `Computation.think_bind` states that for all types `α` and `β`, and for any computation `c` of type `α` and any function `f` from `α` to a computation of type `β`, the result of binding the computation `Computation.think c` (which represents delaying the computation `c` by one "tick") with the function `f` is the same as delaying (by one "tick") the result of binding the original computation `c` with `f`. In essence, it captures the property that delaying a computation before applying a function via bind is the same as applying the function via bind and then delaying the result, demonstrating that the `think` operation is compatible with the bind operation in this computation model.

For all types `α` and `β`, and computations `c` of type `α` and `f` from `α` to a computation of type `β`, `Computation.think (bind c f) = bind (Computation.think c) f`.


theorem List.range_succ_eq_map : ∀ (n : ℕ), List.range (n + 1) = 0 :: List.map Nat.succ (List.range n) := by sorry

This theorem states that for any natural number `n`, the range of `n+1` (which is a list of natural numbers from `0` to `n+1`, exclusive) is equal to a list that starts with `0` and then maps the successor function `Nat.succ` (which adds one to a natural number) to each element in the range of `n`. In other words, it's stating that getting the range of `n+1` is the same as taking the range of `n`, adding one to each element, and prepending `0` to the list.

The range of `n+1` is the list obtained by adding 1 to each element of the range of `n` and prepending 0.


theorem Mathlib.Data.Finsupp.Basic._auxLemma.2 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) := by sorry

This theorem states that for any type `α` and any type `M` equipped with a zero-element (denoted by `Zero M`), given a function `f` from `α` to `M` and an element `a` of type `α`, `a` is in the support of `f` if and only if the function `f` evaluated at `a` is not equal to zero. In mathematical terms, the support of a function is the set of points where the function is not zero. Therefore, this theorem provides a condition to check whether a point is in the support of a function.

The theorem asserts that for any function `f` from type `α` to type `M` equipped with a zero-element, an element `a` in `α` is in the support of `f` if and only if `f a ≠ Zero M`.


ENNReal.dichotomy

theorem ENNReal.dichotomy : ∀ (p : ENNReal) [inst : Fact (1 ≤ p)], p = ⊤ ∨ 1 ≤ p.toReal := by sorry

The theorem `ENNReal.dichotomy` states that for any extended nonnegative real number `p`, given that `p` is greater than or equal to 1 (`1 ≤ p`), there are only two possibilities: `p` is either equal to the infinity symbol `⊤`, which represents an infinite quantity in extended nonnegative real numbers, or `p` is greater than or equal to 1 when converted to a real number (`1 ≤ p.toReal`).

For every extended nonnegative real number `p` greater than or equal to 1, either `p = ⊤` or `1 ≤ p.toReal`.


Continuous.update

theorem Continuous.update :
    ∀ {X : Type u} {ι : Type u_5} {π : ι → Type u_6} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (π i)]
      {f : X → (i : ι) → π i} [inst_1 : DecidableEq ι],
      Continuous f → ∀ (i : ι) {g : X → π i}, Continuous g → Continuous fun a => Function.update (f a) i (g a) :=
  by sorry

This theorem states that if we have a continuous function `f` from a topological space `X` to a dependent function type `(i : ι) → π i` where each `π i` is a topological space, and we have another continuous function `g` from `X` to one of the `π i`, then the function that updates the value of `f` at `i` with the value of `g` at the same point is also continuous.

The updating operation is carried out using the `Function.update` function, which replaces the value of a function at a given point by a given value. Decidability of equality in `ι` is needed to perform this updating operation. The theorem is universally quantified over all `X`, `ι`, `π`, `f`, `i` and `g` that satisfy the given conditions.

If `f` is a continuous function from a topological space `X` to a dependent function type `(i : ι) → π i`, where each `π i` is a topological space, and `g` is a continuous function from `X` to some `π i`, then the function obtained by updating `f` with `g` using `Function.update` is also continuous.


theorem RingHom.comp_id :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β),
      RingHom.comp f (RingHom.id α) = f :=
  by sorry

This theorem states that for all types `α` and `β` with structures of non-associative semirings, and for any ring homomorphism `f` from `α` to `β`, the composition of `f` with the identity ring homomorphism on `α` is equal to `f`. This is essentially the mathematical principle that applying identity does not change the function.

For any non-associative semirings `α` and `β`, and ring homomorphism `f` from `α` to `β`, the identity ring homomorphism on `α` and `f` commute, i.e., the composition of the identity homomorphism and `f` equals `f`.


theorem Equiv.Perm.cycleOf_eq_one_iff :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {x : α} (f : Equiv.Perm α),
      Equiv.Perm.cycleOf f x = 1 ↔ f x = x :=
  by sorry

This theorem states that for any type `α`, where `α` has decidable equality and is finite, for any element `x` of `α` and for any permutation `f` of `α`, the cycle of permutation `f` to which `x` belongs is equivalent to the identity permutation if and only if applying `f` to `x` returns `x`. In other words, `x` remains unchanged under the permutation `f` if and only if `x` belongs to a cycle of `f` that is the same as the identity permutation.

For any finite type `α` with decidable equality, an element `x` of `α` is in the same cycle as the identity under a permutation `f` if and only if `f(x) = x`.


theorem completeSpace_coe_iff_isComplete :
    ∀ {α : Type u} [inst : UniformSpace α] {s : Set α}, CompleteSpace ↑s ↔ IsComplete s := by sorry

This theorem states that for any type `α` equipped with a `UniformSpace` structure and for any set `s` of `α`, the set `s` is a complete space (i.e., every Cauchy filter on `s` has a limit in `s`) if and only if `s` is complete. In mathematical terms, a set `s` in a uniform space `α` is considered to be a complete space if every Cauchy filter of `s` converges to a limit within `s`, and this is equivalent to the condition that `s` itself is complete.

A set `s` in a uniform space `α` is complete if and only if every Cauchy filter on `s` has a limit in `s`.


theorem MvPolynomial.C_mul' :
    ∀ {R : Type u} {σ : Type u_1} {a : R} [inst : CommSemiring R] {p : MvPolynomial σ R},
      MvPolynomial.C a * p = a • p :=
  by sorry

This theorem states that for any commutative semiring `R`, any type `σ`, any element `a` of `R`, and any multivariate polynomial `p` with variables indexed by `σ` and coefficients in `R`, the result of multiplying the constant polynomial with value `a` by `p` (using the function `MvPolynomial.C a * p`) is the same as scaling `p` by `a` (using the scalar multiplication `a • p`). In other words, in this context, polynomial multiplication with a constant behaves like scalar multiplication.

For any commutative semiring `R`, any type `σ`, any element `a` of `R`, and any multivariate polynomial `p` over `R` indexed by `σ`, the constant polynomial `a` multiplied with `p` is equivalent to scaling `p` by `a`.


theorem Subgroup.commutator_le :
    ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ H₃ : Subgroup G}, ⁅H₁, H₂⁆ ≤ H₃ ↔ ∀ g₁ ∈ H₁, ∀ g₂ ∈ H₂, ⁅g₁, g₂⁆ ∈ H₃ := by
  sorry

This theorem states that for any type `G` that forms a group with some operation, and for any subgroups `H₁`, `H₂`, and `H₃` of `G`, the commutator subgroup generated by `H₁` and `H₂` is a subset of `H₃` if and only if for every element `g₁` in `H₁` and every element `g₂` in `H₂`, the commutator of `g₁` and `g₂` is an element of `H₃`. The commutator of two elements in a group is defined as the product of the first element and the second, followed by the product of the inverse of the first and the inverse of the second.

The commutator subgroup of subgroups H₁ and H₂ in a group G is contained in H₃ if and only if every commutator of an element from H₁ and an element from H₂ belongs to H₃.


/-- The **Cauchy criterion** for infinite sums, also known as the
**Cauchy convergence test** -/
theorem summable_iff_cauchySeq_finset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [inst_2 : CompleteSpace α]
      {f : β → α}, Summable f ↔ CauchySeq fun s => Finset.sum s fun b => f b :=
  by sorry

This theorem is known as the Cauchy criterion for infinite sums, or the Cauchy convergence test. It states that for any function `f` from type `β` to `α`, where `α` is a type with an addition operation and a uniform space structure, and `β` is any type, `f` is summable (meaning that the infinite sum of `f` exists and is finite) if and only if the function that maps each finite set `s` of elements of type `β` to the sum of `f(b)` for `b` in `s` is a Cauchy sequence. Here, a Cauchy sequence is a sequence where the difference between later terms gets arbitrarily small as the sequence progresses. This theorem is fundamental in the study of series and convergence in analysis.

A function from a type to a type with an addition operation and a uniform space structure is summable if and only if the sequence of finite sums of its values forms a Cauchy sequence.


theorem Polynomial.degree_add_eq_right_of_degree_lt :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.degree p < Polynomial.degree q → Polynomial.degree (p + q) = Polynomial.degree q :=
  by sorry

The theorem states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the degree of polynomial `p` is less than the degree of polynomial `q`, then the degree of the sum of the polynomials `p` and `q` is equal to the degree of the polynomial `q`. In mathematical terms, this can be written as: if $\deg(p) < \deg(q)$, then $\deg(p + q) = \deg(q)$.

For any semiring `R`, if `p` and `q` are polynomials over `R` with $\deg(p) < \deg(q)$, then $\deg(p + q) = \deg(q)$.


theorem Cardinal.mul_eq_max_of_aleph0_le_left :
    ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a → b ≠ 0 → a * b = max a b := by sorry

The theorem `Cardinal.mul_eq_max_of_aleph0_le_left` states that for any two cardinal numbers `a` and `b` in a given type `u_1`, if `a` is greater than or equal to `ℵ₀` (aleph null, the smallest infinite cardinal) and `b` is not equal to zero, then the product of `a` and `b` is equal to the maximum of `a` and `b`. This reflects the property of infinite cardinal numbers where the multiplication of an infinite cardinal number and a non-zero cardinal number results in the larger of the two cardinal numbers.

For any cardinal numbers `a` and `b` with `a ≥ ℵ₀` and `b ≠ 0`, we have `a * b = max {a, b}`.


theorem sub_sub_cancel_left : ∀ {G : Type u_3} [inst : AddCommGroup G] (a b : G), a - b - a = -b := by sorry

This theorem, `sub_sub_cancel_left`, states that for all values `a` and `b` that belong to some type `G`, which must be an additive commutative group, the result of subtracting `b` from `a`, and then subtracting `a` from the result, is equal to the additive inverse of `b`. In mathematical terms, this is saying that for any `a` and `b` in an additive commutative group `G`, we have `a - b - a = -b`.

For all `a` and `b` in an additive commutative group `G`, we have `(a - b) - a = -b`.


theorem MeasureTheory.restrict_withDensity :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → ∀ (f : α → ENNReal), (μ.withDensity f).restrict s = (μ.restrict s).withDensity f :=
  by sorry

The theorem `MeasureTheory.restrict_withDensity` states that for any given type `α`, a measurable space `m0` on `α`, a measure `μ` on `α`, and a set `s` of type `α`, if `s` is a measurable set, then for any function `f` mapping elements of `α` to extended nonnegative real numbers (`ENNReal`), the measure of `s` obtained by first applying `withDensity f` to `μ` and then restricting to `s` is equal to the measure obtained by first restricting `μ` to `s` and then applying `withDensity f`. In other words, the sequence of applying `withDensity` and `restrict` operations on `μ` is commutative. This theorem is related to the properties of a measure when it is transformed by a function and then restricted to a measurable subset, or vice versa.

For any measurable space `(α, μ)`, measurable set `s ∈ α`, and function `f: α → ENNReal`, the measures of `s` obtained by first applying `withDensity f` to `μ` and then restricting to `s`, and by first restricting `μ` to `s` and then applying `withDensity f`, are equal.


theorem Mathlib.Data.Finset.Powerset._auxLemma.15 :
    ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, (s ∈ Finset.powersetCard n t) = (s ⊆ t ∧ s.card = n) := by sorry

The theorem `Mathlib.Data.Finset.Powerset._auxLemma.15` states that for any type `α`, natural number `n`, and finsets `s` and `t` of type `α`, `s` is an element of the finset generated by the `powersetCard n t` function if and only if two conditions are met: (1) `s` is a subset of `t`, and (2) the cardinality (or size) of `s` is `n`. In other words, this theorem connects the concept of a powerset of a certain size with the properties of being a subset and having a specific cardinality.

A finset of type `α` is an element of the finset generated by `powersetCard n t` if and only if it has size `n` and is a subset of `t`.


/-- The preimage of a compact set under a closed embedding is a compact set.  -/
theorem ClosedEmbedding.isCompact_preimage :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      ClosedEmbedding f → ∀ {K : Set Y}, IsCompact K → IsCompact (f ⁻¹' K) :=
  by sorry

The theorem `ClosedEmbedding.isCompact_preimage` states that for any two types `X` and `Y` equipped with topological spaces, a function `f` from `X` to `Y`, and a set `K` in `Y` that is compact, if `f` is a closed embedding (which means it is a function that is continuous, injective, and its image is a closed set), then the preimage of `K` under `f` (the set of all elements in `X` that `f` maps into `K`) is also a compact set. In other words, the preimage of a compact set under a closed embedding retains the property of compactness.

If `f : X ⟹ Y` is a closed embedding of topological spaces and `K ⊆ Y` is compact, then `f⁻¹(K) ⊆ X` is also compact.


theorem PowerSeries.coeff_monomial :
    ∀ {R : Type u_1} [inst : Semiring R] (m n : ℕ) (a : R),
      (PowerSeries.coeff R m) ((PowerSeries.monomial R n) a) = if m = n then a else 0 :=
  by sorry

This theorem states that for any semiring `R`, and for any integers `m` and `n` and an element `a` of `R`, the `m`th coefficient of the `n`th monomial with coefficient `a` in the formal power series over `R` is `a` if `m` equals `n` and `0` otherwise. In other words, it's stating that in a power series, the coefficient for a given power is the value associated with that power in the monomial, and zero for all other powers.

For any semiring `R`, the `m`th coefficient of the `n`th monomial with coefficient `a` in the formal power series over `R` is equal to `a` if `m = n`, and `0` otherwise.


theorem Nat.Primrec'.comp₁ :
    ∀ (f : ℕ → ℕ),
      (Nat.Primrec' fun v => f (Vector.head v)) →
        ∀ {n : ℕ} {g : Vector ℕ n → ℕ}, Nat.Primrec' g → Nat.Primrec' fun v => f (g v) :=
  by sorry

This is a theorem about the composition of primitive recursive functions in natural numbers. The theorem states that for any function `f` from natural numbers to natural numbers, if `f` composed with the `head` function on a vector is primitive recursive, then for any natural number `n` and any function `g` from vectors of length `n` of natural numbers to natural numbers that is primitive recursive, the composition of `f` with `g` is also primitive recursive. In other words, if `f` and `g` are both primitive recursive functions, then their composition `f(g(v))` is also a primitive recursive function.

If `f` is a primitive recursive function and `g` is a primitive recursive function from vectors of natural numbers to natural numbers, then their composition `f ∘ g` is also a primitive recursive function.


theorem MvPowerSeries.coeff_monomial_same :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (n : σ →₀ ℕ) (a : R),
      (MvPowerSeries.coeff R n) ((MvPowerSeries.monomial R n) a) = a :=
  by sorry

This theorem states that for any semiring `R`, any multivariate formal power series `MvPowerSeries σ R`, and any coefficient `a` of type `R`, if you apply the `n`th coefficient function `MvPowerSeries.coeff R n` to the result of applying the `n`th monomial function `MvPowerSeries.monomial R n` to `a`, you get `a` back. In other words, the `n`th coefficient of the `n`th monomial of `a` is `a` itself. This theorem essentially captures the property that the `n`th monomial maps an element of the semiring to a power series where the `n`th coefficient is that element and all other coefficients are zero.

For any semiring `R`, `MvPowerSeries σ R a n`, where `σ` is the `n`th monomial and `a` is an element of `R` with `n`th coefficient `a`, holds that `MvPowerSeries.coeff R σ a n = a`.


theorem MeasurableEmbedding.measurableSet_range :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β},
      MeasurableEmbedding f → MeasurableSet (Set.range f) :=
  by sorry

This theorem, named `MeasurableEmbedding.measurableSet_range`, states that for any two types `α` and `β`, given a measurable space on `α` and `β`, and a function `f` from `α` to `β`, if `f` is a measurable embedding, then the range of `f` is a measurable set. In other words, the theorem asserts that the image of the measurable space `α` under the function `f` is also measurable. This is a fundamental property in measure theory.

If `f` is a measurable embedding from the measurable space `(α, Σα)` to the measurable space `(β, Σβ)`, then the range of `f` is a measurable set in `(β, Σβ)`.


theorem Finset.union_subset_union :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t u v : Finset α}, s ⊆ u → t ⊆ v → s ∪ t ⊆ u ∪ v := by sorry

The theorem `Finset.union_subset_union` states that for any type `α` with decidable equality, and any four finite sets `s`, `t`, `u`, `v` of this type, if `s` is a subset of `u` and `t` is a subset of `v`, then the union of `s` and `t` is a subset of the union of `u` and `v`. Here, the union and subset relations are taken with respect to the usual set-theoretic definitions.

For any type `α` with decidable equality, if `s` is a subset of `u` and `t` is a subset of `v`, then `s ∪ t` is a subset of `u ∪ v`.


theorem Mathlib.Order.LocallyFinite._auxLemma.34 :
    ∀ {α : Type u} [inst : LT α] {p : α → Prop} {x y : Subtype p}, (↑x < ↑y) = (x < y) := by sorry

This theorem, `Mathlib.Order.LocallyFinite._auxLemma.34`, states that for any type `α`, which has a less-than (`<`) ordering, and for any predicate `p` on `α`, if we have two elements `x` and `y` which are subtypes of `α` satisfying predicate `p`, then the inequality of their subtype coercions to `α` is equivalent to the inequality of `x` and `y` themselves. In simpler terms, for any two subtypes, comparing them directly is the same as comparing them after coercing them back to their original type.

For any type `α` with a total ordering and any subtypes `x` and `y` of `α` satisfying a predicate `p`, the inequality `x < y` holds if and only if the inequality of their subtype coercions to `α` also holds, i.e., `x.to_alpha < y.to_alpha`.


theorem Mathlib.Order.LocallyFinite._auxLemma.33 :
    ∀ {α : Type u} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (↑x ≤ ↑y) = (x ≤ y) := by sorry

The theorem `Mathlib.Order.LocallyFinite._auxLemma.33` states that for any ordered type `α`, and for any property `p` that elements of type `α` might have, if `x` and `y` are subtypes of `α` that satisfy property `p`, then `x` is less than or equal to `y` according to the order on `α` if and only if `x` is less than or equal to `y` according to the induced order on the subtype. In other words, the order on the subtype is consistent with the order on the original type.

For any ordered type `α` and subtypes `x` and `y` of `α` satisfying a property `p`, if `x ≤ y` holds in `α`, then `x ≤ y` holds in the induced order on `x` and `y`.


theorem Nat.strong_induction_on : ∀ {p : ℕ → Prop} (n : ℕ), (∀ (n : ℕ), (∀ m < n, p m) → p n) → p n := by sorry

This theorem is a statement about strong induction on natural numbers. For any property `p` that applies to natural numbers, given a natural number `n`, if it's true that for any natural number `n`, if `p` is true for all natural numbers less than `n` then `p` is true for `n`, then it follows that `p` is true for the given `n`. In simpler terms, it states that if a property holds for `0` and for each natural number it holds that if the property is true for all smaller numbers then it's true for this number, then the property is true for all natural numbers.

If a property holds for 0 and is closed under the successor function, then it holds for all natural numbers. (Strong Induction Principle)


theorem Set.mem_Ioc : ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Ioc a b ↔ a < x ∧ x ≤ b := by sorry

This theorem states that for any type `α` with a preorder relation, and for any elements `a`, `b`, and `x` of this type, `x` belongs to the interval `Ioc a b` (which represents the set of elements greater than `a` and less than or equal to `b`) if and only if the two conditions `a < x` and `x ≤ b` are both satisfied. In other words, the theorem provides a characterization of membership in the left-open right-closed interval in terms of the preorder relation on the type `α`.

For any type `α` with a preorder relation, an element `x` belongs to the left-open right-closed interval `Ioc a b` if and only if `a < x` and `x ≤ b`.


theorem PartialEquiv.IsImage.iff_preimage_eq :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
      PartialEquiv.IsImage e s t ↔ e.source ∩ ↑e ⁻¹' t = e.source ∩ s :=
  by sorry

The theorem `PartialEquiv.IsImage.iff_preimage_eq` states that for any types `α` and `β`, any partial equivalence `e` from `α` to `β`, and any sets `s` of `α` and `t` of `β`, the set `t` is an image of the set `s` under the partial equivalence `e` if and only if the intersection of the source of `e` and the preimage of `t` under `e` equals the intersection of the source of `e` and `s`. This provides a condition to check if a set is an image of another set under a partial equivalence.

For any types α and β, partial equivalence e from α to β, and sets s of α and t of β, the sets s and the preimage of t under e have equal intersections with the source of e if and only if t is the image of s under e.


/-- **Number of Subsets of a Set**  -/
theorem Finset.card_powerset : ∀ {α : Type u_1} (s : Finset α), (Finset.powerset s).card = 2 ^ s.card := by sorry

This theorem, referred to as the "Number of Subsets of a Set", states that for any finite set `s` of arbitrary type `α`, the number of subsets of `s` (captured by `(Finset.powerset s).card`) is equal to 2 raised to the power of the number of elements in `s` (expressed as `2 ^ s.card`). In mathematical terms, if `s` is a finite set with `n` elements, then the number of subsets of `s` is `2^n`.

The number of subsets of a finite set `s` with `n` elements is equal to 2 raised to the power of `n`.


theorem Finset.card_le_one : ∀ {α : Type u_1} {s : Finset α}, s.card ≤ 1 ↔ ∀ a ∈ s, ∀ b ∈ s, a = b := by sorry

This theorem states that for any finite set `s` of a certain type `α`, the cardinality (or size) of `s` is less than or equal to 1 if and only if for every pair of elements `a` and `b` in `s`, `a` is equal to `b`. In other words, all elements in the set are identical if the set's size is 1 or less.

For a finite set `s` of type `α`, the cardinality of `s` is equal to 1 if and only if all elements in `s` are equal.


Asymptotics.IsEquivalent.refl

theorem Asymptotics.IsEquivalent.refl :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l u u :=
  by sorry

The theorem `Asymptotics.IsEquivalent.refl` states that for any type `α`, another type `β` which forms a normed add commutative group, a function `u` from `α` to `β`, and a filter `l` on `α`, the function `u` is asymptotically equivalent to itself along the filter `l`. In the mathematical language, as `x` tends to the limit along the filter `l`, the difference between `u(x)` and `u(x)` (which is `0`) is infinitely smaller than `u(x)`, which holds for all functions and filters.

For any type `α`, normed add commutative group `β`, function `u` from `α` to `β`, and filter `l` on `α`, `u` is asymptotically equivalent to itself along `l`, i.e., for all `ε > 0`, there exists `N` such that for all `x` in `α` with `l.contains x`, the norm of `u(x) - u(x)` is less than `ε` times the norm of `u(x)`.


Filter.Tendsto.frequently

theorem Filter.Tendsto.frequently :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop},
      Filter.Tendsto f l₁ l₂ → (∃ᶠ (x : α) in l₁, p (f x)) → ∃ᶠ (y : β) in l₂, p y :=
  by sorry

The theorem `Filter.Tendsto.frequently` asserts that if a function `f` defined from one type `α` to another type `β` tends to a limit `l₂` at a point `l₁`, and if there frequently exists an `x` in the filter `l₁` such that a certain property `p` holds for `f(x)`, then there frequently exists a `y` in the filter `l₂` for which the property `p` also holds. Here, "frequently" means that the statement holds on a set that is not a "small" neighborhood of `l₁` or `l₂`, respectively, and "tends to a limit `l₂` at a point `l₁`" means that for any neighborhood of `l₂`, its inverse image under `f` is a neighborhood of `l₁`.

If a function `f` tends to a limit `l₂` at `l₁` and there is a filter on `l₁` such that the property `p` holds for `f(x)` frequently in that filter, then there is a filter on `l₂` such that `p` holds for `f(y)` frequently in that filter.


Relation.ReflTransGen.head

theorem Relation.ReflTransGen.head :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b c : α},
      r a b → Relation.ReflTransGen r b c → Relation.ReflTransGen r a c :=
  by sorry

This theorem states that for any relation `r` on a type `α` and any three elements `a`, `b`, and `c` of type `α`, if `r a b` holds and `b` is related to `c` by the reflexive transitive closure of `r`, then `a` is also related to `c` by the reflexive transitive closure of `r`. In other words, the relation `r` and its reflexive transitive closure are transitive together: if `a` is related to `b` by `r`, and `b` is related to `c` through a series of steps each of which either does nothing (reflexivity) or applies `r` (transitivity), then `a` is related to `c` through a similar series of steps.

If `r` is a relation on type `α`, and `a`, `b`, and `c` are elements of `α` with `r a b` and `b` related to `c` by the reflexive transitive closure of `r`, then `a` is related to `c` by the reflexive transitive closure of `r`.


theorem AlgebraicGeometry.locallyOfFiniteType_eq :
    @AlgebraicGeometry.LocallyOfFiniteType = AlgebraicGeometry.affineLocally @RingHom.FiniteType := by sorry

The theorem `AlgebraicGeometry.locallyOfFiniteType_eq` states that a morphism in the category of schemes is locally of finite type if and only if for every pair of affine opens, one in the source and its preimage in the target, the induced ring homomorphism between their coordinate rings satisfies the property of being of finite type. Thus, it connects the geometric notion of being locally of finite type with the algebraic notion of ring homomorphisms being of finite type. This means, in essence, that the morphism has the property that the target is finitely generated as an algebra over the source, for every pair of affine open subsets, one in the source and its preimage in the target.

A morphism of schemes is locally of finite type if and only if the induced homomorphism between the coordinate rings of every pair of affine open subsets is of finite type.


theorem Set.encard_insert_of_not_mem :
    ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → Set.encard (insert a s) = Set.encard s + 1 := by sorry

The theorem `Set.encard_insert_of_not_mem` states that for any type `α`, any set `s` of type `α`, and any element `a` of type `α`, if `a` does not belong to `s` (formally, `a ∉ s`), then the cardinality of the set obtained by inserting `a` into `s` is equal to the cardinality of `s` plus one. In other words, adding a new, unique element to a set increases the size of the set by one.

For any set `s` and element `a` such that `a` is not in `s`, the cardinality of `s ∪ {a}` equals the cardinality of `s` plus one.


theorem IsUnit.mul_val_inv : ∀ {M : Type u_1} [inst : Monoid M] {a : M} (h : IsUnit a), a * ↑(IsUnit.unit h)⁻¹ = 1 := by
  sorry

The theorem `IsUnit.mul_val_inv` states that for any type `M` that forms a `Monoid`, for any element `a` of `M` that is a unit, the product of `a` and the inverse of the unit corresponding to `a` is the multiplicative identity, 1. In other words, for any unit element `a` in a monoid, `a` times its reciprocal equals 1.

For any monoid `M` and unit `a` in `M`, `a` multiplied with the multiplicative inverse of `a` equals the identity element of `M`.


/-- This is just a special case of the global `mul_smul_comm` lemma that requires less typeclass
search (and was here first).  -/
theorem Algebra.mul_smul_comm :
    ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : R) (x y : A),
      x * s • y = s • (x * y) :=
  by sorry

This theorem, `Algebra.mul_smul_comm`, states that for any commutative semiring `R`, semiring `A`, and `R`-algebra `A`, and for any elements `s` in `R` and `x`, `y` in `A`, the operation `x * (s • y)` is equal to `s • (x * y)`. Here, `*` represents the multiplication operation in the semiring `A` and `s • y` denotes the scalar multiplication of `s` and `y`. Essentially, this theorem is saying that scalar multiplication can be "commuted" with multiplication in the algebra.

For any commutative semiring `R`, semiring `A`, and `R`-algebra `A` with elements `s` in `R` and `x`, `y` in `A`, the scalar multiplication `s • y` commutes with the multiplication `x * y` in `A`, i.e., `x * (s • y) = s • (x * y)`.


theorem CategoryTheory.ShortComplex.exact_of_g_is_cokernel :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (S : CategoryTheory.ShortComplex C),
      CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯) →
        ∀ [inst_2 : CategoryTheory.ShortComplex.HasHomology S], CategoryTheory.ShortComplex.Exact S :=
  by sorry

The theorem `CategoryTheory.ShortComplex.exact_of_g_is_cokernel` states that for any category `C` (of type `u_1`), which has the structure of a category and is preadditive, given a short complex `S` in the category, if the morphism `S.g` determines a cokernel cofork that is a colimit, then `S` is exact. In other words, if the morphism `S.g` satisfies the universal property of a cokernel, the short complex `S` satisfies the exactness condition. This theorem is fundamental in homological algebra, where exact sequences and their properties are central topics. A short complex is exact when the image of each morphism is equal to the kernel of the next morphism. In the context of the theorem, this is expressed in terms of the cokernel of `S.g`.

In a preadditive category `C`, a short complex `S` is exact if the morphism `S.g` determines a cokernel that is a colimit.


theorem CategoryTheory.Adjunction.homEquiv_naturality_right :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {X : C} {Y Y' : D} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'),
      (adj.homEquiv X Y') (CategoryTheory.CategoryStruct.comp f g) =
        CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y) f) (G.map g) :=
  by sorry

This theorem states that given two categories `C` and `D`, with functors `F` and `G` forming an adjunction `F ⊣ G`, and morphisms `f : F.obj X ⟶ Y` and `g : Y ⟶ Y'`, the hom-set equivalence provided by the adjunction obeys a naturalness condition. This condition says that applying the hom-set equivalence to the composition `f ≫ g` is equivalent to first applying it to `f`, then post-composing with the morphism `G.map g`. This is a general property of adjunctions in category theory. In more mathematical terms, we could write it as `(adj.homEquiv X Y') (f ≫ g) = (adj.homEquiv X Y f) ≫ (G.map g)`.

Given an adjunction between categories `F ⊣ G` and morphisms `f : F(X) → Y` and `g : Y → Y'`, the naturalness condition holds, that is, `(adj.homEquiv X Y' (f ≫ g)) = (adj.homEquiv X Y f) ≫ (G.map g)`.


theorem compl_inj_iff : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], xᶜ = yᶜ ↔ x = y := by sorry

This theorem states that for any type `α` that is a Boolean algebra, and any two elements `x` and `y` of that type, the complement of `x` is equal to the complement of `y` if and only if `x` is equal to `y`. In other words, the operation of taking the complement is injective in any Boolean algebra.

In a Boolean algebra, the complement operation is injective, that is, for all elements x and y, x = y implies ·x = ·y, where · denotes the complement operation.


/-- We can write both `n.factorization p` and `n.factors.count p` to represent the power
of `p` in the factorization of `n`: we declare the former to be the simp-normal form.  -/
theorem Nat.factors_count_eq : ∀ {n p : ℕ}, List.count p (Nat.factors n) = (Nat.factorization n) p := by sorry

The theorem `Nat.factors_count_eq` states that for any natural numbers `n` and `p`, the count of `p` in the list of prime factors of `n` (given by `List.count p (Nat.factors n)`) is equal to the multiplicity of `p` in the prime factorization of `n` (given by `(Nat.factorization n) p`). In other words, both expressions represent the exponent of prime `p` in the prime factorization of `n`, and the theorem declares the latter expression as the standard or simplified form.

The number of occurrences of prime number `p` in the prime factorization of natural number `n` (given by `Nat.factorization n p`) equals the count of `p` in the list of prime factors of `n` (given by `List.count p (Nat.factors n)`).


theorem mul_eq_zero_of_left : ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] {a : M₀}, a = 0 → ∀ (b : M₀), a * b = 0 := by
  sorry

This theorem, `mul_eq_zero_of_left`, establishes the rule for multiplication with zero in a `MulZeroClass`. Given any type `M₀` that is a multiplication-zero class (i.e., a set with an operation of multiplication that obeys certain laws and contains an element, 0, that when multiplied with any other element results in 0), the theorem states that if any element `a` is equal to zero, then the product of `a` and any other element `b` is also zero. In simpler words, multiplying by zero always yields zero in a multiplication-zero class.

In a multiplication-zero class, multiplying any element by zero results in zero.


theorem Submodule.span_union :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s t : Set M),
      Submodule.span R (s ∪ t) = Submodule.span R s ⊔ Submodule.span R t :=
  by sorry

The theorem `Submodule.span_union` states that for any semiring `R` and an additive commutative monoid `M` over which `R` is a module, and for any two sets `s` and `t` of elements in `M`, the span of the union of `s` and `t` is equal to the sup (join) of the span of `s` and the span of `t`. In other words, the smallest submodule of `M` that contains all elements of either `s` or `t` is the same as the smallest submodule that contains both the smallest submodule for `s` and the smallest submodule for `t`.

The submodule generated by the union of two sets in an additive commutative monoid over a semiring is equal to the sum of the submodules generated by each set.


theorem CategoryTheory.IsIso.inv_comp_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : X ⟶ Z} {g : Y ⟶ Z},
      CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f = g ↔ f = CategoryTheory.CategoryStruct.comp α g :=
  by sorry

The theorem `CategoryTheory.IsIso.inv_comp_eq` states that in any category `C`, for any objects `X`, `Y`, and `Z` in `C` and any isomorphism `α` from `X` to `Y`, and any morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the composition of the inverse of `α` and `f` equals `g` if and only if `f` equals the composition of `α` and `g`. In other words, it provides a condition under which two morphisms are equal in terms of the composition of an isomorphism and another morphism.

For any category C, given objects X, Y, Z, an isomorphism α from X to Y, and morphisms f from X to Z and g from Y to Z, if and only if the composition of the inverse of α and f equals g, then f equals the composition of α and g.


theorem CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_left :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      (s : CategoryTheory.Limits.Cofork f g),
      s.ι.app CategoryTheory.Limits.WalkingParallelPair.zero =
        CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Cofork.π s) :=
  by sorry

This theorem states that for any category `C`, any two objects `X` and `Y` in `C`, and any two morphisms `f` and `g` from `X` to `Y`, if `s` is a cofork on `f` and `g`, then applying the cocone morphism `s.ι` to the initial object `CategoryTheory.Limits.WalkingParallelPair.zero` is equivalent to composing `f` with the projection morphism `CategoryTheory.Limits.Cofork.π s`. Here, the cofork is a particular kind of cocone over the parallel pair constructed from `f` and `g`, and the projection morphism is a morphism from the cofork to `Y`.

 For any category `C`, given objects `X`, `Y`, morphisms `f`, `g : X → Y`, and a cofork `s` on `f` and `g`, the following commutative diagram holds:

```
⋢───⌣─── s.ι ≫ CategoryTheory.Limits.WalkingParallelPair.zero
|       |
v       v
X       Y
|       |
↙─── f ───⟩ g ───────────────────────────────────────────────π_s
```

Therefore, `s.ι ∘ CategoryTheory.Limits.WalkingParallelPair.zero = π_s ∘ f`.


theorem le_add_of_le_of_nonneg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      b ≤ c → 0 ≤ a → b ≤ c + a :=
  by sorry

This theorem, `le_add_of_le_of_nonneg`, states that for any type `α` that has an addition operation, a zero element, and a preorder relation (basically, a mathematical structure where you can add elements, have a concept of zero, and compare elements), and if addition of elements respects the preorder relation, then for any three elements `a`, `b`, and `c` of type `α`, if `b` is less than or equal to `c`, and `a` is non-negative (greater than or equal to zero), then `b` is less than or equal to the sum of `c` and `a`. This is a generalization of a common property in number systems: if `b` ≤ `c` and `a` ≥ 0, then `b` ≤ `c` + `a`.

If `α` is a type with addition, zero, and a preorder relation such that `a ≤ b` implies `a + c ≤ b + c` for all `a, b, c` in `α` with `a` non-negative, then `b ≤ c` implies `b ≤ c + a`.


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

This theorem states that for any type `α` that has an additive monoid structure, and any elements `a` of type `α` and `b` of type `AddUnits α` (which means `b` is an additive unit in `α`), adding `b` and the additive inverse of `b` to `a` (in that order) will just result in `a`. In mathematical terms, it's saying that for all `a` in `α` and `b` in `AddUnits α`, `a + b + (-b) = a`. This is a formal statement of the property that adding an element and its additive inverse results in no change.

For any additive monoid type `α` and its additive unit `b`, the equation `a + b + (-b) = a` holds for all `a` in `α`.


theorem Nat.add_mod_left : ∀ (x z : ℕ), (x + z) % x = z % x := by sorry

This theorem, `Nat.add_mod_left`, states that for all natural numbers 'x' and 'z', the modulus of the sum of 'x' and 'z' with respect to 'x' is equal to the modulus of 'z' with respect to 'x'. In simple terms, adding 'x' to 'z' doesn't change the remainder when 'z' is divided by 'x'. This theorem represents a fundamental property of modular arithmetic.

For all natural numbers x and z, x | (z + x) if and only if x | z. (x being a divisor of z + x if and only if x being a divisor of z in the context of modular arithmetic)


padicNormE.mul

theorem padicNormE.mul : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ_[p]), ‖q * r‖ = ‖q‖ * ‖r‖ := by sorry

This theorem states that for any natural number `p` which is prime, and any two p-adic numbers `q` and `r`, the p-adic norm of the product of `q` and `r` is equal to the product of the p-adic norms of `q` and `r`. In mathematical notation, this could be written as `‖q * r‖ = ‖q‖ * ‖r‖`. This theorem essentially states that the p-adic norm is multiplicative.

For any prime natural number p and p-adic numbers q and r, the p-adic norm of their product equals the product of their individual p-adic norms: ‖q * r‖ = ‖q‖ * ‖r‖.


theorem Set.image_update_Icc :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → PartialOrder (α i)]
      (f : (i : ι) → α i) (i : ι) (a b : α i),
      Function.update f i '' Set.Icc a b = Set.Icc (Function.update f i a) (Function.update f i b) :=
  by sorry

This theorem states that for any type `ι`, any function `α` from `ι` to another type, given a decidable equality on `ι` and a partial order on `α i` for each `i` in `ι`, for any function `f` from `ι` to `α i`, any index `i` in `ι`, and any `a` and `b` in `α i`, the image of the set of `f`'s values updated at index `i` over the closed interval `[a, b]` is the same as the closed interval between `f` updated at `i` with `a` and `f` updated at `i` with `b`.

In other words, if you update the value of the function at a certain point and then take the image of that function over a closed interval, it's the same as if you took the closed interval of the function with the updated values. This is a property related to the preservation of order and continuity after a function update.

For any type `ι`, function `α : ι → Type`, decidable equality on `ι`, partial order on `α i` for each `i ∈ ι`, function `f : ι → α`, index `i ∈ ι`, and elements `a, b ∈ α i`, the image of `f` over the closed interval `[a, b]` is equal to the closed interval `[f i a, f i b]` in `α`.


theorem MeasureTheory.NullMeasurableSet.mono_ac :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.NullMeasurableSet s μ →
        MeasureTheory.Measure.AbsolutelyContinuous ν μ → MeasureTheory.NullMeasurableSet s ν :=
  by sorry

The theorem `MeasureTheory.NullMeasurableSet.mono_ac` states that for any type `α`, given a measurable space `m0` over `α`, and two measures `μ` and `ν` over `α`, and a set `s` of type `α`, if `s` is a Null Measurable Set with respect to the measure `μ`, and if the measure `ν` is absolutely continuous with respect to `μ`, then `s` is a Null Measurable Set with respect to the measure `ν`. This means that a set's null measurability and a measure's absolute continuity are transitive properties across measures.

If `μ` is absolutely continuous with respect to `ν`, and `s` is a Null Measurable Set with respect to `μ` over measurable space `m0` on type `α`, then `s` is a Null Measurable Set with respect to `ν`.


theorem Pi.apply_single :
    ∀ {I : Type u} {f : I → Type v₁} {g : I → Type v₂} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)]
      [inst_2 : (i : I) → Zero (g i)] (f' : (i : I) → f i → g i),
      (∀ (i : I), f' i 0 = 0) → ∀ (i : I) (x : f i) (j : I), f' j (Pi.single i x j) = Pi.single i (f' i x) j :=
  by sorry

This theorem, `Pi.apply_single`, states that for any types `I`, `f`, and `g`, given a function `f'` that maps elements of type `f` to type `g` for each element in `I`, and assuming that `f' i 0` is always `0` for all `i` in `I`, the application of `f'` on `Pi.single i x j` (i.e., a function that is `0` everywhere except at `i` where it is `x`) is equal to `Pi.single i (f' i x) j`. In other words, under these conditions, applying `f'` to the function supported at `i` does not change its support. This theorem is a generalization of the property of sparse functions where applying a function to a sparse vector preserves its sparsity.

For any types `I`, `f`, and `g`, if `f' : I → g` is a function such that `f' i 0 = 0` for all `i` in `I`, then `f' (Pi.single i x) = Pi.single i (f' i x)` for all `i` in `I` and `x : f`.


theorem nonempty_of_exists : ∀ {α : Sort u} {p : α → Prop}, (∃ x, p x) → Nonempty α := by sorry

This theorem states that for any type `α` and any property `p` that applies to elements of `α`, if there exists an element `x` of `α` that satisfies property `p`, then `α` is nonempty. In more mathematical terms, given any set `α` and any predicate `p : α → Prop`, if there exists an `x` in `α` such that `p(x)` holds true, then set `α` must be nonempty.

If a set `α` has an element `x` satisfying a property `p : α → Prop`, then `α` is nonempty.


theorem dist_zero_left : ∀ {E : Type u_6} [inst : SeminormedAddGroup E], dist 0 = norm := by sorry

This theorem, `dist_zero_left`, states that for any type `E` that is an instance of a seminormed add group, the distance from zero is equal to the norm. In other words, in the context of a seminormed add group, the norm function can be used to measure the distance from the zero element.

In a seminormed add group, the norm of an element is equal to its distance to the zero element.


/-- A subring contains the ring's 1.  -/
theorem Subring.one_mem : ∀ {R : Type u} [inst : Ring R] (s : Subring R), 1 ∈ s := by sorry

This theorem states that for any ring `R` and any subring `s` of `R`, the multiplicative identity element `1` of the ring is always an element of the subring `s`. In other words, every subring of a ring must contain the unit or '1' of the parent ring. This is an important property in ring theory that defines the structure of subrings within a ring.

For any ring `R` and subring `s` of `R`, the multiplicative identity `1` of `R` belongs to `s`.


theorem AddGroup.closure_subset :
    ∀ {G : Type u_1} [inst : AddGroup G] {s t : Set G}, IsAddSubgroup t → s ⊆ t → AddGroup.closure s ⊆ t := by sorry

The theorem `AddGroup.closure_subset` states that for any type `G` that has an additive group structure (denoted as `AddGroup G`), and for any two sets `s` and `t` of elements of `G`, if `t` is an additive subgroup and all elements of `s` are contained within `t` (expressed as `s ⊆ t`), then the additive subgroup generated by `s` (given as `AddGroup.closure s`) is also contained within `t`. In other words, the smallest additive subgroup containing `s` is a subset of any additive subgroup that contains `s`.

For any additive group `G` and sets `s` and `t` of its elements with `s ⊆ t` and `t` an additive subgroup, `AddGroup.closure s` is contained in `t`.


/-- Cauchy–Schwarz inequality with norm  -/
theorem norm_inner_le_norm :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y : E), ‖⟪x, y⟫_𝕜‖ ≤ ‖x‖ * ‖y‖ :=
  by sorry

The theorem `norm_inner_le_norm` is a statement of the Cauchy-Schwarz inequality in the context of an inner product space. Specifically, it says that for any scalar field `𝕜` and any type `E` that forms a normed additive commutative group and also an inner product space over `𝕜`, the norm of the inner product of any two elements `x` and `y` of `E` is less than or equal to the product of the norms of `x` and `y`. In other words, if `⟪., .⟫_𝕜` denotes the inner product and `‖.‖` denotes the norm, then `‖⟪x, y⟫_𝕜‖ ≤ ‖x‖ * ‖y‖` for all `x` and `y` in `E`.

For any inner product space over a scalar field endowed with a norm, the inner product of any two elements is less than or equal to the product of their respective norms.


theorem AdjoinRoot.eval₂_root :
    ∀ {R : Type u} [inst : CommRing R] (f : Polynomial R),
      Polynomial.eval₂ (AdjoinRoot.of f) (AdjoinRoot.root f) f = 0 :=
  by sorry

The theorem `AdjoinRoot.eval₂_root` states that for any commutative ring `R` and any polynomial `f` over `R`, if we evaluate the polynomial `f` using the ring homomorphism `AdjoinRoot.of f` which embeds the ring `R` into the ring of adjoined roots of `f`, and the adjoined root `AdjoinRoot.root f` of the polynomial `f`, the result is zero. This essentially means that the adjoined root is a root of the polynomial `f`.

For any commutative ring R and polynomial f over R, evaluating f using the ring homomorphism AdjoinRoot.of f in the ring of adjoined roots results in zero at the adjoined root of f.


theorem isBounded_iff_forall_norm_le :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {s : Set E}, Bornology.IsBounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
  sorry

This theorem, `isBounded_iff_forall_norm_le`, states that for any set `s` in a seminormed add group `E`, the set `s` is bounded relative to the ambient bornology on `E` if and only if there exists a real number `C` such that for all elements `x` in the set `s`, the seminorm (or "length") of `x` is less than or equal to `C`. This essentially means that every element in set `s` has a "length" that does not exceed a certain upper bound `C`.

A set `s` in a seminormed add group `E` is bounded relative to the ambient bornology if and only if there exists a real number `C` such that the seminorm of every element `x` in `s` is less than or equal to `C`.


theorem Fin.succAbove_of_lt_succ :
    ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), p < Fin.succ i → Fin.succAbove p i = Fin.succ i := by sorry

The theorem `Fin.succAbove_of_lt_succ` states that for any natural number `n` and for two terms `p` and `i` of the types `Fin (n + 1)` and `Fin n` respectively, if `p` is less than the successor of `i`, then the result of the function `Fin.succAbove` applied to `p` and `i` is equal to the successor of `i`. In simpler terms, if `p` is less than the next number after `i`, then embedding `Fin n` into `Fin (n + 1)` with a hole around `p` is equivalent to just moving to the next number after `i`.

For all natural numbers `n`, `i : Fin n`, and `p : Fin (n + 1)`, if `p < succ i`, then `Fin.succAbove p i = succ i`.


/-- **Alias** of the forward direction of `Polynomial.natDegree_le_iff_degree_le`. -/
theorem Polynomial.degree_le_of_natDegree_le :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ},
      Polynomial.natDegree p ≤ n → Polynomial.degree p ≤ ↑n :=
  by sorry

This theorem, `Polynomial.degree_le_of_natDegree_le`, states that for any type `R` that is a semiring and any polynomial `p` of type `R` and natural number `n`, if the natural degree of the polynomial `p` is less than or equal to `n`, then the degree of polynomial `p` is also less than or equal to `n`. In other words, it states that the degree of a polynomial, which is the highest power of `X` that appears in the polynomial, is less than or equal to a certain natural number if the natural degree of the polynomial, which is the same as the degree but defined to be zero for the zero polynomial, is less than or equal to that number.

For any semiring `R` and polynomial `p` of degree `n` over `R` with natural degree `m`, if `m` is less than or equal to `n`, then the degree of `p` is also less than or equal to `n`.


theorem monotone_iff_forall_lt :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f ↔ ∀ ⦃a b : α⦄, a < b → f a ≤ f b :=
  by sorry

This theorem states that for any two types `α` and `β`, given a partial order on `α` and a preorder on `β`, a function `f` from `α` to `β` is monotone if and only if for all pairs of elements `a` and `b` from `α` such that `a` is strictly less than `b`, the result of applying `f` to `a` is less than or equal to the result of applying `f` to `b`. In mathematical terms, it states that a function `f: α → β` is monotone (i.e., `a ≤ b` implies `f(a) ≤ f(b)` for all `a, b ∈ α`) if and only if for all `a, b ∈ α` such that `a < b`, we have `f(a) ≤ f(b)`.

A function between two types is monotone with respect to given partial orders if and only if the image of any strictly smaller element is less than or equal to the image of any strictly larger element.


PartialHomeomorph.ext

/-- Two partial homeomorphisms are equal when they have equal `toFun`, `invFun` and `source`.
It is not sufficient to have equal `toFun` and `source`, as this only determines `invFun` on
the target. This would only be true for a weaker notion of equality, arguably the right one,
called `EqOnSource`.  -/
theorem PartialHomeomorph.ext :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e e' : PartialHomeomorph X Y),
      (∀ (x : X), ↑e x = ↑e' x) →
        (∀ (x : Y), ↑(PartialHomeomorph.symm e) x = ↑(PartialHomeomorph.symm e') x) → e.source = e'.source → e = e' :=
  by sorry

This theorem states that two partial homeomorphisms, namely `e` and `e'` between two topological spaces `X` and `Y`, are equal if and only if their mapping functions `toFun`, their inverse functions `invFun`, and their `source` sets are equal. It is necessary to specify equality of both `toFun` and `invFun` since only specifying `toFun` and `source` only determines `invFun` on the target set, which is a weaker notion of equality termed `EqOnSource`.

Two partial homeomorphisms `e` and `e'` between topological spaces `X` and `Y` are equal if and only if their mapping functions `toFun` and inverse functions `invFun` are equal.


theorem Finset.empty_union : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), ∅ ∪ s = s := by sorry

This theorem, named "Finset.empty_union", states that for any type `α` that has a decidable equality and any finite set `s` of type `α`, the union of the empty set and `s` is equal to `s` itself. Essentially, this is the set theoretical concept that the union of any set with the empty set returns the original set. Thus, in mathematical terms, it can be written as `∅ ∪ s = s` for any finite set `s`.

The union of the empty set and a finite set is equal to the original set.


ContinuousLinearMap.contDiff

theorem ContinuousLinearMap.contDiff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      (f : E →L[𝕜] F), ContDiff 𝕜 n ⇑f :=
  by sorry

This theorem states that for any continuous linear map `f` from a normed additive commutative group `E` into another normed additive commutative group `F` (both of which are also normed spaces over a nontrivially normed field `𝕜`), the function `f` is `n`-times continuously differentiable. In other words, `f` has continuous derivatives up to order `n`, where `n` can be any natural number or infinity (`ℕ∞`).

For any continuous linear map between normed additive commutative groups over a nontrivially normed field, the map is infinitely differentiable.


theorem Set.image_eq_empty : ∀ {α : Type u_6} {β : Type u_7} {f : α → β} {s : Set α}, f '' s = ∅ ↔ s = ∅ := by sorry

This theorem states that for all types `α` and `β`, for all functions `f` from `α` to `β`, and for all sets `s` of type `α`, the image of the set `s` under the function `f` is empty if and only if the set `s` itself is empty. In other words, a function `f` produces an empty set when applied to all elements of another set `s` if and only if the original set `s` is empty.

For all types `α` and `β`, and for all functions `f` from `α` to `β`, if `s` is a set of type `α`, then `f''s` is empty if and only if `s` is empty.


theorem Function.invFun_surjective :
    ∀ {α : Sort u_1} {β : Sort u_2} [inst : Nonempty α] {f : α → β},
      Function.Injective f → Function.Surjective (Function.invFun f) :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is nonempty, and any function `f` from `α` to `β`, if the function `f` is injective, then the inverse of `f` is surjective. In other words, if for a function `f`, the condition "for all pairs of elements in `α`, if `f` applied to the first element equals `f` applied to the second element, then the first and second elements are the same" holds true, then for the inverse of this function, for every element in the codomain `β`, there exists an element in the domain `α` such that the inverse function applied to the former equals the latter.

If `α` is nonempty and `f` is a function from `α` to `β` that is injective, then the inverse function `g:` `β` `→` `α` is surjective.


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

This theorem states that for any two natural numbers `a` and `b`, if `b` is less than or equal to `a`, then the maximum of `a` and `b` is `a`. In other words, when comparing two natural numbers, if the second one is not larger than the first, the maximum of the two is the first number. This is a basic property of the maximum operation, which in this case is applied to natural numbers in Lean 4.

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


/-- Two affine subspaces are equal if they have the same points.  -/
theorem AffineSubspace.coe_injective :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P], Function.Injective SetLike.coe :=
  by sorry

The theorem `AffineSubspace.coe_injective` states that two affine subspaces are considered equal if and only if they contain the same points. This applies for any field `k`, any additive commutative group `V`, and any affine space `P` over that group with scalar multiplication by elements of `k`. The theorem relies on the property of the injectiveness of the `SetLike.coe` function, which means that distinct affine subspaces map to distinct sets of points, thereby ensuring that the same set of points can only come from one affine subspace.

Two affine subspaces of an affine space over a field with the same set of points are equal.


theorem Submodule.IsPrincipal.span_singleton_generator :
    ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Ring R] [inst_2 : Module R M] (S : Submodule R M)
      [inst_3 : Submodule.IsPrincipal S], Submodule.span R {Submodule.IsPrincipal.generator S} = S :=
  by sorry

The theorem `Submodule.IsPrincipal.span_singleton_generator` states that for any ring `R`, any additively commutative group `M` and any `R`-module structure on `M`, and for any submodule `S` of `M` that is a principal submodule, the span of the set containing only the generator of `S` is equal to `S` itself. In other words, a principal submodule `S` is exactly the submodule spanned by its generator.

A submodule of an `R`-module `M` is principal if and only if it is equal to the span of its generator.


theorem Polynomial.leadingCoeff_zero : ∀ {R : Type u} [inst : Semiring R], Polynomial.leadingCoeff 0 = 0 := by sorry

The theorem `Polynomial.leadingCoeff_zero` states that for any type `R` that forms a semiring, the leading coefficient of the zero polynomial is zero. Here, the leading coefficient of a polynomial is defined as the coefficient of the term with the highest power of `X`. In other words, if we have a polynomial which is identically zero, then the coefficient of its highest degree term (which doesn't exist because all terms are zero) is also zero.

For any semiring `R`, the leading coefficient of the zero polynomial is 0.


theorem Int.natAbs_ne_zero : ∀ {a : ℤ}, Int.natAbs a ≠ 0 ↔ a ≠ 0 := by sorry

The theorem `Int.natAbs_ne_zero` states that for any integer `a`, the absolute value of `a` is not equal to zero if and only if `a` is not equal to zero. This is a bi-directional implication, which means that both the conditions imply each other. If the absolute value of an integer is not zero, then the integer itself is not zero, and conversely, if an integer is not zero, then its absolute value is also not zero.

For any integer `a`, |a| ≠ 0 if and only if a ≠ 0.


ContinuousAt.div

/-- Continuity at a point of the result of dividing two functions continuous at that point, where
the denominator is nonzero.  -/
theorem ContinuousAt.div :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : TopologicalSpace G₀]
      [inst_2 : HasContinuousInv₀ G₀] [inst_3 : ContinuousMul G₀] {f g : α → G₀} [inst_4 : TopologicalSpace α] {a : α},
      ContinuousAt f a → ContinuousAt g a → g a ≠ 0 → ContinuousAt (f / g) a :=
  by sorry

This theorem states that for any point `a` in a topological space `α` and two functions `f` and `g` from `α` to a topological group with zero `G₀` (a group with zero that is also a topological space where the inversion and multiplication operations are continuous), if `f` and `g` are both continuous at the point `a` and `g` is nonzero at `a`, then the function that maps `x` to `f(x) / g(x)` is also continuous at `a`.

If `f` and `g` are continuous functions from a topological space `α` to a topological group `G₀` with zero, where `g(a) ≠ 0` for some point `a` in `α`, then the function `x => f(x) / g(x)` is continuous at `a`.


theorem Set.image2_iInter₂_subset_right :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} (f : α → β → γ) (s : Set α)
      (t : (i : ι) → κ i → Set β), Set.image2 f s (⋂ i, ⋂ j, t i j) ⊆ ⋂ i, ⋂ j, Set.image2 f s (t i j) :=
  by sorry

The theorem `Set.image2_iInter₂_subset_right` states that for all types `α`, `β`, `γ`, a function `f` from `α` and `β` to `γ`, a set `s` of type `α`, and a dependent family of sets `t` of type `β` indexed by `ι` and `κ`, the image set of `f` with respect to `s` and the intersection of all sets `t i j` is a subset of the intersection of all image sets of `f` with respect to `s` and each `t i j`. In other words, it states that applying a function to elements from a set and an intersection of sets results in a set that is contained within the intersection of the sets resulted from applying the function to elements from the set and each set in the intersection individually.

For all types α, β, γ, function f from α × β to γ, set s ∈ α, and dependent family of sets t(ι, κ) ∈ β, the image of s under f and the intersections of t(ι, κ) are included in the intersections of the images of s under f and each t(ι, κ).


theorem Filter.eventually_le_atBot : ∀ {α : Type u_3} [inst : Preorder α] (a : α), ∀ᶠ (x : α) in Filter.atBot, x ≤ a :=
  by sorry

This theorem states that for any type `α` that has an order (a `Preorder`), and for any element `a` of type `α`, at the limit of the sequence going to negative infinity (`atBot`), all elements `x` of the sequence will eventually be less than or equal to `a`. In mathematical terms, this means that for a sequence converging to negative infinity, there exists a point beyond which all elements of the sequence are less than or equal to a given value `a`.

For any sequence converging to negative infinity in a preordered type, all elements beyond a certain point are less than or equal to any given element.


theorem IsAdjoinRoot.aeval_root :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      (h : IsAdjoinRoot S f), (Polynomial.aeval (IsAdjoinRoot.root h)) f = 0 :=
  by sorry

The theorem `IsAdjoinRoot.aeval_root` states that for any commutative ring `R` and any ring `S`, and for any polynomial `f` over `R`, if `h` is an instance of `IsAdjoinRoot` for `S` and `f` (meaning that `S` is generated by adjoining a root of `f` to `R`), then applying the algebraic evaluation of the polynomial `f` at this root yields zero. In other words, the root defined by `IsAdjoinRoot.root h` is indeed a root of the polynomial `f`.

For any commutative rings R and S, and polynomial f over R, if S is generated by adjoining a root of f to R (via an instance h of IsAdjoinRoot for f and S), then the algebraic evaluation of f at h.root h equals zero.


theorem CharP.charP_to_charZero : ∀ (R : Type u_2) [inst : AddGroupWithOne R] [inst_1 : CharP R 0], CharZero R := by
  sorry

This theorem states that for any type `R` that forms an additive group with an identity element, if `R` has characteristic `0`, then `R` also satisfies the property of being `CharZero`. In the field of mathematics, a ring `R` is said to have characteristic `0` if and only if for any positive integer `n`, `n` times the multiplicative identity is not the additive identity. The `CharZero` property indicates that the natural number embedding into `R` is injective. Thus, this theorem provides a link between the characteristic of a ring and an important property about its structure.

If `R` is an additive group with an identity element and has characteristic 0, then `R` is a CharZero ring.


theorem one_leftCoset : ∀ {α : Type u_1} [inst : Monoid α] (s : Set α), 1 • s = s := by sorry

This theorem, `one_leftCoset`, states that for all types `α` endowed with a `Monoid` structure, for any set `s` of elements of type `α`, the left coset of `s` by `1` (denoted as `1 • s`) is equal to `s` itself. In mathematical terms, when we "act" on the set `s` by the multiplicative identity of the monoid (which is `1`), the set remains unchanged. This result is a fundamental property in group theory, specifically in the study of cosets.

For any set `s` of elements in a monoid `α`, the left coset `1 • s` equals `s`.


theorem Set.preimage_const_of_mem :
    ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : Set β}, b ∈ s → (fun x => b) ⁻¹' s = Set.univ := by sorry

The theorem `Set.preimage_const_of_mem` states that for any types `α` and `β`, for any element `b` of type `β`, and for any set `s` of type `β`, if `b` is an element of `s`, then the preimage of the set `s` under the constant function that maps each element of `α` to `b` is the universal set of `α`. In simple terms, since all elements of `α` map to `b` (and `b` belongs to `s`), all elements of `α` are in the preimage of `s`.

If `b` is an element of set `s` in type `β`, then the preimage of `s` under the constant function from `α` to `b` is the universal set of `α`.


theorem Ordinal.opow_log_le_self : ∀ (b : Ordinal.{u_1}) {x : Ordinal.{u_1}}, x ≠ 0 → b ^ Ordinal.log b x ≤ x := by
  sorry

The theorem `Ordinal.opow_log_le_self` states that for any ordinal number `b` and any non-zero ordinal `x`, raising `b` to the power of the ordinal logarithm of `x` with base `b` (`b` to the power of `Ordinal.log b x`) is less than or equal to `x`. In other words, it's stating that the ordinal logarithm is a kind of upper bound on the power to which you can raise `b` without exceeding `x`.

For any non-zero ordinal number `x` and base `b`, the ordinal logarithm of `x` with base `b` (`Ordinal.log b x`) satisfies `b^(Ordinal.log b x) ≤ x`.


theorem List.length_pmap :
    ∀ {α : Type u} {β : Type v} {p : α → Prop} {f : (a : α) → p a → β} {l : List α} {H : ∀ a ∈ l, p a},
      List.length (List.pmap f l H) = List.length l :=
  by sorry

The theorem `List.length_pmap` states that for any types `α` and `β`, any property `p` of elements of type `α`, and any function `f` from elements of type `α` satisfying the property `p` to elements of type `β`, and any list `l` of elements of type `α` such that each element in `l` satisfies the property `p`, the length of the list obtained by applying the function `f` to each element of `l` (given by `List.pmap f l H`) is the same as the length of the original list `l`. This means that applying the function `f` to each element of `l` using `List.pmap` does not change the length of the list.

For any type `α`, property `p` on `α`, function `f : α → β` preserving `p`, and list `l : List α` of elements satisfying `p`, the length of `List.pmap f l` equals the length of `l`.


theorem List.getD_eq_default : ∀ {α : Type u} (l : List α) (d : α) {n : ℕ}, List.length l ≤ n → List.getD l n d = d :=
  by sorry

This theorem, `List.getD_eq_default`, states that for any type `α`, any list `l` of type `α`, any default value `d` of type `α`, and any natural number `n`, if the length of the list `l` is less than or equal to `n`, then the function `List.getD` applied to the list `l`, the number `n`, and the default value `d` will return the default value `d`. In other words, when trying to access an item at a position in the list that exceeds its length, the function `List.getD` returns the provided default value.

For any type `α`, list `l` of length `n` in `α`, and default value `d` in `α`, `List.getD l n d = d` when `n` exceeds the length of `l`.


theorem Polynomial.nat_cast_comp :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ}, Polynomial.comp (↑n) p = ↑n := by sorry

This theorem states that for any semiring `R`, any polynomial `p` in `R`, and any natural number `n`, the composition of the polynomial corresponding to the natural number `n` with `p` is equal to the polynomial corresponding to `n`. In other words, if you take the polynomial associated with a natural number and substitute another polynomial into it, the result is still the same polynomial associated with the original natural number. In terms of mathematical notation, this could be written as: for all `n` in ℕ and all `p` in the set of polynomials over `R`, we have `(↑n) ∘ p = ↑n`.

For any semiring `R`, given a natural number `n` and a polynomial `p` over `R`, the polynomial composition `n ∘ p` equals the polynomial corresponding to the natural number `n`.


Group.closure.isSubgroup

theorem Group.closure.isSubgroup : ∀ {G : Type u_1} [inst : Group G] (s : Set G), IsSubgroup (Group.closure s) := by
  sorry

The theorem `Group.closure.isSubgroup` states that for any type `G` that has a group structure (denoted by `[inst : Group G]`), and for any set `s` of elements of `G` (denoted by `(s : Set G)`), the closure of `s` under the group operation is itself a subgroup of `G`. In other words, if you take any set of elements from a group and generate all possible elements from them through the group operation, the resulting set is also a subgroup of the original group.

If `G` is a group and `s` is a subset of `G`, then the closure of `s` under the group operation is a subgroup of `G`.


theorem AddSubmonoid.add_fromLeftNeg :
    ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) (x : ↥(AddSubmonoid.leftNeg S)),
      ↑x + ↑(AddSubmonoid.fromLeftNeg S x) = 0 :=
  by sorry

The theorem `AddSubmonoid.add_fromLeftNeg` states that for any type `M` which has an addition operation (`AddMonoid M`), for any additive submonoid `S` of `M`, and for any element `x` in the set of left additive inverses of `S` (denoted by `AddSubmonoid.leftNeg S`), the sum of `x` and its right additive inverse in `S` (obtained using the function `AddSubmonoid.fromLeftNeg`) is zero. In other words, the theorem establishes that every element in the left additive inverses of `S` and its corresponding right additive inverse in `S` sum up to zero.

For any additive submonoid `S` of an additive monoid `M`, and for any `x` in the set of left additive inverses of `S`, the element `x` and its right additive inverse in `S` sum up to zero.


/-- A filter which is eventually bounded is in particular frequently bounded (in the opposite
direction). At least if the filter is not trivial.  -/
theorem Filter.IsBounded.isCobounded_flip :
    ∀ {α : Type u_1} {r : α → α → Prop} {f : Filter α} [inst : IsTrans α r] [inst : Filter.NeBot f],
      Filter.IsBounded r f → Filter.IsCobounded (flip r) f :=
  by sorry

The theorem states that for any type `α`, relation `r`, and filter `f` over `α` which is transitive and not trivial (i.e., not bottom), if the filter `f` is eventually bounded with respect to `r` (meaning that eventually, all its elements are bounded by some uniform value with respect to `r`), then it is also frequently bounded in the opposite direction of `r`. In other words, the filter is co-bounded with respect to the relation obtained by flipping `r`. The flipping is performed by the function `flip`, which inverts the order of arguments in a binary function or relation, thereby inverting the direction of an order relation.

If `f` is a transitive and non-trivial filter over type `α` that is eventually bounded with respect to relation `r`, then `f` is also co-bounded with respect to the relation `r.reverse`.