/-- A family is affinely independent if and only if the differences
from a base point in that family are linearly independent.  -/
theorem affineIndependent_iff_linearIndependent_vsub :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {ι : Type u_4} (p : ι → P) (i1 : ι),
      AffineIndependent k p ↔ LinearIndependent k fun i => p ↑i -ᵥ p i1 :=
  by sorry

The theorem `affineIndependent_iff_linearIndependent_vsub` states that for any type `k` with a ring structure, and types `V` and `P` such that `V` is an additive commutative group and is a module over `k`, and `P` is an additive torsor over `V`, given a function `p` from type `ι` to `P` and an element `i1` of type `ι`, a family of points `p` in `P` indexed by `ι` is affinely independent if and only if the family of vectors obtained by subtracting the point `p i1` from each point `p i` (for `i` in `ι`) is linearly independent over `k`. In other words, no nontrivial linear combination of the differences between the points in the family and a fixed base point equals zero if and only if no nontrivial weighted subtraction of the points in the family (where the sum of the weights is zero) equals zero.

Given a ring `k`, an additive commutative group and `k`-module `V`, an additive torsor `P` over `V`, and a family `p` of points in `P`, the family is affinely independent if and only if the family of vectors obtained by subtracting a fixed point from each point in the family is linearly independent over `k`.


theorem continuous_if_le :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α]
      [inst_2 : OrderClosedTopology α] {f g : β → α} [inst_3 : TopologicalSpace β] [inst_4 : TopologicalSpace γ]
      [inst_5 : (x : β) → Decidable (f x ≤ g x)] {f' g' : β → γ},
      Continuous f →
        Continuous g →
          ContinuousOn f' {x | f x ≤ g x} →
            ContinuousOn g' {x | g x ≤ f x} →
              (∀ (x : β), f x = g x → f' x = g' x) → Continuous fun x => if f x ≤ g x then f' x else g' x :=
  by sorry

The theorem `continuous_if_le` states that given topological spaces `α`, `β`, and `γ`, and functions `f` and `g` from `β` to `α` (with `α` having a linear order and order-closed topology), if `f` is continuous, `g` is continuous, and the functions `f'` and `g'` from `β` to `γ` are continuous on the sets where `f` is less than or equal to `g` and `g` is less than or equal to `f`, respectively, and for all `x` in `β`, whenever `f(x)` equals `g(x)`, `f'(x)` also equals `g'(x)`, then the function that maps `x` to `f'(x)` if `f(x)` is less than or equal to `g(x)` (otherwise `g'(x)`) is continuous.

If functions `f` and `g` from a topological space `β` to an order-closed space `α` are continuous, `f` is less than or equal to `g` where both are defined, `g` is continuous at points where `f = g`, and `f'(x) = g'(x)` whenever `f(x) = g(x)`, then the function that maps `x` to `f'(x)` if `f(x) ≤ g(x)` and `g'(x)` otherwise is continuous.


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

This theorem, `neg_add_eq_zero`, states that for all types `G` that have an additive group structure (`AddGroup G`), given any two elements `a` and `b` of `G`, the negation of `a` added to `b` equals zero if and only if `a` itself equals `b`. In mathematical notation, this can be expressed as $-a + b = 0 \Leftrightarrow a = b$, valid for all `a` and `b` belonging to the additive group `G`.

For all additive groups `G`, `a`, and `b` in `G`, `-a + b = 0` if and only if `a = b`.


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

This theorem states that for any type `α` that is a linear ordered semifield, and for any three elements `a`, `b`, and `c` of this type where `b` is positive, the statement "the product of the inverse of `b` and `a` is less than or equal to `c`" is equivalent to the statement " `a` is less than or equal to the product of `b` and `c`". This theorem is a useful property of inequalities in fields.

For any linear ordered semifield type `α` and elements `a`, `b` (with `b` positive), `a ≤ b × c` if and only if `b⁻¹ × a ≤ c`.


theorem CategoryTheory.OverPresheafAux.OverArrows.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A}
      {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {u v : CategoryTheory.OverPresheafAux.OverArrows η s},
      CategoryTheory.OverPresheafAux.OverArrows.val u = CategoryTheory.OverPresheafAux.OverArrows.val v → u = v :=
  by sorry

The theorem `CategoryTheory.OverPresheafAux.OverArrows.ext` states that for any category `C`, functors `A` and `F` from the opposite of `C` to `Type v`, morphism `η` from `F` to `A`, object `X` in `C`, morphism `s` from the Yoneda embedding of `X` to `A`, and for any two elements `u` and `v` of the type `CategoryTheory.OverPresheafAux.OverArrows η s`, if the value of `u` and `v` under the `CategoryTheory.OverPresheafAux.OverArrows.val` function are equal, then `u` and `v` must be equal. In other words, this theorem asserts that the function `CategoryTheory.OverPresheafAux.OverArrows.val` is injective.

For any category C, functors A and F from C\^op to Type v, morphism η from F to A, and objects X in C, if the Yoneda morphism s from X to A and morphisms u and v in the over-category of arrows from η to s have equal images under the val function, then u and v are equal.


theorem AddLECancellable.tsub_le_tsub_iff_left :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b c : α},
      AddLECancellable a → AddLECancellable c → c ≤ a → (a - b ≤ a - c ↔ c ≤ b) :=
  by sorry

The theorem `AddLECancellable.tsub_le_tsub_iff_left` states that for any elements `a`, `b`, and `c` in a canonically ordered additive commutative monoid that also supports subtraction and ordered subtraction, if `a` and `c` are additive left cancellable and `c` is less than or equal to `a`, then `a - b` is less than or equal to `a - c` if and only if `c` is less than or equal to `b`. In simpler terms, it states that in such a structure, if adding a certain element to the left side of two different elements preserves the order relation, then the order relation between the differences of these elements and another element is equivalent to the order relation between the subtracted elements.

If `a`, `b`, and `c` are elements in a canonically ordered additive commutative monoid with subtraction and ordered subtraction, then `a - b <= a - c` if and only if `c <= b`.


MeasureTheory.OuterMeasure.union

theorem MeasureTheory.OuterMeasure.union :
    ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) (s₁ s₂ : Set α), ↑m (s₁ ∪ s₂) ≤ ↑m s₁ + ↑m s₂ := by sorry

The theorem `MeasureTheory.OuterMeasure.union` states that for any given type `α`, any outer measure `m` on `α`, and any two sets `s₁` and `s₂` of `α`, the measure of the union of `s₁` and `s₂` is less than or equal to the sum of the measures of `s₁` and `s₂`. This is a formal statement of the subadditivity property of outer measures. In mathematical notation, this would be written as m(s₁ ∪ s₂) ≤ m(s₁) + m(s₂).

For any outer measure `m` on a type `α`, the measure of the union of any two sets `s₁` and `s₂` satisfies `m(s₁ ∪ s₂) ≤ m(s₁) + m(s₂)`.


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

This theorem states that for any type `α` that has a preorder structure and any element `a` of that type, the preimage of the set of elements greater than `a` (not inclusive) under the canonical map from `α` to `WithBot α` is equal to the set of elements greater than `a` in `α`. In other words, applying the canonical mapping to the set of elements greater than `a` in `α` doesn't change the set; it remains the set of elements greater than `a`.

For any preordered type `α` and element `a` in `α`, the image of the set of elements strictly greater than `a` under the canonical map from `α` to `WithBot α` is equal to the set of elements strictly greater than `a` in `α`.


theorem Multiset.subset_dedup : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α), s ⊆ Multiset.dedup s := by
  sorry

This theorem states that for any given multiset `s` of an arbitrary type `α` with decidable equality, `s` is a subset of the deduplicated version of `s`. In other words, every element in the original multiset `s` also appears in the multiset resulting from the `dedup` operation on `s`. This makes sense as `dedup` operation only eliminates duplicate elements and does not add or remove unique elements.

For any decidably equal multiset `s` of type `α`, every element in `s` is contained in the multiset obtained by applying the `dedup` operation to `s`.


theorem mem_closure_iff_frequently :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], x ∈ closure s ↔ ∃ᶠ (x : X) in nhds x, x ∈ s := by
  sorry

The theorem `mem_closure_iff_frequently` states that for any type `X`, any element `x` of `X`, and any set `s` of `X`, under a given topological space, `x` belongs to the closure of `s` if and only if, frequently in the neighbourhood filter at `x`, `x` belongs to `s`. In other words, an element is in the closure of a set if it is frequently in that set when considering neighborhoods around it.

An element belongs to the closure of a set in a topological space if and only if it is in the set frequently in the neighborhood filter at that element.


/-- A point is in an affine subspace coerced to a set if and only if it is in that affine
subspace.  -/
theorem AffineSubspace.mem_coe :
    ∀ (k : Type u_1) {V : Type u_2} (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p : P) (s : AffineSubspace k P), p ∈ ↑s ↔ p ∈ s :=
  by sorry

This theorem states that for any type `k` with ring structure, a type `V` with additive commutative group structure, a module structure of `V` over `k`, and `V` acting on a type `P` via an additive torsor structure, a point `p` of type `P` is contained in the set representation of an affine subspace `s` of `P` if and only if it is in the affine subspace `s` itself. In mathematical terms, this theorem asserts the equivalence between set membership and subspace membership for affine spaces.

For any affine space (V, +, mul over a ring k), module action of V on type P, additive torsor structure on P, and subset s of P representing an affine subspace, the point p in P belongs to s if and only if it is in the subspace s itself.


theorem Matrix.frobenius_nnnorm_def :
    ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
      [inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α),
      ‖A‖₊ = (Finset.sum Finset.univ fun i => Finset.sum Finset.univ fun j => ‖A i j‖₊ ^ 2) ^ (1 / 2) :=
  by sorry

The theorem `Matrix.frobenius_nnnorm_def` states that for any matrix `A` with entries in a seminormed additive commutative group `α`, the nonnegative norm `‖A‖₊` of the matrix is equal to the square root of the sum of the squares of the nonnegative norms `‖A i j‖₊` of its elements, where the sum is taken over all indices `i` and `j` in the respective finite sets of row and column indices of `A`.

The L1-norm of a matrix equals the square root of the sum of the squares of the L1-norms of its elements.


theorem Mathlib.Geometry.Manifold.Instances.Real._auxLemma.3 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) := by sorry

This theorem states that for any linearly ordered type `α`, and for any three elements `a`, `b`, `c` of this type, `a` is less than or equal to the maximum of `b` and `c` if and only if `a` is less than or equal to `b` or `a` is less than or equal to `c`. In short, in a linear order, an element is less than or equal to the maximum of two other elements exactly when it is less than or equal to at least one of them.

For any linearly ordered type `α` and elements `a, b, c` in `α`, `a ≤ max(b, c)` if and only if `a ≤ b` or `a ≤ c`.


theorem Mathlib.Geometry.Manifold.Instances.Real._auxLemma.2 : ∀ (p : Prop), (p ∨ True) = True := by sorry

This theorem, `Mathlib.Geometry.Manifold.Instances.Real._auxLemma.2`, states that for any proposition `p`, the disjunction of `p` and `True` is always `True`. In other words, regardless of whether `p` is true or false, the entire expression `(p ∨ True)` will always be true, because `True` is always true by definition.

The theorem `Mathlib.Geometry.Manifold.Instances.Real._auxLemma.2` asserts that the disjunction of any proposition `p` and `True` is always `True`.


theorem Mathlib.Geometry.Manifold.Instances.Real._auxLemma.1 :
    ∀ {α : Type u} [inst : Preorder α] (a : α), (a ≤ a) = True := by sorry

This theorem, `Mathlib.Geometry.Manifold.Instances.Real._auxLemma.1`, states that for any type `α` with a defined `Preorder` structure, any element `a` of type `α` satisfies the condition `a ≤ a`. In other words, it asserts the reflexivity property of the preorder relation, stating that for any element in a preordered set, that element is less than or equal to itself. This is always true, hence the result is `True`.

For any type `α` with a defined preorder relation, every element `a` in `α` satisfies `a ≤ a` (reflexivity property).


theorem interior_empty : ∀ {X : Type u} [inst : TopologicalSpace X], interior ∅ = ∅ := by sorry

This theorem states that for any type `X` which is equipped with a topology (i.e., `X` is a topological space), the interior of the empty set is also the empty set. In mathematical terms, given any topological space `X`, if we consider the set of all open subsets of the empty set that are contained in the empty set itself, the union of all such subsets results in the empty set. This is the definition of the interior of a set in topology.

The interior of the empty set in a topological space is the empty set.


theorem List.enum_eq_zip_range : ∀ {α : Type u} (l : List α), List.enum l = List.zip (List.range (List.length l)) l :=
  by sorry

This theorem states that for any list `l` of type `α`, the enumeration of `l` (that is, pairing up each element with its index in the list) is equal to zipping the range of the length of `l` (that is, creating a list of numbers from `0` to the length of `l` exclusive) with `l` itself. In other words, the process of enumerating a list of elements is equivalent to pairing each element of the list with its corresponding index from the range of the list's length.

For any list `l` of type `α`, the enumeration of `l` is equivalent to zipping `l` with the range `0` to the length of `l`.


theorem MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range' :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
      {τ : Ω → ι} (hτ : MeasureTheory.IsStoppingTime f τ),
      Set.Countable (Set.range τ) → ∀ (i : ι), MeasurableSet {ω | τ ω = i} :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range'` states that for any types `Ω` and `ι`, any measurable space `m` over `Ω`, any linear order over `ι`, any filtration `f` over the measurable space `m` indexed by `ι`, and any function `τ` from `Ω` to `ι` which respects the stopping time property with respect to `f`, if the range of the function `τ` is countable, then for any `i` in `ι`, the set of elements of `Ω` such that `τ` of the element equals `i` is a measurable set.

In simpler terms, given a stopping time rule `τ` whose possible outcomes are countable, the set of all outcomes that stop at a specific time `i` can be measured using the given measure theory.

If `τ: Ω → ι` is a measurable, countably-valued stopping time with respect to filtration `f` on measurable space `(Ω, m)`, then for all `i` in `ι`, the set `{ω in Ω | τ(ω) = i}` is measurable.


IsLocalExtrOn.elim

theorem IsLocalExtrOn.elim :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {s : Set α} {a : α}
      {p : Prop}, IsLocalExtrOn f s a → (IsLocalMinOn f s a → p) → (IsLocalMaxOn f s a → p) → p :=
  by sorry

The theorem `IsLocalExtrOn.elim` states that for any topological space `α`, any preorder `β`, any function `f` from `α` to `β`, any set `s` of `α`, and any element `a` of `α`, if `f` has a local extremum at `a` on `s` (meaning it is either a local minimum or a local maximum at `a` on `s`), then any property `p` that holds when `f` has a local minimum at `a` on `s` and also holds when `f` has a local maximum at `a` on `s`, must hold. This uses the principle of disjunction elimination: since `f` having a local extremum at `a` on `s` means `f` is either a local minimum at `a` on `s` or a local maximum at `a` on `s`, if `p` holds in both cases, `p` must hold.

If a function `f` has a local extremum at `a` in a set `s` of a topological space `α` with respect to a preorder `β`, then any property `p` that holds for local minima and local maxima of `f` at `a` in `s` also holds.


theorem Multiset.bind_map :
    ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} (m : Multiset α) (n : β → Multiset γ) (f : α → β),
      Multiset.bind (Multiset.map f m) n = Multiset.bind m fun a => n (f a) :=
  by sorry

The `Multiset.bind_map` theorem states that for all types `α`, `β`, and `γ`, and for all multisets `m` of type `α`, functions `n` from `β` to multiset `γ`, and functions `f` from `α` to `β`, the operation of binding the multiset obtained by mapping `f` over `m` with `n` is the same as the operation of binding `m` with the function that first applies `f` to its argument and then applies `n`. In mathematical terms, this theorem asserts the equality of `(map f m).bind n` and `m.bind (λ a => n (f a))`, underscoring the interchangeability of the map and bind operations on multisets.

For all types `α`, `β`, and `γ`, and for all multisets `m` of type `α`, functions `n : β -> multiset γ`, and functions `f : α -> β`, `(map f m).bind n` equals `m.bind (λ a => n (f a))`.


theorem ContinuousOn.preimage_isClosed_of_isClosed :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
      {t : Set β}, ContinuousOn f s → IsClosed s → IsClosed t → IsClosed (s ∩ f ⁻¹' t) :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with topological structures, a function `f` from `α` to `β`, and sets `s` of type `α` and `t` of type `β`, if the function `f` is continuous on the set `s`, and both sets `s` and `t` are closed, then the intersection of set `s` and the preimage of set `t` under the function `f` is also closed. Here, the preimage of set `t` under function `f` consists of all the elements in `α` that get mapped to elements in `t` by `f`.

If `f` is a continuous function between topological spaces `(α, τα)` and `(β, τβ)`, `s ⊆ α` and `t ⊆ β` are closed sets, then the preimage `f⁻¹(t)` of `t` under `f` and `s` have a closed intersection.


theorem intervalIntegral.integral_comp_add_right :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} (f : ℝ → E) (d : ℝ),
      ∫ (x : ℝ) in a..b, f (x + d) = ∫ (x : ℝ) in a + d..b + d, f x :=
  by sorry

This theorem states that for any normed additively commutative group `E` and any normed space over the real numbers `ℝ` with elements of type `E`, given two real numbers `a` and `b`, a function `f` from real numbers to `E`, and another real number `d`, the integral of `f` evaluated at `(x + d)` over the interval `[a, b]` is equal to the integral of `f` evaluated at `x` over the interval `[a + d, b + d]`. In other words, adding a constant `d` to the variable of integration inside the integral and to the limits of integration outside the integral does not change the value of the integral.

For any normed additively commutative group `E` and real-valued function `f` on an interval `[a, b]`, the integral of `f` over `[a, b]` is equal to the integral of `f` over `[a + d, b + d]` for any real number `d`.


theorem CompositionSeries.length_toList :
    ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] (s : CompositionSeries X),
      List.length (CompositionSeries.toList s) = s.length + 1 :=
  by sorry

The theorem `CompositionSeries.length_toList` states that for any type `X` that is a Lattice and a Jordan-Hölder Lattice, and for any `s` which is a CompositionSeries of `X`, the length of the list obtained by converting `s` using the `CompositionSeries.toList` function is equal to the length of the CompositionSeries `s` plus one.

For any CompositionSeries `s` of a Jordan-Hölder Lattice `X`, the length of the list obtained by converting `s` to a list is one more than the length of `s`.


theorem Int.natAbs_eq_iff : ∀ {a : ℤ} {n : ℕ}, Int.natAbs a = n ↔ a = ↑n ∨ a = -↑n := by sorry

The theorem `Int.natAbs_eq_iff` states that for any integer `a` and natural number `n`, the absolute value of `a` is equal to `n` if and only if `a` is equal to the integer representation of `n` (notated `↑n`) or `a` is equal to the negative of the integer representation of `n` (notated `-↑n`). In other words, this theorem relates the absolute value function on integers with positive and negative numbers: an integer's absolute value is some natural number if and only if the integer is either that number or its negation.

The absolute value of an integer equals a natural number if and only if the integer is that number or its negative.


theorem ne_zero_of_lt : ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a b : α}, b < a → a ≠ 0 := by sorry

This theorem, `ne_zero_of_lt`, states that for any type `α` that is a linearly ordered commutative monoid with a zero element, if `b` is less than `a` (both `a` and `b` are of type `α`), then `a` is not equal to zero. In mathematical terms, for any elements `a` and `b` of such a structure, if `b < a`, then it must be the case that `a ≠ 0`.

If `α` is a linearly ordered commutative monoid with a zero element, then for all `a b` in `α`, if `b < a`, then `a ≠ 0`.


theorem Polynomial.C_add :
    ∀ {R : Type u} {a b : R} [inst : Semiring R], Polynomial.C (a + b) = Polynomial.C a + Polynomial.C b := by sorry

The theorem `Polynomial.C_add` states that for any type `R`, and any elements `a` and `b` of `R` where `R` is a semiring, the constant polynomial of the sum of `a` and `b` (`Polynomial.C (a + b)`) is equal to the sum of the constant polynomials of `a` and `b` (`Polynomial.C a + Polynomial.C b`). In other words, it states that the constant polynomial function preserves addition in the underlying semiring `R`.

For any semiring R and elements a, b in R, Polynomial.C (a + b) = Polynomial.C a + Polynomial.C b.


theorem Function.bijective_id : ∀ {α : Sort u₁}, Function.Bijective id := by sorry

The theorem `Function.bijective_id` states that for all types `α`, the identity function `id` is bijective. In mathematical terms, this means that the identity function, which maps each element of a type to itself, is both injective (no two different elements map to the same element) and surjective (every element of the type is the image of at least one element), thus forming a one-to-one correspondence between the elements of the type.

The identity function is a bijection on any type.


theorem Nat.ord_proj_le : ∀ {n : ℕ} (p : ℕ), n ≠ 0 → p ^ (Nat.factorization n) p ≤ n := by sorry

This theorem establishes that for any natural number `n` that is not zero and any prime number `p`, the power of `p` raised to the multiplicity of `p` in the prime factorization of `n` is less than or equal to `n`. Here, the multiplicity of a prime factor is represented by `(Nat.factorization n) p`, which is the count of `p` in the prime factorization of `n`. In mathematical terms, if `p^k` is a term in the prime factorization of `n`, then `p^k ≤ n`.

For any natural number $n$ and prime number $p$, the power $p^{\text{valuation}_p(n)}$ of $p$ in the prime factorization of $n$ satisfies $p^{\text{valuation}_p(n)} \leq n$.


Irreducible.separable

theorem Irreducible.separable :
    ∀ {F : Type u} [inst : Field F] [inst_1 : CharZero F] {f : Polynomial F}, Irreducible f → Polynomial.Separable f :=
  by sorry

This theorem states that for any field `F` with characteristic zero, any irreducible polynomial `f` over `F` is separable. In other words, the polynomial `f` and its derivative are coprime. Here, a polynomial is said to be separable if it is coprime with its derivative, and a field is said to have characteristic zero if its characteristic, which is the smallest positive integer such that multiplication by it results in zero, is zero. Note that an irreducible polynomial is a non-constant polynomial that cannot be factored into the product of two non-constant polynomials.

In a field of characteristic zero, every irreducible polynomial is separable, meaning it is coprime with its derivative.


/-- A predicate is true in a neighborhood of `x` iff it is true for all the points in an open set
containing `x`.  -/
theorem eventually_nhds_iff :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {p : X → Prop},
      (∀ᶠ (x : X) in nhds x, p x) ↔ ∃ t, (∀ x ∈ t, p x) ∧ IsOpen t ∧ x ∈ t :=
  by sorry

This theorem states that a predicate is true in a neighborhood of a point 'x' if and only if it is true for all the points in an open set containing 'x'. In other words, for a given topological space 'X', a point 'x' in 'X', and a predicate 'p' on 'X', the property 'p' holds eventually (i.e., in the neighborhood filter) at 'x' if and only if there exists an open set 't' containing 'x' such that 'p' holds for every point in 't'.

A predicate holds in a neighborhood of a point if and only if it holds in every point of some open set containing that point.


theorem PartENat.dom_natCast : ∀ (x : ℕ), (↑x).Dom := by sorry

This theorem, `PartENat.dom_natCast`, asserts that for every natural number `x`, the domain of the cast of `x` to a partial extended natural number (as represented by `(↑x).Dom`) is well-defined. In other words, you can always cast a natural number to a partial extended natural number.

For every natural number x, the cast of x to a partial extended natural number is a defined value.


theorem LinearMap.range_le_ker_iff :
    ∀ {R : Type u_1} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_9} {M₂ : Type u_12} {M₃ : Type u_13}
      [inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M]
      [inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid M₃] [inst_6 : Module R M] [inst_7 : Module R₂ M₂]
      [inst_8 : Module R₃ M₃] {τ₁₂ : R →+* R₂} {τ₂₃ : R₂ →+* R₃} {τ₁₃ : R →+* R₃}
      [inst_9 : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃] [inst_10 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂}
      {g : M₂ →ₛₗ[τ₂₃] M₃}, LinearMap.range f ≤ LinearMap.ker g ↔ LinearMap.comp g f = 0 :=
  by sorry

This theorem states that for all semirings `R`, `R₂`, and `R₃`, additive commutative monoids `M`, `M₂`, `M₃`, and modules over them, ring homomorphisms `τ₁₂`, `τ₂₃`, `τ₁₃`, and `f` & `g` which are linear maps, if the homomorphisms are such that the composition of `τ₁₂` and `τ₂₃` equals `τ₁₃` and `τ₁₂` is surjective, then the range of the linear map `f` is less than or equal to the kernel of the linear map `g` if and only if the composition of `g` and `f` equals zero.

In simpler terms, this theorem is about the relationship between the range and kernel of two linear mappings: if the image of the first map is entirely contained within the null space of the second map, then the composition of the two maps is the zero map.

If `τ₁:` R -> R₂, `τ₂:` R₂ -> R₃ are surjective ring homomorphisms, `f:` M -> N and `g:` N -> P are linear maps of modules such that `τ₁∘τ₂ = τ₁₃`, then `∣∣f∣∣ ≤ ∣∣ker g∣∣ if and only if `g∘f = 0`.


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

This theorem states that for all types `α`, sort `ι`, an element `x` of type `α`, and a mapping `s` from `ι` to a set of elements of type `α`, the membership of `x` in the union of all sets `s i` (for each `i` in `ι`) is equivalent to the existence of some `i` in `ι` for which `x` is a member of the set `s i`. In other words, an element belongs to the union of several sets if and only if there exists at least one set among them in which the element is found.

For any type `α`, sort `ι`, element `x` of type `α`, and mapping `s` from `ι` to subsets of `α`, the element `x` belongs to the union of sets `s i` if and only if there exists some `i` in `ι` such that `x` is in `s i`.


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

The theorem `Finset.sup'_le_iff` asserts that for any types `α` and `β`, given a semilattice structure on `α`, a nonempty finset `s` of elements of type `β`, a function `f` from `β` to `α`, and an element `a` of type `α`, the supremum of the images of elements of `s` under `f` is less than or equal to `a` if and only if every element `b` of `s` satisfies that its image under `f` is less than or equal to `a`. This essentially means that the supremum of the images under `f` is the smallest upper bound for all such images.

For any semilattice `α`, nonempty finset `s` of elements `β`, function `f` from `β` to `α`, and `a` in `α`, the image supremum of `s` under `f` is less than or equal to `a` if and only if the image of every element in `s` under `f` is less than or equal to `a`.


/-- A family `𝓕 : ι → β → α` is uniformly equicontinuous on `S` iff the function
`swap 𝓕 : β → ι → α` is uniformly continuous on `S`
*when `ι → α` is equipped with the uniform structure of uniform convergence*. This is very useful
for developping the equicontinuity API, but it should not be used directly for other purposes.  -/
theorem uniformEquicontinuousOn_iff_uniformContinuousOn :
    ∀ {ι : Type u_1} {α : Type u_7} {β : Type u_9} [uα : UniformSpace α] [uβ : UniformSpace β] {F : ι → β → α}
      {S : Set β}, UniformEquicontinuousOn F S ↔ UniformContinuousOn (⇑UniformFun.ofFun ∘ Function.swap F) S :=
  by sorry

The theorem states that for a family of functions `𝓕 : ι → β → α`, it is uniformly equicontinuous on a set `S` if and only if the function `swap 𝓕 : β → ι → α` is uniformly continuous on `S` when the function type `ι → α` is equipped with the uniform structure of uniform convergence. In simpler terms, this theorem connects the concept of uniform equicontinuity of a family of functions to the uniform continuity of a function obtained by swapping the arguments of the original function. This is primarily used for developing the equicontinuity application programming interface (API) and is not intended for direct use in other contexts.

A family of functions `𝓕 : ι → β → α` is uniformly equicontinuous on a set `S` if and only if the swapped function `swap 𝓕 : β → ι → α` is uniformly continuous on `S` with respect to the uniform structure of uniform convergence on `ι → α`.


theorem dirSupInacc_compl : ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, DirSupInacc sᶜ ↔ DirSupClosed s := by
  sorry

The theorem `dirSupInacc_compl` states that, for any set `s` of a type `α` with a preorder, the set `s` is inaccessible by directed joins if and only if the complement of set `s` is closed under directed joins. In other words, given a set `s` in a preordered type `α`, whenever the least upper bound of a directed set lies outside `s`, it implies that there is some element of the directed set also outside `s`. This is equivalently stated as: if every directed subset of `s` has its least upper bound in `s`, then `s` is closed under directed joins.

A set in a preordered type is inaccessible by directed joins if and only if the complement is closed under directed joins.


theorem Int.lt_trichotomy : ∀ (a b : ℤ), a < b ∨ a = b ∨ b < a := by sorry

This theorem, "Int.lt_trichotomy", states that for any two integers `a` and `b`, exactly one of the following is true: `a` is less than `b`, `a` is equal to `b`, or `b` is less than `a`. This is essentially the principle of trichotomy for integers, a basic property of ordered fields.

For any integers `a` and `b`, exactly one of `a < b`, `a = b`, or `b < a` holds.


theorem Ideal.Quotient.algebraMap_eq :
    ∀ {R : Type u} [inst : CommRing R] (I : Ideal R), algebraMap R (R ⧸ I) = Ideal.Quotient.mk I := by sorry

The theorem `Ideal.Quotient.algebraMap_eq` states that for any given commutative ring `R` and any ideal `I` of `R`, the algebra map from `R` to the quotient ring `R/I` is equivalent to the quotient map of `I`. This means that the map embedding `R` into the quotient ring `R/I` as defined by the algebra structure on `R` coincides with the map that sends each element of `R` to its equivalence class in `R/I` under the equivalence relation defined by the ideal `I`.

The algebra map from a commutative ring to its quotient by an ideal is equal to the quotient map.


HeytingHom.ext

theorem HeytingHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : HeytingAlgebra α] [inst_1 : HeytingAlgebra β] {f g : HeytingHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `HeytingHom.ext`, states that for any two Heyting algebra homomorphisms `f` and `g` from a Heyting algebra `α` to another Heyting algebra `β`, if for all elements `a` in `α` the result of applying `f` to `a` is equal to the result of applying `g` to `a`, then `f` and `g` must be the same homomorphism. In other words, two Heyting algebra homomorphisms are equal if they produce the same output for every input from the domain Heyting algebra.

If two Heyting algebra homomorphisms from one Heyting algebra to another agree on all elements, then they are equal.


theorem Fin.predAbove_succ_of_le : ∀ {n : ℕ} (p i : Fin n), p ≤ i → Fin.predAbove p (Fin.succ i) = i := by sorry

The theorem `Fin.predAbove_succ_of_le` states that for any natural number `n` and any two elements `p` and `i` from the finite set of size `n`, if `p` is less than or equal to `i`, then the result of applying the `predAbove` function to `p` and the successor of `i` is `i`. The `predAbove` function surjects `i` from `Fin (n+1)` into `Fin n` by subtracting one if `p` is less than `i`. The `succ` function adds one to `i`, turning an element of `Fin n` into an element of `Fin (n+1)`.

For all natural numbers n and Fin n elements p and i, if p ≤ i then predAbove p (succ i) = i.


theorem List.nil_bagInter : ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), List.bagInter [] l = [] := by sorry

The theorem `List.nil_bagInter` states that for any type `α` that has a decidable equality and for any list `l` of type `α`, the bag intersection of an empty list with `l` is an empty list. Here, a bag intersection is a concept similar to the intersection of two sets, but it applies to lists (or "bags") and takes into account the multiplicity of elements.

For any type `α` with decidable equality and any list `l` of type `α`, the bag intersection of the empty list with `l` is the empty list.


theorem Nat.Prime.pow_dvd_iff_le_factorization :
    ∀ {p k n : ℕ}, Nat.Prime p → n ≠ 0 → (p ^ k ∣ n ↔ k ≤ (Nat.factorization n) p) := by sorry

This theorem states that for any natural numbers `p`, `k`, and `n`, where `p` is a prime number and `n` is not zero, `p` raised to the power of `k` divides `n` if and only if `k` is less than or equal to the multiplicity of `p` in the prime factorization of `n`. In other words, the exponent of a prime `p` in the prime factorization of `n` is at least `k` if `p^k` is a divisor of `n`.

For a prime number `p` and natural numbers `k` and `n` with `n \neq 0`, `p^k` divides `n` if and only if the multiplicity of `p` in the prime factorization of `n` is greater than or equal to `k`.


Joined.trans

theorem Joined.trans : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y z : X}, Joined x y → Joined y z → Joined x z :=
  by sorry

The theorem `Joined.trans` states that for any topological space `X` and any three points `x`, `y`, and `z` in `X`, if `x` is joined to `y` by a path and `y` is joined to `z` by a path, then `x` is also joined to `z` by a path. This is essentially stating the transitivity of the "being joined by a path" relation in a topological space.

If $x$ is connected to $y$ and $y$ is connected to $z$ in a topological space, then $x$ is connected to $z$.


theorem nhdsWithin_empty : ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α), nhdsWithin a ∅ = ⊥ := by sorry

This theorem states that for any type `α` that has a `TopologicalSpace` instance and for any element `a` of this type, the "neighborhood within" of `a` with respect to the empty set is the bottom filter. In other words, in a topological space, the intersection of an empty set with a neighborhood of any point is considered to be the most trivial filter, represented as `⊥`, which basically means it contains no open sets.

In a topological space, the intersection of the empty set with any neighborhood of a point is the bottom filter.


Set.PairwiseDisjoint.aedisjoint

theorem Set.PairwiseDisjoint.aedisjoint :
    ∀ {ι : Type u_1} {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : ι → Set α} {s : Set ι},
      Set.PairwiseDisjoint s f → Set.Pairwise s (MeasureTheory.AEDisjoint μ on f) :=
  by sorry

This theorem states that for any type `ι`, any measurable space `α`, any measure `μ` on `α`, any function `f` from `ι` to sets of `α`, and any set `s` of `ι`, if the set `s` is pairwise disjoint with respect to function `f` (meaning the images of any two distinct elements of `s` under `f` are disjoint), then the relation `MeasureTheory.AEDisjoint μ` holds pairwise on the set `s` on the function `f` (meaning for all distinct `x` and `y` in `s`, the sets `f(x)` and `f(y)` are almost everywhere disjoint with respect to measure `μ`, i.e., the intersection of `f(x)` and `f(y)` has measure zero).

If `s` is a pairwise disjoint set of indices for a measurable function `f` on measurable space `(α, μ)`, then for all distinct `x, y ∈ s`, the sets `f(x)` and `f(y)` are almost everywhere disjoint with respect to `μ`.


theorem FractionalIdeal.div_zero :
    ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
      [frac : IsFractionRing R₁ K] [inst_3 : IsDomain R₁] {I : FractionalIdeal (nonZeroDivisors R₁) K}, I / 0 = 0 :=
  by sorry

The theorem `FractionalIdeal.div_zero` states that for any commutative ring `R₁`, any field `K` that is the field of fractions of `R₁`, and any fractional ideal `I` of the domain `R₁` over the submonoid of non-zero divisors of `R₁` in `K`, the result of dividing `I` by zero is zero. In other words, it signifies that any fractional ideal divided by zero equals zero in the context of algebraic structures such as rings and fields.

For any commutative ring R₁, field K as its fraction field, and fractional ideal I of R₁ over its non-zero divisors, I ∕ 0 = 0.


/-- If x ∈ α is in 2 elements of a set of sets partitioning α, those 2 sets are equal.  -/
theorem Setoid.eq_of_mem_eqv_class :
    ∀ {α : Type u_1} {c : Set (Set α)},
      (∀ (a : α), ∃! b x, a ∈ b) → ∀ {x : α} {b b' : Set α}, b ∈ c → x ∈ b → b' ∈ c → x ∈ b' → b = b' :=
  by sorry

This theorem states that for any type `α` and a set `c` containing subsets of `α`, given that each element `a` of `α` belongs to exactly one subset `b` that contains some element `x`, if an element `x` of `α` belongs to two different subsets `b` and `b'` that are both elements of `c`, then these two subsets must be equal. In other words, if we have a partition of a type into subsets, and an element is in two subsets of the partition, then these two subsets are the same. This theorem enforces the property of a partition where each element of the set being partitioned belongs to exactly one part of the partition.

If `α` is a type, `c` is a set of subsets of `α`, and for all `a ∈ α`, there exists unique `b ∈ c` such that `a ∈ b`, then for all distinct `b, b' ∈ c` with `x ∈ b ∧ x ∈ b'`, we have `b = b'`.


theorem SimpleGraph.Walk.mem_support_nil_iff :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ∈ SimpleGraph.Walk.support SimpleGraph.Walk.nil ↔ u = v := by sorry

This theorem states that for any given simple graph `G` with vertices of type `V`, and any two vertices `u` and `v`, the vertex `u` is in the support of the nil walk (the walk that visits no edges) from `u` to `v` if and only if `u` is equal to `v`. In other words, the only vertex visited in a nil walk is the endpoint `v`, so for `u` to be in the support of such a walk, it must be the same as `v`.

In a simple graph, a vertex is in the support of the nil walk (visit no edges) between two vertices if and only if the vertices are equal.


HasSum.nonneg

theorem HasSum.nonneg :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {g : ι → α} {a : α}, (∀ (i : ι), 0 ≤ g i) → HasSum g a → 0 ≤ a :=
  by sorry

This theorem states that for any types `ι` and `α`, where `α` is an ordered additive commutative monoid and also a topological space with an order-closed topology, given a function `g` from `ι` to `α` and an element `a` of type `α`, if all values of the function `g` are non-negative, and if the function `g` has a sum `a`, then `a` is also non-negative. In simpler terms, it means that if we sum up a bunch of non-negative values (according to the function `g`), the result can't be negative.

For any ordered additive commutative monoid and topological space `α`, if `g : ι → α` is a function with non-negative values and has sum `a` in `α`, then `a` is non-negative.


theorem instCoeTCFrameHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
      [inst_2 : CompleteLattice β] [inst_3 : FrameHomClass F α β] (f : F) (a b : α), f (a ⊓ b) = f a ⊓ f b :=
  by sorry

This theorem asserts that given types `F`, `α`, and `β`, where `F` is a type with a function-like structure from `α` to `β`, and `α` and `β` are both complete lattices, and `F` has a frame homomorphism structure between `α` and `β`, then for any element `f` of type `F`, and any elements `a` and `b` of type `α`, the image of the infimum (or meet, denoted by `⊓`) of `a` and `b` under `f` is equal to the infimum of the images of `a` and `b` under `f`. This is a property that characterizes frame homomorphisms (also known as lattice homomorphisms) between complete lattices.

Given a function-like type `F` from complete lattices `α` and `β`, with `F` having a frame homomorphism structure, for all `f:F`, `a, b ∈ α`, the image of the infimum `a ⊓ b` under `f` equals the infimum of `f a` and `f b`.


theorem instCoeTCFrameHom.proof_3 :
    ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
      [inst_2 : CompleteLattice β] [inst_3 : FrameHomClass F α β] (f : F) (s : Set α), f (sSup s) = sSup (⇑f '' s) :=
  by sorry

This theorem states that for any type `F`, `α`, and `β`, under the conditions that `F` can be injectively coerced into a function from `α` to `β` (as expressed by the `FunLike F α β` instance), `α` and `β` are complete lattices, and `F` forms a frame homomorphism between `α` and `β` (as indicated by the `FrameHomClass F α β` instance), for any function `f` of type `F` and any set `s` of type `α`, the image of the supremum (`sSup`) of `s` under `f` is equal to the supremum of the image of `s` under `f`. In other words, the function `f` preserves the supremum when applied to a set from a complete lattice.

If `F` is a function from a complete lattice `α` to another complete lattice `β` that forms a frame homomorphism between them, then `F` preserves suprema, i.e., `F (supremum s) = supremum (map F s)` for any set `s` in `α`.


theorem instCoeTCFrameHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
      [inst_2 : CompleteLattice β] [inst_3 : FrameHomClass F α β] (f : F), f ⊤ = ⊤ :=
  by sorry

This theorem states that for any types `F`, `α`, and `β`, if `F` is a function-like type from `α` to `β`, `α` and `β` are both complete lattices, and `F` is a frame homomorphism class from `α` to `β`, then for any element `f` of type `F`, the image of the top element (denoted as `⊤`) under `f` is also the top element. In essence, this theorem expresses a property of frame homomorphisms, namely that they preserve the top element of the lattice.

If `F` is a frame homomorphism from a complete lattice `α` to a complete lattice `β`, then `F(⊤) = ⊤`, where `⊤` denotes the top element in both `α` and `β`.


theorem SimpleGraph.Walk.length_append :
    ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : SimpleGraph.Walk G u v) (q : SimpleGraph.Walk G v w),
      SimpleGraph.Walk.length (SimpleGraph.Walk.append p q) = SimpleGraph.Walk.length p + SimpleGraph.Walk.length q :=
  by sorry

This theorem states that for any simple graph `G` with vertices of type `V` and any three vertices `u`, `v`, and `w` in the graph, if there exists a walk `p` from `u` to `v` and a walk `q` from `v` to `w`, then the length of the walk obtained by appending `q` to `p` (in other words, the walk from `u` to `w` that first follows `p` and then follows `q`) is equal to the sum of the lengths of `p` and `q`. The length of a walk is defined as the number of edges or darts along it.

For any simple graph, the length of a walk from one vertex to another through a third vertex is equal to the sum of the lengths of the walks between each pair of vertices.


theorem Ordinal.typein_top :
    ∀ {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s]
      (f : r ≺i s), Ordinal.typein s f.top = Ordinal.type r :=
  by sorry

The theorem `Ordinal.typein_top` states that for any two types `α` and `β` with well-ordering relations `r` and `s` respectively, and for any order-embedding `f` from `r` to `s`, the order type of the maximal element of `f` under `s` is equal to the order type of `r`. In simple terms, it implies that the order type of the "largest" element in the image of an order-embedding function is same as the order type of the initial well-ordered set. This is a fundamental property in the theory of ordinals.

Given well-ordered types `α` and `β`, an order-embedding `f` from `α` to `β`, the order type of the maximal element of `f` under `β` equals the order type of `α`.


theorem List.keys_kerase :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {l : List (Sigma β)},
      List.keys (List.kerase a l) = List.erase (List.keys l) a :=
  by sorry

This theorem states that for any type α, for a function β from α to another type, for a list 'l' of key-value pairs where the type α has decidable equality, and for any key 'a' of type α, the list of keys obtained after removing the first pair with key 'a' from 'l' (using the function `List.kerase`) is the same as the list obtained by first getting the list of keys from 'l' and then removing the key 'a' from this list (using the function `List.erase`). In other words, the order of the operations 'get keys' and 'remove key' does not matter.

For any type α with decidable equality, any function β from α to another type, and list 'l' of key-value pairs in α, the lists obtained by removing the first pair with key 'a' from 'l' using `List.kerase` and by first getting the list of keys from 'l' and then removing key 'a' using `List.erase` are equal.


/-- If `s` is compact, `t` is open and `s ⊆ t`, some `cthickening` of `s` is contained in `t`.  -/
theorem IsCompact.exists_cthickening_subset_open :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α},
      IsCompact s → IsOpen t → s ⊆ t → ∃ δ, 0 < δ ∧ Metric.cthickening δ s ⊆ t :=
  by sorry

This theorem states that if we have a subset `s` of a given type `α` in a pseudo emetric space, and `s` is compact, and if `t` is another subset of the same type `α` which is an open set, and `s` is contained in `t`, then we can find a positive real number `δ` such that the δ-thickening of `s` is still contained within `t`. Here, δ-thickening of `s` refers to the set of all points in the pseudo emetric space that are at an infimum distance of `δ` or less from `s`.

If `s` is a compact subset of a pseudo metric space `α`, `t` is an open set containing `s`, then there exists a real number `δ > 0` such that the `δ`-thickening of `s` (the set of points within infimum distance `δ` of `s`) is contained in `t`.


theorem ssubset_iff_subset_not_subset :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
      [inst_2 : IsNonstrictStrictOrder α (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1] {a b : α},
      a ⊂ b ↔ a ⊆ b ∧ ¬b ⊆ a :=
  by sorry

The theorem `ssubset_iff_subset_not_subset` states that for any types `α`, given the type has the subset relationship (⊆), and the strict subset relationship (⊂), and the order of these relationships is nonstrict-strict (a strict subset is indeed a subset but not the other way around), then an element `a` is strictly subset of another element `b` if and only if `a` is a subset of `b` and `b` is not a subset of `a`. In simpler terms, `a` is strictly contained in `b` when `a` is contained in `b` and there is at least one element in `b` that is not in `a`.

For types with the subset and strict subset relations (⊆ and ⊂, respectively), with the order being non-strict-strict, the strict subset relationship holds if and only if one set is a proper subset of the other, i.e., a set is strictly contained in another if and only if it is a subset but not vice versa and there exists an element in the larger set not in the smaller set.


ConvexOn.neg

/-- **Alias** of the reverse direction of `neg_concaveOn_iff`.

---

A function `-f` is concave iff `f` is convex.  -/
theorem ConvexOn.neg :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommGroup β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] {s : Set E} {f : E → β},
      ConvexOn 𝕜 s f → ConcaveOn 𝕜 s (-f) :=
  by sorry

The theorem `ConvexOn.neg` states that for any ordered semiring `𝕜`, a set `s` of elements of type `E`, and a function `f` from `E` to `β` where `β` is an ordered additively commutative group, if the function `f` is convex over the set `s`, then the function `-f` (the negation of `f`) is concave over the same set `s`. This means that if for any two points in the set, the function value at a weighted average of the points is no less than the weighted average of the function values at the two points (the property of convexity), then for the negated function `-f`, the function value at the weighted average of any two points in the set is no more than the weighted average of the function values at the two points (the property of concavity).

If a function `f` from an ordered semiring to an ordered additively commutative group is convex over a set `s`, then the negation `-f` is concave over the same set `s`. That is, for all `x, y in s` and `r in [0, 1]`, we have `-f(rx + (1-r)y) <= r*-f(x) + (1-r)*(-f(y))`.


theorem Filter.Tendsto.const_vadd :
    ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : VAdd M α]
      [inst_2 : ContinuousConstVAdd M α] {f : β → α} {l : Filter β} {a : α},
      Filter.Tendsto f l (nhds a) → ∀ (c : M), Filter.Tendsto (fun x => c +ᵥ f x) l (nhds (c +ᵥ a)) :=
  by sorry

This theorem states that given a topological space `α` which allows "vector addition" with some type `M`, and a function `f` from type `β` to `α` which converges to a limit `a` as per some filter `l`, adding a constant `c` from `M` to the function `f` will result in a new function that converges to `c + a`. In mathematical terms, if $\lim_{x \to l} f(x) = a$, then $\lim_{x \to l} (c + f(x)) = c + a$. This is true under the precondition that the vector addition operation with a constant `c` is continuous in this topological space.

If `α` is a topological space with continuous vector addition of constant `c` from `M`, and `f : β → α` converges to `a` as `x` approaches a filter `l`, then `c + f` converges to `c + a`.


theorem map_rat_cast_smul :
    ∀ {M : Type u_5} {M₂ : Type u_6} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] {F : Type u_9}
      [inst_2 : FunLike F M M₂] [inst_3 : AddMonoidHomClass F M M₂] (f : F) (R : Type u_10) (S : Type u_11)
      [inst_4 : DivisionRing R] [inst_5 : DivisionRing S] [inst_6 : Module R M] [inst_7 : Module S M₂] (c : ℚ) (x : M),
      f (↑c • x) = ↑c • f x :=
  by sorry

This theorem, `map_rat_cast_smul`, asserts that, given two types `M` and `M₂`, which are both additive commutative groups, and a type `F` that is a function-like object from `M` to `M₂` and also exhibits the structure of an additive monoid homomorphism, then for any function `f` of type `F`, any rational number `c`, any element `x` of `M`, and any two division rings `R` and `S` that act as scalar multipliers (with `R` acting on `M` and `S` acting on `M₂`), the application of `f` to `c` times `x` (where `c` is cast to `R` and the multiplication is done in `M`) is the same as `c` times the application of `f` to `x` (where `c` is cast to `S` and the multiplication is done in `M₂`). In other words, this theorem asserts that the function `f` commutes with the action of rational scalar multiplication, after appropriate type casting.

For additive commutative groups M and M₂, additive monoid homomorphism F from M to M₂, and division rings R and S acting as scalar multipliers on M and M₂ respectively, the application of F to the product of an element x in M and a rational number c, with c cast to R, is equal to the product of c cast to S and the application of F to x.


theorem Set.mem_of_eq_of_mem : ∀ {α : Type u} {x y : α} {s : Set α}, x = y → y ∈ s → x ∈ s := by sorry

This theorem states that for any type `α`, any two elements `x` and `y` of that type, and any set `s` of elements of type `α`, if `x` equals `y` and `y` belongs to the set `s`, then `x` also belongs to the set `s`. In simpler terms, it says that if two elements are equal and one of them is in a set, then the other one is also in that set. This is consistent with the intuitive understanding of sets and equality.


theorem Filter.lift'_mono :
    ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {h₁ h₂ : Set α → Set β},
      f₁ ≤ f₂ → h₁ ≤ h₂ → Filter.lift' f₁ h₁ ≤ Filter.lift' f₂ h₂ :=
  by sorry

The theorem `Filter.lift'_mono` states that for any two types `α` and `β`, given any two filters `f₁` and `f₂` on `α`, and any two function `h₁` and `h₂` that map a set of `α` to a set of `β`, if filter `f₁` is less than or equal to filter `f₂` (in the sense of a partial order), and function `h₁` is less than or equal to function `h₂` (in the sense of a partial order), then the lift of filter `f₁` via `h₁` is less than or equal to the lift of filter `f₂` via `h₂`. Essentially, this theorem is saying that the `lift'` operation in filter theory preserves the order of both filters and functions.

Given filters `f₁` and `f₂` on type `α` and functions `h₁` and `h₂` from `α` to `β`, if `f₁ ≤ f₂` and `h₁ ≤ h₂`, then `h₁⁁ⁱ⁻¹⁁(f₁) ≤ h₂⁁ⁱ⁻¹⁁(f₂)`.


theorem OrderHom.le_nextFixed :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} (hx : x ≤ f x), x ≤ ↑(OrderHom.nextFixed f x hx) :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, given a function `f` that is a monotone self-map on `α`, and a point `x` such that `x` is less than or equal to the image of `x` under `f`, then `x` is less than or equal to the next fixed point of `f` starting from `x`. In other words, it guarantees that the ordering of `x` and its next fixed point under the function `f` is preserved, which is a fundamental property in the study of monotone functions over complete lattices.

For any complete lattice `α` and monotone self-map `f` on `α`, if `x` is in `α` and `x ≤ f(x)`, then `x ≤ f^(n+1)(x)` for some `n ∈ ℕ`. (Here, `f^n` denotes the `n`-th power of the function `f`.)


theorem Finset.mem_add :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Add α] {s t : Finset α} {x : α},
      x ∈ s + t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x :=
  by sorry

This theorem, `Finset.mem_add`, states that for any type `α` that has decidable equality and an addition operation, along with any two finite sets `s` and `t` of this type, and any element `x` of the same type, `x` is in the sum of `s` and `t` if and only if there exists an element `y` in `s` and an element `z` in `t` such that `y + z = x`. In other words, an element is in the sum of two finite sets if and only if it can be expressed as the sum of an element from each set.

For any type `α` with decidable equality and addition, and finite sets `s` and `t` of `α`, an element `x` is in the sum `s ∪ {t}` if and only if there exist `y ∈ s` and `z ∈ t` such that `y + z = x`.


theorem MeasureTheory.SignedMeasure.toJordanDecomposition_neg :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α),
      MeasureTheory.SignedMeasure.toJordanDecomposition (-s) = -MeasureTheory.SignedMeasure.toJordanDecomposition s :=
  by sorry

This theorem states that for any measurable space `α` and for any signed measure `s` on that space, the Jordan Decomposition of the negation of `s` is equal to the negation of the Jordan Decomposition of `s`. In other words, negating a signed measure and then finding its Jordan Decomposition is the same as first finding the Jordan Decomposition and then negating it. This property is akin to the distributive law in algebra.

For any measurable space `α` and signed measure `s` on `α`, the negated Jordan Decomposition of `s` is equal to the Jordan Decomposition of the negation of `s`: `-(jordan_decomp s) = jordan_decomp (-s)`.


theorem InnerProductSpace.Core.inner_smul_left :
    ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
      [c : InnerProductSpace.Core 𝕜 F] (x y : F) {r : 𝕜}, ⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜 :=
  by sorry

This theorem states that for any scalar `r` and any two vectors `x` and `y` in an inner product space (over a field `𝕜` with a star-ring-end operation) with scalar multiplication, the inner product of the multiplication of `r` and `x`, with `y`, is equal to the multiplication of the star of `r` and the inner product of `x` and `y`. In mathematical terms, it represents the property: `⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜`. This theorem demonstrates one of the essential properties of inner product spaces, namely the distributive property of scalar multiplication with respect to the inner product operation.

For any scalar `r` and vectors `x` and `y` in an inner product space, the scalar multiplication of `r` with vector `x`, and the inner product of `x` with `y`, is equal to the inner product of `x` with the star-operation of `r` times `y`. In symbolic form: `⟪r • x, y⟫_𝕜 = ⟪x, (starRingEnd 𝕜) r * y⟫_𝕜`.


theorem directed_comp :
    ∀ {α : Type u} {β : Type v} {r : α → α → Prop} {ι : Sort u_1} {f : ι → β} {g : β → α},
      Directed r (g ∘ f) ↔ Directed (g ⁻¹'o r) f :=
  by sorry

The theorem `directed_comp` states that for any types `α`, `β`, and `ι`, a relation `r` on `α`, and functions `f : ι → β` and `g : β → α`, a family of elements is directed by `r` after being transformed by `g ∘ f` if and only if it is directed by the relation `g ⁻¹'o r` before being transformed by `f`. Here, `g ⁻¹'o r` is the preimage of the relation `r` under `g`, which means we apply `g` to the elements before comparing them with `r`. This theorem links the concept of directional relations and function composition.

Given types α, β, and ι, a relation r on α, and functions f : ι → β and g : β → α, the families {x\_i : α} are directed by r after being transformed by g ∘ f if and only if they are directed by g ⁻¹'o r before being transformed.


theorem Finset.disjoint_erase_comm :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α},
      Disjoint (Finset.erase s a) t ↔ Disjoint s (Finset.erase t a) :=
  by sorry

The theorem `Finset.disjoint_erase_comm` states that for any two given finite sets `s` and `t` and an element `a` of a type `α` with decidable equality, removing `a` from `s` and checking if the resulting set is disjoint from `t` is equivalent to removing `a` from `t` and checking if `s` is disjoint from the resulting set. In other words, the operation of erasing an element from a finite set commutes with the operation of checking disjointness of two finite sets.

For finite sets `s` and `t` and an element `a` of type `α` with decidable equality, `(s \\ {a}).disjoint t <-> t \\ {a}.disjoint s`.


theorem Nat.minSqFac_has_prop : ∀ (n : ℕ), Nat.MinSqFacProp n (Nat.minSqFac n) := by sorry

The theorem `Nat.minSqFac_has_prop` asserts that for every natural number `n`, the function `Nat.minSqFac` satisfies the property `Nat.MinSqFacProp`. In other words, if `Nat.minSqFac` returns `none` for a natural number `n`, then `n` is squarefree, meaning it has no square factor other than 1. If `Nat.minSqFac` returns `some d`, then `d` is a prime number and the smallest square factor of `n`. This means that `d * d` divides `n` and any other prime number `p` whose square divides `n` must be greater than or equal to `d`.

For every natural number `n`, if `Nat.minSqFac n` is `none`, then `n` is squarefree, and if `Nat.minSqFac n` is `some d`, then `d` is a prime number and `d^2` is the smallest square factor of `n`.


theorem List.map_injective_iff :
    ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective (List.map f) ↔ Function.Injective f := by sorry

This theorem states that for all types `α` and `β`, and a given function `f` from `α` to `β`, the function `List.map f`, which applies `f` to each element of a list, is injective if and only if the function `f` itself is injective. In other words, if applying `f` to each element of a list doesn't change the relative uniqueness of elements (if two different elements in the list give two different results when passed through `f`), then `f` must also have this property when applied to any individual elements of `α`. Similarly, if `f` is injective, then so is `List.map f`.

For all types `α` and `β`, and functions `f : α → β`, the function `List.map f` is an injection if and only if `f` is an injection.


theorem ENNReal.le_rpow_one_div_iff : ∀ {x y : ENNReal} {z : ℝ}, 0 < z → (x ≤ y ^ (1 / z) ↔ x ^ z ≤ y) := by sorry

The theorem `ENNReal.le_rpow_one_div_iff` states that for any extended nonnegative real numbers `x` and `y`, and any real number `z` greater than zero, `x` is less than or equal to the `z`th root of `y` if and only if `x` raised to the power `z` is less than or equal to `y`. In other words, it provides a relationship between the comparison of two extended nonnegative real numbers and the comparison of their powers.

For any extended nonnegative real numbers `x` and `y`, and real number `z` > 0, `x` ≤ y if and only if x^z ≤ y.


theorem Complex.cpow_int_cast : ∀ (x : ℂ) (n : ℤ), x ^ ↑n = x ^ n := by sorry

This theorem states that for every complex number `x` and every integer `n`, the power of `x` raised to the real number equivalent of `n` (denoted as `↑n`) is equal to `x` raised to the power of `n`. In mathematical terms, it asserts that for all `x` in the set of complex numbers ℂ and all `n` in the set of integers ℤ, `x ^ ↑n` is equal to `x ^ n`.

For all complex numbers x and integers n, x ^ ↑n = x ^ n.


theorem Int.emod_add_emod : ∀ (m n k : ℤ), (m % n + k) % n = (m + k) % n := by sorry

This theorem states that for any three integers `m`, `n`, and `k`, the remainder of the sum `(m % n + k)` when divided by `n` is equal to the remainder of the sum `(m + k)` when divided by `n`. In other words, adding `k` either before or after taking the modulus does not change the final result. This is a property of the modular arithmetic in integer domain.

For any integers `m`, `n`, and `k`, `(m % n + k) % n = (m + k) % n`.


/-- In the specific case of multilinear maps on spaces indexed by `Fin (n+1)`, where one can build
an element of `∀ (i : Fin (n+1)), M i` using `cons`, one can express directly the multiplicativity
of a multilinear map along the first variable.  -/
theorem MultilinearMap.cons_smul :
    ∀ {R : Type uR} {n : ℕ} {M : Fin (Nat.succ n) → Type v} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
      [inst_3 : (i : Fin (Nat.succ n)) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂)
      (m : (i : Fin n) → M (Fin.succ i)) (c : R) (x : M 0), f (Fin.cons (c • x) m) = c • f (Fin.cons x m) :=
  by sorry

This theorem, "MultilinearMap.cons_smul", states that for any semiring `R`, natural number `n`, types `M` indexed by `Fin (n+1)` and `M₂`, where `M i` and `M₂` are modules over `R` and the elements of `M` are additive commutative monoids, if we have a multilinear map `f` from `M` to `M₂`, a function `m` mapping elements of `Fin n` to `M (Fin.succ i)`, a scalar `c` from `R`, and an element `x` of `M 0`, then the multilinear map `f` exhibits multiplicativity along the first variable when constructed with `Fin.cons`. Specifically, applying `f` to the tuple obtained by scaling `x` by `c` and then constructing a `Fin.cons` tuple with `m` equals the result of scaling by `c` the output of `f` applied to the `Fin.cons` tuple of `x` and `m`.

For any semiring `R`, natural number `n`, additive commutative `R`-modules `M` indexed by `Fin (n+1)` and `M₂`, and multilinear map `f` from `M` to `M₂`, if `x` is an element of `M 0`, `c` is a scalar from `R`, and `m` is a function mapping elements of `Fin n` to `M (Fin.succ i)`, then `f (c * x, Fin.cons ⟨i, m i⟩) = c * f (x, Fin.cons ⟨i, m⟩)`.


theorem Ideal.radical_mono :
    ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, I ≤ J → Ideal.radical I ≤ Ideal.radical J := by sorry

The theorem `Ideal.radical_mono` states that, for any commutative semiring `R` and any two ideals `I` and `J` of `R`, if `I` is a subset of `J`, then the radical of `I` is also a subset of the radical of `J`. Here, the radical of an ideal `A` is defined as the set of all elements `r` in the semiring such that `r` to the power `n` is in `A` for some `n`.

If `I` is an ideal of a commutative semiring `R` and `I` is contained in ideal `J`, then the radical of `I` is contained in the radical of `J`.


Basis.ext'

/-- Two linear equivs are equal if they are equal on basis vectors.  -/
theorem Basis.ext' :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (b : Basis ι R M) {R₁ : Type u_10} [inst_3 : Semiring R₁] {σ : R →+* R₁} {σ' : R₁ →+* R}
      [inst_4 : RingHomInvPair σ σ'] [inst_5 : RingHomInvPair σ' σ] {M₁ : Type u_11} [inst_6 : AddCommMonoid M₁]
      [inst_7 : Module R₁ M₁] {f₁ f₂ : M ≃ₛₗ[σ] M₁}, (∀ (i : ι), f₁ (b i) = f₂ (b i)) → f₁ = f₂ :=
  by sorry

This theorem states that, given two linear equivalences `f₁` and `f₂` between two modules `M` and `M₁` over different semirings `R` and `R₁` respectively, if they both map each basis vector of `M` (as defined by the basis `b`) to the same vector in `M₁`, then `f₁` and `f₂` are equal. This holds under the conditions that `R` and `R₁` are related by ring homomorphisms that form an inverse pair.

Given linear equivalences `f₁ : M → M₁` and `f₂ : M → M₁` between modules `M` over semirings `R` and `M₁` over `R₁`, and ring homomorphisms `h : R → R₁` and `g : R₁ → R` with `h ∘ g = id R` and `f₁ (b) = f₂ (b)` for all basis vectors `b` of `M`, then `f₁ = f₂`.


theorem Mathlib.Topology.Separation._auxLemma.65 :
    ∀ {X : Type u_3} [inst : TopologicalSpace X],
      R1Space X = ∀ (x y : X), Inseparable x y ∨ Disjoint (nhds x) (nhds y) :=
  by sorry

This theorem states that for any type `X` which is equipped with a topology, `X` is an R1 space if and only if for any two points `x` and `y` in `X`, either `x` and `y` are inseparable (i.e., for every open set `s`, `x` is in `s` if and only if `y` is in `s`) or the neighborhoods of `x` and `y` (represented by the filters `nhds x` and `nhds y`) are disjoint (meaning that there is no common smaller neighborhood of `x` and `y`, formally, their infimum is the bottom element).

A topological space X, equipped with a topology, is an R1 space if and only if for all points x and y in X, their neighborhood filters are either identical or have empty infimum.


theorem Function.Injective.sigma_map :
    ∀ {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : α₁ → Type u_5} {β₂ : α₂ → Type u_6} {f₁ : α₁ → α₂}
      {f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)},
      Function.Injective f₁ → (∀ (a : α₁), Function.Injective (f₂ a)) → Function.Injective (Sigma.map f₁ f₂) :=
  by sorry

The theorem `Function.Injective.sigma_map` states that for any two types `α₁` and `α₂`, and two type-dependent functions `β₁ : α₁ → Type` and `β₂ : α₂ → Type`, if we have functions `f₁ : α₁ → α₂` and `f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)` such that `f₁` is injective and for every `a` in `α₁`, `f₂ a` is also injective, then the function `Sigma.map f₁ f₂`, which maps the left and right components of a sigma type, is also injective. In mathematical terms, injectivity of component functions implies the injectivity of the resulting function after a sigma mapping.

If `f₁ : α₁ → α₂` is injective and for all `a` in `α₁`, the function `β₁ a → β₂ (f₁ a)` given by `f₂` is also injective, then the function `Sigma.map f₁ f₂` on sigma types is injective.


theorem Submodule.mul_bot :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (M : Submodule R A), M * ⊥ = ⊥ :=
  by sorry

This theorem states that for any module `M` over a commutative semiring `R` and a semiring `A`, which also has a defined algebra structure over `R`, the product of `M` and the bottom element (denoted by `⊥`) equals the bottom element. Essentially, it says that multiplying any submodule with the zero submodule results in the zero submodule.

For any module M over a commutative semiring R and a semiring A with an algebra structure over R, the product of M and the bottom element of A is the bottom element of the module M. In other words, M⊤ = ⊥M, where ⊤ is the bottom element of A and ⊥M is the bottom element of M.


theorem CategoryTheory.Limits.Multicofork.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C}
      (K : CategoryTheory.Limits.Multicofork I) (a : I.L),
      CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicofork.π K (I.fstFrom a)) =
        CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.Limits.Multicofork.π K (I.sndFrom a)) :=
  by sorry

The theorem `CategoryTheory.Limits.Multicofork.condition` states that for any type `C` with an instance of a category structure, for any multispan index `I` of this category, and for any multicofork `K` of this multispan index, every object `a` on the left of the index satisfies a certain condition. The condition is that the composition of the first morphism from `a` and the morphism from the target of the first morphism to the point of the cocone is equal to the composition of the second morphism from `a` and the morphism from the target of the second morphism to the point of the cocone. In simpler terms, this means that the two possible paths from `a` to the cocone point through the multispan give the same result.

For any category `C` with a multispan index `I` and multicofork `K`, the composition of the first morphism from an object `a` in `C` with the morphism from the target of the first morphism to the cocone point equals the composition of the second morphism from `a` with the morphism from the target of the second morphism to the cocone point, for all cocones over `K` in `C`.


/-- The inductively defined smallest additive congruence relation
containing a binary relation `r` equals the infimum of the set of additive congruence relations
containing `r`. -/
theorem AddCon.addConGen_eq :
    ∀ {M : Type u_1} [inst : Add M] (r : M → M → Prop), addConGen r = sInf {s | ∀ (x y : M), r x y → s x y} := by sorry

This theorem states that for any type `M` with an addition operation and a binary relation `r` on `M`, the smallest inductively defined additive congruence relation that contains `r` is equal to the greatest lower bound (infimum) of the set of all additive congruence relations that contain `r`. In other words, the smallest relation that is both an additive congruence and contains `r`, is exactly the infimum of all additive congruences containing `r`.

The smallest additive congruence relation containing a binary relation on a type with addition is equal to the infimum of all additive congruences containing it.


theorem equicontinuousWithinAt_univ :
    ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_7} [tX : TopologicalSpace X] [uα : UniformSpace α] (F : ι → X → α)
      (x₀ : X), EquicontinuousWithinAt F Set.univ x₀ ↔ EquicontinuousAt F x₀ :=
  by sorry

The theorem `equicontinuousWithinAt_univ` states that for any type `ι`, a topological space `X`, a uniform space `α`, and a family `F` of functions from `X` to `α`, the family `F` is equicontinuous within the universal set at a point `x₀` if and only if it is equicontinuous at `x₀`. In mathematical terms, for all entourages `U` in the uniform space `α`, there is a neighborhood `V` of `x₀` such that for all `x` in `V` and for all `i` in `ι`, the value `F i x` is `U`-close to `F i x₀`.

A family of functions from a topological space to a uniform space is equicontinuous within the universal set at a point if and only if it is equicontinuous at that point. That is, for every entourage in the uniform space, there exists a neighborhood of the point such that for all functions in the family and points in the neighborhood, the values of the functions are close to the values at the point.


theorem CategoryTheory.Limits.image.fac_lift_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasImage f] (F' : CategoryTheory.Limits.MonoFactorisation f) {Z : C}
      (h : F'.I ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.lift F') h) =
        CategoryTheory.CategoryStruct.comp F'.e h :=
  by sorry

This theorem states that in a category `C`, for any objects `X` and `Y` and a morphism `f : X ⟶ Y` with an existing image, given a monomorphism factorisation `F'` of `f`, and any morphism `h : F'.I ⟶ Z`, the composition of the morphism from `X` to the image of `f` with the composition of the lift of `F'` to the image of `f` and `h` is equal to the composition of `F'.e` and `h`. This principle is generally used in the context of category theory and abstract algebra, specifically while dealing with image factorisations and monomorphisms.

In a category C, given morphisms f : X ⟶ Y with an image, F' a monomorphism factorization of f, and h : F'.I ⟶ Z, the compositions of f to the image of f, F'.e with h, and the lift of F' to the image of f with h are equal.


theorem idRel_subset : ∀ {α : Type ua} {s : Set (α × α)}, idRel ⊆ s ↔ ∀ (a : α), (a, a) ∈ s := by sorry

The theorem `idRel_subset` states that for all types `α` and for all sets `s` of pairs of elements of type `α`, the identity relation is a subset of `s` if and only if for every element `a` of type `α`, the pair `(a, a)` belongs to `s`. In mathematical terms, we can say that the graph of the identity function is a subset of a set `s` if and only if every element in `α` paired with itself is an element of `s`.

The identity relation on a type `α` is contained in a binary relation `s` if and only if the diagonal elements `(a, a)` of `α` belong to `s`.


theorem Primrec.nat_casesOn :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → ℕ} {g : α → β}
      {h : α → ℕ → β}, Primrec f → Primrec g → Primrec₂ h → Primrec fun a => Nat.casesOn (f a) (g a) (h a) :=
  by sorry

The theorem `Primrec.nat_casesOn` states that for any types `α` and `β` that can be encoded as natural numbers, and for any functions `f : α → ℕ`, `g : α → β`, and `h : α → ℕ → β`, if `f`, `g`, and `h` are all primitive recursive functions, then the function that takes an element `a` of type `α`, applies `f` to `a` to get a natural number, and then uses the `nat_casesOn` function to produce a value of type `β` based on whether the result of `f a` is zero or a successor of a natural number, is also a primitive recursive function. In other words, the primitive recursiveness is preserved under the operation of case analysis on natural numbers.

If `f : α → ℕ`, `g : α → β`, and `h : α → ℕ → β` are primitive recursive functions, then the function `x => if h x 0 then g x else h x (S x)` is also primitive recursive, where `S` denotes the successor function.


/-- Characterize the equality of points by the vanishing of their extended distance  -/
theorem edist_eq_zero : ∀ {γ : Type w} [inst : EMetricSpace γ] {x y : γ}, edist x y = 0 ↔ x = y := by sorry

This theorem establishes a characteristic of points in an extended metric space. Specifically, for any two points 'x' and 'y' in a given extended metric space 'γ', the theorem states that the extended distance between 'x' and 'y' is zero if and only if 'x' and 'y' are the same point. The extended distance between two points is a generalization of the concept of distance that allows for the possibility of infinite distances.

In an extended metric space, two points have zero extended distance if and only if they are equal.


theorem Finsupp.embDomain_eq_mapDomain :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (f : α ↪ β) (v : α →₀ M),
      Finsupp.embDomain f v = Finsupp.mapDomain (⇑f) v :=
  by sorry

The theorem `Finsupp.embDomain_eq_mapDomain` states that for any types `α`, `β` and `M`, with `M` being an additive commutative monoid, and for any injective function `f` from `α` to `β` and any finitely supported function `v` from `α` to `M`, the function obtained by embedding the domain of `v` in `β` using `f` (`Finsupp.embDomain f v`) is equal to the function obtained by mapping the domain of `v` to `β` using `f` (`Finsupp.mapDomain (⇑f) v`). In other words, if we treat an injective function as a regular function, then the processes of embedding the domain and mapping the domain yield the same result.

For any injective function `f` and finitely supported function `v`, the embedding of the domain of `v` in `β` using `f` equals the mapping of the domain of `v` to `β` using `f` in the context of additive commutative monoids `M` over types `α` and `β`.


theorem Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts._auxLemma.3 :
    ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True := by sorry

This theorem, `Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts._auxLemma.3`, states that for any type `α` that is a subsingleton (i.e., a type that has at most one element), any two elements `x` and `y` of type `α` are equal. This is expressed as `(x = y) = True`, where the equality is universally valid for all `x` and `y`. In other words, in a type where there can be at most one distinct value, any two values of that type must necessarily be equal.

In a subsingleton type, any two elements are equal.


theorem Option.map₂_eq_none_iff :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β},
      Option.map₂ f a b = none ↔ a = none ∨ b = none :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ` and any binary function `f : α → β → γ` applied to `Option α` and `Option β`, `Option.map₂ f a b` results in `none` if and only if either `a` is `none` or `b` is `none`. This means that in the context of option types, the failure of the binary function `f` to produce a result equates to the absence of a value in either of the input options.

For any functions `f : α → β → γ` and `a : Option α`, `b : Option β`, `Option.map₂ f a b = none` if and only if `a = none` or `b = none`.


theorem isClosed_sInter :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set (Set X)}, (∀ t ∈ s, IsClosed t) → IsClosed (⋂₀ s) := by sorry

This theorem states that for any type `X` equipped with a topology, and for any set `s` of subsets of `X`, if every subset `t` in `s` is a closed set, then the intersection of all subsets in `s` is also a closed set. In mathematical terms, for any topological space `X` and any collection `s` of closed subsets of `X`, the intersection over `s` is closed.

Given a topological space `X` and a collection `s` of closed subsets of `X`, their intersection is also a closed subset of `X`.


theorem MeasureTheory.ae_restrict_iff'₀ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {p : α → Prop},
      MeasureTheory.NullMeasurableSet s μ → ((∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x) :=
  by sorry

This theorem states that for any type `α`, measurable space `m0`, measure `μ`, set `s` of type `α`, and a property `p` from `α` to `Prop`, if `s` is a null measurable set with respect to measure `μ`, then the property `p` holds almost everywhere with respect to the measure restricted to `s` if and only if the property `p` holds almost everywhere in the measure `μ` under the condition that `x` belongs to `s`. Here, "almost everywhere" means for all but a subset of `α` of measure zero.

For any measurable space `(α, m0)`, measure `μ`, set `s` of type `α`, and property `p` from `α` to `Prop`, if `s` is a null set with respect to `μ`, then `p` holds almost everywhere on `s` if and only if `p` holds almost everywhere on `α` for elements in `s`.


theorem HasStrictFDerivAt.congr_of_eventuallyEq :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {f f₁ : E → F} {f' : E →L[𝕜] F} {x : E}, HasStrictFDerivAt f f' x → f =ᶠ[nhds x] f₁ → HasStrictFDerivAt f₁ f' x :=
  by sorry

This theorem states that if a function `f` has a strict Frechet derivative `f'` at a point `x` in a nontrivial normed field, then if `f` equals another function `f₁` in a neighborhood of `x`, `f₁` also has a strict Frechet derivative `f'` at `x`. Here, both `f` and `f₁` are functions from a normed additive commutative group `E` to another such group `F`, and the topology on `E` and `F` is defined by a norm. This neighborhood is defined in the context of a topological space, and the Frechet derivative is a linear map from `E` to `F`.

If `f` and `f₁` are functions from a normed additive commutative group `E` to another such group `F`, with `f` having a strict Frechet derivative `f'` at `x` in `E`, and `f` equals `f₁` in a neighborhood of `x`, then `f₁` also has a strict Frechet derivative `f'` at `x`.


theorem Fin.forall_fin_succ :
    ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) ↔ P 0 ∧ ∀ (i : Fin n), P (Fin.succ i) := by sorry

The theorem `Fin.forall_fin_succ` states that for every natural number `n` and a property `P` that each element of the type `Fin (n + 1)` might have, the property `P` holds for all elements in `Fin (n + 1)` if and only if `P` holds for the zeroth element and for all elements in `Fin n` when they are passed through the function `Fin.succ`. The function `Fin.succ` takes an element of `Fin n` and returns an element of `Fin (n + 1)`, effectively shifting the index of the element by 1.

For any natural number `n` and property `P`, `P` holds for all elements in `Fin (n + 1)` if and only if `P` holds for the zero element and for the successor of each element in `Fin n`.


theorem Dioph.vec_ex1_dioph :
    ∀ (n : ℕ) {S : Set (Vector3 ℕ (Nat.succ n))}, Dioph S → Dioph {v | ∃ x, Vector3.cons x v ∈ S} := by sorry

The theorem `Dioph.vec_ex1_dioph` states that for any natural number `n` and for any Diophantine set `S` of vectors in `ℕ^(n+1)`, the set of vectors `v` in `ℕ^n` such that there exists a natural number `x` for which appending `x` to the front of `v` results in a vector in `S`, is also Diophantine. Thus, if a set of vectors (of size `n+1`) is Diophantine, then the set of all vectors that can be obtained by removing the first element from the vectors in the original set is also Diophantine.

If `S` is a Diophantine set of vectors in `ℕ^(n+1)`, then the set of vectors in `ℕ^n` that can be extended to a vector in `S` is also Diophantine.


Set.Countable.prod

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

The theorem `Set.Countable.prod` states that for all types `α` and `β`, and for all sets `s` of type `α` and `t` of type `β`, if `s` and `t` are countable, then the Cartesian product of `s` and `t` (denoted as `s ×ˢ t`) is also countable. In other words, if we can establish a one-to-one correspondence between each of the sets `s` and `t` and the set of natural numbers, then we can also establish a similar correspondence for the set of all ordered pairs `(a, b)` where `a` is from `s` and `b` is from `t`.

If `α` and `β` are countable types, and `s:` `Type α` and `t:` `Type β` are countable sets, then their Cartesian product `s ×β t` is also countable.


theorem Nat.sqrt_eq : ∀ (n : ℕ), Nat.sqrt (n * n) = n := by sorry

The theorem `Nat.sqrt_eq` states that for every natural number `n`, the integer square root of the square of `n` is equal to `n` itself. In other words, if we square a natural number and then take its integer square root, we will arrive back at the original number. This corresponds to the mathematical statement: $\forall n \in \mathbb{N}, \ \sqrt{n^2} = n$.

For every natural number $n$, the integer square root of $n^2$ equals $n$. In other words, $\sqrt{n^2} = n$.


theorem MeasureTheory.measure_add_right_null :
    ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : MeasurableAdd₂ G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.SigmaFinite μ] {s : Set G} [inst_4 : MeasurableNeg G]
      [inst_5 : MeasureTheory.Measure.IsAddLeftInvariant μ] (y : G), ↑↑μ ((fun x => x + y) ⁻¹' s) = 0 ↔ ↑↑μ s = 0 :=
  by sorry

This theorem, named `MeasureTheory.measure_add_right_null`, states that for any type `G` equipped with a `MeasurableSpace` structure, an `AddGroup` structure, and a `MeasurableAdd₂` structure, for any measure `μ` on `G` that is `SigmaFinite` and `IsAddLeftInvariant`, for any set `s` in `G`, and for any element `y` in `G`, the measure of the preimage of `s` under the function that adds `y` to an element is zero if and only if the measure of `s` is zero. This is essentially saying that shifting a set by an element in an additive group does not change its measure, if its measure is zero.

For any `SigmaFinite` and `IsAddLeftInvariant` measure `μ` on an additive group `G` with `MeasurableSpace` and `AddGroup` structures, the preimage of a measurable set under the function that adds a fixed element of `G` has measure zero if and only if the original set has measure zero.


theorem Set.union_diff_right : ∀ {α : Type u} {s t : Set α}, (s ∪ t) \ t = s \ t := by sorry

This theorem is about set operations in the context of some type `α`. Specifically, it states that for any two sets `s` and `t` of type `α`, the set difference of the union of `s` and `t` with `t` is equal to the set difference of `s` and `t`. In mathematical notation, this is saying that `(s ∪ t) \ t = s \ t` for all sets `s` and `t`. This is a property of the set union and set difference operations.

For all sets `s` and `t` of type `α`, the set difference of `s` and `t` is equal to the set difference of `s` and the subset `t` of its union with `t`. In other words, `(s ∪ t) \ t = s \ t`.


/-- The range of a surjective ring homomorphism is the whole of the codomain.  -/
theorem RingHom.rangeS_top_of_surjective :
    ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S),
      Function.Surjective ⇑f → RingHom.rangeS f = ⊤ :=
  by sorry

The theorem `RingHom.rangeS_top_of_surjective` states that for any two types `R` and `S`, given that both `R` and `S` are non-associative semirings, if there exists a ring homomorphism `f` from `R` to `S` that is surjective (i.e., for every element `b` in `S`, there is some element `a` in `R` such that `f(a) = b`), then the range of `f`, as defined by `RingHom.rangeS`, is the entire codomain `S` (denoted by `⊤`). In other words, a surjective ring homomorphism maps to every element in the codomain.

A surjective ring homomorphism between non-associative semirings maps the entire domain to the entire codomain.


theorem Complex.range_exp : Set.range Complex.exp = {0}ᶜ := by sorry

The theorem `Complex.range_exp` states that the range of the complex exponential function, defined as `Complex.exp`, is the set of all complex numbers excluding zero. In other words, every complex number except zero can be obtained as the exponential of some complex number, and zero cannot be obtained this way. In mathematical notation, this can be written as $\mathrm{range}(\exp) = \mathbb{C} \setminus \{0\}$.

The complex exponential function, `Complex.exp`, maps complex numbers to all non-zero complex numbers.


theorem Polynomial.comp_C :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R},
      Polynomial.comp p (Polynomial.C a) = Polynomial.C (Polynomial.eval a p) :=
  by sorry

This theorem states that for any type `R` which forms a semiring, for any element `a` of `R`, and for any polynomial `p` with coefficients from `R`, the composition of the polynomial `p` with the constant polynomial `a` is the same as the constant polynomial whose value is the evaluation of `p` at `a`. In mathematical terms, it says that the composition of a polynomial `p(x)` with a constant `a`, denoted as `p(a)`, is a constant polynomial whose value is `p(a)`.

For any semiring `R`, any element `a` in `R`, and any polynomial `p(x)` with coefficients in `R`, `p(a)` is the constant polynomial equal to the value of `p` evaluated at `a`.


theorem Filter.HasBasis.ex_mem :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α}, Filter.HasBasis l p s → ∃ i, p i :=
  by sorry

The theorem `Filter.HasBasis.ex_mem` states that for any type `α`, any type `ι`, any filter `l` on `α`, and any functions `p` from `ι` to `Prop` and `s` from `ι` to `Set α`, if the filter `l` has a basis characterized by the properties `p` and sets `s`, then there exists an `i` such that the property `p` holds true for `i`.
In other words, if a filter has a basis, then there exists at least one element in this basis that satisfies a certain property.

If a filter on a type has a basis characterized by a property and sets, then there exists an element in the basis with the property.


theorem Cardinal.succ_zero : Order.succ 0 = 1 := by sorry

This theorem states that the successor of zero is one in the context of an ordered set. In more detail, it specifies that when the "Order.succ" function, which gives the next element in an ordered set, is applied to the element zero, the output is the element one. This is analogous to the familiar concept in the natural numbers where the successor of 0 is 1.


/-- If `u` is a uniform structure on `β` and `f : γ → β`, then
`𝒱(α, γ, 𝔖, comap f u) = comap (fun g ↦ f ∘ g) 𝒱(α, γ, 𝔖, u₁)`.  -/
theorem UniformOnFun.comap_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] {𝔖 : Set (Set α)} {f : γ → β},
      UniformOnFun.uniformSpace α γ 𝔖 = UniformSpace.comap (fun x => f ∘ x) (UniformOnFun.uniformSpace α β 𝔖) :=
  by sorry

The theorem `UniformOnFun.comap_eq` states that for any types `α`, `β`, and `γ`, a uniform space structure `inst` on `β`, a set `𝔖` of subsets of `α`, and a function `f` from `γ` to `β`, the uniform structure on functions from `α` to `γ` induced by `𝔖` is the same as the uniform structure obtained by taking the preimage under the function composition `f ∘ x` of the uniform structure on functions from `α` to `β` induced by `𝔖`. In simpler terms, this theorem expresses an equality between two ways of constructing a uniform structure on the function space from `α` to `γ`, either directly or by precomposing with a given function `f`.

For any uniform spaces (β, inst) on type β, set 𝔖 of subsets of α, and function f from γ to β, the uniform structure on Functions from α to γ induced by 𝔖 is equal to the preimage under f ∘ x of the uniform structure on Functions from α to β induced by 𝔖.


theorem Polynomial.rootMultiplicity_eq_multiplicity :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableRel fun x x_1 => x ∣ x_1]
      (p : Polynomial R) (a : R),
      Polynomial.rootMultiplicity a p =
        if h0 : p = 0 then 0 else (multiplicity (Polynomial.X - Polynomial.C a) p).get ⋯ :=
  by sorry

This theorem states that for any ring `R` with decidable equality and a decidable relation for divisibility, given a polynomial `p` and an element `a` of `R`, the root multiplicity of `a` in `p` is equal to the multiplicity of the polynomial `X - C a` in `p`. In other words, the root multiplicity of `a` in `p` is the largest power of `X - C a` that divides `p`. If `p` is the zero polynomial, the root multiplicity is defined to be zero. The multiplicity is computed with respect to the PartENat number system, which includes natural numbers and an infinity element.

For any ring with decidable equality and a decidable divisibility relation, the root multiplicity of an element in a polynomial is equal to the multiplicity of the corresponding linear polynomial in the given polynomial.


theorem MeasureTheory.AEEqFun.cast.proof_1 :
    ∀ {α : Type u_2} {β : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] (f : α →ₘ[μ] β), MeasureTheory.AEStronglyMeasurable (↑(Quotient.out' f)) μ :=
  by sorry

The theorem `MeasureTheory.AEEqFun.cast.proof_1` states that for any measure space `α`, measure `μ` on `α`, and topological space `β`, if we have a function `f` from `α` to `β` that is equivalent almost everywhere (denoted by `α →ₘ[μ] β`), then the function obtained by taking the equivalence class of `f` under almost everywhere equality (`Quotient.out' f`) and casting it to a function (`↑(Quotient.out' f)`), is almost everywhere strongly measurable with respect to `μ`. In simpler terms, it says that the function that represents an equivalence class under almost everywhere equality is almost everywhere strongly measurable.

For any measure space `(α, Σ, μ)`, topological space `(β, τ)`, and almost everywhere equal functions `f: α → β`, the quotient function `↑(Quotient.out' f): Σ → τ` is almost everywhere μ-measurable.


theorem Function.Injective.hasSum_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
      {a : α} {g : γ → β}, Function.Injective g → (∀ x ∉ Set.range g, f x = 0) → (HasSum (f ∘ g) a ↔ HasSum f a) :=
  by sorry

The theorem `Function.Injective.hasSum_iff` states that for any types `α`, `β`, and `γ`, given an addition commutative monoid structure and a topological space structure on `α`, a function `f : β → α`, a value `a : α`, and an injective function `g : γ → β`, if `f x = 0` for all `x` not in the range of `g`, then the sum of the sequence `(f ∘ g)` converges to `a` if and only if the sum of the sequence `f` converges to `a`. Here, `HasSum` is a predicate stating that a sequence (represented by a function from the natural numbers) converges to a particular value.

Given a commutative monoid with addition on types `α`, a topological space `α`, a function `f : β → α`, an injective function `g : γ → β`, value `a : α`, and sequences `(x_n : β)` in the range of `g` and `(y_n : γ)`, if `f ∘ g (y_n) = 0` for all `y_n ≠ y_m`, then the sequence `(f (g (y_n)))` converges to `a` if and only if the sequence `(f x_n)` converges to `a`.


theorem Ideal.pow_right_strictAnti :
    ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDedekindDomain A] (I : Ideal A),
      I ≠ ⊥ → I ≠ ⊤ → StrictAnti fun x => I ^ x :=
  by sorry

This theorem states that for any type `A` that is a commutative ring and also a Dedekind domain, along with any ideal `I` in `A` that is neither the bottom nor the top ideal, the function that maps `x` to the `x`-th power of `I` is strictly antitone. In mathematical terms, if `a < b`, then `I^b < I^a`. This means the function decreases as its input increases, hence it's 'strictly antitone'.

For any commutative ring and Dedekind domain `A` with ideal `I` neither bottom nor top, the function `x => I^x` is strictly decreasing on the positive integers.


/-- If `α` is an infinite type, then `α ⊕ α` and `α` have the same cardinality.  -/
theorem Cardinal.add_eq_self : ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → c + c = c := by sorry

The theorem `Cardinal.add_eq_self` states that for any cardinal number `c` (from the type of cardinal numbers `Cardinal.{u_1}`), if `c` is greater than or equal to `ℵ₀` (the smallest infinite cardinal number, represented by `Cardinal.aleph0`), then the sum of `c` and `c` is equal to `c`. In other words, if a type `α` is infinite (has cardinality at least `ℵ₀`), then the cardinality of `α ⊕ α` (the sum type of `α` and `α`, or the type of all data that either comes from `α` or from `α`) is the same as the cardinality of `α`.

For any cardinal number `c` greater than or equal to `ℵ₀`, `c + c = c`. In other words, the cardinality of the sum type of a type of infinite cardinality is equal to its own cardinality.