theorem finprod_def :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M)
      [inst_1 : Decidable (Set.Finite (Function.mulSupport f))],
      (finprod fun i => f i) =
        if h : Set.Finite (Function.mulSupport f) then Finset.prod (Set.Finite.toFinset h) fun i => f i else 1 :=
  by sorry

The theorem `finprod_def` states that for any types `α` and `M`, where `M` forms a commutative monoid, and a function `f` from `α` to `M`, given that it is decidable whether the set of points where `f` does not equal one is finite (the multiplicative support of `f`), then the product of `f i` for all `i` (denoted `finprod fun i => f i`) is equivalent to: if the multiplicative support of `f` is finite, then the product of `f i` for all `i` in the finite set that represents the multiplicative support of `f`; otherwise, the result is one. In other words, the product over the entire domain is equivalent to the product over the multiplicative support when it's finite; otherwise, the result is the multiplicative identity.

Given a function `f` from a type `α` to a commutative monoid `M` with a decidable finite multiplicative support, the product of `f i` over all `i` is equal to the product over the finite support set or the multiplicative identity if the support is infinite.


theorem Mathlib.SetTheory.ZFC.Basic._auxLemma.19 : ∀ {x y z : ZFSet}, (x ∈ insert y z) = (x = y ∨ x ∈ z) := by sorry

This theorem states that for any three sets `x`, `y`, and `z` in the Zermelo–Fraenkel set theory universe (`ZFSet`), `x` is an element of the set obtained by inserting `y` into `z` if and only if `x` is equal to `y` or `x` is an element of `z`. This mirrors the familiar property of sets in classical set theory.

For any sets `x`, `y`, and `z` in `ZFSet`, `x ∈ {y | ∈ z} <--> x = y ∨ x ∈ z`.


theorem Mathlib.SetTheory.ZFC.Basic._auxLemma.23 :
    ∀ {p : ZFSet → Prop} {x y : ZFSet}, (y ∈ ZFSet.sep p x) = (y ∈ x ∧ p y) := by sorry

The theorem `_auxLemma.23` in the `Mathlib.SetTheory.ZFC.Basic` module states that for any predicate `p` and any Zermelo–Fraenkel set theory (ZFC) sets `x` and `y`, `y` is an element of the set of elements in `x` that satisfy `p` (represented by `ZFSet.sep p x`) if and only if `y` is an element of `x` and `y` satisfies `p`. In mathematical notation, this would be expressed as ∀p, x, y, (y ∈ {x ∈ a | p(x)}) ⇔ (y ∈ a ∧ p(y)).

For any set `a` and predicate `p`, an element `y` is in the subset of `a` satisfying `p` if and only if it is in `a` and satisfies `p` itself.


theorem Mathlib.SetTheory.ZFC.Basic._auxLemma.25 : ∀ {x y : ZFSet}, (y ∈ ⋃₀ x) = ∃ z ∈ x, y ∈ z := by sorry

This theorem from the Mathlib Set Theory ZFC library states that for any two sets `x` and `y` in the ZFC universe of sets, `y` is a member of the union over `x` if and only if there exists a subset `z` of `x` such that `y` is a member of `z`. In other words, a set `y` belongs to the union of a collection of sets `x` if `y` belongs to at least one set in that collection.

For any sets `x` and `y`, `y` is in the union of `x` if and only if there exists a subset `z` of `x` such that `y` is in `z`.


theorem Mathlib.SetTheory.ZFC.Basic._auxLemma.15 : ∀ (x : ZFSet), (x ∈ ∅) = False := by sorry

This theorem states that for all x, where x is of type ZFSet (the ZFC universe of sets), x is not a member of the empty set. In other words, it asserts that the empty set does not contain any elements.

The theorem asserts that the empty set is empty and contains no elements, that is, ∀x, x ∉ ∅.


theorem iSup_dite :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] (p : ι → Prop) [inst_1 : DecidablePred p]
      (f : (i : ι) → p i → α) (g : (i : ι) → ¬p i → α),
      (⨆ i, if h : p i then f i h else g i h) = (⨆ i, ⨆ (h : p i), f i h) ⊔ ⨆ i, ⨆ (h : ¬p i), g i h :=
  by sorry

The theorem `iSup_dite` states that for any type `α` that forms a complete lattice, any predicate `p` on some sort `ι` that is decidable, and any two functions `f` and `g` from `ι` to `α` that depend on whether `p` holds or not, respectively, the supremum (or `⨆`, the greatest lower bound in the lattice) over `ι` of the piecewise function that evaluates to `f i` if `p i` holds and `g i` otherwise, is equal to the join (`⊔`, the least upper bound in the lattice) of the supremum over `ι` of `f i` for which `p i` holds and the supremum over `ι` of `g i` for which `p i` does not hold. This theorem essentially expresses a distributive property of the supremum operation over a disjunction in a complete lattice.

For any complete lattice α, decidable predicate p on sort ι, and functions f and g from ι to α that depend on p, the supremum of the piecewise function evaluating to fi if pi holds and gi otherwise is equal to the join of the supremum of fi for pi holds and the supremum of gi for pi does not hold.


theorem Units.inv_eq_of_mul_eq_one_right : ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, ↑u * a = 1 → ↑u⁻¹ = a :=
  by sorry

This theorem states that for any type `α` that forms a monoid, and for any unit `u` and element `a` of this type, if the product of `u` and `a` equals 1 (the multiplicative identity of the monoid), then the inverse of `u` is equal to `a`. In mathematical terms, `u * a = 1` implies `u⁻¹ = a` for all `u` and `a` in a given monoid `α`.

If `u` is the multiplicative identity of a monoid `α` with invertible element `a`, then `u = a⁻¹`.


Irreducible.prime

theorem Irreducible.prime :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecompositionMonoid α] {a : α}, Irreducible a → Prime a :=
  by sorry

This theorem states that for any type `α` that is a Commutative Monoid with Zero and can be decomposed (i.e., it has the properties of a `DecompositionMonoid`), any irreducible element `a` of type `α` is also a prime element. In mathematical terms, for a commutative monoid with zero and decomposition property, if an element is irreducible, then it's also prime. An irreducible element `a` is one that can't be expressed as a product of two non-unit elements, while a prime element `p` is a non-zero, non-unit element that satisfies the property that if `p` divides the product of `a` and `b`, then `p` must divide `a` or `b`.

In a commutative monoid with zero and decomposition property, every irreducible element is prime.


theorem Multiset.mem_pmap :
    ∀ {α : Type u_1} {β : Type v} {p : α → Prop} {f : (a : α) → p a → β} {s : Multiset α} {H : ∀ a ∈ s, p a} {b : β},
      b ∈ Multiset.pmap f s H ↔ ∃ a, ∃ (h : a ∈ s), f a ⋯ = b :=
  by sorry

The theorem `Multiset.mem_pmap` states that for any types `α` and `β`, a property `p` on `α`, a function `f` from `α` (satisfying property `p`) to `β`, a multiset `s` consisting of elements of type `α` (where all elements satisfy `p`), and any element `b` of type `β`, the element `b` is in the multiset obtained by applying the partially mapped function `f` to multiset `s` if and only if there exists an element `a` in `s` such that applying the function `f` to `a` (and the proof of `a` satisfying `p`) gives `b`. In other words, an element is in the output of the partial map operation on a multiset if and only if it is the image of an element of the initial multiset under the function in the partial map operation.

For any types `α`, `β`, property `p` on `α`, function `f : α →β` satisfying `p`, multiset `s` of `α` elements satisfying `p`, and `β` element `b`, `b` is in the multiset obtained by applying `f` to `s` if and only if there exists an `α` element `a` in `s` with `f(a) = b` and `p(a)` holds.


/-- The oriented angle between two nonzero vectors is plus or minus the unoriented angle.  -/
theorem Orientation.oangle_eq_angle_or_eq_neg_angle :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V},
      x ≠ 0 →
        y ≠ 0 →
          Orientation.oangle o x y = ↑(InnerProductGeometry.angle x y) ∨
            Orientation.oangle o x y = -↑(InnerProductGeometry.angle x y) :=
  by sorry

This theorem states that in a 2-dimensional real vector space, the oriented angle between two nonzero vectors is either equal to or the negative of the unoriented angle between those two vectors. Here, the oriented angle is a measure of the angle from one vector to the other, taking into account the direction of rotation (and defined to be 0 if either vector is 0), while the unoriented angle is the measure of the smallest angle between two vectors, without consideration for the direction of rotation (and defined to be π/2 if either vector is 0).

In a 2-dimensional real vector space, the oriented angle between two nonzero vectors is equal to the unoriented angle with its sign determined by their cross product's sign.


theorem AddMonoidHomClass.antilipschitz_of_bound :
    ∀ {𝓕 : Type u_1} {E : Type u_6} {F : Type u_7} [inst : SeminormedAddGroup E] [inst_1 : SeminormedAddGroup F]
      [inst_2 : FunLike 𝓕 E F] [inst_3 : AddMonoidHomClass 𝓕 E F] (f : 𝓕) {K : NNReal},
      (∀ (x : E), ‖x‖ ≤ ↑K * ‖f x‖) → AntilipschitzWith K ⇑f :=
  by sorry

The theorem `AddMonoidHomClass.antilipschitz_of_bound` states that for all types `𝓕`, `E`, and `F`, where `E` and `F` are seminormed add groups, and `𝓕` is a type that behaves like a function from `E` to `F` and is also an additive monoid homomorphism, given a certain function `f` of type `𝓕` and a nonnegative real number `K`, if for every element `x` of type `E`, the seminorm of `x` is less than or equal to `K` times the seminorm of `f x`, then the function `f` is `K`-Antilipschitz.

In mathematical terms, a function `f` is `K`-Antilipschitz if the extended distance between any two points `x` and `y` is always less than or equal to `K` times the extended distance between `f(x)` and `f(y)`.

Given a type `𝓕` that is a function from a seminormed add group `E` to another seminormed add group `F`, is an additive monoid homomorphism, and satisfies the condition that for all `x` in `E`, the seminorm of `x` is less than or equal to `K` times the seminorm of `𝓕(x)`, then `𝓕` is `K`-Antilipschitz.


theorem AddMonoidAlgebra.divOf_add_modOf :
    ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCancelCommMonoid G] (x : AddMonoidAlgebra k G)
      (g : G), AddMonoidAlgebra.of' k G g * AddMonoidAlgebra.divOf x g + AddMonoidAlgebra.modOf x g = x :=
  by sorry

This theorem states that for any semiring `k` and any add-cancel-commutative monoid `G`, for any element `x` in the monoid algebra of `G` over `k` and any element `g` in `G`, if we multiply the embedding of `g` in the monoid algebra by the division of `x` by the embedding of `g`, then add the remainder of `x` divided by the embedding of `g`, we get back `x`. This is a division algorithm in the monoid algebra, analogous to the division algorithm in the integers where `a = bq + r` for integers `a, b, q, r` with `r < b`.

For any semiring `k` and add-cancel-commutative monoid `G`, the division algorithm holds in the monoid algebra over `k`: for all `x` in the monoid algebra and `g` in `G`, there exist unique elements `q` and `r` in the monoid algebra such that `x = g * q + r` and `r = 0` or `r` is the remainder of the division of `x` by `g`, with degree of `r` strictly less than the degree of `g`.


theorem Finsupp.mem_graph_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {c : α × M} {f : α →₀ M},
      c ∈ Finsupp.graph f ↔ f c.1 = c.2 ∧ c.2 ≠ 0 :=
  by sorry

The theorem `Finsupp.mem_graph_iff` states that for any types `α` and `M`, where `M` has an instance of Zero, and for any pair `c` of type α × M and finitely supported function `f` of type α →₀ M, the pair `c` is in the graph of `f` if and only if the result of applying `f` to the first element of `c` is equal to the second element of `c` and the second element of `c` is not zero. This theorem essentially gives the condition for a pair to belong to the graph of a finitely supported function.

A pair `(a, m)` belongs to the graph of a finitely supported function `f : α →₀ M` if and only if `f a = m` and `m ≠ 0`.


IsCompact.diff

/-- The set difference of a compact set and an open set is a compact set.  -/
theorem IsCompact.diff :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsOpen t → IsCompact (s \ t) := by sorry

The theorem `IsCompact.diff` states that in any topological space `X`, if `s` is a compact set and `t` is an open set, then the set difference of `s` and `t`, denoted `(s \ t)`, is also a compact set. In other words, subtracting an open set from a compact set still leaves us with a compact set. This is an important result in topology, which helps to understand the properties and behavior of compact sets in different contexts.

In any topological space, the difference of a compact set and an open set is a compact set.


theorem Int.div_eq_of_eq_mul_right : ∀ {a b c : ℤ}, b ≠ 0 → a = b * c → Int.div a b = c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `b` is not equal to zero and `a` is equal to the product of `b` and `c`, then the integer division of `a` by `b` is equal to `c`. Essentially, it is saying that if you have an equation of the form `a = b * c`, where `b` is not zero, you can divide both sides by `b` to get `c = a div b`.

If integers `a`, `b`, and `c` satisfy `b ≠ 0` and `a = b * c`, then `a / b = c`.


theorem Filter.biInter_finset_mem :
    ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} (is : Finset β), ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f :=
  by sorry

This theorem, `Filter.biInter_finset_mem`, states that for any given filter `f` of type `α`, and a function `s` mapping from type `β` to a set of type `α`, and also a finite set `is` of type `β`, the intersection over all elements `i` in `is` of `s i` belongs to the filter `f` if and only if each individual `s i` for all `i` in `is` belongs to the filter `f`. In mathematical terms, this means that the intersection over a finite set of sets, each belonging to a filter, belongs to the filter itself.

For any filter `f` on type `α`, and a function `s` from type `β` to `α`, if `s i ∈ f` for all `i` in a finite set `is` of type `β`, then `∩ i in is (s i) ∈ f`.


theorem Function.Injective.embedding_induced :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [t : TopologicalSpace Y], Function.Injective f → Embedding f := by sorry

This theorem states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, if `Y` is equipped with a topological space structure and the function `f` is injective (meaning that if `f x = f y`, then `x = y`), then `f` is an embedding. An embedding in this context is a function that induces a topology on `X` from the topology on `Y`, such that the function is continuous and its inverse function from its image to `X` is also continuous.

If `f` is an injective function from type `X` to a topological space `Y`, then `f` is an embedding.


/-- The negation of a nonsingular affine point in `W` is nonsingular.  -/
theorem WeierstrassCurve.Affine.nonsingular_neg :
    ∀ {R : Type u} [inst : CommRing R] {W : WeierstrassCurve.Affine R} {x y : R},
      W.nonsingular x y → W.nonsingular x (W.negY x y) :=
  by sorry

The theorem `WeierstrassCurve.Affine.nonsingular_neg` states that for any commutative ring `R`, and any Weierstrass curve `W` defined over `R`, along with any points `x, y` in `R`, if the point `(x, y)` is a nonsingular point on the curve `W`, then the point `(x, W.negY x y)` is also a nonsingular point on the curve `W`. In other words, the negation of a nonsingular affine point in a Weierstrass curve is also nonsingular.

For any Weierstrass curve `W` over a commutative ring `R` and any nonsingular point `(x, y)` on `W`, the point `(x, W.negY x y)` is also a nonsingular point on `W`.


theorem Finset.sum_pi_single' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (a : α) (x : β) (s : Finset α),
      (Finset.sum s fun a' => Pi.single a x a') = if a ∈ s then x else 0 :=
  by sorry

This theorem, `Finset.sum_pi_single'`, states that for any type `α`, type `β` with an associated additive commutative monoid structure, any decidable equality on `α`, any element `a` of type `α`, any element `x` of type `β`, and any finite set `s` of `α`, the sum of the function `Pi.single a x` applied to each element `a'` in the finite set `s` equals `x` if `a` is in `s`, and `0` otherwise. In other words, it expresses that the sum of the function that assigns `x` to `a` and `0` to all other elements of `s`, is equal to `x` if `a` is an element of `s`, and `0` if not.

For any type `α`, type `β` with an additive commutative monoid structure, decidable equality relation on `α`, and finite set `s` of `α`, the function that maps each `a` in `s` to `x` and all other elements to `0` has sum equal to `x` if `a` is in `s`, and `0` otherwise.


theorem IsometryEquiv.image_closedBall :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x : α)
      (r : ℝ), ⇑h '' Metric.closedBall x r = Metric.closedBall (h x) r :=
  by sorry

The theorem `IsometryEquiv.image_closedBall` states that for any isometry `h` between two pseudo metric spaces `α` and `β`, the image of the closed ball in `α` centered at `x` with radius `r` under the isometry `h` is the closed ball in `β` centered at `h(x)` with the same radius `r`. In other words, an isometry maps a closed ball in one pseudo metric space to a closed ball with the same radius in the other pseudo metric space.

For any isometry between pseudo metric spaces and any point and radius in those spaces, the image of the closed ball centered at that point with that radius is a closed ball with the same radius centered at the image of that point in the other space.


theorem MeasureTheory.volume_pi_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasureTheory.MeasureSpace (α i)]
      [inst_2 : ∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume] (s : (i : ι) → Set (α i)),
      ↑↑MeasureTheory.volume (Set.pi Set.univ s) = Finset.prod Finset.univ fun i => ↑↑MeasureTheory.volume (s i) :=
  by sorry

This theorem, called `MeasureTheory.volume_pi_pi`, states that for any finite type `ι`, and a function `α` that maps each element of `ι` to a type, under the assumptions that each `α i` is a measure space and that the measure volume is sigma-finite for all `i` in `ι`, the measure of the product of sets `s : (i : ι) → Set (α i)` equals the product of the measures of each individual set `s i`. Specifically, it says that the measure of the set of all functions `f : ι → α i` such that for all `i` in `ι`, `f i` is in `s i`, is equal to the product of the measures of all `s i` as `i` ranges over all elements of `ι`.

For any sigma-finite measure space `(α i)` indexed by a finite type `ι`, the measure of the product of sets `{f : ι → α i | ∀ i, f i ∈ s i}` equals the product of the measures of `s i` as `i` ranges over `ι`.


theorem dist_lineMap_right :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] {𝕜 : Type u_6} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V] (p₁ p₂ : P)
      (c : 𝕜), dist ((AffineMap.lineMap p₁ p₂) c) p₂ = ‖1 - c‖ * dist p₁ p₂ :=
  by sorry

The theorem `dist_lineMap_right` states that for any two points `p₁` and `p₂` in a pseudo-metric space `P` with a seminormed add commutative group structure `V` and a normed add torsor structure, and for any scalar `c` from a normed field `𝕜`, the distance between the image of `c` under the affine map from `𝕜` to `P` sending `0` to `p₁` and `1` to `p₂` and the point `p₂` equals the absolute value of `(1 - c)` times the distance between `p₁` and `p₂`. This means that the distance from any point `c` on the line segment between `p₁` and `p₂` to `p₂` scales linearly with the distance between `p₁` and `p₂` and the deviation of `c` from `1`.

Given a pseudo-metric space with a seminormed add commutative group structure and a normed add torsor structure, the distance from a point on the line segment between two points to the second point is proportional to the difference between 1 and the scalar representing the point, multiplied by the distance between the two points.


theorem MeasureTheory.frequently_ae_mem_iff :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
      (∃ᵐ (a : α) ∂μ, a ∈ s) ↔ ↑↑μ s ≠ 0 :=
  by sorry

The theorem `MeasureTheory.frequently_ae_mem_iff` states that for any given type `α` equipped with a measurable space structure, a measure `μ` on that space, and a set `s` of elements of type `α`, the condition that there almost everywhere exists an element `a` of type `α` (with respect to measure `μ`) which belongs to the set `s` is equivalent to the measure of the set `s` not being zero. In other words, if a set `s` has non-zero measure then almost every point in the measurable space `α` will be a member of `s`, and vice versa.

A measurable set in a measure space has non-zero measure if and only if almost every point in the space belongs to the set.


theorem Finset.inf'_cons :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) (f : β → α) {b : β}
      {hb : b ∉ s}, Finset.inf' (Finset.cons b s hb) ⋯ f = f b ⊓ Finset.inf' s H f :=
  by sorry

This theorem states that for any types `α` and `β`, with `α` being a semilattice, any nonempty finite set `s` of `β`, function `f` mapping `β` to `α`, and any element `b` of `β` not in `s`, the infimum of the image under `f` of the set obtained by adding `b` to `s` is equal to the infimum of `f(b)` and the infimum of the image under `f` of `s`. In other words, it describes how the infimum of a set changes when a new element is added to it.

For any semilattice `α`, function `f` from `β` to `α`, nonempty finite set `s` of `β`, and `b` not in `s`, the infimum of `{f(x) | x ∈ s ∪ {b}}` equals the infimum of `{f(x) | x ∈ s}` and `f(b)`.


theorem quadraticCharFun_zero :
    ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F], quadraticCharFun F 0 = 0 := by
  sorry

This theorem, `quadraticCharFun_zero`, states that for any field `F` of a given type `u_1`, if `F` is finite (`Fintype`) and has decidable equality (`DecidableEq`), then the quadratic character function (`quadraticCharFun`) of `F` evaluated at zero (`0`) equals to zero. Here, a field is a set on which addition, subtraction, multiplication, and division are defined, and satisfy certain mathematical laws. `Fintype` means that the field is finite, and `DecidableEq` indicates that we can decide whether any two elements in the field are equal or not. The quadratic character function is a type of function in mathematics often encountered in number theory and algebra.

If `F` is a finite field of type `u_1` with decidable equality, then `quadraticCharFun F 0` equals to `0`.


theorem MeasureTheory.FiniteMeasure.ennreal_mass :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {μ : MeasureTheory.FiniteMeasure Ω},
      ↑(MeasureTheory.FiniteMeasure.mass μ) = ↑↑↑μ Set.univ :=
  by sorry

The theorem `MeasureTheory.FiniteMeasure.ennreal_mass` states that for any measurable space `Ω` and any finite measure `μ` on this space, the total mass of `μ`, when converted to the extended nonnegative real number type (`ennreal`), is equal to the measure of the universal set under `μ`. In other words, the total mass of a finite measure is just the measure of the whole space.

For any measurable space Ω and finite measure μ, the total mass of μ, when considered as an extended nonnegative real number, equals the measure of Ω under μ.


theorem Nat.sub_le_sub_left : ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), k - m ≤ k - n := by sorry

This theorem states that for any three natural numbers `n`, `m` and `k`, if `n` is less than or equal to `m`, then the result of subtracting `m` from `k` is less than or equal to the result of subtracting `n` from `k`. In mathematical terms, this can be written as: if n ≤ m, then k - m ≤ k - n for all natural numbers n, m, and k. Essentially, subtracting a larger number from `k` results in a smaller value.

For all natural numbers n, m, and k, if n <= m then k - m <= k - n.


theorem Ordinal.limitRecOn_zero :
    ∀ {C : Ordinal.{u_4} → Sort u_5} (H₁ : C 0) (H₂ : (o : Ordinal.{u_4}) → C o → C (Order.succ o))
      (H₃ : (o : Ordinal.{u_4}) → Ordinal.IsLimit o → ((o' : Ordinal.{u_4}) → o' < o → C o') → C o),
      Ordinal.limitRecOn 0 H₁ H₂ H₃ = H₁ :=
  by sorry

The theorem `Ordinal.limitRecOn_zero` states that for any type family `C` indexed over ordinals, given that `C` holds for the ordinal `0`, `C` holds for the successor of any ordinal `o` given that `C` holds for `o`, and `C` holds for any limit ordinal `o` given that `C` holds for all ordinals less than `o`, then the limit recursion on `0` with these properties is equal to the given proof that `C` holds for `0`. In other words, the theorem provides the base case for a form of ordinal recursion, stating that the recursion at zero is just the initial element `H₁`.

Given a type family `C` indexed over ordinals satisfying `C 0`, `C (o + 1)` for all `o`, and `C o` for limit ordinals `o`, the limit recursion on `0` of `C` is equal to the proof that `C 0` holds.


theorem mul_self_eq_mul_self_iff :
    ∀ {R : Type x} [inst : CommRing R] [inst_1 : NoZeroDivisors R] {a b : R}, a * a = b * b ↔ a = b ∨ a = -b := by sorry

This theorem states that for any type `R` which is a commutative ring with no zero divisors, and for any two elements `a` and `b` from `R`, the statement "the square of `a` is equal to the square of `b`" is equivalent to the statement "`a` is equal to `b` or `a` is equal to negative `b`". In mathematical notation, this is saying that if \(a^2 = b^2\), then either \(a = b\) or \(a = -b\).

For any commutative ring with no zero divisors R and elements a, b ∈ R, a² = b² if and only if a = b or a = -b.


theorem Polynomial.map_dvd_map :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S),
      Function.Injective ⇑f →
        ∀ {x y : Polynomial R}, Polynomial.Monic x → (Polynomial.map f x ∣ Polynomial.map f y ↔ x ∣ y) :=
  by sorry

The theorem `Polynomial.map_dvd_map` states that for any two types `R` and `S` with ring structure, any ring homomorphism `f` from `R` to `S`, and for any two polynomials `x` and `y` over `R`, if `f` is injective and `x` is a monic polynomial, then `x` divides `y` if and only if the image of `x` under `f` divides the image of `y` under `f`. Here, a polynomial is said to divide another if there exists a third polynomial which multiplied by the first gives the second. The mapping of a polynomial `p` across a ring hom `f` is performed using the `Polynomial.map` function.

For any injective ring homomorphism `f` between rings `R` and `S` and monic polynomials `x` and `y` over `R`, `x` divides `y` if and only if the image of `x` under `f` divides the image of `y` under `f` in `S`.


/-- The edist of `x` to `s` is bounded by the sum of the edist of `y` to `s` and
the edist from `x` to `y`  -/
theorem EMetric.infEdist_le_infEdist_add_edist :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {s : Set α},
      EMetric.infEdist x s ≤ EMetric.infEdist y s + edist x y :=
  by sorry

This theorem states that for any pseudo extended metric space and for any two points `x` and `y` within this space, as well as any set `s` of points in the same space, the minimum extended distance from `x` to `s` is less than or equal to the sum of the minimum extended distance from `y` to `s` and the extended distance from `x` to `y`. Here, the minimum extended distance from a point to a set is the infimum of the extended distances from the point to the elements of the set. This is a property of distances that is often used in geometric and topological proofs.

For any pseudo extended metric space and points `x`, `y` within it, and set `s` of points in the same space, the minimum extended distance from `x` to `s` is less than or equal to the minimum extended distance from `y` to `s` plus the extended distance from `x` to `y`.


theorem Finset.coe_sups :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] (s t : Finset α), ↑(s ⊻ t) = ↑s ⊻ ↑t := by sorry

The theorem `Finset.coe_sups` states that for all types `α`, given that `α` has decidable equality and is a semilattice for the operation supremum, and given two finite sets `s` and `t` of type `α`, the symmetric difference of the coe (type-cast) of `s` and `t` is equal to the coe of the symmetric difference of `s` and `t`. In simpler terms, the theorem asserts that the operation of taking the symmetric difference commutes with the operation of type-casting from finite sets to sets in the context of semilattice structures with decidable equality.

For type-casted finite sets `s` and `t` in a semilattice with decidable equality, `(s ++ t)}^.{Finset α} = s.^.{Finset α} ++ t.^.{Finset α}`, where `++` denotes symmetric difference and `.^` denotes type-casting.


/-- **Alias** of `Filter.tendsto_atTop_finset_of_monotone`.

---

If `f` is a monotone sequence of `Finset`s and each `x` belongs to one of `f n`, then
`Tendsto f atTop atTop`.  -/
theorem Monotone.tendsto_atTop_finset :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {f : β → Finset α},
      Monotone f → (∀ (x : α), ∃ n, x ∈ f n) → Filter.Tendsto f Filter.atTop Filter.atTop :=
  by sorry

The theorem `Monotone.tendsto_atTop_finset` states that, for any types `α` and `β` and a preorder on `β`, if `f` is a monotone function from `β` to sets of `α` (`Finset α`), and every element `x` of type `α` is in the set `f n` for some `n` of type `β`, then `f` tends to `atTop` as `n` tends to `atTop`. In other words, if `f` is a monotone sequence of finite sets `Finset α` that includes every `α` in some set `f n`, then `f` approaches the limit of `atTop` as `n` approaches `atTop`. This implies that the sequence `f` grows to cover all of `α` as `n` grows.

If `f` is a monotonic function from a preordered type `β` to sets of type `α`, and every `α` element is in some `f(n)` for some `n` approaching the top element `atTop` of `β`, then `f` tends to the limit `atTop` as `n` tends to `atTop`.


theorem DifferentiableAt.sub_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E}, DifferentiableAt 𝕜 f x → ∀ (c : F), DifferentiableAt 𝕜 (fun y => f y - c) x :=
  by sorry

The theorem `DifferentiableAt.sub_const` says that for all types 𝕜, E, and F, where 𝕜 is a non-trivially normed field, E is a normed add commutative group over 𝕜, and F is also a normed add commutative group over 𝕜, if a function f from E to F is differentiable at a point x in E, then the function obtained by subtracting a constant c from f is also differentiable at the same point x. This theorem establishes that the differentiability property is preserved under subtraction of a constant.

If a function f : ℝ≤x, ℝ is differentiable at x, then the function g(x) = f(x) - c is differentiable at x for any constant c.


theorem MeasureTheory.mem_lpMeas_iff_aeStronglyMeasurable' :
    ∀ {α : Type u_1} {F : Type u_3} {𝕜 : Type u_5} {p : ENNReal} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      {f : ↥(MeasureTheory.Lp F p μ)},
      f ∈ MeasureTheory.lpMeas F 𝕜 m p μ ↔ MeasureTheory.AEStronglyMeasurable' m (↑↑f) μ :=
  by sorry

The theorem `MeasureTheory.mem_lpMeas_iff_aeStronglyMeasurable'` states that for any type `α`, any normed additive commutative group `F`, any type `𝕜` that behaves like a real number (captured by the `RCLike 𝕜` typeclass), any extended nonnegative real number `p`, any two measurable spaces `m` and `m0` over `α`, any measure `μ` on `α`, and any function `f` in the `Lp` space over `F` with respect to `p` and `μ`, `f` belongs to the subspace of `Lp` measurable functions if and only if `f` is almost everywhere `m`-strongly measurable with respect to `μ`. In mathematical terms, a function is in the space `Lp` of `F` with respect to a measure `μ` if and only if it is almost everywhere strongly measurable.

A function belongs to the space of `Lp` measurable functions with respect to a measure if and only if it is almost everywhere strongly measurable.


theorem MeasureTheory.integral_mono_measure :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ} {ν : MeasureTheory.Measure α},
      μ ≤ ν →
        0 ≤ᶠ[MeasureTheory.Measure.ae ν] f → MeasureTheory.Integrable f ν → ∫ (a : α), f a ∂μ ≤ ∫ (a : α), f a ∂ν :=
  by sorry

The theorem `MeasureTheory.integral_mono_measure` states that for any measurable space `α`, and any two measures `μ` and `ν` on `α`, if `μ` is less than or equal to `ν`, and a function `f` from `α` to the real numbers is non-negative almost everywhere with respect to `ν` and is integrable with respect to `ν`, then the integral of `f` with respect to `μ` is less than or equal to the integral of `f` with respect to `ν`. In other words, if a measure increases, then the integral with respect to that measure does not decrease, as long as the function being integrated is non-negative almost everywhere.

If `μ` is a measure less than or equal to `ν` on measurable space `α`, and `f` is a non-negative integrable function with respect to `ν`, then `∫f dμ ≤ ∫f dν`.


theorem IsClosed.mem_of_frequently_of_tendsto :
    ∀ {X : Type u} {α : Type u_1} {x : X} {s : Set X} [inst : TopologicalSpace X] {f : α → X} {b : Filter α},
      IsClosed s → (∃ᶠ (x : α) in b, f x ∈ s) → Filter.Tendsto f b (nhds x) → x ∈ s :=
  by sorry

This theorem states that for any type `X` and `α`, and given a set `s` of type `X` and a function `f` from `α` to `X`, if `s` is a closed set in a topological space, and if there are frequently (meaning on a set of elements whose complement has empty interior) elements of `b`, a filter on `α`, such that their images under `f` belong to `s`, and if the function `f` tends to a limit which lies in the neighborhood filter at a point `x` in `X` when evaluated at points from `b`, then `x` is an element of `s`. In essence, it says that if a function's range frequently lies in a closed set and the function tends to a limit, then that limit point belongs to the closed set.

If a closed set `s` in a topological space and a function `f` from `α` to `X` have the property that for some filter `b` on `α`, the images of elements in `b` under `f` lie in `s` and `f` converges to a limit in `s` at a point `x` in `X`, then `x` is an element of `s`.


theorem compl_compl_compl : ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), aᶜᶜᶜ = aᶜ := by sorry

This theorem states that for any type `α` that forms a Heyting algebra (a structure that includes operations for 'and', 'or', and an implication operation), the triple complement of an element `a` in `α` (denoted as `aᶜᶜᶜ`) is equal to the single complement of `a` (denoted as `aᶜ`). This is analogous to how in boolean algebra, double negation returns the original value, but in a Heyting algebra, triple negation returns the single negation.

In a Heyting algebra, the triple negation of an element equals the single negation. That is, `aᶜᶜᶜ = aᶜ` for any `a` in the algebra.


theorem Int.subNatNat_self : ∀ (n : ℕ), Int.subNatNat n n = 0 := by sorry

This theorem states that for any natural number `n`, the result of the function `Int.subNatNat` applied to `n` and `n` is always zero. In other words, subtracting a natural number from itself using the `Int.subNatNat` function always yields zero, regardless of the specific natural number being considered.

For all natural numbers n, Int.subNatNat n n equals zero.


theorem Bornology.isCobounded_def :
    ∀ {α : Type u_2} {x : Bornology α} {s : Set α}, Bornology.IsCobounded s ↔ s ∈ Bornology.cobounded α := by sorry

The theorem `Bornology.isCobounded_def` states that for any type `α` endowed with a bornology `x` and any set `s` of type `α`, `s` is cobounded in the bornology if and only if `s` belongs to the filter of cobounded sets in the bornology on `α`. In other words, a set is cobounded in a bornology if it is included in the collection of all sets that are cobounded in that bornology.

A set is cobounded in a bornology if and only if it belongs to the filter of cobounded sets in that bornology.


SimpleGraph.Reachable.trans

theorem SimpleGraph.Reachable.trans :
    ∀ {V : Type u} {G : SimpleGraph V} {u v w : V},
      SimpleGraph.Reachable G u v → SimpleGraph.Reachable G v w → SimpleGraph.Reachable G u w :=
  by sorry

This theorem states that for any given SimpleGraph `G` with vertices of type `V`, and any three vertices `u`, `v`, and `w` in `G`, if `u` is reachable from `v`, and `v` is reachable from `w`, then `u` is also reachable from `w`. This property is known as transitivity in graph theory, which states that reachability in a graph is a transitive relation.

In a simple graph, if there exist paths from vertex `v` to `u` and from vertex `u` to `w`, then there exists a path from vertex `v` to `w`.


theorem Num.bit0_of_bit0 : ∀ (n : Num), bit0 n = Num.bit0 n := by sorry

The theorem `Num.bit0_of_bit0` states that for all numbers `n` of the type `Num`, the `bit0` function (which doubles a number `n`) produces the same result as the `Num.bit0` function (which appends a `0` to the end of `n`, effectively doubling it). Essentially, this theorem establishes the equivalence of two methods of doubling a number: one using addition and the other using bitwise operations.

The theorem `Num.bit0_of_bit0` asserts that for all numbers `n` in Lean's `Num` type, `2 * n = 2 * (n % 2) + n`, where `%` denotes modulo arithmetic and `Num.bit0` is defined as `x % 2`.


theorem hnot_le_iff_codisjoint_left : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, ￢a ≤ b ↔ Codisjoint b a :=
  by sorry

This theorem states that for any type `α` that forms a Coheyting algebra, and any two elements `a` and `b` of that type, `a` is not less than or equal to `b` if and only if `b` and `a` are codisjoint. In the context of a lattice, two elements `a` and `b` are said to be codisjoint if, for any element `x` such that `a` and `b` are both less than or equal to `x`, the top element of the lattice is less than or equal to `x`. The theorem establishes a correspondence between the non-existence of a partial order relationship (not less than or equal) between two elements and their codisjointness in the lattice structure of a Coheyting algebra.

In a Coheting algebra, elements are codisjoint if and only if they have no partial order relationship.


theorem Real.exists_cos_eq_zero : 0 ∈ Real.cos '' Set.Icc 1 2 := by sorry

This theorem states that there exists a real number between 1 and 2 (inclusive) such that the cosine of that number is zero. In other words, the cosine function, when applied to some number within the closed interval from 1 to 2, yields zero.

There exists a real number x in the interval [1, 2] such that cos(x) = 0.


theorem AffineSubspace.wSameSide_smul_vsub_vadd_left :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {p₁ p₂ : P} (x : P),
      p₁ ∈ s → p₂ ∈ s → ∀ {t : R}, 0 ≤ t → AffineSubspace.WSameSide s (t • (x -ᵥ p₁) +ᵥ p₂) x :=
  by sorry

The theorem `AffineSubspace.wSameSide_smul_vsub_vadd_left` states that for any strict ordered commutative ring `R`, an additive commutative group `V`, a module `V` over `R`, an "additive torsor" `P` over `V`, an affine subspace `s` of `P`, and points `p₁`, `p₂`, and `x` in `P`, if `p₁` and `p₂` belong to the subspace `s` and a scalar `t` from `R` is non-negative, then the point obtained by subtracting `p₁` from `x`, scaling the result by `t`, and then adding `p₂`, is weakly on the same side of the subspace `s` as `x`.

In mathematical terms, this theorem is essentially saying that if `p₁` and `p₂` are points in an affine subspace `s`, then any point along the line segment from `x` to `p₁`, translated by `p₂`, is weakly on the same side of `s` as `x`.

For any strict ordered commutative ring R, additive commutative group V, R-module V, additive torsor P over V, affine subspace s of P, and points p₁, p₂ in s and x in P, if t is a non-negative scalar in R, then the point (x - p₁ + p₂) is weakly on the same side of s as x.


theorem Ordinal.nadd_le_nadd_left :
    ∀ {b c : Ordinal.{u}}, b ≤ c → ∀ (a : Ordinal.{u}), Ordinal.nadd a b ≤ Ordinal.nadd a c := by sorry

The theorem `Ordinal.nadd_le_nadd_left` states that for any ordinals `b` and `c` in a given type, if `b` is less than or equal to `c`, then for any ordinal `a`, the natural addition of `a` and `b` (denoted as `Ordinal.nadd a b`) is less than or equal to the natural addition of `a` and `c` (denoted as `Ordinal.nadd a c`). In other words, if an ordinal `b` is less than or equal to an ordinal `c`, then adding any ordinal `a` to `b` naturally will always result in an ordinal that is less than or equal to the ordinal resulting from naturally adding `a` to `c`. This shows a property of monotonicity in the natural addition of ordinals.

For all ordinals `a`, `b`, and `c`, if `b` is less than or equal to `c`, then `Ordinal.nadd a b` is less than or equal to `Ordinal.nadd a c`.


theorem Set.projIci_of_mem :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a x : α} (hx : x ∈ Set.Ici a),
      Set.projIci a x = { val := x, property := hx } :=
  by sorry

The theorem `Set.projIci_of_mem` states that for any type `α` with a linear order, and for any elements `a` and `x` of `α`, if `x` belongs to the left-closed right-infinite interval starting at `a` (i.e., `x` is in the set of all elements greater than or equal to `a`), then the projection of `x` onto this interval (which maps `x` to the maximum of `a` and `x`) is equal to `x` itself. The projection of `x` into this set is represented as a dependent pair with `x` as its value and the proof of `x` belonging to the interval as its property. This essentially means that if `x` is already in the interval `[a, ∞)`, its projection onto this interval is simply `x` itself.

For any type with a linear order and any element `x` greater than or equal to `a`, the projection of `x` onto the interval `[a, ∞)` is equal to `x`.


theorem intervalIntegral.continuousWithinAt_primitive :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b₀ b₁ b₂ : ℝ}
      {μ : MeasureTheory.Measure ℝ} {f : ℝ → E},
      ↑↑μ {b₀} = 0 →
        IntervalIntegrable f μ (min a b₁) (max a b₂) →
          ContinuousWithinAt (fun b => ∫ (x : ℝ) in a..b, f x ∂μ) (Set.Icc b₁ b₂) b₀ :=
  by sorry

This theorem states that for any normed additively commutative group `E` and normed space over the real numbers, given five real numbers `a`, `b₀`, `b₁`, `b₂`, a measure `μ` on the real numbers, and a function `f` from the real numbers to `E`, if the measure of the singleton set `{b₀}` is zero and the function `f` is interval integrable with respect to the measure `μ` on the interval from `min(a, b₁)` to `max(a, b₂)`, then the function that maps a real number `b` to the interval integral of `f` from `a` to `b` with respect to the measure `μ` is continuous at the point `b₀` within the closed interval from `b₁` to `b₂`. In other words, as `b` tends to `b₀` within the interval `[b₁, b₂]`, the integral of `f` from `a` to `b` tends to the integral of `f` from `a` to `b₀`.

If `E` is a normed additively commutative group, `μ` is a measure on the real numbers with `{b₀}` having measure 0, and `f` is interval integrable on `[min(a, b₁), max(a, b₂)]`, then the function that maps `b` to the interval integral of `f` from `a` to `b` with respect to `μ` is continuous at `b₀`.


/-- The sum of the dimensions of s + t and s ∩ t is the sum of the dimensions of s and t  -/
theorem Submodule.finrank_sup_add_finrank_inf_eq :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      (s t : Submodule K V) [inst_3 : FiniteDimensional K ↥s] [inst_4 : FiniteDimensional K ↥t],
      FiniteDimensional.finrank K ↥(s ⊔ t) + FiniteDimensional.finrank K ↥(s ⊓ t) =
        FiniteDimensional.finrank K ↥s + FiniteDimensional.finrank K ↥t :=
  by sorry

The theorem 'Submodule.finrank_sup_add_finrank_inf_eq' asserts that for any division ring 'K' and additively commutative group 'V' with a 'K'-module structure, and for any two submodules 's' and 't' of 'V' which are finite-dimensional over 'K', the sum of the dimensions of the supremum (join) of 's' and 't' and the infimum (meet) of 's' and 't' is equal to the sum of the dimensions of 's' and 't'. In mathematical terms, this can be written as $\dim_K(s \vee t) + \dim_K(s \wedge t) = \dim_K(s) + \dim_K(t)$, where $\dim_K$ denotes the dimension over 'K', $\vee$ denotes the supremum (or the smallest submodule containing both 's' and 't'), and $\wedge$ denotes the infimum (or the largest submodule contained in both 's' and 't').

For any finite-dimensional submodules $s$ and $t$ of a $K$-module $V$, the dimension of their join (supremum) plus the dimension of their meet (infimum) equals the sum of their dimensions: $\dim_K(s \vee t) + \dim_K(s \wedge t) = \dim_K(s) + \dim_K(t)$.


/-- The **extreme value theorem**: a continuous function realizes its maximum on a compact set.  -/
theorem IsCompact.exists_isMaxOn :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
      [inst_3 : ClosedIciTopology α] {s : Set β},
      IsCompact s → Set.Nonempty s → ∀ {f : β → α}, ContinuousOn f s → ∃ x ∈ s, IsMaxOn f s x :=
  by sorry

This theorem is known as the "Extreme Value Theorem". It states that if we have a continuous function `f` from a compact, nonempty set `s` in a topological space, to a set in a linearly ordered topological space with a closed interval topology, then there exists an element `x` in `s` such that `f` attains its maximum at `x` for all elements in `s`. In other words, for a given continuous function on a compact, nonempty set, there will always be a point in the set where the function reaches its maximum value.

If `f` is a continuous function on the compact, nonempty set `s` in a linearly ordered topological space with a closed interval topology, then there exists an element `x` in `s` such that for all `y` in `s`, `f(x)` is greater than or equal to `f(y)`.


theorem ProbabilityTheory.kernel.indep_biSup_compl :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → MeasurableSpace Ω},
      (∀ (n : ι), s n ≤ m0) →
        ProbabilityTheory.kernel.iIndep s κ μα →
          ∀ (t : Set ι), ProbabilityTheory.kernel.Indep (⨆ n ∈ t, s n) (⨆ n ∈ tᶜ, s n) κ μα :=
  by sorry

This theorem, `ProbabilityTheory.kernel.indep_biSup_compl`, states that for any types `α`, `Ω`, and `ι`, a measurable space `_mα`, a measurable space `m0`, a kernel `κ` from the probability theory, a measure `μα`, a Markov kernel instance, and a function `s` mapping `ι` to `MeasurableSpace Ω` such that each `s n` is less than or equal to `m0`, if the family of measurable space structures is independent with respect to kernel `κ` and measure `μα`, then for any set `t` of type `ι`, the sup (supremum) of `s n` for each `n` in `t` is independent with the sup of `s n` for each `n` in the complement of `t` with respect to the kernel `κ` and measure `μα`. This is a theorem in the field of probability theory dealing with measure theory and Markov kernels.

If `κ` is a probability kernel, `μα` is a measure, `s` maps `ι` to measurable spaces `Ω` with each `s n` less than or equal to `m0`, and the family of measurable spaces `{s n : n ∈ ι}` is independent with respect to `κ` and `μα`, then the supremum of `s n` for `n` in any subset `t` of `ι` is independent of the supremum of `s n` for `n` in the complement of `t` with respect to `κ` and `μα`.


/-- Definition of `IsBigOWith`. We record it in a lemma as `IsBigOWith` is irreducible.  -/
theorem Asymptotics.isBigOWith_iff :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E} {g : α → F}
      {l : Filter α}, Asymptotics.IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ :=
  by sorry

The theorem `Asymptotics.isBigOWith_iff` expresses equivalence between two descriptions of big O notation with a constant. For any real number `c`, functions `f` and `g` from a type `α` to types `E` and `F` equipped with norms, and a filter `l` on `α`, the statement that `f` is big O of `g` with constant `c` with respect to `l` (denoted `Asymptotics.IsBigOWith c l f g`) is equivalent to the statement that, eventually for `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`. In other words, for all `x` in the neighborhood defined by the filter `l`, `‖f x‖` is bounded by `c * ‖g x‖`.

For functions `f` and `g` from a type `α` to types `E` and `F` equipped with norms, and a filter `l` on `α`, the functions `f` is big O of `g` with constant `c` with respect to `l` if and only if for all `x` in the neighborhood defined by `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`.


theorem Filter.mem_zero : ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, s ∈ 0 ↔ 0 ∈ s := by sorry

This is a theorem about filters in the context of a set theory. Specifically, the theorem states that for any type `α` that has a zero element (denoted by the `Zero α` instance), and any set `s` of elements of type `α`, the set `s` is an element of the zero filter if and only if the zero element is an element of the set `s`. In other words, the zero filter contains a set if and only if that set contains the zero element.

For any set `s` of type `α` with a zero element, `s` is in the zero filter if and only if `Zero α` is in `s`.


theorem alexandrovDiscrete_coinduced :
    ∀ {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : AlexandrovDiscrete α] {β : Type u_5} {f : α → β},
      AlexandrovDiscrete β :=
  by sorry

This theorem states that for any type `α` with a topological space structure and an Alexandrov discrete structure, and for any type `β` and any function from `α` to `β`, `β` has an Alexandrov discrete structure. In terms of mathematics, given a topological space `(α, τ)` that is Alexandrov discrete (i.e., any intersection of open sets is also open) and any function `f` from `α` to another set `β`, the topology on `β` induced by `f` is also Alexandrov discrete.

Given a topological space `(α, τ)` that is Alexandrov discrete and a function `f : α → β`, the image `f(α)` under `f` inherits an Alexandrov discrete topology.


theorem Ordinal.card_one : Ordinal.card 1 = 1 := by sorry

The theorem `Ordinal.card_one` states that the cardinality of the ordinal number 1 is 1. In other words, any type with a well-order relation that has the order type of the ordinal 1 (which in essence is a singleton set) has exactly one element.

The theorem `Ordinal.card_1` asserts that the ordinal number 1 has cardinality 1.


theorem jacobiTheta_eq_jacobiTheta₂ : ∀ (τ : ℂ), jacobiTheta τ = jacobiTheta₂ 0 τ := by sorry

This theorem states that for every complex number τ, the Jacobi one-variable theta function `jacobiTheta τ`, which is defined as the sum over all integers n of the complex exponential function `exp (π * I * n ^ 2 * τ)`, is equal to the Jacobi two-variable theta function `jacobiTheta₂ 0 τ`, which is defined as the sum over all integers n of the complex exponential function `exp (2 * π * I * n * 0 + π * I * n ^ 2 * τ)`. In other words, when the first argument of the two-variable Jacobi theta function is zero, it simplifies to the one-variable Jacobi theta function.

The one-variable Jacobi theta function equals the zero-first-argument two-variable Jacobi theta function. Specifically, for all complex numbers τ, `jacobiTheta τ = jacobiTheta₂ 0 τ`.


theorem Set.disjoint_compl_right_iff_subset : ∀ {α : Type u} {s t : Set α}, Disjoint s tᶜ ↔ s ⊆ t := by sorry

The theorem `Set.disjoint_compl_right_iff_subset` states that for any two sets `s` and `t` of some type `α`, the set `s` and the complement of set `t` (`tᶜ`) are disjoint if and only if `s` is a subset of `t`. In other words, `s` shares no common element with the complement of `t` exactly when every element in `s` is also an element of `t`. This theorem generalizes the concept of disjoint sets in the context of lattices.

For sets `s` and `t` in type `α`, `s` is disjoint with the complement of `t` if and only if `s` is a subset of `t`.


theorem DihedralGroup.r_one_pow : ∀ {n : ℕ} (k : ℕ), DihedralGroup.r 1 ^ k = DihedralGroup.r ↑k := by sorry

This theorem states that for any natural number `n` and any natural number `k`, the rotation operation `r 1` of the Dihedral Group raised to the power `k` is equal to the rotation `r` by `k`. In mathematical terms, it signifies that power operations within the Dihedral Group can be simplified by directly applying the rotation by a given degree.

For any natural numbers $n$ and $k$, in the Dihedral Group, $r^k = r$ where $r$ is a rotation operation and $r^k$ denotes raising $r$ to the power of $k$.


theorem Cardinal.aleph_succ : ∀ {o : Ordinal.{u_1}}, Cardinal.aleph (Order.succ o) = Order.succ (Cardinal.aleph o) := by
  sorry

The theorem `Cardinal.aleph_succ` states that for any ordinal `o`, the aleph of the successor of `o` is equal to the successor of the aleph of `o`. In other words, if we move to the next element in the ordinal order, the corresponding cardinal also moves to the next element. This formalizes the intuition that the aleph function and the successor operation are compatible in the sense that applying the successor operation before or after applying the aleph function yields the same result. In mathematical terms, this can be written as 𝔞(𝔬+1) = 𝔞(𝔬)+1 for all ordinals 𝔬, where 𝔞 stands for the aleph function.

The theorem `Cardinal.aleph_succ` asserts that for all ordinals `o`, the aleph number of the successor ordinal `o+1` equals the successor of the aleph number of `o`, i.e., `aleph_o+1 = aleph_o + 1`.


theorem UniformSpace.Completion.uniformContinuous_extension₂ :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
      [inst_2 : UniformSpace γ] (f : α → β → γ) [inst_3 : CompleteSpace γ],
      UniformContinuous₂ (UniformSpace.Completion.extension₂ f) :=
  by sorry

The theorem `UniformSpace.Completion.uniformContinuous_extension₂` states that for any three types `α`, `β`, and `γ` equipped with uniform spaces, any function `f` from `α` to `β` to `γ`, and given that `γ` is a complete space, then the extension of the function `f` to the completion of `α` and `β` is uniformly continuous. In mathematical terms, if `f : α → β → γ` is a function with `α`, `β`, `γ` being uniform spaces and `γ` is complete, then the function `f' : UniformSpace.Completion α → UniformSpace.Completion β → γ`, which extends `f`, is uniformly continuous.

Given functions `f : α → β → γ` between complete uniform spaces `α`, `β`, and a complete uniform space `γ`, the extension `f' : UniformSpace.Completion α → UniformSpace.Completion β → γ` of `f` is uniformly continuous.


theorem PolynomialModule.eval_single :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r : R) (i : ℕ)
      (m : M), (PolynomialModule.eval r) ((PolynomialModule.single R i) m) = r ^ i • m :=
  by sorry

The theorem `PolynomialModule.eval_single` states that for any commutative ring `R`, any additively commutative group `M`, and any module `M` over `R`, for any element `r` of `R`, natural number `i`, and element `m` of `M`, evaluating the monomial `m * x ^ i` at `r` (using the function `PolynomialModule.eval`) is equal to `r ^ i` times `m`. In mathematical terms, it means `p(r) = r^i * m` where `p` is a polynomial represented as `m * x ^ i`. This provides a specific case of how to evaluate a polynomial at a specific point in the context of a module over a ring.

For any commutative ring R, additively commutative group M, and module M over R, for all r in R, natural number i, and m in M, the evaluation of the monomial m * x^i in R via PolynomialModule.eval equals r^i * m.


theorem Rat.divInt_nonneg : ∀ (a : ℤ) {b : ℤ}, 0 < b → (Rat.Nonneg (Rat.divInt a b) ↔ 0 ≤ a) := by sorry

This theorem, `Rat.divInt_nonneg`, states that for all integers `a` and for any integer `b` that is greater than zero, the quotient formed by dividing `a` by `b` is nonnegative if and only if `a` is nonnegative. In other words, a rational number obtained by dividing an integer `a` by a positive integer `b` is nonnegative exactly when `a` is nonnegative.

For integers `a` and positive integer `b`, `a / b` is nonnegative if and only if `a` is nonnegative.


theorem Multiset.count_eq_zero :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, Multiset.count a s = 0 ↔ a ∉ s := by sorry

This theorem states that for any type `α` with a decidable equality and any element `a` of type `α` and multiset `s` of type `α`, the count of `a` in `s` is zero if and only if `a` is not in `s`. In other words, the multiplicity of an element in a multiset being zero is equivalent to the element not being present in the multiset.

For any type `α` with decidable equality, element `a` of type `α`, and multiset `s` of type `α`, the number of occurrences of `a` in `s` is zero if and only if `a` is not an element of `s`.


theorem Int.isUnit_eq_one_or : ∀ {a : ℤ}, IsUnit a → a = 1 ∨ a = -1 := by sorry

This theorem states that for every integer `a`, if `a` is a unit in the monoid of integers, then `a` is equal to 1 or `a` is equal to -1. In mathematical terms, a unit in a monoid is an element that has a multiplicative inverse. Hence, in the context of integers, this theorem basically says that the only units (elements that have a multiplicative inverse) are 1 and -1, as these are the only integers whose product with another integer results in the multiplicative identity, i.e., 1.

In the monoid of integers, the only units are 1 and -1.


theorem EventuallyEq.countable_iUnion :
    ∀ {ι : Sort u_1} {α : Type u_2} {l : Filter α} [inst : CountableInterFilter l] [inst : Countable ι]
      {s t : ι → Set α}, (∀ (i : ι), s i =ᶠ[l] t i) → ⋃ i, s i =ᶠ[l] ⋃ i, t i :=
  by sorry

The theorem `EventuallyEq.countable_iUnion` states that for any type `ι` and any type `α`, given a filter `l` on `α` for which countable intersections are defined, and assuming that `ι` is countable, then for any two functions `s` and `t` from `ι` to the set of `α`, if each set `s i` is eventually equal to `t i` with respect to the filter `l` for all `i` in `ι`, then the countable union of all sets `s i` is eventually equal to the countable union of all sets `t i` with respect to the same filter `l`. This theorem relates the concept of eventual equality of sets with the operation of forming countable unions of sets under certain conditions.

If `ι` is countable and `l` is a filter on `α` for which countable intersections are defined, then for any two functions `s` and `t` from `ι` to `α`, if each `s i` is eventually equal to `t i` with respect to `l`, then the countable unions of `s` and `t` are eventually equal with respect to `l`.


theorem Nat.prime_three : Nat.Prime 3 := by sorry

The theorem `Nat.prime_three` asserts that the natural number 3 is a prime number. In other words, 3 is a natural number which is at least 2 and its only divisors are 3 and 1.

The theorem `Nat.prime_three` asserts that 3 is a prime natural number. (Equivalently, 3 has exactly two positive divisors: 1 and 3.)


theorem AddSubmonoid.LocalizationMap.lift_of_comp :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {P : Type u_3} [inst_2 : AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) (j : N →+ P),
      AddSubmonoid.LocalizationMap.lift f ⋯ = j :=
  by sorry

This theorem, `AddSubmonoid.LocalizationMap.lift_of_comp`, stipulates that for any types `M`, `N`, and `P`, where `M` and `N` are additive commutative monoids and `S` is a submonoid of `M`, if we have a localization map `f` from `S` to `N` and an additive map `j` from `N` to `P`, then the composition of localization lifting of `f` with `j` equals to `j`. This is a property of localization in the context of additive monoids.

Given additive commutative monoids M, N, and P, a submonoid S of M, a localization map f from S to N, and an additive map j from N to P, we have f.lift (j) = j.


theorem Mathlib.GroupTheory.Index._auxLemma.12 :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), Subgroup.index H = Subgroup.relindex H ⊤ := by sorry

The theorem `Mathlib.GroupTheory.Index._auxLemma.12` states that for any given group `G` and any subgroup `H` of `G`, the index of `H` is equal to the relative index of `H` with respect to the total group `G`. Here, the index of a subgroup is defined as the number of its cosets, and returns 0 if the index is infinite. The relative index of a subgroup is similar but is measured with respect to another subgroup, in this case, the total group `G`.

The theorem `Mathlib.GroupTheory.Index._auxLemma.12` asserts that the index of a subgroup in a group equals its relative index with respect to the total group.


theorem Real.exp_mul : ∀ (x y : ℝ), Real.exp (x * y) = Real.exp x ^ y := by sorry

This theorem states that for all real numbers `x` and `y`, the exponential function of the product of `x` and `y` is equal to the exponential function of `x` raised to the power `y`. In mathematical notation, this can be written as: for all `x, y` in ℝ, exp(xy) = (exp(x))^y. This is an important property of the exponential function in real numbers, which is defined as the real part of the complex exponential function.

For all real numbers x and y, exp(xy) = (exp x)^y.


theorem AddLocalization.mk_eq_addMonoidOf_mk'_apply :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} (x : M) (y : ↥S),
      AddLocalization.mk x y = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) x y :=
  by sorry

This theorem states that for any additive commutative monoid `M` and any of its additive submonoids `S`, and for any element `x` from `M` and `y` from `S`, applying the `AddLocalization.mk` function to `x` and `y` is equivalent to applying the `AddSubmonoid.LocalizationMap.mk'` function to the additive monoid of the localization at `S`, `x`, and `y`. In other words, these two ways of creating an element in the localization of `M` at `S` are equivalent.

For any additive commutative monoid `M`, submonoid `S`, and elements `x` from `M` and `y` from `S`, `AddLocalization.mk x y` is equal to `AddSubmonoid.LocalizationMap.mk' (localization at S) x y`.


theorem CategoryTheory.MonoidalCategory.whiskerLeft_eqToHom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
      {Y Z : C} (f : Y = Z),
      CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.eqToHom f) = CategoryTheory.eqToHom ⋯ :=
  by sorry

This theorem states that in a monoidal category `C`, for any object `X` and any two objects `Y` and `Z` in `C` such that `Y = Z` (denoted by `f`), whiskering on the left by `X` to the morphism from `Y` to `Z` obtained from the equality `f` (using the `eqToHom` function) is the same as applying `eqToHom` to the relevant equality. In other words, `whiskerLeft` function commutes with the `eqToHom` function.

In a monoidal category, whiskering on the left by an object X to the equality morphism between Y and Z is equal to applying the equality morphism to the identity morphism from Y to Z.


theorem Submodule.ClosedComplemented.of_isCompl_isClosed :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {p q : Subspace 𝕜 E},
      IsCompl p q → IsClosed ↑p → IsClosed ↑q → Submodule.ClosedComplemented p :=
  by sorry

The theorem `Submodule.ClosedComplemented.of_isCompl_isClosed` states that for any two subspaces `p` and `q` of a complete normed space `E` over a nontrivially normed field `𝕜`, if `p` and `q` are complements of each other and both `p` and `q` are closed, then `p` is a complemented submodule. This means there exists a continuous linear projection from `E` onto `p`.

If two closed subspaces of a complete normed space over a nontrivially normed field have complementary closures, then one is the continuous linear projection of the other.


ContDiffOn.differentiableOn

/-- If a function is `C^n` on a set with `n ≥ 1`, then it is differentiable there.  -/
theorem ContDiffOn.differentiableOn :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {n : ℕ∞}, ContDiffOn 𝕜 n f s → 1 ≤ n → DifferentiableOn 𝕜 f s :=
  by sorry

The theorem `ContDiffOn.differentiableOn` states that if a function `f`, which maps from a normed vector space `E` over a non-trivially normed field `𝕜` to another normed vector space `F` over the same field, is `C^n` continuous on a set `s` of `E` for `n` equal to or greater than 1 (`1 ≤ n`), then it is differentiable on `s`. Here `C^n` continuity implies that the function is differentiable `n` times and all those derivatives are continuous. Hence, in more simple terms, it states that if a function is smooth enough (at least once differentiable and that derivative is continuous) on a set, then it is differentiable on that set.

If a function between normed vector spaces is `C^1` continuous on a set, then it is differentiable on that set.


theorem Mathlib.Topology.Constructions._auxLemma.7 :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ := by sorry

This theorem, named `Mathlib.Topology.Constructions._auxLemma.7`, states that for any type `X` and any set `s` of type `X` within a topological space (denoted by `inst : TopologicalSpace X`), the set `s` is closed if and only if the complement of `s` (denoted by `sᶜ`) is open. Here, `IsClosed s` and `IsOpen sᶜ` refer to the properties of the set being closed and the complement of the set being open in the given topological space, respectively.

A set in a topological space is closed if and only if the complement of the set is open.


theorem IsLocalization.mk'_eq_iff_eq_mul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x : R} {y : ↥M} {z : S},
      IsLocalization.mk' S x y = z ↔ (algebraMap R S) x = z * (algebraMap R S) ↑y :=
  by sorry

The theorem `IsLocalization.mk'_eq_iff_eq_mul` establishes an equivalency relation in the context of ring theory and algebraic structures. Specifically, for any commutative semiring `R`, a submonoid `M` of `R`, a commutative semiring `S`, a ring homomorphism between `R` and `S`, and elements `x` of `R`, `y` of `M` and `z` of `S`. The theorem states that the mapping of `(x, y)` in `R × M` to `f(x) * (f(y))⁻¹` in `S` (where `f` is the function defined by `IsLocalization.mk'`) is equivalent to `z` if and only if the image of `x` under the algebra map from `R` to `S` is equal to `z` multiplied by the image of `y` under the same algebra map. Here, `algebraMap R S` represents the ring homomorphism from `R` to `S` induced by the given algebra structure.

For any commutative semiring `R`, submonoid `M` of `R`, commutative semiring `S`, ring homomorphism `f: R -> S`, and elements `x in R`, `y in M`, and `z in S`, `(x, y) in R × M` maps to `z` under `IsLocalization.mk'` if and only if `f(x) = z * f(y)`.


theorem Real.log_ne_zero : ∀ {x : ℝ}, Real.log x ≠ 0 ↔ x ≠ 0 ∧ x ≠ 1 ∧ x ≠ -1 := by sorry

The theorem `Real.log_ne_zero` states that the real logarithm of a real number `x` is not equal to zero if and only if `x` is not equal to zero, `x` is not equal to one, and `x` is not equal to negative one. In other words, the logarithm of a number `x` will be non-zero only when `x` is any real number except 0, 1, and -1.

The real logarithm of a non-zero real number is never equal to zero.


/-- The exponential in a Banach algebra `𝔸` over a normed field `𝕂` has strict Fréchet derivative
`1 : 𝔸 →L[𝕂] 𝔸` at zero, as long as it converges on a neighborhood of zero.  -/
theorem hasStrictFDerivAt_exp_zero_of_radius_pos :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕂 𝔸] [inst_3 : CompleteSpace 𝔸],
      0 < FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸) → HasStrictFDerivAt (NormedSpace.exp 𝕂) 1 0 :=
  by sorry

The theorem `hasStrictFDerivAt_exp_zero_of_radius_pos` states that, given a Banach algebra `𝔸` over a normed field `𝕂`, if the exponential series converges on a neighborhood of zero, then the exponential function has a strict Fréchet derivative of `1` at zero. This strict Fréchet derivative is a linear map from `𝔸` to `𝔸` over the field `𝕂`. The convergence of the series is captured by the condition that the radius of convergence of the exponential series is greater than zero.

If a Banach algebra over a normed field has an exponential series that converges in a neighborhood of zero, then the exponential function has a strict Fréchet derivative of 1 at zero.


theorem Multiset.mem_of_subset : ∀ {α : Type u_1} {s t : Multiset α} {a : α}, s ⊆ t → a ∈ s → a ∈ t := by sorry

The theorem `Multiset.mem_of_subset` states that for any type `α`, and for any two multiset `s` and `t` of type `α`, if `s` is a subset of `t` and if an element `a` of type `α` is in `s`, then `a` is also in `t`. In other words, if a multiset is a subset of another multiset, then any element in the subset is also an element of the larger set. This is a basic property of subset relationships in set theory.

If `s` is a subset of `t` and `a` is in `s`, then `a` is in `t`. (In the context of multisets, "a is in `s`" means that `s` contains `a` with some multiplicity.)


theorem List.filterMap_append :
    ∀ {α : Type u_1} {β : Type u_2} (l l' : List α) (f : α → Option β),
      List.filterMap f (l ++ l') = List.filterMap f l ++ List.filterMap f l' :=
  by sorry

This theorem, `List.filterMap_append`, states that for any two lists `l` and `l'` of the same type `α`, and a function `f` that maps from `α` to an `Option β`, filtering and mapping the concatenation of `l` and `l'` (i.e., `l ++ l'`) using `f` is equivalent to concatenating the filtering and mapping of `l` and `l'` separately. In other words, the operation of `filterMap` over the concatenation of two lists produces the same result as concatenating the `filterMap` results of each list individually.

For any lists `l` and `l'` of type `α` and function `f : α → Option β`, `List.filterMap (λx => f x) (l ++ l')` is equivalent to `List.filterMap f l ++ List.filterMap f l'`.


theorem NNReal.zero_le_coe : ∀ {q : NNReal}, 0 ≤ ↑q := by sorry

This theorem states that for any nonnegative real number `q`, the real number it represents is also nonnegative. In other words, if `q` is an element of the set of nonnegative real numbers (`NNReal`), then when `q` is converted to a standard real number (using the coercion function `↑q`), the result will always be greater than or equal to zero. In mathematical terms, for all `q` in `NNReal`, `0 ≤ ↑q`.

For any nonnegative real number `q`, its standard real number representation `↑q` is nonnegative.


theorem Ordinal.limitRecOn.proof_1 : ∀ {C : Ordinal.{u_2} → Sort u_1} (o : Ordinal.{u_2}), o = 0 → C o = C 0 := by sorry

The theorem `Ordinal.limitRecOn.proof_1` states that for any function `C` from ordinals in `Type u_2` to the type `Sort u_1` and any ordinal `o` from `Type u_2`, if `o` is equal to the ordinal 0, then the value of `C` at `o` is the same as the value of `C` at 0. This theorem essentially states that, under the provided conditions, the function `C` behaves the same way at `o` and at 0.

For any function `C` from ordinals to a type and any ordinal `o`, if `o` equals 0, then `C o` equals `C 0`.


theorem Ordinal.limitRecOn.proof_2 :
    ∀ {C : Ordinal.{u_2} → Sort u_1} (o : Ordinal.{u_2}),
      (∃ a, o = Order.succ a) → C o = C (Order.succ (Ordinal.pred o)) :=
  by sorry

This theorem says that for all ordinals `o` and for any function `C` from ordinals to any type, if `o` is the successor of some ordinal, then the value of `C` at `o` is equal to the value of `C` at the successor of the predecessor of `o`. In other words, given a function `C` defined on ordinals and an ordinal `o` that is a successor, we can replace `o` with the successor of its predecessor in the function `C` without changing the value of `C(o)`.

For any function `C` from ordinals to a type and for all successor ordinals `o`, `C(o) = C(suc (pred o))`, where `suc` and `pred` denote the successor and predecessor functions on ordinals, respectively.


theorem Ordinal.limitRecOn.proof_3 : ∀ (o : Ordinal.{u_1}), (∃ a, o = Order.succ a) → Ordinal.pred o < o := by sorry

The theorem `Ordinal.limitRecOn.proof_3` states that for any ordinal `o`, if there exists another ordinal `a` such that `o` is the successor of `a` (i.e., `o = Order.succ a`), then the predecessor of `o` (as determined by the function `Ordinal.pred`) is strictly less than `o`. In essence, if `o` is a successor ordinal, then its predecessor is a lesser ordinal.

For any ordinal `o` and `a`, if `o` is the successor of `a` (`o = Order.succ a`), then `Ordinal.pred o < o`.


theorem Ordinal.limitRecOn.proof_4 :
    ∀ (o : Ordinal.{u_1}), ¬o = 0 → (¬∃ a, o = Order.succ a) → o ≠ 0 ∧ ∀ a < o, Order.succ a < o := by sorry

The theorem `Ordinal.limitRecOn.proof_4` states that for any ordinal `o` that is not zero, and for which there does not exist an `a` such that `o` is the successor of `a`, it is true that `o` is not zero and for any `a` less than `o`, the successor of `a` is also less than `o`. This implies that `o` is a limit ordinal, i.e., an ordinal that is not zero and is not the successor of any ordinal, and hence, it also implies that limit ordinals are closed under taking successors.

For any non-zero limit ordinal `o`, for all `a` less than `o`, the successor of `a` is also less than `o`.


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

This theorem states that for any type `α` and any lists `l₁` and `l₂` of this type, along with any element `a` of this type, if `l₁` is a subset of `l₂`, then the list that starts with `a` followed by `l₁` is a subset of the list that starts with `a` followed by `l₂`. In other words, prepending the same element to two lists preserves the subset relationship between them.

If `l₁ ⊆ l₂` are lists of type `α`, then `a :: l₁ ⊆ a :: l₂`.


theorem Set.Iic_union_Ioi : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Iic a ∪ Set.Ioi a = Set.univ := by
  sorry

The theorem `Set.Iic_union_Ioi` states that for any type `α` equipped with a linear order and any element `a` of `α`, the union of the left-infinite right-closed interval up to `a` and the left-open right-infinite interval from `a` equals the universal set of `α`. In other words, combining the set of all elements less than or equal to `a` with the set of all elements strictly greater than `a` yields the entire set of elements in `α`.

For any type `α` with a linear order, the union of the left-closed, right-unbounded interval `[min α, a]` and the left-open, right-unbounded interval `(a, max α)` equals the entire set `α`.


theorem Functor.Comp.run_pure :
    ∀ {F : Type u → Type w} {G : Type v → Type u} [inst : Applicative F] [inst_1 : Applicative G] {α : Type v} (x : α),
      Functor.Comp.run (pure x) = pure (pure x) :=
  by sorry

The theorem `Functor.Comp.run_pure` states that for all type constructors `F` and `G`, where `F` maps a type from universe `u` to `w` and `G` maps a type from `v` to `u`, given that `F` and `G` are both Applicative functors, and for any type `α` in universe `v` and any term `x` of type `α`, running the composition functor on `pure x` (i.e., applying `pure` to `x` and then using `run` function on it) yields the same result as applying `pure` twice on `x` (i.e., first applying `pure` to `x` and then again applying `pure` to the result). In essence, it is a property of applicative composition of functors.

For all Applicative functors F : Type u -> Type w and G : Type v -> Type u, the application of the composition functor (F ∘ G) to a term x : Type v is equivalent to applying F twice to x, i.e., F (G x) ≈ F (pure x).


theorem Mathlib.Order.Filter.Subsingleton._auxLemma.3 : ∀ {α : Type u_1}, Filter.Subsingleton ⊥ = True := by sorry

The theorem `Mathlib.Order.Filter.Subsingleton._auxLemma.3` states that, for any type `α`, the bottom filter (denoted by `⊥`) is a subsingleton. Recall that a filter is considered a subsingleton if there exists a subsingleton set that belongs to the filter. The bottom filter is a subsingleton because it contains only the empty set, which is a subsingleton set.

The bottom filter (⊥) over any type α is a subsingleton due to it containing the subsingleton empty set.


theorem deriv_add :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {x : 𝕜},
      DifferentiableAt 𝕜 f x → DifferentiableAt 𝕜 g x → deriv (fun y => f y + g y) x = deriv f x + deriv g x :=
  by sorry

The theorem `deriv_add` states that for any point `x` in a specific type `𝕜`, and for any two functions `f` and `g` from `𝕜` to another specific type `F`, if both `f` and `g` are differentiable at the point `x`, the derivative at `x` of the sum of `f` and `g` is equal to the sum of the derivatives of `f` and `g` at `x`. Here, `𝕜` is a nontrivially normed field and `F` is a normed space over `𝕜`. The function `deriv` is used to denote the derivative of a function at a point, and the function `DifferentiableAt` indicates whether a function is differentiable at a particular point.

If `f` and `g` are differentiable functions from a normed field `𝕜` to a normed space `F` at a point `x ∈ 𝕜`, then `(f + g).deriv x = f.deriv x + g.deriv x`.


theorem X_pow_sub_C_irreducible_of_odd :
    ∀ {K : Type u} [inst : Field K] {n : ℕ},
      Odd n →
        ∀ {a : K},
          (∀ (p : ℕ), Nat.Prime p → p ∣ n → ∀ (b : K), b ^ p ≠ a) → Irreducible (Polynomial.X ^ n - Polynomial.C a) :=
  by sorry

The theorem `X_pow_sub_C_irreducible_of_odd` states that for any field `K` and any odd natural number `n`, if for any prime number `p` that divides `n` and any element `b` of `K`, `b` to the power of `p` is not equal to `a`, then the polynomial `X^n - C(a)` is irreducible. In simpler terms, if a polynomial is of the form `X^n - a` where `n` is an odd number and `a` is any constant, and there are no elements in the field which to some prime power that divides `n` equals `a`, then this polynomial cannot be factored into simpler polynomials.

For any odd natural number `n` and constant `a` in a field `K` such that for all prime `p` dividing `n` and all `b` in `K`, `b^p ≠ a`, the polynomial `X^n - a` is irreducible.


theorem WeierstrassCurve.Affine.eval_polynomialX :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R) (x y : R),
      Polynomial.eval x (Polynomial.eval (Polynomial.C y) W.polynomialX) =
        W.a₁ * y - (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄) :=
  by sorry

This theorem states that for any commutative ring `R`, and for any Weierstrass curve `W` over `R` represented in affine coordinates, and any elements `x` and `y` from `R`, if you evaluate `W`'s `polynomialX` by first replacing every instance of `X` with the constant polynomial `y` and then evaluating the result at `x`, you get the result `W.a₁ * y - (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄)`. In other words, the polynomial `polynomialX` on `W` behaves in a certain way when evaluated at `(x, y)`.

For any commutative ring `R`, Weierstrass curve `W` over `R` in affine coordinates, and elements `x, y` from `R`, the evaluation of `W.polynomialX` at `x` after substituting all occurrences of `X` with `y` is equal to `W.a₁ * y - (3 * x ^ 2 + 2 * W.a₂ * x + W.a₄)`.


theorem WeierstrassCurve.Affine.eval_polynomialY :
    ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve.Affine R) (x y : R),
      Polynomial.eval x (Polynomial.eval (Polynomial.C y) W.polynomialY) = 2 * y + W.a₁ * x + W.a₃ :=
  by sorry

This theorem states that for any commutative ring `R`, given a Weierstrass curve `W` in the affine coordinate system over `R`, and any elements `x` and `y` of `R`, the evaluation of the `W.polynomialY` at the point where the variable is replaced by the constant polynomial `y` and then evaluated at `x`, equals `2 * y + W.a₁ * x + W.a₃`. In other words, when you substitute `y` into `W.polynomialY` and then evaluate the resulting polynomial at `x`, you get `2 * y + W.a₁ * x + W.a₃`.

For any commutative ring `R`, the evaluation of the polynomial `W.polynomialY` at a point (x, y) on a Weierstrass curve `W` over `R` equals `2 * y + W.a₁ * x + W.a₃`.


theorem Polynomial.map_rootOfSplits :
    ∀ {K : Type v} {L : Type w} [inst : Field K] [inst_1 : Field L] (i : K →+* L) {f : Polynomial K}
      (hf : Polynomial.Splits i f) (hfd : Polynomial.degree f ≠ 0),
      Polynomial.eval₂ i (Polynomial.rootOfSplits i hf hfd) f = 0 :=
  by sorry

The theorem `Polynomial.map_rootOfSplits` states that for any field `K`, another field `L`, and a ring homomorphism `i` from `K` to `L`, given a polynomial `f` over `K` that splits under `i`, and assuming that the degree of `f` is not zero, if you evaluate `f` at the root produced by `Polynomial.rootOfSplits` using the ring homomorphism `i`, the result is zero. In other words, `Polynomial.rootOfSplits` indeed produces a root of `f` when `f` is mapped into `L` using `i`.

Given a field homomorphism `i` from `K` to `L`, a polynomial `f` of non-zero degree over `K` that splits at some `α` in `K`, the image `i(α)` is a root of the polynomial `i(f)` in `L`.


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

The theorem `AddUnits.add_neg_cancel_left` states that for any type `α` which has an additive monoid structure and any element `a` of the additive units of `α` and `b` of type `α`, adding `a` and the negation of `a` to `b` results in `b`. In other words, the additive unit `a` and its negation `(-a)` cancel each other out when added to any `b`, in the context of an additive monoid.

For any additive monoid type `α` and additive unit `a` in `α`, we have `a + (-a) = 0`, where `0` is the additive identity of `α`.


theorem AddCommGroup.not_modEq_iff_toIcoMod_eq_toIocMod :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) {a b : α},
      ¬a ≡ b [PMOD p] ↔ toIcoMod hp a b = toIocMod hp a b :=
  by sorry

The theorem `AddCommGroup.not_modEq_iff_toIcoMod_eq_toIocMod` states that for any type `α` that is a linear ordered additive commutative group and an Archimedean field, and for any positive real number `p`, and any two real numbers `a` and `b`, `a` is not congruent to `b` modulo `p` if and only if the reduction of `b` to the interval `[a, a + p)` (`toIcoMod`) is equal to the reduction of `b` to the interval `(a, a + p]` (`toIocMod`).

For any Archimedean additive commutative group `α`, real numbers `p`, `a`, and `b`, `a` is not congruent to `b` modulo `p` if and only if `toIcoMod p a b` equals `toIocMod p a b`.


theorem ProbabilityTheory.kernel.indep_iSup_directed_limsup :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {s : ι → MeasurableSpace Ω} {α_1 : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : α_1 → Set ι},
      (∀ (n : ι), s n ≤ m0) →
        ProbabilityTheory.kernel.iIndep s κ μα →
          (∀ (t : Set ι), p t → tᶜ ∈ f) →
            Directed (fun x x_1 => x ≤ x_1) ns →
              (∀ (a : α_1), p (ns a)) →
                ProbabilityTheory.kernel.Indep (⨆ a, ⨆ n ∈ ns a, s n) (Filter.limsup s f) κ μα :=
  by sorry

This theorem establishes a condition for independence in the context of probability theory and measure theory. Specifically, it states that for any given types `α`, `Ω`, `ι`, and `α_1`, and given a measurable space structure on `α`, a specific measurable space `m0` on `Ω`, a kernel `κ`, a measure `μα` on `α`, a family of measurable spaces `s` indexed by `ι`, a property `p` on sets of `ι`, a filter `f` on `ι`, and a function `ns` mapping elements of `α_1` to sets of `ι`, if the following conditions are satisfied:

- Each measurable space `s n` is a subset of `m0`,
- The family `s` is independent with respect to the kernel `κ` and the measure `μα`,
- For every set `t` of `ι` satisfying property `p`, the complement of `t` belongs to the filter `f`,
- The function `ns` is directed with respect to the order relation `≤` on sets of `ι`, and
- For each element `a` of `α_1`, the set `ns a` satisfies property `p`,

then it follows that the family of measurable spaces generated by taking the suprema over all `a` and `n` in the set `ns a` of the spaces `s n`, is independent with respect to the kernel `κ` and the measure `μα`, where the measure is the limit superior of `s` along the filter `f`. This relates concepts from order theory, filter theory, and measure theory, establishing a relationship between directed sets, limit superior, independence, and suprema in the context of measurable spaces and probability kernels.

Given measurable spaces `α`, `Ω`, `ι`, `α_1`, a measurable space structure on `α`, a measurable space `m0` on `Ω`, a kernel `κ`, a measure `μα` on `α`, a family `s` of measurable spaces indexed by `ι`, a property `p` on sets of `ι`, a filter `f` on `ι`, and a function `ns` mapping elements of `α_1` to sets of `ι`, if conditions 1-5 hold, then the family of measurable spaces generated by the suprema of `s n` over all `a` in `α_1` and `n` in `ns a` is independent with respect to `κ` and `μα`, and is the limit superior of `s` along `f`.


/-- A monotone function `f` sending `bot` to `bot` and continuous at the supremum of a set sends
this supremum to the supremum of the image of this set.  -/
theorem Monotone.map_sSup_of_continuousAt :
    ∀ {α : Type u} {β : Type v} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : CompleteLinearOrder β] [inst_4 : TopologicalSpace β] [inst_5 : OrderClosedTopology β] {f : α → β}
      {s : Set α}, ContinuousAt f (sSup s) → Monotone f → f ⊥ = ⊥ → f (sSup s) = sSup (f '' s) :=
  by sorry

The theorem `Monotone.map_sSup_of_continuousAt` states that for all types `α` and `β`, given the conditions that `α` and `β` are complete linear orders, `α` is a topological space with an order topology, and `β` is a topological space with an order-closed topology, if `f` is a monotone function from `α` to `β` that sends `bot` (the least element) to `bot`, and is continuous at the supremum of a set `s` of elements in `α`, then `f` sends the supremum of the set `s` to the supremum of the image of `s` under `f`.

In simpler terms, a monotone function that is continuous at the maximum value of a set will map this maximum value to the maximum value of the set of output values.

For monotone functions `f` from a complete linear order `α` (with order topology) to a topological space `β` (with order-closed topology), if `f` is continuous at the supremum of a set `s` in `α` and sends the least element to the least element, then `f` maps the supremum of `s` to the supremum of `f``(s)`.


theorem Filter.liminf_le_liminf :
    ∀ {β : Type u_2} {α : Type u_6} [inst : ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β},
      (∀ᶠ (a : α) in f, u a ≤ v a) →
        autoParam (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝ →
          autoParam (Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) f v) _auto✝¹ →
            Filter.liminf u f ≤ Filter.liminf v f :=
  by sorry

The theorem `Filter.liminf_le_liminf` states that for any types `β` and `α`, and under the condition that `β` is a conditionally complete lattice, given filter `f` on `α` and two functions `u` and `v` from `α` to `β`, if `u a` is less than or equal to `v a` for all `a` in the filter `f`, the lower limit (liminf) of `u` along the filter `f` is less than or equal to the lower limit of `v` along the same filter. This also assumes that the image of the filter `f` under `u` is eventually bounded above (expressed using `autoParam` and `Filter.IsBoundedUnder`), and the image of `f` under `v` is not tending to negative infinity (expressed using `autoParam` and `Filter.IsCoboundedUnder`).

If `β` is a conditionally complete lattice, filter `f` on `α` has an eventual upper bound for the image under `u`, and the image under `v` is not tending to negative infinity, then `liminf(u) ≤ liminf(v)` for functions `u` and `v` from `α` to `β` satisfying `u a ≤ v a` for all `a` in `f`.


theorem Set.toFinset_range :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype β] (f : β → α)
      [inst_2 : Fintype ↑(Set.range f)], Set.toFinset (Set.range f) = Finset.image f Finset.univ :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` has decidable equality and `β` is finite, given a function `f` mapping from `β` to `α` and under the assumption that the range of `f` is finite, the set obtained by converting the range of `f` to a finite set equals the image of the universal finite set of type `β` under the function `f`. In other words, it says that the set of all outputs of `f` when applied to any element of `β` is the same set as applying `f` to the entire set `Finset.univ` of `β` and taking the image under `f`.

For functions `f` from a finite type `β` to a type `α` with decidable equality, the image of `f` and the image of the universal finite set `Finset.univ` of `β` under `f` are equal.


theorem LipschitzWith.dist_right : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), LipschitzWith 1 (dist x) := by
  sorry

The theorem `LipschitzWith.dist_right` states that for any type `α` with a pseudo-metric space structure and for any point `x` of type `α`, the function that measures the distance from `x` is Lipschitz continuous with a constant of 1. This means that for any two points `y` and `z` in the pseudo-metric space, the distance between the images under the function (i.e., the absolute differences between the distances from `x` to `y` and `z`) is less than or equal to the distance between the points `y` and `z` themselves.

For any pseudo-metric space `(α, d)` and point `x ∈ α`, the function `d(x, *) : α → ℝ` is Lipschitz continuous with constant 1, i.e., `|d(x, y) - d(x, z)| ≤ d(y, z)` for all `y, z ∈ α`.


theorem Filter.hasBasis_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s ↔ ∀ (t : Set α), t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t :=
  by sorry

This theorem states a property for a filter `l` on a type `α`. It says that a filter `l` has a basis characterized by a predicate `p` and a function `s` from indices of sort `ι` to sets of α, if and only if for every set `t` of elements of type `α`, `t` is in the filter `l` if and only if there exists an index `i` such that `p i` is true and the set `s i` is a subset of `t`. The basis here refers to the fundamental sets that generate the filter. In other words, the filter consists of all sets that include some set `s i` for which the predicate `p i` holds.

A filter on type α has a basis consisting of sets `{x ∈ α | p i} for some i and subset s i ⊆ x if and only if for every set t ⊆ α, t ∈ filter iff there exists i such that p i holds and s i ⊆ t.


theorem Ordinal.out_empty_iff_eq_zero : ∀ {o : Ordinal.{u_3}}, IsEmpty (Quotient.out o).α ↔ o = 0 := by sorry

This theorem establishes a relationship between the type of well orders and the concept of emptiness. It states that for any well order 'o' of a certain type, the set of elements 'α' chosen from the equivalence class of 'o' is empty if and only if 'o' is the zero ordinal. This theorem essentially links the property of a well order being equivalent to the zero ordinal with the absence of elements in its equivalence class.

For any well order 'o', the equivalence class of 'o' is empty if and only if 'o' is the zero ordinal.


theorem Mathlib.Data.Polynomial.Laurent._auxLemma.16 : (¬False) = True := by sorry

This theorem in the Mathlib library for Lean 4 proposes that the negation of "False" is equivalent to "True". This is a fundamental concept in logic, where "not false" is always considered to be true.

The negation of False is equivalent to True. (In mathematical logic, ⟂ (False) ≈ True)


theorem Finset.sized_falling :
    ∀ {α : Type u_2} [inst : DecidableEq α] (k : ℕ) (𝒜 : Finset (Finset α)), Set.Sized k ↑(Finset.falling k 𝒜) := by
  sorry

The theorem `Finset.sized_falling` states that for any type `α` with decidable equality and any natural number `k`, given a finset `𝒜` of finsets of `α`, every finset in the finset resulting from applying `Finset.falling` operation on `𝒜` with `k` has size `k`. In other words, it asserts that the `Finset.falling` operation on `𝒜` results in a finset where all its elements (which are finsets of `α`) have a cardinality of `k`. This operation essentially generates all subsets of elements in `𝒜` that have a size of `k`.

For any type `α` with decidable equality and natural number `k`, `Finset.falling 𝒜 k` is a finset of `α` subsets with cardinality `k`, where `𝒜` is a finset of `α` finsets.


theorem Set.subset_compl_singleton_iff : ∀ {α : Type u} {a : α} {s : Set α}, s ⊆ {a}ᶜ ↔ a ∉ s := by sorry

This theorem, named `Set.subset_compl_singleton_iff`, is a universal statement in the context of set theory. It asserts that for any type `α`, any element `a` of this type, and any set `s` of elements of type `α`, the set `s` is a subset of the complement of the singleton set `{a}` if and only if the element `a` is not an element of the set `s`. In mathematical terms, we can say that $s \subseteq (\{a\})^c$ if and only if $a \notin s$.

For any set $s$ and element $a$ in type $\alpha$, $s \subseteq \{a\}^c$ if and only if $a \notin s$.


theorem Decidable.imp_iff_not_or : ∀ {a b : Prop} [inst : Decidable a], a → b ↔ ¬a ∨ b := by sorry

This theorem states that, for any propositions `a` and `b`, and given that `a` is decidable (meaning we can definitively say whether `a` is true or false), the implication `a → b` (if `a` then `b`) is logically equivalent to `¬a ∨ b` (either `a` is not true, or `b` is true). In other words, an implication holds true either when its antecedent is false or when its consequent is true.

For any propositions `a` and `b`, `a → b` is logically equivalent to `¬a ∨ b`.


theorem Mathlib.Data.MvPolynomial.Variables._auxLemma.8 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (Multiset.toFinset s ⊆ Multiset.toFinset t) = (s ⊆ t) :=
  by sorry

This theorem states that for any type α equipped with a decidable equality and any two multisets `s` and `t` of elements of type α, the finset derived from `s` is a subset of the finset derived from `t` if and only if `s` is a subset of `t`. In simpler terms, it establishes the relationship between the subset property of multisets and the corresponding property of their respective finsets (sets with no duplicates).

For any type α with decidable equality, the finset of elements from α in multiset s is a subset of the finset of elements from α in multiset t if and only if multiset s is a subset of multiset t.


theorem mul_nonneg_iff :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α} [inst_1 : ExistsAddOfLE α],
      0 ≤ a * b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0 :=
  by sorry

This theorem states that for any type `α` that is a linearly ordered semiring, and any `a` and `b` of type `α`, the product `a * b` is non-negative if and only if either both `a` and `b` are non-negative or both `a` and `b` are non-positive. Here, non-negative and non-positive are represented by `0 ≤ a` and `0 ≤ b`, and `a ≤ 0` and `b ≤ 0`, respectively. The existence of an addition operation for the semiring `α` that respects order (denoted by `[inst_1 : ExistsAddOfLE α]`) is assumed.

For any linearly ordered semiring `α` with addition respecting order, the product of two elements `a` and `b` is non-negative (`0 ≤ a * b`) if and only if both `a` and `b` are non-negative (`0 ≤ a` and `0 ≤ b`) or both are non-positive (`a ≤ 0` and `b ≤ 0`).


theorem Stream'.Seq.map_tail :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Stream'.Seq α),
      Stream'.Seq.map f (Stream'.Seq.tail s) = Stream'.Seq.tail (Stream'.Seq.map f s) :=
  by sorry

This theorem, named `Stream'.Seq.map_tail`, states that for all types `α` and `β` and for all functions `f` from `α` to `β` and for any sequence `s` of type `α`, mapping the function `f` over the tail of the sequence `s` is the same as taking the tail of the sequence that results from mapping `f` over `s`. In other words, the ordering of applying the map operation and the tail operation does not matter. This can be seen as a property of commutativity between the two operations 'map' and 'tail' on sequences.

For all types `α` and `β` and functions `f` from `α` to `β`, the operation of taking the tail of the sequence obtained by mapping `f` over a sequence `s` is equal to mapping `f` over the tail of sequence `s`.


theorem Isometry.preimage_closedBall :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r :=
  by sorry

The theorem `Isometry.preimage_closedBall` states that for any isometry `f` between two pseudometric spaces `α` and `β`, for any point `x` in `α` and any real number `r`, the preimage of the closed ball centered at `f(x)` with radius `r` under `f` is exactly the closed ball centered at `x` with radius `r`. In other words, an isometry maps closed balls in the domain space to corresponding closed balls in the codomain space, preserving their centers and radii.

For any isometry between pseudometric spaces and any point and radius, the preimage of the closed ball centered at the image point with the given radius is the closed ball centered at the original point with the same radius.