theorem MeasureTheory.AEEqFun.coeFn_inf :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] [inst_2 : SemilatticeInf β] [inst_3 : ContinuousInf β] (f g : α →ₘ[μ] β),
      ↑(f ⊓ g) =ᶠ[MeasureTheory.Measure.ae μ] fun x => ↑f x ⊓ ↑g x :=
  by sorry

The theorem `MeasureTheory.AEEqFun.coeFn_inf` states that for any type `α` that has a structure of a measurable space and any type `β` that has a structure of a topological space, a semilattice (i.e., a poset in which every two elements have a greatest lower bound), and where the infimum operation is continuous, given any measure `μ` on `α` and any two almost everywhere-equal functions `f` and `g` from `α` to `β` (i.e., functions that are equal except on a set of measure zero), the infimum of `f` and `g` as almost everywhere-equal functions is equal almost everywhere (i.e., except potentially on a set of measure zero) to the function that maps every point to the infimum of the values of `f` and `g` at that point.

In mathematical notations, the theorem asserts that if `f, g : α →ₘ[μ] β`, then `f ⊓ g =ᶠ[μ] (λx, f(x) ⊓ g(x))` almost everywhere.

For measurable spaces `α` with measure `μ` and topological spaces `β` where infima of continuous functions exist, if `f` and `g` are almost everywhere equal functions from `α` to `β`, then their infimum as almost everywhere equal functions is equal to the pointwise infimum almost everywhere.


/-- The special case of the first simplicial identity  -/
theorem SimplexCategory.δ_comp_δ_self :
    ∀ {n : ℕ} {i : Fin (n + 2)},
      CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i) (SimplexCategory.δ (Fin.castSucc i)) =
        CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i) (SimplexCategory.δ (Fin.succ i)) :=
  by sorry

This theorem states a special case of the first simplicial identity in the context of a simplicial category. Specifically, for any natural number `n` and any `i` in the set `Fin (n + 2)`, the composition of the `i`-th face map from `[n]` to `[n+1]` with the face map for the successor of `i` (when considered as an element of `Fin n` embedded into `Fin (n+1)`), is equal to the composition of the `i`-th face map with the face map for the successor of `i` (when considered as an element of `Fin n` succeeding to `Fin (Nat.succ n)`). In simpler words, it says that two particular compositions of face maps in the simplicial category are equal.

For any natural number `n` and `i` in `Fin (n + 2)`, the composition of the `i`-th face map from `[n]` to `[n+1]` with the face map for `i.succ` (considered as an element of `Fin n` embedded into `Fin (Nat.succ n)`), is equal to the composition of the `i`-th face map with the face map for `i.succ` (considered as an element of `Fin n`).


theorem Mathlib.Order.Cover._auxLemma.10 :
    ∀ {α : Type u_1} [inst : LT α] {a b : α}, (OrderDual.toDual b ⋖ OrderDual.toDual a) = (a ⋖ b) := by sorry

The theorem, named `Mathlib.Order.Cover._auxLemma.10`, states that for all types `α` equipped with a less-than operation, and for any two elements `a` and `b` of type `α`, the less-than relation between the `OrderDual` of `b` and the `OrderDual` of `a` is equivalent to the less-than relation between `a` and `b`. In other words, flipping the order of comparison through the `OrderDual` transformation does not change the outcome of the less-than relation, and hence the `OrderDual` is essentially a reflection of the original order.

For all types equipped with a total order and any two elements, the order relation between their OrderDual is equivalent.


theorem MeasureTheory.integrable_toReal_of_lintegral_ne_top :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      AEMeasurable f μ → ∫⁻ (x : α), f x ∂μ ≠ ⊤ → MeasureTheory.Integrable (fun x => (f x).toReal) μ :=
  by sorry

The theorem `MeasureTheory.integrable_toReal_of_lintegral_ne_top` states that for all measure spaces `α` with `m` as the measurable space and `μ` as the measure, and for all functions `f` from `α` to the extended nonnegative real numbers (`ENNReal`), if `f` is almost everywhere measurable with respect to `μ` and the Lebesgue integral of `f` with respect to `μ` is not infinite, then the function that sends each `x` from `α` to the real part of `f(x)` is integrable with respect to `μ`. In other words, if a function's values are almost always measurable and its integral is finite, then we can ensure that the real part of this function is integrable.

If a measurable function from a measure space to the extended nonnegative real numbers with finite Lebesgue integral has almost everywhere defined real part, then the real part is integrable.


theorem CharP.int_cast_eq_zero_iff :
    ∀ (R : Type u_1) [inst : AddGroupWithOne R] (p : ℕ) [inst_1 : CharP R p] (a : ℤ), ↑a = 0 ↔ ↑p ∣ a := by sorry

This theorem states that for any type `R` that is an additive group with one, and for any natural number `p` where `R` has characteristic `p`, an integer `a` cast to `R` equals zero if and only if `p` divides `a`. In mathematical terms, for a given ring `R` with characteristic `p`, the integer `a` is equivalent to zero in `R` if and only if `p` is a divisor of `a`.

For an additive group `R` with characteristic `p`, an integer `a` maps to zero in `R` if and only if `p` divides `a`.


theorem FreeAddGroup.negRev_negRev :
    ∀ {α : Type u} {L₁ : List (α × Bool)}, FreeAddGroup.negRev (FreeAddGroup.negRev L₁) = L₁ := by sorry

The theorem `FreeAddGroup.negRev_negRev` states that for any list `L₁` of pairs consisting of an element from an arbitrary type `α` and a boolean, the function `FreeAddGroup.negRev` is an involution. In other words, applying the function `FreeAddGroup.negRev` twice to `L₁` yields `L₁` itself. This function `FreeAddGroup.negRev` first negates the boolean in each pair, and then reverses the entire list, which essentially represents the negative of a free group element. So, the theorem asserts that the negative of the negative of any element in the free group is the element itself.

For any list of pairs from an arbitrary type with boolean values, the function `FreeAddGroup.negRev` applying negation and list reversal twice results in the original list.


/-- Alternative description of `χ₄ n` for odd `n : ℕ` in terms of powers of `-1`  -/
theorem ZMod.χ₄_eq_neg_one_pow : ∀ {n : ℕ}, n % 2 = 1 → ZMod.χ₄ ↑n = (-1) ^ (n / 2) := by sorry

This theorem presents an alternative characterization for the nontrivial quadratic character `χ₄` on the integers modulo 4, when applied to an odd natural number `n`. It states that for any natural number `n` such that `n mod 2 = 1` (which ensures `n` is odd), the result of applying `χ₄` to `n` (converted into an integer modulo 4) is equivalent to `-1` raised to the power of `n divided by 2`.
In other words, for odd natural numbers, the quadratic character `χ₄` can be computed as the power of `-1` where the exponent is the integer division of `n` by 2.

For odd natural numbers n, the quadratic character χ₄ maps n to (-1)^(n/2) modulo 4.


theorem Set.zero_mem_sub_iff : ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α}, 0 ∈ s - t ↔ ¬Disjoint s t := by sorry

This theorem states that for any type `α` that forms an additive group, given any two sets `s` and `t` of elements of this type, the additive identity `0` is an element of the difference set `s - t` if and only if the sets `s` and `t` are not disjoint. Here, a difference set `s - t` refers to the set of all elements `x` such that `x` is in `s` and `x` is not in `t`. Two sets are disjoint if every element `x` that is less than or equal to both `s` and `t` is also less than or equal to the bottom element `⊥`.

For any additive group `α`, the additive identity `0` is an element of the difference `s - t` of sets `s` and `t` if and only if `s` and `t` have non-empty intersection.


theorem finprod_def' :
    ∀ {M : Type u_7} {α : Sort u_8} [inst : CommMonoid M] (f : α → M),
      finprod f =
        if h : Set.Finite (Function.mulSupport (f ∘ PLift.down)) then
          Finset.prod (Set.Finite.toFinset h) fun i => f i.down
        else 1 :=
  by sorry

The theorem `finprod_def'` states that for any type `M` with a commutative monoid structure and any function `f` from an arbitrary type `α` to `M`, the finitary product `finprod f` is defined as follows: If the multiplicative support of the function `f` composed with the function that extracts a value from a `PLift` object (i.e., `f ∘ PLift.down`) is a finite set (i.e., there exists a natural number `n` and an equivalence between this set and `Fin n`), then `finprod f` is the product of `f x` for `x` ranging over the elements of this finite set. This product is computed using the function `Finset.prod`, which takes a finite set and a function, and computes the product of the function values over the elements of the finite set. We obtain a finite set from the finite multiplicative support using the `Set.Finite.toFinset` function. On the other hand, if the multiplicative support of `f ∘ PLift.down` is not a finite set, then `finprod f` is defined to be `1` (the multiplicative identity in the commutative monoid `M`).

If the multiplicative support of a function from an arbitrary type to a commutative monoid with a finite multiplicative support has a finite image under the extraction function, then the finitary product is the product of the function values on those images; otherwise, the finitary product is the identity element.


theorem Semiquot.ext_s : ∀ {α : Type u_1} {q₁ q₂ : Semiquot α}, q₁ = q₂ ↔ q₁.s = q₂.s := by sorry

This theorem states that for any type `α`, and any two objects `q₁` and `q₂` of type `Semiquot α`, `q₁` is equal to `q₂` if and only if the `.s` field of `q₁` is equal to the `.s` field of `q₂`. In other words, two semiquotients of the same type are equal exactly when their `.s` fields, which represent the underlying set, are equal.

For any type `α` and semiquotients `q₁` and `q₂` of type `Semiquot α`, `q₁ = q₂` if and only if `q₁.s = q₂.s`.


theorem Mathlib.MeasureTheory.Measure.Restrict._auxLemma.11 :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p : α → Prop},
      (∀ᵐ (a : α) ∂μ, p a) = (↑↑μ {a | ¬p a} = 0) :=
  by sorry

This theorem states that for any type `α` that has a `MeasurableSpace` instance, a measure `μ` on that `α`, and a predicate `p` on `α`, the condition that `p` holds almost everywhere (i.e., for `μ`-almost every `a` in `α`) is equivalent to the measure of the set of all `a` in `α` for which `p` does not hold being zero.

For any measurable space `(α, Σ, μ)`, predicate `p` on `α`, the condition that `p` holds almost everywhere (i.e., for `μ`-almost all `a` in `α`) is equivalent to the measure of the set of `a` in `α` where `p` does not hold being zero.


Continuous.isClosedMap

/-- A continuous map from a compact space to a Hausdorff space is a closed map.  -/
theorem Continuous.isClosedMap :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : CompactSpace X]
      [inst_3 : T2Space Y] {f : X → Y}, Continuous f → IsClosedMap f :=
  by sorry

The theorem states that a continuous map from a compact space to a Hausdorff space is a closed map. In other words, for any types `X` and `Y` with topological space structures, if `X` is compact, `Y` is a Hausdorff space, and `f` is a continuous function from `X` to `Y`, then `f` is a closed map. A closed map being a function such that the image of any closed set in `X` is also closed in `Y`.

A continuous function from a compact space to a Hausdorff space is a closed map.


theorem Fin.succ_ne_zero : ∀ {n : ℕ} (k : Fin n), Fin.succ k ≠ 0 := by sorry

The theorem `Fin.succ_ne_zero` states that for any natural number `n` and any `k` in the finite set `Fin n`, the successor of `k` in the finite set `Fin (Nat.succ n)` is not zero. In other words, it asserts that when we increment any element in a finite set of natural numbers, the result is never zero. This reflects the fact that there is no wrap-around in the increment operation in the set of natural numbers.

For all natural numbers `n` and `k` in `Fin n`, the successor of `k` in `Fin (Nat.succ n)` is non-zero.


theorem Nat.ceil_natCast :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] (n : ℕ), ⌈↑n⌉₊ = n := by sorry

This theorem, `Nat.ceil_natCast`, states that for any natural number `n`, when this number is cast to a type `α` (which is a linear ordered semiring and a floor semiring), and we take the ceiling of this value, we will always get back `n`. In other words, the ceiling of a natural number, when it is considered as a real number, is just the number itself.

For any natural number `n` and any linear ordered semiring and floor semiring type `α`, the ceiling of `n` cast to `α` is equal to `n`.


theorem Mathlib.Data.Real.NNReal._auxLemma.7 : ∀ {r : NNReal}, (↑r = 0) = (r = 0) := by sorry

This theorem states that for any nonnegative real number `r`, `r` is equal to `0` if and only if its coercion to a real number is equal to `0`. In other words, a nonnegative real number `r` is zero if and only if it is zero when considered as a real number. This theorem connects the equality of `r` in two different types, `NNReal` and `Real` - asserting that equality in one implies equality in the other.

For any nonnegative real number `r`, `r = 0` if and only if its real number representation `real r = 0`.


ContinuousAt.add

theorem ContinuousAt.add :
    ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : Add M]
      [inst_3 : ContinuousAdd M] {f g : X → M} {x : X},
      ContinuousAt f x → ContinuousAt g x → ContinuousAt (fun x => f x + g x) x :=
  by sorry

The theorem `ContinuousAt.add` states that for any two functions `f` and `g` from a topological space `X` to another topological space `M` equipped with an addition operation, if both `f` and `g` are continuous at a point `x` in `X`, then their pointwise sum function, which maps each point in `X` to the sum of `f` and `g` evaluated at that point, is also continuous at `x`. Here, continuity of a function at a point is defined as the function's output values tending to the output value at the given point as the inputs tend to that point. This is under the assumption that the addition operation in `M` is continuous.

If functions `f` and `g` from topological space `X` to a topologically closed and commutative group `M` with continuous addition are continuous at a point `x` in `X`, then their pointwise sum `f + g` is also continuous at `x`.


theorem Equiv.leftInverse_symm : ∀ {α : Sort u} {β : Sort v} (f : α ≃ β), Function.LeftInverse ⇑f.symm ⇑f := by sorry

The theorem `Equiv.leftInverse_symm` states that for any equivalence `f` between two types `α` and `β`, the inverse of `f` (denoted by `f.symm`) is a left inverse to `f`. In other words, for every element `x` of type `α`, applying `f` followed by `f.symm` returns the original element `x`. This means `f.symm ∘ f = id` for all `x` in `α`.

For any equivalence relation `f` between types `α` and `β`, the inverse `f.symm` of `f` is a left inverse, i.e., `f.symm ∘ f = id` on `α`.


theorem SetTheory.PGame.numeric_zero : SetTheory.PGame.Numeric 0 := by sorry

The theorem `SetTheory.PGame.numeric_zero` states that the zero pre-game in set theory is numeric. In this context, a pre-game is numeric if all elements in the left set are less than all elements in the right set, and all elements of the left and right sets are also numeric. The zero pre-game, represented as `0`, satisfies these conditions and thus is considered numeric.

The theorem `SetTheory.PGame.numeric_zero` asserts that the set `0` (zero) is numeric in the context of set theory pre-games, meaning that all elements in `0` are less than all elements outside of `0`.


theorem Mathlib.Data.Nat.Cast.SetInterval._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.OrdConnected (Set.Ici a) = True := by sorry

The theorem `Mathlib.Data.Nat.Cast.SetInterval._auxLemma.1` states that for any type `α` with a preorder and any element `a` of type `α`, the left-closed right-infinite interval starting from `a` (denoted as `Set.Ici a`) is order-connected. In mathematical terms, it means that for any two points `x` and `y` in the interval `Set.Ici a` where `x ≤ y`, all points `z` such that `x ≤ z ≤ y` are also in `Set.Ici a`.

For any type `α` with a preorder and any element `a` of type `α`, the left-closed right-infinite interval `Set.Ici a` is an order-connected set. (That is, all points `x ≤ y` in the interval have all points `z` between them also in the interval.)


theorem LinearPMap.le_of_le_graph :
    ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
      [inst_3 : AddCommGroup F] [inst_4 : Module R F] {f g : E →ₗ.[R] F},
      LinearPMap.graph f ≤ LinearPMap.graph g → f ≤ g :=
  by sorry

The theorem `LinearPMap.le_of_le_graph` states that for any ring `R`, and any two linear maps `f` and `g` from a module `E` over `R` to a module `F` over `R` (where `E` and `F` are also additive commutative groups), if the graph of `f` is a sub-module of (or equal to) the graph of `g`, then `f` is less than or equal to `g`. The 'graph' of a linear map here refers to the set of tuples `(x, f(x))` for all `x` in the domain of `f`.

If `f` and `g` are linear maps from module `E` to module `F` over ring `R`, and the graph of `f` is contained in the graph of `g`, then `f ≤ g`.


theorem sub_eq_of_eq_add' : ∀ {G : Type u_3} [inst : AddCommGroup G] {a b c : G}, a = b + c → a - b = c := by sorry

This theorem states that for any type `G` which is an instance of `AddCommGroup` (i.e., it's a group under commutative addition), given any three elements `a`, `b`, and `c` of this type, if `a` is equal to the sum of `b` and `c` (`a = b + c`), then the difference of `a` and `b` (`a - b`) is equal to `c`. This is a property of subtraction in the context of a commutative additive group.

In a commutative additive group, if `a = b + c`, then `a - b = c`.


/-- Product of elements of a list `L` equals zero if and only if `0 ∈ L`. See also
`List.prod_eq_zero` for an implication that needs weaker typeclass assumptions.  -/
theorem List.prod_eq_zero_iff :
    ∀ {M₀ : Type u_8} [inst : MonoidWithZero M₀] [inst_1 : Nontrivial M₀] [inst_2 : NoZeroDivisors M₀] {L : List M₀},
      List.prod L = 0 ↔ 0 ∈ L :=
  by sorry

This theorem states that for a list `L` of elements of type `M₀`, where `M₀` is a monoid with zero, nontrivial, and with no zero divisors, the product of the elements of `L` is zero if and only if zero is an element of `L`. In other words, the combined multiplication of all elements in the list `L` results in zero specifically when the list `L` contains at least one zero. The theorem also refers to `List.prod_eq_zero` for a similar statement that requires less restrictive assumptions on the type `M₀`.

For a list of elements from a monoid `M₀` with no zero divisors and a zero element, the product of the list is zero if and only if the list contains the zero element.


theorem List.prod_set :
    ∀ {M : Type u_5} [inst : Monoid M] (L : List M) (n : ℕ) (a : M),
      List.prod (List.set L n a) =
        (List.prod (List.take n L) * if n < List.length L then a else 1) * List.prod (List.drop (n + 1) L) :=
  by sorry

The theorem `List.prod_set` states that for any list of elements of monoidal type `M`, replacing an element at position `n` in the list with a new element `a` and then taking the product of the list is the same as taking the product of the first `n` elements of the original list (or all elements if `n` is greater than the length of the list), multiplying it by `a` (or `1` if `n` is greater than or equal to the length of the list), and then multiplying the result by the product of the rest of the elements in original list after position `n`. Therefore, changing a single element in a list does not affect the product of the list elements outside of the new value replacing the old one at the specified index.

For any monoidal type `M` and list `ls` of length `n+1`, replacing the `n`-th element of `ls` with `a` preserves the product of `ls`, that is, `ls.take(n) &* a &* ls.drop(n) = ls.take(n+1).product`.


theorem Finset.le_inf' :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) (f : β → α) {a : α},
      (∀ b ∈ s, a ≤ f b) → a ≤ Finset.inf' s H f :=
  by sorry

The theorem `Finset.le_inf'` states that for any types `α` and `β` with `α` being a meet-semilattice, for any nonempty finite set `s` of type `β`, any function `f` from `β` to `α`, and any element `a` of type `α`, if `a` is less than or equal to the image of every element of `s` under `f`, then `a` is less than or equal to the infimum of the image of `s` under `f`. This infimum of the image under `f` is computed using the function `Finset.inf'`.

For any meet-semilattice `α`, if `f : β → α` is a function and `a ∈ α` satisfies `a ≤ f x` for all `x ∈ nonempty finite s : β`, then `a ≤ Finset.inf' s f`.


theorem sdiff_sdiff_right :
    ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], x \ (y \ z) = x \ y ⊔ x ⊓ y ⊓ z := by sorry

This theorem, `sdiff_sdiff_right`, states that for any type `α` that forms a Generalized Boolean Algebra, and any elements `x`, `y`, `z` of this type, the set difference of `x` and the set difference of `y` and `z` equals the join of the set difference of `x` and `y` with the meet of `x`, `y`, and `z`. In mathematical notation, this can be written as: \(x \ (y \ z) = x \ y \cup (x \cap y \cap z)\).

For any type `α` forming a Generalized Boolean Algebra and elements `x`, `y`, `z` of `α`, `x ∖ (y ∖ z) = (x ∖ y) ⋃ (x ∩ y ∩ z)`.


/-- In "English notation", a Young diagram is drawn so that (i1, j1) ≤ (i2, j2)
means (i1, j1) is weakly up-and-left of (i2, j2).  -/
theorem YoungDiagram.up_left_mem :
    ∀ (μ : YoungDiagram) {i1 i2 j1 j2 : ℕ}, i1 ≤ i2 → j1 ≤ j2 → (i2, j2) ∈ μ → (i1, j1) ∈ μ := by sorry

The theorem `YoungDiagram.up_left_mem` states that for any Young diagram `μ` and for any four natural numbers i1, i2, j1, j2, if i1 is less than or equal to i2 and j1 is less than or equal to j2, and if the pair (i2, j2) is in `μ`, then the pair (i1, j1) is also in `μ`. In other words, if a point is in the Young diagram, then any point weakly up-and-left of it is also in the diagram.

If (i1, j1) is a weakly northwest lying cell of a Young diagram μ, and (i2, j2) is a cell in μ with i1 ≤ i2 and j1 ≤ j2, then (i1, j1) is also in μ.


theorem Mathlib.CategoryTheory.Preadditive.Generator._auxLemma.1 :
    ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) := by sorry

This theorem states that for any type `G` that forms an additive group, and any two elements `a` and `b` of `G`, the statement "`a` minus `b` equals zero" is equivalent to the statement "`a` equals `b`". In other words, in any additive group, subtracting an element from itself always results in the zero element of that group.

In an additive group, for all elements `a` and `b`, `a - b = 0` if and only if `a = b`.


theorem Multiset.eq_replicate :
    ∀ {α : Type u_1} {a : α} {n : ℕ} {s : Multiset α},
      s = Multiset.replicate n a ↔ Multiset.card s = n ∧ ∀ b ∈ s, b = a :=
  by sorry

The theorem `Multiset.eq_replicate` in Lean 4 states that for any given type `α`, element `a` of type `α`, natural number `n`, and a multiset `s` of type `α`, the multiset `s` is equal to the multiset produced by `Multiset.replicate n a` (which is a multiset containing only `a` with multiplicity `n`) if and only if the cardinality (number of elements, including duplicates) of `s` is `n` and every element `b` in `s` is equal to `a`.

A multiset `s` of type `α` equals the multiset `Multiset.replicate n a` if and only if `s` has cardinality `n` and consists only of elements equal to `a`.


PartialHomeomorph.injOn

theorem PartialHomeomorph.injOn :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y), Set.InjOn (↑e) e.source :=
  by sorry

The theorem `PartialHomeomorph.injOn` states that for any two topological spaces `X` and `Y`, any partial homeomorphism `e` from `X` to `Y` is injective on its source set. This means that if `x₁` and `x₂` are any two elements in the source set where `x₁` is not equal to `x₂`, then their images under the partial homeomorphism `e`, i.e., `e(x₁)` is not equal to `e(x₂)`.

For any partial homeomorphism between topological spaces, its source set elements map distinctly to their images.


theorem FractionalIdeal.mem_one_iff :
    ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {x : P}, x ∈ 1 ↔ ∃ x', (algebraMap R P) x' = x :=
  by sorry

The theorem `FractionalIdeal.mem_one_iff` states that for any given commutative rings `R` and `P` with an algebra structure, and for any submonoid `S` of `R` and any element `x` of `P`, `x` is an element of the unit ideal in the ring `P` if and only if there exists an element `x'` in `R` such that `x'` mapped into `P` using the algebra structure is equal to `x`. Here, `FractionalIdeal` is a concept in commutative algebra used to generalize the idea of an ideal in a ring, and `algebraMap` is a function embedding `R` into `A` given by the algebra structure.

For a commutative ring `R` with algebra structure over a commutative ring `P`, an element `x` of `P` belongs to the unit ideal of `P` if and only if there exists an element `x'` in `R` such that `x'` maps to `x` under the algebra map from `R` to `P`.


theorem PadicSeq.norm_nonneg : ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p), 0 ≤ PadicSeq.norm f := by sorry

The theorem `PadicSeq.norm_nonneg` states that for any natural number `p`, given that `p` is prime, and for any sequence `f` of Cauchy sequences of rationals with respect to the `p`-adic norm, the norm of this sequence `f`, as calculated by the `PadicSeq.norm` function, is always nonnegative. In other words, the norm of a p-adic Cauchy sequence is always greater than or equal to zero.

For any prime number `p` and any Cauchy sequence `f` of rationals with respect to the `p`-adic norm, `PadicSeq.norm f ≥ 0`.


/-- A partial homeomorphism is an open map on its source:
the image of an open subset of the source is open.  -/
theorem PartialHomeomorph.isOpen_image_of_subset_source :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {s : Set X}, IsOpen s → s ⊆ e.source → IsOpen (↑e '' s) :=
  by sorry

The theorem `PartialHomeomorph.isOpen_image_of_subset_source` states that a partial homeomorphism is an open mapping on its source set. More specifically, it means that for any types `X` and `Y` equipped with topological spaces, given a partial homeomorphism `e` from `X` to `Y` and a set `s` in `X` that is open and is a subset of the source of `e`, the image of `s` under `e` (denoted as `e '' s`) is also an open set. Thus, it assures the preservation of open sets under partial homeomorphisms, which is a key property in topology.

Given a partial homeomorphism between topological spaces, the image of any open and subset of its source set is an open set.


Convex.add

theorem Convex.add :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      {s t : Set E}, Convex 𝕜 s → Convex 𝕜 t → Convex 𝕜 (s + t) :=
  by sorry

The theorem `Convex.add` states that for any ordered semiring `𝕜` and any type `E` that forms an additive commutative monoid and is a `𝕜`-module, if `s` and `t` are two convex sets in `E`, then their Minkowski sum (denoted `s + t`), is also a convex set in `E`. In other words, the sum of two convex sets in a vector space over an ordered semiring is also a convex set in that vector space.

If `𝕜` is an ordered semiring, `E` is an additive commutative monoid and a `𝕜`-module, and `s` and `t` are convex sets in `E`, then their Minkowski sum `s + t` is also a convex set in `E`.


theorem derivWithin_univ :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, derivWithin f Set.univ = deriv f :=
  by sorry

This theorem, `derivWithin_univ`, states that for any function `f` from a nontrivially normed field `𝕜` to a normed group `F`, the derivative of `f` at any point `x` within the universal set (which contains all elements of `𝕜`) is equal to the derivative of `f` at `x`. In mathematical terms, for any function `f : 𝕜 → F`, the derivative of `f` within the entire domain `𝕜` (represented by `Set.univ` or the universal set) at any point is the same as the general derivative of `f` at that point.

For any function `f` from a nontrivially normed field to a normed group, the derivative of `f` at any point within the universal set equals the general derivative of `f` at that point.


theorem Ordinal.nat_cast_mul : ∀ (m n : ℕ), ↑(m * n) = ↑m * ↑n := by sorry

This theorem, named `Ordinal.nat_cast_mul`, states that for any two natural numbers `m` and `n`, the result of their multiplication when cast to an ordinal is equal to the product of their individual castings to ordinals. In mathematical terms, if you first multiply two natural numbers and then convert the result to an ordinal, it is the same as if you first convert each natural number to an ordinal, multiply those ordinals, and then take the result.

For all natural numbers m and n, (m : Ordinal) * (n : Ordinal) = (m * n : Ordinal).


theorem Real.hasDerivAt_sqrt : ∀ {x : ℝ}, x ≠ 0 → HasDerivAt Real.sqrt (1 / (2 * Real.sqrt x)) x := by sorry

The theorem `Real.hasDerivAt_sqrt` states that for all real numbers `x`, if `x` is not equal to 0, then the square root function `Real.sqrt` has a derivative at the point `x` which is equal to `1 / (2 * Real.sqrt x)`. This means that the rate of change of the square root function at any non-zero point `x` is given by `1 / (2 * Real.sqrt x)`. This is a formalization of the well-known result from calculus that the derivative of the square root of `x` is `1 / (2 * sqrt(x))`, where `sqrt(x)` denotes the square root of `x`.

For all non-zero real numbers x, the derivative of the square root function at x is 1 / (2 * √x).


theorem Polynomial.mul_X_comp :
    ∀ {R : Type u} [inst : Semiring R] {p r : Polynomial R},
      Polynomial.comp (p * Polynomial.X) r = Polynomial.comp p r * r :=
  by sorry

The theorem `Polynomial.mul_X_comp` states that for any semiring `R` and any polynomials `p` and `r` over `R`, the composition of the polynomial `p * Polynomial.X` with `r` is equal to the composition of `p` with `r` times `r`. In other words, `(p * X) ∘ r = (p ∘ r) * r`, where `X` is the polynomial variable, `∘` denotes composition of polynomials, and `*` denotes multiplication of polynomials. The result holds regardless of the specific semiring and the specific polynomials chosen.

For any semiring `R` and polynomials `p` and `r` over `R`, the composition of `p * X` with `r` equals the product of the compositions of `p` with `r` and `r`, where `X` is the polynomial variable, and `*` and `∘` denote multiplication and composition of polynomials, respectively.


theorem PNat.one_le : ∀ (n : ℕ+), 1 ≤ n := by sorry

The theorem `PNat.one_le` states that for all positive natural numbers `n` (`ℕ+`), `n` is greater than or equal to 1. That is, no positive natural number is less than 1.


theorem eq_bot_or_bot_lt : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] (a : α), a = ⊥ ∨ ⊥ < a := by
  sorry

This theorem, `eq_bot_or_bot_lt`, states that for any value `a` of a type `α` that has a partial order and a least element (`⊥`), `a` is either equal to the least element (`⊥`) or is greater than the least element. In mathematical terms, for all `a` in a partially ordered set `α` with a smallest element, `a` is either equal to `⊥` or `a` is larger than `⊥`.

For all partially ordered sets `α` with a smallest element `⊥`, every element `a` in `α` is either equal to `⊥` or strictly greater than `⊥`.


theorem CategoryTheory.transferNatTransSelf_id :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C}
      (adj₁ : L₁ ⊣ R₁),
      (CategoryTheory.transferNatTransSelf adj₁ adj₁) (CategoryTheory.CategoryStruct.id L₁) =
        CategoryTheory.CategoryStruct.id R₁ :=
  by sorry

This theorem states that for any two categories `C` and `D` of types `u₁` and `u₂` respectively, and any two functors `L₁` and `R₁` from `C` to `D` and from `D` to `C` respectively, if `L₁` is left adjoint to `R₁` (denoted as `L₁ ⊣ R₁`), then the natural transformation associated with the identity morphism on `L₁` under the transfer operation (i.e., `CategoryTheory.transferNatTransSelf adj₁ adj₁ (CategoryTheory.CategoryStruct.id L₁)`) is equal to the identity morphism on `R₁` (`CategoryTheory.CategoryStruct.id R₁`). In other words, the identity morphism on a functor is preserved under the adjunction transfer operation.

For any functors `L₁ : C → D` and `R₁ : D → C` with `L₁` left adjoint to `R₁`, the natural transformation `transferNatTransSelf adj₁ adj₁ (id L₁)` equals `id R₁`.


theorem CauSeq.coe_smul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {G : Type u_3} [inst_3 : SMul G β] [inst_4 : IsScalarTower G β β] (a : G)
      (f : CauSeq β abv), ↑(a • f) = a • ↑f :=
  by sorry

The theorem `CauSeq.coe_smul` states that for any linear ordered field α, ring β, an absolute value function 'abv' of β into α, a type G that is a scalar multiple on β, and an instance where β is a scalar tower over G and β, and given any element 'a' of G and any Cauchy sequence 'f' of type β with respect to the absolute value function 'abv', the coercion of the scalar multiplication of 'a' and 'f' equals to the scalar multiplication of 'a' and the coercion of 'f'.

For any linear ordered field α, ring β with an absolute value function 'abv', scalar multiple type G over β and β, and elements 'a' in G and Cauchy sequence 'f' in β, the coercion of 'a' times 'f' equals 'a' times the coercion of 'f'.


theorem IsAtom.lt_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a x : α}, IsAtom a → (x < a ↔ x = ⊥) := by sorry

The theorem `IsAtom.lt_iff` states that for any type `α` that has a partial order and a least element (denoted by `⊥`), given any elements `a` and `x` of `α`, if `a` is an atom (meaning that there exists no element between `a` and `⊥`, and `a` is not `⊥`), then `x` is less than `a` if and only if `x` is equal to `⊥`.

For any type with a partial order and a least element, an atom (which is neither the least element nor equal to it) is related to any other element via the partial order if and only if that other element is the least element.


theorem LieAlgebra.derivedSeriesOfIdeal_le :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {I J : LieIdeal R L}
      {k l : ℕ}, I ≤ J → l ≤ k → LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L l J :=
  by sorry

The theorem `LieAlgebra.derivedSeriesOfIdeal_le` states that for any commutative ring `R`, any Lie ring `L`, any Lie algebra `L` over `R`, and any two Lie ideals `I` and `J` of this Lie algebra, along with two natural numbers `k` and `l`, if Lie ideal `I` is a subset of Lie ideal `J` and `l` is less than or equal to `k`, then the `k`-th derived series of the ideal `I` is a subset of the `l`-th derived series of the ideal `J`. In other words, this theorem shows a monotonic property of the derived series of an ideal in a Lie algebra: The derived series of a smaller ideal and higher order is contained in the derived series of a larger ideal and lower order.

For any commutative ring R, Lie ring L, Lie algebra L over R, Lie ideals I and J of L, and natural numbers k ≥ l, if I ⊆ J and k ≤ l then d^k(I) ⊆ d^l(J), where d^i denotes the i-th derived series of an ideal.


/-- Let `f` be a local homeomorphism of a nontrivially normed field, let `a` be a point in its
target. if `f` is `n` times continuously differentiable at `f.symm a`, and if the derivative at
`f.symm a` is nonzero, then `f.symm` is `n` times continuously differentiable at the point `a`.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function.  -/
theorem PartialHomeomorph.contDiffAt_symm_deriv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ∞} [inst_1 : CompleteSpace 𝕜] (f : PartialHomeomorph 𝕜 𝕜)
      {f₀' a : 𝕜},
      f₀' ≠ 0 →
        a ∈ f.target →
          HasDerivAt (↑f) f₀' (↑(PartialHomeomorph.symm f) a) →
            ContDiffAt 𝕜 n (↑f) (↑(PartialHomeomorph.symm f) a) → ContDiffAt 𝕜 n (↑(PartialHomeomorph.symm f)) a :=
  by sorry

The theorem `PartialHomeomorph.contDiffAt_symm_deriv` states that given a local homeomorphism `f` of a nontrivially normed field, and a point `a` in the target of `f`, if `f` is `n` times continuously differentiable at `f.symm a` (the preimage of `a` under `f`), and the derivative of `f` at `f.symm a` is not zero, then the inverse of `f` (denoted `f.symm`) is `n` times continuously differentiable at the point `a`. This theorem is part of the inverse function theorem, under the assumption that an inverse function already exists.

If a local homeomorphism of a nontrivially normed field is `n` times continuously differentiable at the preimage of a point with non-zero derivative, then its inverse is `n` times continuously differentiable at that point.


theorem CategoryTheory.Mat.hom_ext :
    ∀ {R : Type u} [inst : Semiring R] {X Y : CategoryTheory.Mat R} (f g : X ⟶ Y),
      (∀ (i : ↑X) (j : ↑Y), f i j = g i j) → f = g :=
  by sorry

This theorem states that for any semiring `R`, and any two objects `X` and `Y` in the category `CategoryTheory.Mat R` (which is equipped with a category structure where the morphisms are matrices with components in `R`), if two morphisms `f` and `g` from `X` to `Y` are such that their corresponding entries are equal for all indices `i` in `X` and `j` in `Y`, then the two morphisms `f` and `g` are equal. In other words, two morphisms in this category are considered equal if and only if their matrix representations are elementwise equal.

In the category of matrices over a semiring `R`, two morphisms have equal matrix representations if and only if they are equal as morphisms.


theorem Matroid.Basis.subset_ground : ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.Basis I X → X ⊆ M.E := by sorry

This theorem is stating that for any type `α` and a `Matroid` `M` of that type, and any two sets `I` and `X` of type `α`, if `I` is a basis of `X` in `M` (denoted as `M.Basis I X`), then `X` is a subset of the ground set of `M` (denoted as `M.E`). In mathematical terms, if $I$ is a basis of $X$ in a matroid $M$, it implies that $X$ is included in the ground set of $M$.

If `α` is a type and `M` is a Matroid of type `α`, then for any sets `I` and `X` of type `α` with `I` being a basis of `X` in `M`, we have `X ⊆ M.E`.


theorem Ordinal.card_type :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r], Ordinal.card (Ordinal.type r) = Cardinal.mk α := by
  sorry

The theorem `Ordinal.card_type` states that for any type `α` and a relation `r` on `α` that forms a well order, the cardinality of the ordinal corresponding to the order type `r` is equal to the cardinal number of the type `α`. In layman's terms, it says that the size (cardinality) of the set of order types of well-orders on a type `α` is the same as the size of the set `α` itself.

For any type `α` and well-order `r` on `α`, the order type `r` has the same cardinality as `α`.


theorem Ideal.comap_top :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] {f : F}, Ideal.comap f ⊤ = ⊤ :=
  by sorry

The theorem `Ideal.comap_top` states that for any semirings `R` and `S`, any type `F` that behaves like a function from `R` to `S` (`FunLike F R S`), and any ring homomorphism `f` of type `F`, the preimage of the entire ring `S` (`⊤`) under `f` is the entire ring `R` (`⊤`). In other words, the preimage of the top ideal of `S` under any ring homomorphism is the top ideal of `R`.

For any semirings R and S, any FunLike F from R to S, and any ring homomorphism f : F, the preimage of the top ideal of S under f is the top ideal of R.


theorem zpow_bit0_nonneg : ∀ {α : Type u_1} [inst : LinearOrderedField α] (a : α) (n : ℤ), 0 ≤ a ^ bit0 n := by sorry

The theorem `zpow_bit0_nonneg` states that for any linearly ordered field `α`, and for any elements `a` from `α` and `n` from integers `ℤ`, the result of raising `a` to the power of two times `n` (`a ^ (2n)`) is always non-negative (greater than or equal to zero). In simpler terms, it asserts that, in a linearly ordered field, the square of any integer power of any element is non-negative. Here `bit0 n` is a function that doubles the integer `n`, and `0 ≤ a ^ bit0 n` is the non-negativity claim.

In a linearly ordered field, for all elements `a` and integers `n`, `a ^ (2n)` is non-negative.


theorem t2Space_iff_disjoint_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], T2Space X ↔ Pairwise fun x y => Disjoint (nhds x) (nhds y) := by sorry

This theorem states that for any type `X` equipped with a topological structure, `X` is a T2-space (also known as a Hausdorff space) if and only if for every pair of distinct elements `x` and `y` in `X`, the neighborhoods of `x` and `y` are disjoint. In mathematical terms, the neighborhoods are disjoint if their intersection is the bottom element, symbolically represented as `⊥`. Here, 'disjoint' is generalized from the notion of disjoint sets to elements of a lattice by defining two elements as disjoint if their infimum (greatest lower bound) is the bottom element.

A topological space `X` is T2 (Hausdorff) if and only if for all distinct points `x` and `y` in `X`, the neighborhood filters of `x` and `y` have empty intersection (i.e., their infimum is the bottom element).


theorem isLocalHomeomorph_iff_isLocalHomeomorphOn_univ :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      IsLocalHomeomorph f ↔ IsLocalHomeomorphOn f Set.univ :=
  by sorry

This theorem states that for any function `f` from a type `X` to a type `Y`, where `X` and `Y` are equipped with some topological spaces, the function `f` is a local homeomorphism if and only if it is a local homeomorphism on the universal set in `X`. In other words, `f` is a local homeomorphism (meaning, every point in `X` is contained in the source of some partial homeomorphism that equals `f`) if and only if this condition holds when we restrict our attention to the universal set in `X` (which contains all elements of `X`).

A function `f : X → Y` between topological spaces `X` and `Y` is a local homeomorphism if and only if it is a local homeomorphism on the universal set of `X`.


theorem Subgroup.index_dvd_of_le :
    ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G}, H ≤ K → Subgroup.index K ∣ Subgroup.index H := by sorry

This theorem states that for any given group `G`, if `H` and `K` are subgroups of `G` and `H` is a subgroup of `K`, then the index of `K` in `G` divides the index of `H` in `G`. Here, the index of a subgroup is defined as the cardinality of the set of all left cosets of the subgroup in the group, or it is zero if this set is infinite. The theorem is about an important property of the index function in group theory.

If `H` is a subgroup of `K` and `K` is a subgroup of group `G`, then the index of `H` in `G` is a multiple of the index of `K` in `G`.


theorem gauge_ball :
    ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {r : ℝ},
      0 ≤ r → ∀ (x : E), gauge (Metric.ball 0 r) x = ‖x‖ / r :=
  by sorry

The theorem `gauge_ball` states that for any type `E` that is a semi-normed additive commutative group and a normed space over the set of real numbers, for any real number `r` greater than or equal to zero, and for any element `x` of `E`, the Minkowski functional (gauge) of the metric ball centered at 0 with radius `r` evaluated at `x` is equal to the norm of `x` divided by `r`. In other words, the smallest scalar `r` that scales the set such that `x` belongs to the set is equal to the norm of `x` divided by `r`, where the set is a metric ball (set of all points at a distance less than `r` from the origin).

For any semi-normed additive commutative group and normed space `E` over the real numbers, the Minkowski functional (gauge) of the metric ball centered at 0 with radius `r` is equal to the norm of `x` divided by `r` for all `x` in `E` and `r` greater than or equal to the norm of `x`.


theorem CategoryTheory.Pretriangulated.id_hom₁ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      (A : CategoryTheory.Pretriangulated.Triangle C),
      (CategoryTheory.CategoryStruct.id A).hom₁ = CategoryTheory.CategoryStruct.id A.obj₁ :=
  by sorry

This theorem, `CategoryTheory.Pretriangulated.id_hom₁`, states that for any category `C` with a shift and any pretriangulated triangle `A` in that category, the first morphism (`hom₁`) of the identity morphism on `A` is equal to the identity morphism on the first object (`obj₁`) of `A`. In other words, in the context of pretriangulated categories, the identity morphism on a triangle preserves the identity of the first object of the triangle.

In a pretriangulated category with shift, the identity morphism on a triangle maps the first object to itself.


theorem CategoryTheory.Pretriangulated.id_hom₂ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      (A : CategoryTheory.Pretriangulated.Triangle C),
      (CategoryTheory.CategoryStruct.id A).hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ :=
  by sorry

The theorem `CategoryTheory.Pretriangulated.id_hom₂` states that for any category `C` of a certain type, given that `C` has a shift structure over the integers (`ℤ`), for any pretriangulated triangle `A` in `C`, the `hom₂` (second homomorphism) of the identity of `A` is equal to the identity of the object `obj₂` of `A`. In other words, applying the identity morphism of the triangle to the second homomorphism results in the same object as applying the identity morphism to the second object of the triangle.

For any pretriangulated category `C` with shift structure over `ℤ`, the identity morphism of a triangle in `C` equals the second homomorphism on the identity morphism of the second object of the triangle.


theorem CategoryTheory.Pretriangulated.id_hom₃ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
      (A : CategoryTheory.Pretriangulated.Triangle C),
      (CategoryTheory.CategoryStruct.id A).hom₃ = CategoryTheory.CategoryStruct.id A.obj₃ :=
  by sorry

This theorem, `CategoryTheory.Pretriangulated.id_hom₃`, states that for every pre-triangulated category `C` (of any type `u`) that also has an integer (ℤ) shift, and for any given triangle `A` in this category, the third morphism `hom₃` of the identity morphism on `A` is equal to the identity morphism on the third object `obj₃` of `A`. In essence, this theorem ensures that the identity operation is preserved when applying the third morphism in a triangle in a pre-triangulated category.

In a pre-triangulated category with integer shifts, the third morphism of the identity on an object equals the identity morphism on the third object in any triangle.


theorem Turing.ListBlank.head_map :
    ∀ {Γ : Type u_1} {Γ' : Type u_2} [inst : Inhabited Γ] [inst_1 : Inhabited Γ'] (f : Turing.PointedMap Γ Γ')
      (l : Turing.ListBlank Γ), Turing.ListBlank.head (Turing.ListBlank.map f l) = f.f (Turing.ListBlank.head l) :=
  by sorry

The theorem `Turing.ListBlank.head_map` states that for any `ListBlank` `l` of type `Γ` and any pointed map `f` from `Γ` to `Γ'`, the result of applying `f` to the head of `l` is the same as the head of the result of mapping `f` over `l`. That is, when we have an infinitely extendable list (a `ListBlank`) and a function that can be applied to each element of the list, applying this function to the first element of the list is the same as first applying the function to all elements of the list and then taking the first element. This aligns with the expected behaviour of the `map` operation in functional programming.

For any `ListBlank` `l` of type `Γ` and any pointed map `f` from `Γ` to `Γ'`, the head of `map f l` equals `f (head l)`.


theorem Polynomial.support_eq_empty :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.support p = ∅ ↔ p = 0 := by sorry

This theorem states that for any type `R` which forms a semiring, and for any polynomial `p` with coefficients in `R`, the support of the polynomial `p` (that is, the set of all exponents `n` such that `X^n` has a non-zero coefficient in the polynomial) is empty if and only if the polynomial `p` is the zero polynomial. In other words, a polynomial has no non-zero coefficients if and only if it is the zero polynomial.

A polynomial over a semiring has an empty support if and only if it is the zero polynomial.


theorem AffineEquiv.pointReflection_apply :
    ∀ (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
      [inst_3 : AddTorsor V₁ P₁] (x y : P₁), (AffineEquiv.pointReflection k x) y = x -ᵥ y +ᵥ x :=
  by sorry

The theorem `AffineEquiv.pointReflection_apply` states that for any type `k` having a ring structure, types `P₁` and `V₁` where `V₁` is an additive commutative group and a module over `k`, and `P₁` is an additive torsor over `V₁`, for any points `x` and `y` in `P₁`, applying the point reflection affine equivalence at `x` to `y` gives `x -ᵥ y +ᵥ x`. In other words, the point reflection of a point `y` in a point `x` is obtained by subtracting the vector from `y` to `x` from `x`, and then adding the result to `x`.

For any additive torsor `P₁` over an additive commutative group `V₁` (which is a module over a ring `k`), and any points `x` and `y` in `P₁`, the point reflection of `y` in `x` is given by `x - y + x`.


theorem update_le_iff :
    ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Preorder (π i)] {x y : (i : ι) → π i}
      {i : ι} {a : π i}, Function.update x i a ≤ y ↔ a ≤ y i ∧ ∀ (j : ι), j ≠ i → x j ≤ y j :=
  by sorry

The theorem `update_le_iff` states that, for all index types `ι`, value types `π` (which is a function of `ι`), a decidable equality instance on `ι`, a preorder instance on each `π i`, and functions `x` and `y` from `ι` to `π i`, along with a specific index `i` and a value `a` of type `π i`, the updated function `x` with `a` at position `i` is less than or equal to `y` if and only if `a` is less than or equal to the value of `y` at index `i` and for all other indices `j` not equal to `i`, the value of `x` at `j` is less than or equal to the value of `y` at `j`. In simpler terms, updating a function at a specific index doesn't change the order relationship of the function at other indices.

For functions from an index type to a preordered type, updating one index with a value less than or equal to the existing value at that index preserves the preorder relationship with the function at all other indices.


theorem iSup_insert :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s : Set β} {b : β},
      ⨆ x ∈ insert b s, f x = f b ⊔ ⨆ x ∈ s, f x :=
  by sorry

This theorem, `iSup_insert`, states that for any types `α` and `β` where `α` is a complete lattice, given a function `f` from `β` to `α`, a set `s` of `β`, and an element `b` of `β`, the supremum (`⨆`) of `f` over all elements `x` in the set obtained by inserting `b` into `s` is equal to the supremum of the function `f` applied to `b` and the supremum of `f` over all elements in the original set `s`. This essentially states a property of the supremum operation in the context of complete lattices and sets.

For any complete lattice `α`, function `f` from a set `β` to `α`, set `s ⊆ β`, and element `b ∈ β`, we have `⨆(f ∪ {(b, f(b))}) = ⨆(f(s)) ⊔ f(b)`, where `⊔` denotes the join (supremum) operation in `α`.


theorem tsub_le_iff_tsub_le :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, a - b ≤ c ↔ a - c ≤ b :=
  by sorry

This theorem states that for any type `α` which has an order defined (`Preorder α`), an addition operation (`AddCommSemigroup α`), a subtraction operation (`Sub α`), and a subtraction operation that respects the order (`OrderedSub α`), and for any three elements `a`, `b`, and `c` of this type, the condition "the result of subtracting `b` from `a` is less than or equal to `c`" is equivalent to "the result of subtracting `c` from `a` is less than or equal to `b`". This theorem is a formalization of a property of subtraction in the context of pre-ordered commutative additive groups.

For any pre-ordered commutative additive group `(α, <, +)`, for all `a, b, c ∈ α`, `a - b ≤ c` if and only if `c - a ≤ b`.


theorem IsRelPrime.add_mul_left_left :
    ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime (x + y * z) y := by sorry

The theorem `IsRelPrime.add_mul_left_left` states that for any commutative ring `R`, and any elements `x`, `y`, and `z` of `R`, if `x` and `y` are relatively prime (that is, their only common divisors are units), then `x + y * z` and `y` are also relatively prime. In other words, multiplying `y` by any element `z` and adding the result to `x` does not introduce any new common divisors with `y`, other than the units.

If `x` and `y` are relatively prime elements in a commutative ring `R`, then `x` and `y + x * z` are relatively prime for all `z` in `R`.


theorem Ideal.absNorm_span_singleton :
    ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDomain S] [inst_2 : Nontrivial S] [inst_3 : IsDedekindDomain S]
      [inst_4 : Module.Free ℤ S] [inst_5 : Module.Finite ℤ S] (r : S),
      Ideal.absNorm (Ideal.span {r}) = Int.natAbs ((Algebra.norm ℤ) r) :=
  by sorry

This theorem, `Ideal.absNorm_span_singleton`, states that for any commutative ring `S` that is also a domain, nontrivial, a Dedekind domain, Z-module free, and Z-module finite, for any element `r` of `S`, the absolute norm of the ideal generated by `r` is equal to the absolute value (considering the absolute value on integers) of the norm of `r` considered as an element of an integer algebra. The absolute norm of an ideal is defined as the cardinality of the quotient of the ring by the ideal, and the norm of an element of an `R`-algebra is the determinant of the multiplication by that element.

For any commutative domain `S` that is a Dedekind domain, Z-module free and finite, the absolute norm of the ideal generated by an element `r` in `S` equals the absolute value of the norm of `r` considered as an element of the ring of integers algebra over `S`.


theorem Real.exp_sub : ∀ (x y : ℝ), Real.exp (x - y) = Real.exp x / Real.exp y := by sorry

The theorem `Real.exp_sub` states that for any two real numbers `x` and `y`, the exponential function of the difference `(x - y)` is equal to the quotient of the exponential function of `x` divided by the exponential function of `y`. This is expressed mathematically as: for all real numbers x and y, `exp(x - y) = exp(x) / exp(y)`, where `exp` denotes the real exponential function.

The real exponential function satisfies the property `exp(x - y) = exp(x) / exp(y)` for all real numbers `x` and `y`.


theorem Urysohns.CU.approx_le_one :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {P : Set X → Prop} (c : Urysohns.CU P) (n : ℕ) (x : X),
      Urysohns.CU.approx n c x ≤ 1 :=
  by sorry

This theorem states that for any type 'X' equipped with a topological space structure, any predicate 'P' on the set of 'X', any Urysohn's lemma function 'c' based on 'P', any natural number 'n', and any element 'x' of type 'X', the Urysohn's lemma approximation function `Urysohns.CU.approx` applied to 'n', 'c', and 'x' will always be less than or equal to one. In other words, it guarantees that the values generated by Urysohn's lemma approximation function will not exceed one.

For any topological space 'X' and predicate 'P' on 'X', the Urysohn's lemma approximation function `Urysohns.CU.approx` applied to any Urysohn's lemma function 'c' based on 'P', any natural number 'n', and any element 'x' in 'X' satisfies `Urysohns.CU.approx n c x ≤ 1`.


theorem AddMonoid.exponent_eq_zero_iff :
    ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.exponent G = 0 ↔ ¬AddMonoid.ExponentExists G := by sorry

This theorem states that for any additive monoid `G`, the exponent of `G` equals to `0` if and only if there does not exist a positive integer `n` such that `n • g = 0` for all `g` in `G`. In other words, the exponent of an additive monoid is zero if and only if it's impossible to find a positive integer that when scaled by any element of the group results in the additive identity (zero).

The additive monoid has exponent 0 if and only if there is no positive integer that annihilates all its elements.


theorem sub_eq_self : ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a - b = a ↔ b = 0 := by sorry

This theorem states that for all types `G` that have an additive group structure, the difference of two elements `a` and `b` of `G` is equal to `a` if and only if `b` is the zero element of the group. In mathematical terms, it states that for all `a` and `b` in an additive group `G`, `a - b = a` if and only if `b = 0`.

For every additive group `G`, the element `b` is the zero element of `G` if and only if the difference of any element `a` from `G` and `b` is equal to `a`.


Quaternion.ext

theorem Quaternion.ext :
    ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R),
      a.re = b.re → a.imI = b.imI → a.imJ = b.imJ → a.imK = b.imK → a = b :=
  by sorry

This theorem is stating that for any commutative ring `R` and any two quaternions `a` and `b` over this ring, if the real part of `a` equals the real part of `b`, the coefficient of `i` in `a` equals the coefficient of `i` in `b`, the coefficient of `j` in `a` equals the coefficient of `j` in `b`, and the coefficient of `k` in `a` equals the coefficient of `k` in `b`, then `a` and `b` must be the same quaternion. This is essentially saying that two quaternions are equal if and only if their corresponding components are equal.

Given a commutative ring `R`, if for any two quaternions `a` and `b` over `R` with equal real parts and identical coefficients of `i`, `j`, and `k`, then `a` and `b` are equal.


PartialHomeomorph.leftInvOn

theorem PartialHomeomorph.leftInvOn :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y), Set.LeftInvOn (↑(PartialHomeomorph.symm e)) (↑e) e.source :=
  by sorry

The theorem `PartialHomeomorph.leftInvOn` states that for any two given types `X` and `Y`, which have their respective topological space structures, and given a partial homeomorphism `e` from `X` to `Y`, the function `e` restricted to its source set has a left inverse given by the inverse of `e`. In other words, applying the inverse of `e` after `e` to any element in the source of `e` will get you back the original element.

Given a partial homeomorphism `e` from topological spaces `X` and `Y`, the restriction of `e` on its source set has a left inverse equal to the inverse of `e`.


theorem IntermediateField.separable_of_mem_isSeparable :
    ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : IntermediateField F E}
      [inst_3 : IsSeparable F ↥L] {x : E}, x ∈ L → Polynomial.Separable (minpoly F x) :=
  by sorry

The theorem `IntermediateField.separable_of_mem_isSeparable` states that for any field `F` and `E` with `E` being an algebra over `F`, and given an intermediate field `L` which is separable over `F`, then for any element `x` that belongs to `L`, the minimal polynomial of `x` over `F` is a separable polynomial. Here, a separable polynomial is defined to be one that is coprime with its derivative.

If `F` is a field, `E` is an algebra over `F`, `L` is a separable extension of `F`, and `x` is an element of `L`, then the minimal polynomial of `x` over `F` is separable.


theorem CategoryTheory.Iso.symm_self_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y),
      α.symm ≪≫ α = CategoryTheory.Iso.refl Y :=
  by sorry

This theorem states that for any category `C` and any objects `X` and `Y` in `C`, given an isomorphism `α` between `X` and `Y`, the composition of the inverse of `α` and `α` itself results in the identity isomorphism on `Y`. In other words, the inverse of an isomorphism followed by the isomorphism gives you back the identity. This is similar to the principle in mathematics where the inverse of a function followed by the function itself yields the identity function.

For any isomorphism α between objects X and Y in a category C, α⁻¹ ∘ α = idY, where idY is the identity isomorphism on Y.


theorem smul_pow :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : MulAction M N]
      [inst_3 : IsScalarTower M N N] [inst_4 : SMulCommClass M N N] (r : M) (x : N) (n : ℕ),
      (r • x) ^ n = r ^ n • x ^ n :=
  by sorry

The theorem `smul_pow` states that for any two types `M` and `N` where `M` is a monoid, `N` is a monoid, there is a multiplication action of `M` on `N`, `N` is a scalar tower over `M`, and the scalar multiplication on `M` and `N` commutes, if you have an element `r` of `M`, an element `x` of `N`, and a natural number `n`, then the `n`-th power of the scalar multiplication of `r` and `x` is equal to the scalar multiplication of the `n`-th power of `r` and the `n`-th power of `x`. In mathematical terms, this can be written as `(r • x) ^ n = r ^ n • x ^ n`.

For any monoids M and N with scalar multiplication action on N commuting with scalar multiplication, and any element r in M and natural number n, (r * x) ^ n = r ^ n * x ^ n holds for all x in N.


theorem smul_nonneg :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulZeroClass α β]
      [inst_3 : Preorder α] [inst_4 : Preorder β] [inst_5 : PosSMulMono α β], 0 ≤ a → 0 ≤ b₁ → 0 ≤ a • b₁ :=
  by sorry

This theorem, `smul_nonneg`, states that for any types `α` and `β`, and for any elements `a` of type `α` and `b₁` of type `β`, given that `α` and `β` have zero elements, `α` and `β` form a scalar multiplication zero class, and both `α` and `β` are preordered (that is, they are equipped with an associative, transitive and reflexive relation), and positive scalar multiplication is monotonic on `α` and `β`, then if `a` and `b₁` are both nonnegative (i.e., `0 ≤ a` and `0 ≤ b₁`), the scalar multiplication of `a` and `b₁` (denoted as `a • b₁`) is also nonnegative (i.e., `0 ≤ a • b₁`).

If `α` and `β` are preordered types with zero elements and scalar multiplication is monotonic and defines a zero class, then for all nonnegative `a` in `α` and `b₁` in `β`, `a • b₁` is nonnegative.


theorem Set.union_prod :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t : Set β}, (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t := by sorry

The theorem `Set.union_prod` states that for any types `α` and `β`, any sets `s₁` and `s₂` of type `α`, and any set `t` of type `β`, the cartesian product of the union of `s₁` and `s₂` with `t` is equal to the union of the cartesian product of `s₁` with `t` and the cartesian product of `s₂` with `t`. In other words, it expresses a distributive property of the cartesian product operation over the union operation in the context of sets. Mathematically, this can be written as: $(s₁ ∪ s₂) × t = (s₁ × t) ∪ (s₂ × t)$.

The cartesian product of the union of two sets with a third set is equal to the union of the cartesian products of each pair of sets.


theorem Mathlib.MeasureTheory.Measure.Haar.Basic._auxLemma.30 : ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) := by sorry

This theorem, in the context of measure theory in the Haar package of Mathlib, states that for any two non-negative real numbers `r₁` and `r₂`, the proposition that `r₁` is less than or equal to `r₂` is equivalent to the proposition that the real number equivalent of `r₁` is less than or equal to the real number equivalent of `r₂`. In other words, the order relation on the non-negative real numbers is the same as the order relation on the corresponding real numbers.

For any non-negative real numbers `r₁` and `r₂`, `r₁ ≤ r₂` if and only if their real numbers representations `ℝ(r₁)` and `ℝ(r₂)` satisfy `ℝ(r₁) ≤ ℝ(r₂)`.


theorem Mathlib.MeasureTheory.Measure.Haar.Basic._auxLemma.34 : ∀ {p q : NNReal}, (↑p = ↑q) = (p = q) := by sorry

The theorem `Mathlib.MeasureTheory.Measure.Haar.Basic._auxLemma.34` states that for every two non-negative real numbers `p` and `q` (represented as `NNReal`), the statement that their real number equivalents (obtained by the coercion `↑`) are equal is equivalent to the statement that `p` and `q` themselves are equal. This theorem essentially confirms that the equality of `p` and `q` in the `NNReal` type corresponds directly to their equality as real numbers.

The theorem asserts that two non-negative real numbers `p` and `q` are equal if and only if their real number representations `↑p` and `↑q` are equal.


theorem iInf_le_iInf_of_subset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s t : Set β},
      s ⊆ t → ⨅ x ∈ t, f x ≤ ⨅ x ∈ s, f x :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is a complete lattice, and for any function `f` from `β` to `α` and any two sets `s` and `t` of type `β`, if `s` is a subset of `t`, then the infimum (greatest lower bound) of the image of `t` under `f` is less than or equal to the infimum of the image of `s` under `f`. In other words, if we apply `f` to each element of `t` and `s` and take the greatest lower bound of the results, the value for `t` will be less than or equal to the value for `s`.

For any complete lattice `α`, function `f` from type `β` to `α`, and sets `s` and `t` of type `β` with `s` a subset of `t`, the infimum of `f``[t]` is less than or equal to the infimum of `f``[s]`. Here, `f``[X]` denotes the image of set `X` under function `f`.


theorem Finset.prod_eq_single :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] {s : Finset α} {f : α → β} (a : α),
      (∀ b ∈ s, b ≠ a → f b = 1) → (a ∉ s → f a = 1) → (Finset.prod s fun x => f x) = f a :=
  by sorry

This theorem, `Finset.prod_eq_single`, states that for any types `α` and `β`, given a commutative monoid instance on `β`, a finite set `s` of `α`, a function `f` from `α` to `β`, and an element `a` of `α`, if it holds that the function `f` maps any element `b` in the set `s` not equal to `a` to the identity element `1`, and if `a` is not in the set `s`, then `f a` is also `1`, then the product of the function `f` over all elements `x` in `s`, denoted `(Finset.prod s fun x => f x)`, is equal to `f a`. In other words, the product of `f x` across all `x` in `s` collapses to `f a` under these conditions.

Given a commutative monoid `β`, a finite set `s` of `α`, a function `f` from `α` to `β` such that `f x = 1` for all `x in s` except possibly `x = a not in s`, then `(∏ x ∈ s. f x) = f a`.


theorem realPart_apply_coe :
    ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A]
      (a : A), ↑(realPart a) = 2⁻¹ • (a + star a) :=
  by sorry

This theorem, `realPart_apply_coe`, states that for any element `a` from a Star Module `A` over the complex numbers (ℂ), where `A` is also an additive commutative group and a Star Additive Monoid, the real part of `a` (denoted as `ℜ a`) when casted, equals half of the sum of `a` and its conjugate (`star a`). In other words, the real part of `a` in such context is computed as one-half times the sum of `a` and its complex conjugate.

For any complex number `a` in a star module `A` over ℂ that is an additive commutative group and a star additive monoid, the real part `ℜ a` is equal to (1/2) * (a + conjugate `a`).


theorem CategoryTheory.Iso.inv_ext' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : Y ⟶ X},
      CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.id X → g = f.inv :=
  by sorry

This theorem, `CategoryTheory.Iso.inv_ext'`, states that for any category `C` and any two objects `X` and `Y` in `C`, if `f` is an isomorphism from `X` to `Y` and `g` is a morphism from `Y` to `X`, then if the composition of `f` and `g` equals the identity morphism on `X`, it follows that `g` equals the inverse of `f`. In simpler terms, if applying `f` then `g` leaves an object unchanged, then `g` undoes exactly what `f` does.

If `f: X ➝ Y` is an isomorphism in a category `C` and `g: Y ➝ X` is a morphism such that `g ∘ f = id_X`, then `g = f^(-1)`.


/-- The symmetric product of vectors is a scalar  -/
theorem CliffordAlgebra.ι_mul_ι_add_swap :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} (a b : M),
      (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b + (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a =
        (algebraMap R (CliffordAlgebra Q)) (QuadraticForm.polar (⇑Q) a b) :=
  by sorry

This theorem, titled `CliffordAlgebra.ι_mul_ι_add_swap`, states that for any commutative ring `R`, additive commutative group `M` which is also a module over `R`, and any quadratic form `Q` on `M`, the symmetric product of two vectors `a` and `b` under the canonical linear map from `M` to the Clifford Algebra of `Q`, when added together, equals the image of the polar of the quadratic form `Q` at `a` and `b` under the embedding from `R` to the Clifford Algebra of `Q`. In mathematical terms, it says that $(ι(a) * ι(b) + ι(b) * ι(a)) = η(Q_p(a, b))$ where `ι` is the canonical linear map, `η` is the algebra map, and `Q_p` is the polar of the quadratic form `Q`.

For any commutative ring `R`, additive commutative group `M` being an `R`-module, and quadratic form `Q` on `M`, the symmetric product of two vectors `a` and `b` under the canonical linear map to the Clifford Algebra of `Q` equals the polar form value of `Q` at `a` and `b` under the algebra map. In symbols: $(ι(a) * ι(b) + ι(b) * ι(a)) = η(Q\_p(a, b))$.


theorem Metric.isClosed_sphere :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, IsClosed (Metric.sphere x ε) := by sorry

The theorem `Metric.isClosed_sphere` states that for any given type `α` that has a `PseudoMetricSpace` structure, any point `x` of type `α`, and any real number `ε`, the sphere centered at `x` with radius `ε` is a closed set. Here, a 'sphere' is defined as the set of all points `y` such that the distance between `y` and `x` is equal to `ε`. The concept of 'closed set' is defined per the topology induced by the pseudometric on `α`.

For any type `α` with a `PseudoMetricSpace` structure and any `x : α` and real `ε`, the sphere centered at `x` with radius `ε` is a closed set in the topology induced by the pseudometric on `α`.


/-- **Alias** of `not_isMin_of_lt`. -/
theorem LT.lt.not_isMin : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → ¬IsMin a := by sorry

This theorem states that for any ordered type `α`, if there exists an element `b` that is strictly less than `a` (`b < a`), then `a` cannot be a minimal element of `α`. In other words, if there is an element that is smaller than `a`, then `a` is not the smallest possible element in `α`.

If an ordered type `α` has an element `b` such that `b < a`, then `a` is not the minimum element of `α`.


theorem FractionalIdeal.map_comp :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      {P' : Type u_3} [inst_3 : CommRing P'] [inst_4 : Algebra R P'] {P'' : Type u_4} [inst_5 : CommRing P'']
      [inst_6 : Algebra R P''] (I : FractionalIdeal S P) (g : P →ₐ[R] P') (g' : P' →ₐ[R] P''),
      FractionalIdeal.map (AlgHom.comp g' g) I = FractionalIdeal.map g' (FractionalIdeal.map g I) :=
  by sorry

The theorem `FractionalIdeal.map_comp` states that for any commutative ring `R`, any submonoid `S` of `R`, any fractional ideal `I` of a localization `P` of `R` at `S`, and any two algebra homomorphisms `g: P → P'` and `g': P' → P''`, the map of `I` through the composition of `g'` and `g` is equal to the map of the map of `I` through `g` through `g'`. In simpler terms, this theorem states that pushing forward a fractional ideal through a composition of algebra morphisms is the same as pushing forward separately through each morphism, which is an application of the principle of function composition.

For any commutative ring $R$, submonoid $S$ of $R$, fractional ideal $I$ of a localization $P$ of $R$ at $S$, and algebra homomorphisms $g: P \to P'$ and $g': P' \to P''$, the map of $I$ through the composition $g' \circ g$ is equal to the map of $I$ through $g$ composed with $g'$.


theorem MvPolynomial.eval_sub :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (p : MvPolynomial σ R) {q : MvPolynomial σ R} (f : σ → R),
      (MvPolynomial.eval f) (p - q) = (MvPolynomial.eval f) p - (MvPolynomial.eval f) q :=
  by sorry

The theorem `MvPolynomial.eval_sub` states that for any commutative ring `R` and any type `σ`, given any two multivariate polynomials `p` and `q` over the ring `R` with variables indexed by `σ`, and a valuation `f` of the variables, the result of evaluating the difference of `p` and `q` under valuation `f` is equal to the difference of the evaluation of `p` and the evaluation of `q` under the same valuation. In other words, it asserts the compatibility of evaluation with subtraction in the context of multivariate polynomials.

For any commutative ring R and type σ, given multivariate polynomials p and q over R indexed by σ, and a valuation f of the variables, the evaluation of p - q under f equals the evaluation of p under f - the evaluation of q under f.


theorem Polynomial.reflect_C_mul_X_pow :
    ∀ {R : Type u_1} [inst : Semiring R] (N n : ℕ) {c : R},
      Polynomial.reflect N (Polynomial.C c * Polynomial.X ^ n) =
        Polynomial.C c * Polynomial.X ^ (Polynomial.revAt N) n :=
  by sorry

The theorem `Polynomial.reflect_C_mul_X_pow` states that for any semiring `R`, for any positive integer `N` and `n`, and any constant `c` of type `R`, reflecting the polynomial `c * X^n` (where `X` is the polynomial variable) using `N` is equal to the polynomial `c * X^(revAt N n)`. Here, `revAt` is an operation that returns `N - n` if `n` is less than or equal to `N`, and `n` otherwise. Essentially, this theorem is about reflecting a polynomial that is a product of a constant and a power of the polynomial variable `X`.

For any semiring `R`, constant `c` of type `R`, positive integer `N`, and integer `n`, the reflected polynomial `c * X^n` using `N` equals `c * X^(revAt N n)`.


theorem Nat.sub_min_sub_right : ∀ (a b c : ℕ), min (a - c) (b - c) = min a b - c := by sorry

This theorem states that for any three natural numbers `a`, `b`, and `c`, the minimum of the difference between `a` and `c` and the difference between `b` and `c` is equal to the difference between the minimum of `a` and `b` and `c`. In other words, when subtracting `c` from both `a` and `b`, taking the minimum before or after the subtraction yields the same result.

For any natural numbers `a`, `b`, and `c`, `min (a - c) (b - c)` equals `min a b - c`.


theorem CategoryTheory.NatIso.isIso_map_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F₁ F₂ : CategoryTheory.Functor C D},
      (F₁ ≅ F₂) → ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso (F₁.map f) ↔ CategoryTheory.IsIso (F₂.map f) :=
  by sorry

This theorem states that for any two categories `C` and `D`, and any two functors `F₁` and `F₂` from `C` to `D`, if `F₁` is naturally isomorphic to `F₂`, then for any morphism `f` from object `X` to `Y` in `C`, `F₁` mapping `f` is an isomorphism if and only if `F₂` mapping `f` is an isomorphism. In other words, the isomorphism property of a morphism is preserved under a natural isomorphism of functors.

If functors $F\_1$ and $F\_2$ between categories $C$ and $D$ are naturally isomorphic, then for any isomorphism $f$ in $C$ between objects $X$ and $Y$, $F\_1(f)$ and $F\_2(f)$ are mutual inverses.


Convex.prod

theorem Convex.prod :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : AddCommMonoid F] [inst_3 : SMul 𝕜 E] [inst_4 : SMul 𝕜 F] {s : Set E} {t : Set F},
      Convex 𝕜 s → Convex 𝕜 t → Convex 𝕜 (s ×ˢ t) :=
  by sorry

The theorem `Convex.prod` states that for any set `s` of elements of type `E` and any set `t` of elements of type `F`, if `s` and `t` are convex under a semiring `𝕜` (which is an ordered semiring and has scalar multiplication defined for both `E` and `F`), then the Cartesian product of `s` and `t` is also convex under `𝕜`. Here, a set is convex if any point in the set `s` is a star center of `s`, meaning that for any two points in `s`, the line segment that connects them is also entirely contained within `s`. In the context of this theorem, a Cartesian product of two sets is a set of all ordered pairs where the first element of each pair is from the first set and the second element is from the second set.

If sets `s` and `t` are convex under a semiring `𝕜` with ordered and scalar multiplication defined for types `E` and `F` respectively, then the Cartesian product `s × t` is also convex under `𝕜`.


theorem Complex.cos_eq_zero_iff : ∀ {θ : ℂ}, Complex.cos θ = 0 ↔ ∃ k, θ = (2 * ↑k + 1) * ↑Real.pi / 2 := by sorry

This theorem states that for any complex number `θ`, the complex cosine function `Complex.cos θ` is equal to zero if and only if there exists an integer `k` such that `θ` equals `(2k + 1) * π / 2`, where `π` is the real number pi. In mathematical notation, this is saying: for all complex numbers `θ`, `cos(θ) = 0` if and only if `∃ k ∈ ℤ, θ = (2k + 1) * π / 2`.

The complex cosine function equals zero if and only if the argument is a multiple of pi over 2, plus or minus an integer.


theorem pow_sub₀ :
    ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] (a : G₀) {m n : ℕ}, a ≠ 0 → n ≤ m → a ^ (m - n) = a ^ m * (a ^ n)⁻¹ :=
  by sorry

This theorem states that for any type `G₀` that forms a group with zero, and for any element `a` of type `G₀` and natural numbers `m` and `n` such that `a` is not zero and `n` is less than or equal to `m`, the power of `a` to the difference of `m` and `n` (`m - n`) equals to the product of the power of `a` to `m` and the inverse of the power of `a` to `n` (`a ^ m * (a ^ n)⁻¹`). This theorem essentially expresses the basic property of exponents in the context of groups.

For any group `G₀` with identity `0`, and for all `a ≠ 0` in `G₀` and natural numbers `m ≥ n`, `a ^ (m - n) = a ^ m * (a ^ n)⁻¹`.


/-- A helper lemma used to prove that the (scalar or usual) product of a function that
tends to zero and a bounded function tends to zero. This lemma is formulated for any binary
operation `op : E → F → G` with an estimate `‖op x y‖ ≤ ‖x‖ * ‖y‖` instead of multiplication so
that it can be applied to `(*)`, `flip (*)`, `(•)`, and `flip (•)`. -/
theorem Filter.Tendsto.op_zero_isBoundedUnder_le :
    ∀ {α : Type u_3} {E : Type u_6} {F : Type u_7} {G : Type u_8} [inst : SeminormedAddGroup E]
      [inst_1 : SeminormedAddGroup F] [inst_2 : SeminormedAddGroup G] {f : α → E} {g : α → F} {l : Filter α},
      Filter.Tendsto f l (nhds 0) →
        Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ g) →
          ∀ (op : E → F → G),
            (∀ (x : E) (y : F), ‖op x y‖ ≤ ‖x‖ * ‖y‖) → Filter.Tendsto (fun x => op (f x) (g x)) l (nhds 0) :=
  by sorry

This theorem states that for any types `α`, `E`, `F`, and `G`, where `E`, `F`, and `G` are seminormed additive groups, given a filter `l` over `α` and functions `f : α → E` and `g : α → F`, if `f` tends to zero with respect to the filter `l` and the norm of `g` is bounded under the filter `l`, then for any binary operation `op : E → F → G` that satisfies a specific inequality related to norms (namely, the norm of the operation applied to any `x : E` and `y : F` is less than or equal to the product of the norms of `x` and `y`), the function that maps `x` in the domain of the filter to the operation applied to `f(x)` and `g(x)` also tends to zero with respect to `l`. In layman's terms, it states that the product of a function tending to zero and a bounded function also tends to zero under specific conditions.

If `f : α → E` tends to zero under filter `l` and the norm of `g : α → F` is bounded under `l`, then the function `x ↦ op(f(x), g(x))` tends to zero under `l`, given `op : E → F → G` satisfying the norm inequality: ||op(x, y)|| ≤ ||x|| * ||y|| for all `x : E` and `y : F`.


theorem nhdsWithin_inter :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (s t : Set α),
      nhdsWithin a (s ∩ t) = nhdsWithin a s ⊓ nhdsWithin a t :=
  by sorry

The theorem `nhdsWithin_inter` states that for any type `α` that is a topological space and for any element `a` of that type, as well as for any two sets `s` and `t` of that type, the neighborhood within the intersection of `s` and `t` at `a` is equal to the intersection of the neighborhoods within `s` and `t` at `a`. In other words, it establishes the equality between the topological neighborhood within the intersection of two sets and the intersection of the topological neighborhoods within each set, for a given point. This is akin to the distributive property in algebra.

For any topological space `α` and elements `a` in `α`, the neighborhood filter of `a` in the intersection of sets `s` and `t` equals the intersection of the neighborhood filters of `a` in `s` and `t`.


theorem Set.inter_compl_nonempty_iff : ∀ {α : Type u} {s t : Set α}, Set.Nonempty (s ∩ tᶜ) ↔ ¬s ⊆ t := by sorry

The theorem `Set.inter_compl_nonempty_iff` states that for any type `α` and for any sets `s` and `t` of type `α`, the set `s` has a non-empty intersection with the complement of `t` if and only if `s` is not a subset of `t`. In other words, there exists at least one element in set `s` that is not in set `t` if and only if `s` is not entirely contained within `t`.

For sets $s$ and $t$ of type $\alpha$, $s$ has a non-empty intersection with the complement of $t$ if and only if $s$ is not a subset of $t$.


theorem OnePoint.infty_not_mem_image_coe : ∀ {X : Type u_1} {s : Set X}, OnePoint.infty ∉ OnePoint.some '' s := by sorry

This theorem states that, for any type `X` and any set `s` of elements of type `X`, the point at infinity (represented as `OnePoint.infty`) is not a member of the image of the set `s` under the function `OnePoint.some`. In other words, if we apply the `OnePoint.some` function to each element in the set `s` to obtain a new set, this new set will not contain the point at infinity.

For any set `s` of elements from type `X`, the image of `s` under the function `OnePoint.some` does not contain the point at infinity `OnePoint.infty`.


theorem Nat.add_mul_div_right : ∀ (x y : ℕ) {z : ℕ}, 0 < z → (x + y * z) / z = x / z + y := by sorry

This theorem states that for all natural numbers `x`, `y`, and `z`, given that `z` is greater than zero, the integer division of the sum of `x` and the product of `y` and `z` by `z` is equal to the sum of the integer division of `x` by `z` and `y`. This fits with the intuition that dividing a sum by a number distributes over the sum, at least when dealing with integer division where `z` is nonzero.

For all natural numbers x, y, and z with z > 0, (x + y * z) / z = x / z + y.


theorem CategoryTheory.Equivalence.fun_inv_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : D) (f : X ⟶ Y),
      e.functor.map (e.inverse.map f) =
        CategoryTheory.CategoryStruct.comp (e.counit.app X)
          (CategoryTheory.CategoryStruct.comp f (e.counitInv.app Y)) :=
  by sorry

The theorem `CategoryTheory.Equivalence.fun_inv_map` states that for any two categories `C` and `D` and an equivalence `e` between them, for any objects `X` and `Y` in `D` and a morphism `f` from `X` to `Y`, the mapping of the inverse of `f` under the functor of the equivalence `e` is equal to the composition of the application of the counit of the equivalence `e` to `X`, `f`, and the application of the inverse of the counit of the equivalence `e` to `Y`. This is a statement about how morphisms and objects behave under equivalences in category theory.

For any equivalence `e` between categories `C` and `D` and morphism `f` in `D`, the inverse of `f` under the functor of `e` is equal to the composition of the counit of `e` at the source of `f`, `f`, and the counit of `e` at the target of `f` inverse.


IsExtrFilter.congr

theorem IsExtrFilter.congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      IsExtrFilter f l a → f =ᶠ[l] g → f a = g a → IsExtrFilter g l a :=
  by sorry

The theorem `IsExtrFilter.congr` states that, for any types `α` and `β` with a preorder structure on `β`, and for any real-valued functions `f` and `g` on `α`, if `f` has an extremum (either a minimum or a maximum) at a point `a` with respect to a filter `l`, and `f` is eventually equal to `g` at `l`, and the values of `f` and `g` at `a` are equal, then `g` also has an extremum at `a` with respect to the same filter `l`. Essentially, this theorem asserts that the property of having an extremum under a certain filter is preserved under eventual equality of functions.

If function `f` has an extremum at point `a` with respect to filter `l` in types `α` and `β` with a preorder, and `f` is eventually equal to `g` at `l` and `f(a) = g(a)`, then `g` also has an extremum at `a` with respect to filter `l`.


Function.Surjective.subsingleton

/-- If the domain of a surjective function is a subsingleton, then the codomain is a subsingleton as
well.  -/
theorem Function.Surjective.subsingleton :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} [inst : Subsingleton α], Function.Surjective f → Subsingleton β := by
  sorry

This theorem states that if a function `f` from `α` to `β` is surjective (i.e. for every element `b` in `β`, there exists some element `a` in `α` such that `f(a) = b`), and if `α` is a subsingleton (i.e., `α` has at most one element), then `β` is also a subsingleton. In other words, if we have a surjective function whose domain contains at most one element, then its codomain must also contain at most one element.

If a surjective function maps a subsingleton domain to a codomain, then the codomain is also a subsingleton.


theorem Set.empty_diff : ∀ {α : Type u} (s : Set α), ∅ \ s = ∅ := by sorry

The theorem `Set.empty_diff` states that for all types `α` and for any set `s` of type `α`, the difference between the empty set and `s` is the empty set. In mathematical terms, this is equivalent to saying that the set difference between the empty set (∅) and any set `s` is always the empty set (∅). The `\` symbol represents the set difference operation.

For all types α and sets s of α, the set difference between the empty set and s is the empty set. (In mathematical notation: ∅ \ s = ∅)


theorem ZFSet.mem_insert_iff : ∀ {x y z : ZFSet}, x ∈ insert y z ↔ x = y ∨ x ∈ z := by sorry

This theorem states that for any three elements `x`, `y`, and `z` from the ZFC universe of sets, `x` is an element of the set formed by inserting `y` into `z` if and only if `x` is equal to `y` or `x` is an element of `z`. This is a statement of the basic property of set formation in Zermelo-Fraenkel set theory.

For any sets x, y, and z, x is an element of {y | z} if and only if x is equal to y or x is an element of z. (This is the definition of set formation in Zermelo-Fraenkel set theory.)


theorem Summable.tsum_mul_left :
    ∀ {ι : Type u_1} {α : Type u_4} [inst : NonUnitalNonAssocSemiring α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalSemiring α] {f : ι → α} [inst_3 : T2Space α] (a : α),
      Summable f → ∑' (i : ι), a * f i = a * ∑' (i : ι), f i :=
  by sorry

The theorem `Summable.tsum_mul_left` states that, for any index type `ι`, any type `α` that is a non-unital non-associative semiring and a topological space (and also a topological semiring and T2 space), for any function `f : ι → α`, and any element `a` of `α`, if `f` is summable, then the infinite sum of the series formed by multiplying each term of `f` by `a` equals the product of `a` and the infinite sum of `f`. Mathematically, it can be represented as if $\sum_{i} f(i)$ exists, then $\sum_{i} a*f(i) = a*\sum_{i} f(i)$.

For any index type `ι`, any non-unital non-associative semiring and topological space `α`, if `f : ι → α` is summable and `a` is an element of `α`, then $\sum\_{i} a*f(i) = a*\sum\_{i} f(i)$.


Filter.EventuallyLE.isMaxFilter

theorem Filter.EventuallyLE.isMaxFilter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      g ≤ᶠ[l] f → f a = g a → IsMaxFilter f l a → IsMaxFilter g l a :=
  by sorry

The theorem `Filter.EventuallyLE.isMaxFilter` states that for any types `α` and `β`, where `β` has a preorder, for any functions `f` and `g` from `α` to `β`, any element `a` of `α`, and any filter `l` on `α`, if `g` is less than or equal to `f` almost everywhere in the filter `l` and `f(a)` equals `g(a)`, then if `f` has a property that its value at `a` is a maximum among all values in a `l`-neighborhood of `a` (i.e., `f` satisfies the `IsMaxFilter` property at `a` with respect to `l`), then `g` also satisfies the `IsMaxFilter` property at `a` with respect to `l`. This theorem essentially says that if one function is less than or equal to another function almost everywhere within a certain context (the filter `l`), and they are equal at a certain point, then if the larger function has a maximum value at that point within the context, so does the smaller function.

If `f` satisfies `IsMaxFilter` property at `a` with respect to filter `l` over `α`, and `g` is less than or equal to `f` almost everywhere in `l`, then `g` also satisfies `IsMaxFilter` property at `a` with respect to `l`.


theorem differentiableAt_zpow :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {m : ℤ},
      DifferentiableAt 𝕜 (fun x => x ^ m) x ↔ x ≠ 0 ∨ 0 ≤ m :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and any point `x` from `𝕜` and integer `m`, the function `x ↦ x^m` is differentiable at `x` if and only if `x` is nonzero or `m` is nonnegative. In other words, in the context of a given field `𝕜`, the function which maps `x` to `x` raised to the power of `m` is differentiable at a point `x` exactly when `x` is not zero or `m` is zero or positive.

The function `x ↦ x^m` is differentiable at `x` in a nontrivially normed field if and only if `x` is nonzero or `m` is nonnegative.


theorem Polynomial.dvd_iff_isRoot :
    ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R},
      Polynomial.X - Polynomial.C a ∣ p ↔ Polynomial.IsRoot p a :=
  by sorry

The theorem `Polynomial.dvd_iff_isRoot` states that for any commutative ring `R`, an element `a` from `R`, and a polynomial `p` of coefficients from `R`, the polynomial `X - C a` (where `X` is the polynomial variable and `C a` is the constant polynomial `a`) divides `p` if and only if `a` is a root of `p`. In mathematical terms, \(x - a\) divides a polynomial \(p(x)\) if and only if \(a\) is a root of \(p(x)\) which means that the polynomial evaluated at \(a\) is zero.

For any commutative ring R, polynomial p, and element a from R, the polynomial X - a divides p if and only if a is a root of p, i.e., p(a) = 0.


theorem top_ne_bot : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [inst_2 : Nontrivial α], ⊤ ≠ ⊥ :=
  by sorry

The theorem `top_ne_bot` states that for any type `α` with a partial order, a bounded order, and is nontrivial (i.e., it contains at least two distinct elements), the top element (denoted by `⊤`) is not equal to the bottom element (denoted by `⊥`). This implies that in any nontrivial partially ordered set that also has a greatest and least element, these two elements are distinct.

In any nontrivial partially ordered set, the greatest element (top) is distinct from the least element (bottom).


theorem Nat.bodd_add : ∀ (m n : ℕ), Nat.bodd (m + n) = xor (Nat.bodd m) (Nat.bodd n) := by sorry

The theorem `Nat.bodd_add` states that for all natural numbers `m` and `n`, the parity (whether it is odd or even) of the sum `m + n` is the Boolean exclusive or (xor) of the parities of `m` and `n`. In other words, the sum of two numbers is odd if and only if exactly one of them is odd.

The parity of the sum of natural numbers is the XOR of their individual parities.


theorem Ideal.le_toIdeal_homogeneousHull :
    ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_4} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
      [inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜] (I : Ideal A),
      I ≤ HomogeneousIdeal.toIdeal (Ideal.homogeneousHull 𝒜 I) :=
  by sorry

This theorem, `Ideal.le_toIdeal_homogeneousHull`, asserts that for any semiring `A`, any ideal `I` in `A`, any function `𝒜` mapping from a type `ι` to a type `σ`, and given suitable conditions that `A` is `SetLike` (can be treated as a set) and `σ` is an `AddSubmonoidClass` of `A`, if `ι` has decidable equality and `ι` is an add monoid, and the function `𝒜` forms a graded ring, then the ideal `I` is less than or equal to the ideal obtained from converting the homogeneous hull of `I` with respect to `𝒜` into an ideal. In other words, the ideal `I` is contained within or equal to the ideal that results from taking the homogeneous hull of `I` and then converting that into an ideal. The homogeneous hull of an ideal is a type of "closure" of the ideal that includes all elements that can be formed by taking homogeneous elements (those that can be expressed as a single grade in a graded ring) from the ideal.

For any semiring `A`, ideal `I` in `A`, function `𝒜` mapping from a decidable add monoid `ι` to an add-submonoid `σ` of `A`, if `I` is contained in the ideal obtained from the homogeneous hull of `I` with respect to `𝒜`, then `I` is contained in or equal to the ideal generated by the homogeneous hull.


theorem IsAlgClosed.exists_root :
    ∀ {k : Type u} [inst : Field k] [inst_1 : IsAlgClosed k] (p : Polynomial k),
      Polynomial.degree p ≠ 0 → ∃ x, Polynomial.IsRoot p x :=
  by sorry

This theorem states that for any field `k`, given the condition that `k` is algebraically closed, for any polynomial `p` defined over `k`, if the degree of the polynomial is not zero, then there exists a root `x` in `k` such that `x` is a root of the polynomial `p`. In other words, any non-constant polynomial over an algebraically closed field has a root in that field.

If `k` is an algebraically closed field and `p` is a non-constant polynomial over `k`, then `p` has a root in `k`.


/-- Simplify subtraction for a torsor for an `AddGroup G` over
itself.  -/
theorem vsub_eq_sub : ∀ {G : Type u_1} [inst : AddGroup G] (g₁ g₂ : G), g₁ -ᵥ g₂ = g₁ - g₂ := by sorry

This theorem states that for any `AddGroup G` and any two elements `g₁` and `g₂` from `G`, the operation of "subtraction in the sense of torsors" (`g₁ -ᵥ g₂`) is equivalent to the standard subtraction operation (`g₁ - g₂`). Here, a torsor can be intuitively understood as a space that looks exactly like a given group, but doesn't have a designated "zero point". Its subtraction is defined in terms of the group operation, but without reference to any specific point.

For any AddGroup G and elements g₁, g₂ from G, the subtraction in the sense of torsors g₁ -ᵥ g₂ equals the standard subtraction g₁ - g₂.


/-- The inductively defined smallest congruence relation containing a binary relation `r` equals
the infimum of the set of congruence relations containing `r`.  -/
theorem RingCon.ringConGen_eq :
    ∀ {R : Type u_2} [inst : Add R] [inst_1 : Mul R] (r : R → R → Prop),
      ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y} :=
  by sorry

The theorem `RingCon.ringConGen_eq` states that for any type `R` that has both addition and multiplication operations, and any binary relation `r` on `R`, the smallest congruence relation containing `r` (which is inductively defined) is equal to the infimum of the set of all congruence relations that contain `r`. Here, a congruence relation on `R` is a relation that is compatible with the addition and multiplication operations on `R`. This theorem basically asserts the existence and uniqueness of the smallest congruence relation containing a given binary relation in the context of a ring.

The smallest congruence relation containing a binary relation on a ring is equal to the infimum of all congruence relations that contain it.


theorem Function.Bijective.existsUnique_iff :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → ∀ {p : β → Prop}, (∃! y, p y) ↔ ∃! x, p (f x) :=
  by sorry

The theorem `Function.Bijective.existsUnique_iff` states that for any two types `α` and `β` and a function `f` from `α` to `β`, if `f` is bijective, then for any property `p` satisfied by elements of `β`, there exists a unique `y` in `β` such that `p(y)` is true if and only if there exists a unique `x` in `α` such that `p(f(x))` is true. In other words, a property uniquely holds for an element in the codomain of a bijective function if and only if it uniquely holds for its preimage in the domain.

For a bijective function `f` from `α` to `β`, a property `p` holds uniquely for an element `y` in `β` if and only if it holds uniquely for the preimage `x` in `α` such that `f(x) = y`.


Set.Countable.insert

theorem Set.Countable.insert : ∀ {α : Type u} {s : Set α} (a : α), Set.Countable s → Set.Countable (insert a s) := by
  sorry

The theorem `Set.Countable.insert` states that for any type `α`, any set `s` of that type, and any element `a` of the type `α`, if the set `s` is countable, then the set that results from inserting the element `a` into the set `s` is also countable. Therefore, adding an element to a countable set does not change its countability.

If `α` is a type and `s : Set α` is countable, then `s.insert a` is also countable, where `a : α`.