theorem ProbabilityTheory.IsMeasurableRatCDF.tendsto_stieltjesFunction_atBot :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ} (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α),
      Filter.Tendsto (↑(ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction hf a)) Filter.atBot (nhds 0) :=
  by sorry

This theorem states that, for any measurable space α and a function `f : α → ℚ → ℝ` that has the `IsMeasurableRatCDF` property, if we extend `f` from rational numbers to real numbers to obtain a Stieltjes function, then this Stieltjes function tends towards negative infinity and converges to zero. In other words, as we consider smaller and smaller values in the domain of the Stieltjes function, the function values get arbitrarily close to zero. This is expressed formally as the function `f` being continuous from the bottom (`Filter.atBot`) towards a neighborhood of zero (`nhds 0`).

Given a measurable space α and a measurable function `f : α → ℚ → ℝ` with the `IsMeasurableRatCDF` property, its extended Stieltjes function is continuous from below towards zero.


theorem Mathlib.Algebra.GeomSum._auxLemma.5 : ∀ {n : ℕ}, Even (n + 1) = ¬Even n := by sorry

The theorem `Mathlib.Algebra.GeomSum._auxLemma.5` states that for any natural number `n`, the property of `n + 1` being even is equivalent to `n` being not even. In terms of mathematics, this says that if a natural number is even, then adding 1 to it makes it not even, and vice versa.

For any natural number `n`, the parity of `n+1` is opposite to that of `n`.


theorem Mathlib.Algebra.GeomSum._auxLemma.7 :
    ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) := by sorry

This theorem, named `Mathlib.Algebra.GeomSum._auxLemma.7`, states that for any type `G` which has an `AddGroup` instance and for any three elements `a`, `b`, and `c` of type `G`: the statement "`a` minus `b` equals `c`" is equivalent to the statement "`a` equals `c` plus `b`". In mathematical terms, it confirms the principle that subtracting `b` from `a` and adding `b` to `c` are inverse operations.

For any additive group `G` and elements `a, b, c` in `G`, `a - b = c` if and only if `a = c + b`.


theorem Finsupp.mem_neLocus :
    ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] {f g : α →₀ N}
      {a : α}, a ∈ Finsupp.neLocus f g ↔ f a ≠ g a :=
  by sorry

The theorem `Finsupp.mem_neLocus` states that for any types `α` and `N`, given `DecidableEq` instances for α and N, a `Zero` instance for N, and two finitely supported functions `f` and `g` from `α` to `N`, a member `a` of type `α` is in the finset `Finsupp.neLocus f g` if and only if `f a` is not equal to `g a`. In other words, `Finsupp.neLocus f g` contains exactly those elements of `α` for which `f` and `g` yield different values.

Forany types `α` and `N` with Decidable Equation instances, and given zero instances for `N` and finitely supported functions `f` and `g` from `α` to `N`, `Finsupp.neLocus f g` contains exactly the elements `a` in `α` for which `f a ≠ g a`.


theorem PartialEquiv.transEquiv_eq_trans :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (e' : β ≃ γ),
      PartialEquiv.transEquiv e e' = PartialEquiv.trans e (Equiv.toPartialEquiv e') :=
  by sorry

The theorem `PartialEquiv.transEquiv_eq_trans` states that for all types `α`, `β`, and `γ`, and for a given partial equivalence `e` from `α` to `β` and an equivalence `e'` from `β` to `γ`, the composition of the partial equivalence `e` with the equivalence `e'` using `PartialEquiv.transEquiv` is equal to the composition of `e` with the conversion of `e'` to a partial equivalence using `PartialEquiv.trans` and `Equiv.toPartialEquiv`. In simpler terms, it ensures that the composition operation is consistent whether we consider `e'` as a full or partial equivalence.

For all partial equivalences `e : α ≃_∞β` and equivalences `e' : β ≃ γ`, `PartialEquiv.transEquiv e e' = PartialEquiv.trans e (Equiv.toPartialEquiv e')`.


theorem AddAction.nsmul_mod_period_vadd :
    ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] (n : ℕ) {m : M} {a : α},
      (n % AddAction.period m a) • m +ᵥ a = n • m +ᵥ a :=
  by sorry

The theorem `AddAction.nsmul_mod_period_vadd` states that for any natural number `n`, and for any elements `m` of type `M` and `a` of type `α` where `M` is an additive monoid and `α` is acted upon by `M`, the result of adding `m` to `a` scaled by `(n modulo the period of the action of m on a)` will be the same as the result of adding `m` to `a` scaled by `n`. In other words, in the context of an additive action, n times the action of an element follows a periodic pattern with its period defined by the `AddAction.period`.

For any natural number `n` and elements `m` of an additive monoid `M` acting on type `α`, the scaled action `m * n` is equivalent to `m * (n modulo the period of the action of m)` in `α`.


theorem antitone_comp_ofDual_iff :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Antitone (f ∘ ⇑OrderDual.ofDual) ↔ Monotone f :=
  by sorry

This theorem states that for any types `α` and `β` with preorders, and any function `f` from `α` to `β`, the function `f` composed with the order-dual identity function is antitone if and only if the function `f` is monotone. In other words, reversing the order of the arguments of `f` results in an antitone function if and only if `f` itself is monotone. This highlights the relationship between monotone and antitone functions: the former preserves the order of elements while the latter reverses it.

For functions between preordered types, `f : α → β` is antitone if and only if its order-dual `dual f` is monotone, where `dual f(x) := f(x) <= f(y) <-> y <= x`.


theorem List.append_eq_nil : ∀ {α : Type u_1} {p q : List α}, p ++ q = [] ↔ p = [] ∧ q = [] := by sorry

This theorem states that for any type `α` and any two lists `p` and `q` of type `α`, the append operation `p ++ q` equals the empty list if and only if both `p` and `q` are empty. In other words, it's not possible to append two non-empty lists and end up with an empty list.

For any type `α`, lists `p` and `q` of type `α`, the condition `p ++ q = []` if and only if both `p` and `q` are empty.


theorem Finset.map_add_right_Ico :
    ∀ {α : Type u_2} [inst : OrderedCancelAddCommMonoid α] [inst_1 : ExistsAddOfLE α] [inst_2 : LocallyFiniteOrder α]
      (a b c : α), Finset.map (addRightEmbedding c) (Finset.Ico a b) = Finset.Ico (a + c) (b + c) :=
  by sorry

The theorem `Finset.map_add_right_Ico` states that for any ordered cancelable commutative monoid `α` that supports addition of elements and is a locally finite order, given three elements `a`, `b`, and `c` of `α`, the image of the interval `[a, b)` under the embedding by right-addition by `c` is the interval `[a + c, b + c)`. In other words, mapping the interval `[a, b)` in `α` via the function "add `c` to the right" results in the interval `[a + c, b + c)` in `α`.

For any locally finite order monoid `α` with additive structure, the image of the interval `[a, b)` under right-addition by `c` is the interval `[a + c, b + c)`.


theorem induced_const :
    ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace α] {x : α}, TopologicalSpace.induced (fun x_1 => x) t = ⊤ :=
  by sorry

The theorem `induced_const` states that for any types `α` and `β`, given a topological space `t` on `α` and any element `x` of `α`, the topology on `β` induced by the constant function mapping each element to `x` is the discrete topology (denoted by `⊤`). In other words, every subset of `β` is an open set in the induced topology. This is because the preimage of any set through a constant function is either the whole space (if the set contains the constant value) or the empty set (if it doesn't), both of which are always open in any topology.

For any topological spaces `t` on types `α` and `β`, and any element `x` of `α`, the topology on `β` induced by the constant function mapping every element to `x` is the discrete topology.


theorem Polynomial.eval₂_eq_zero_of_dvd_of_eval₂_eq_zero :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p q : Polynomial R} [inst_1 : CommSemiring S] (f : R →+* S)
      (x : S), p ∣ q → Polynomial.eval₂ f x p = 0 → Polynomial.eval₂ f x q = 0 :=
  by sorry

The theorem `Polynomial.eval₂_eq_zero_of_dvd_of_eval₂_eq_zero` states that for any two polynomials `p` and `q` over a semiring `R`, a ring homomorphism `f` from `R` to a commutative semiring `S`, and an element `x` in `S`, if `p` divides `q` and evaluating `p` at `x` using the homomorphism `f` results in zero, then evaluating `q` at `x` using the same homomorphism `f` will also result in zero. In other words, if a polynomial `p` divides another polynomial `q` and `p` evaluates to zero at a certain point under a given homomorphism, then `q` must also evaluate to zero at the same point under the same homomorphism.

If a polynomial `p` divides another polynomial `q` over a semiring and evaluating `p` at an element `x` in a commutative semiring using a ring homomorphism `f` results in zero, then evaluating `q` at `x` using the same homomorphism `f` also results in zero.


theorem Filter.eventually_principal :
    ∀ {α : Type u} {a : Set α} {p : α → Prop}, (∀ᶠ (x : α) in Filter.principal a, p x) ↔ ∀ x ∈ a, p x := by sorry

This theorem, `Filter.eventually_principal`, states that for any type `α`, any set `a` of type `α`, and any property `p`, a statement of the form "eventually, for every element `x` in the principal filter of `a`, `p x` holds" is equivalent to the statement "for every `x` in `a`, `p x` holds". In other words, a property `p` holds eventually for all elements in the principal filter of a set `a` if and only if the property holds for all elements in the set `a` itself.

The theorem asserts that for any set `a` and property `p`, the property holds eventually for all elements in the principal filter of `a` if and only if it holds for all elements in `a`.


theorem Int.rel_of_forall_rel_succ_of_lt :
    ∀ {β : Type v} (r : β → β → Prop) [inst : IsTrans β r] {f : ℤ → β},
      (∀ (n : ℤ), r (f n) (f (n + 1))) → ∀ ⦃a b : ℤ⦄, a < b → r (f a) (f b) :=
  by sorry

This theorem, `Int.rel_of_forall_rel_succ_of_lt`, states that for any type `β` and a binary relation `r` on `β` that is transitive, and a function `f` mapping from integers to `β`, if for all integers `n`, `f(n)` is related to `f(n+1)` by `r`, then for any two integers `a` and `b` with `a < b`, `f(a)` is related to `f(b)` by `r`. Essentially, this says that if each integer is related to its successor via `f` and `r`, then any two integers in increasing order are related in the same way through `f` and `r`.

If `r` is a transitive relation on type `β` and for all integers `n`, `f(n)` is related to `f(n+1)` by `r`, then for any integers `a` and `b` with `a < b`, `f(a)` is related to `f(b)` by `r`.


HasFPowerSeriesOnBall.mono

theorem HasFPowerSeriesOnBall.mono :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {p : FormalMultilinearSeries 𝕜 E F} {x : E} {r r' : ENNReal},
      HasFPowerSeriesOnBall f p x r → 0 < r' → r' ≤ r → HasFPowerSeriesOnBall f p x r' :=
  by sorry

The theorem `HasFPowerSeriesOnBall.mono` states that for any types `𝕜`, `E`, and `F`, where `𝕜` is a nontrivially normed field, `E` and `F` are normed add commutative groups and `E`, `F` are also normed spaces over `𝕜`. Consider a function `f` from `E` to `F`, a formal multilinear series `p` of types `𝕜`, `E`, and `F`, and points `x` in `E` and `r`, `r'` in the extended nonnegative reals `ENNReal`. If `f` has a power series expansion `p` on a ball in `E` centered at `x` with radius `r`, and `r'` is a nonnegative real number that is less than or equal to `r` and greater than zero, then `f` also has a power series expansion `p` on a ball in `E` centered at `x` with radius `r'`.

If `f : E → F` is a function with a power series expansion on the ball `B(x, r)` in the normed spaces `E` and `F` over the nontrivially normed field `𝕜`, then `f` also has a power series expansion on the smaller ball `B(x, r')` for any `r' < r > 0`.


/-- The quotient norm satisfies the triangle inequality.  -/
theorem quotient_norm_add_le :
    ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M) (x y : M ⧸ S), ‖x + y‖ ≤ ‖x‖ + ‖y‖ := by
  sorry

This theorem states that for any seminormed add commutative group `M` and any additive subgroup `S` of `M`, the norm of the sum of any two elements in the quotient group `M ⧸ S` is less than or equal to the sum of their norms. This is a formalization of the triangle inequality in the context of quotient norms.

For any seminormed add commutative group `M`, and additive subgroup `S` of `M`, the quotient norm of the sum of any two elements in `M ⧸ S` is less than or equal to the sum of their quotient norms.


theorem sSup_apply :
    ∀ {α : Type u_9} {β : α → Type u_10} [inst : (i : α) → SupSet (β i)] {s : Set ((a : α) → β a)} {a : α},
      sSup s a = ⨆ f, ↑f a :=
  by sorry

This theorem states that for any type `α`, and any type `β` which is a function of `α`, given a supremum instance `SupSet` for `β i` for each `i` in `α`, for any set `s` of functions from `α` to `β a`, and for any `a` in `α`, the supremum of the set `s` applied to `a` is equal to the supremum over all functions `f` of `f` applied to `a`. This theorem utilizes the concept of supremum in the setting of set of functions, and it relates the supremum of a set of functions to the supremum of the values of these functions at a particular point.

For any type `α` and any function type `β -> α -> Type`, given a supremum `s` for each `β i` over `i ∈ α`, the supremum of a set `s` of functions `f : α -> β a` is equal to the function `sup : β a` such that for all `g : α -> β a`, `sup ≤ g`, and for all `i ∈ α`, `sup i = (sup a) i`.


theorem Ordinal.add_left_cancel : ∀ (a : Ordinal.{u_4}) {b c : Ordinal.{u_4}}, a + b = a + c ↔ b = c := by sorry

The theorem `Ordinal.add_left_cancel` states that for any ordinal number `a` and for any two other ordinal numbers `b` and `c` in the same type, if the sum of `a` and `b` equals the sum of `a` and `c`, then `b` equals `c`. This theorem is basically asserting the property of left-cancellation in ordinal addition. In mathematical terms, if a + b = a + c, then b = c for any ordinals a, b, and c.

If for ordinal numbers `a`, `b`, and `c`, `a + b = a + c`, then `b = c`.


theorem DFunLike.ne_iff :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, f ≠ g ↔ ∃ a, f a ≠ g a := by
  sorry

This theorem states that for any type `F` that behaves like a dependent function (as specified by the `DFunLike F α β` typeclass) from a type `α` to a type `β` dependent on `α`, two such "functions" `f` and `g` are not equal if and only if there exists an element `a` of type `α` such that `f a` is not equal to `g a`. In other words, two dependent function-like objects are different if and only if they differ on at least one input.

For any dependent function-like types `F α β` and functions `f` and `g` of type `F α β`, if `a` is an element of `α` such that `f a ≠ g a`, then `f ≠ g`.


theorem Subgroup.comap_injective :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N},
      Function.Surjective ⇑f → Function.Injective (Subgroup.comap f) :=
  by sorry

The theorem `Subgroup.comap_injective` states that for all groups `G` and `N`, and for all monoid homomorphisms `f` from `G` to `N`, if `f` is a surjective function (that is, for every element in `N`, there exists an element in `G` such that the image of this element under `f` is that element in `N`), then the function `Subgroup.comap f` that maps subgroups of `N` to subgroups of `G` is injective (that is, if `Subgroup.comap f` maps two different subgroups of `N` to the same subgroup of `G`, then the two subgroups of `N` must have been the same to begin with).

If `f` is a surjective group homomorphism from `G` to `N`, then `Subgroup.comap f` is an injective function from the subgroup lattice of `N` to the subgroup lattice of `G`.


theorem ZFSet.mem_image :
    ∀ {f : ZFSet → ZFSet} [H : PSet.Definable 1 f] {x y : ZFSet}, y ∈ ZFSet.image f x ↔ ∃ z ∈ x, f z = y := by sorry

The theorem `ZFSet.mem_image` states that for any function `f` from Zermelo-Fraenkel sets (`ZFSet`) to `ZFSet` that is definable (meaning it corresponds to a formula in the language of set theory with one free variable), and for any Zermelo-Fraenkel sets `x` and `y`, `y` is an element of the image of `x` under `f` (denoted as `ZFSet.image f x`) if and only if there exists an element `z` in `x` such that `f z` equals `y`. In other words, this theorem asserts the basic property of images of functions in the context of Zermelo-Fraenkel set theory.

For any definable function `f` from Zermelo-Fraenkel sets to Zermelo-Fraenkel sets and any sets `x` and `y`, `y` is an element of `f(x)` if and only if there exists an element `z` in `x` such that `f(z) = y`.


theorem Mathlib.Data.Set.Finite._auxLemma.4 :
    ∀ {α : Type u} {s : Set α} (hs : Set.Finite s), (Set.Finite.toFinset hs).Nonempty = Set.Nonempty s := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, if `s` is finite (denoted by `hs : Set.Finite s`), then the non-emptiness of the `Finset` associated with `s` (obtained by calling `Set.Finite.toFinset hs`) is equivalent to the non-emptiness of `s` itself (`Set.Nonempty s`). In other words, a set `s` in our context is non-empty if and only if its corresponding `Finset` is non-empty.

For any set `s` of type `α`, its `Finset` is non-empty if and only if `s` itself is non-empty, assuming `s` is finite.


theorem ENNReal.toReal_eq_toReal : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal = b.toReal ↔ a = b) := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b` that are not equal to positive infinity (`⊤`), `a` is equal to `b` if and only if the real number representations of `a` and `b` are equal. In other words, excluding the positive infinity case, the process of converting extended nonnegative real numbers to real numbers preserves equality.

For extended nonnegative real numbers `a` and `b` not equal to positive infinity, `a = b` if and only if their real number representations are equal.


CategoryTheory.Limits.IsZero.obj

theorem CategoryTheory.Limits.IsZero.obj :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
      [inst_2 : CategoryTheory.Limits.HasZeroObject D] {F : CategoryTheory.Functor C D},
      CategoryTheory.Limits.IsZero F → ∀ (X : C), CategoryTheory.Limits.IsZero (F.obj X) :=
  by sorry

This theorem states that for any categories `C` and `D` where `D` has a zero object, and any functor `F` from `C` to `D`, if `F` is a zero functor (i.e., it maps every object to the zero object of `D` and every morphism to the zero morphism of `D`), then for any object `X` in `C`, the image of `X` under `F` (`F.obj X`) is a zero object in `D`. In simpler terms, a zero functor sends all objects to a zero object and all morphisms to the zero morphism.

For any categories `C` and `D` with a zero object, and any zero functor `F` from `C` to `D`, the image of any object `X` in `C` under `F` is the zero object in `D`.


theorem MeasureTheory.IsFundamentalDomain.nullMeasurableSet_smul :
    ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
      {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableSMul G α]
      [inst_5 : MeasureTheory.SMulInvariantMeasure G α μ],
      MeasureTheory.IsFundamentalDomain G s μ → ∀ (g : G), MeasureTheory.NullMeasurableSet (g • s) μ :=
  by sorry

This theorem states that if a set `s` of elements of type `α` forms a fundamental domain under a group `G` with respect to a measure `μ`, then for any element `g` of the group `G`, the set resulting from the operation `g • s` (which represents the action of `g` on `s`) is a null-measurable set with respect to measure `μ`. Here, a null-measurable set means a set that can be approximated by a measurable set up to a set of null measure. The group `G` is endowed with a group action on `α`, a measurable space structure, and a structure of a `smul` invariant measure. The type `α` is also equipped with a measurable space structure and the property of being measurable with respect to the group action `smul`.

If a set `s` forms a fundamental domain under a group `G` action on measurable space `(α, μ)` with `α` being measurable with respect to `G`, then for all `g` in `G`, `g • s` is a null-measurable set with respect to `μ`.


theorem Commute.left_comm :
    ∀ {S : Type u_2} [inst : Semigroup S] {a b : S}, Commute a b → ∀ (c : S), a * (b * c) = b * (a * c) := by sorry

The theorem `Commute.left_comm` states that for any type `S` that forms a semigroup, and for any elements `a` and `b` in `S` that commute, for any element `c` in `S`, the operation `a * (b * c)` is equal to `b * (a * c)`. In other words, if `a` and `b` commute, then `a` and `b` can be interchanged in multiplication without affecting the result, even when they are multiplied with another element `c`. This property is known as the left commutativity in mathematics.

For any semigroup `S` and commuting elements `a` and `b` in `S`, `a * (b * c)` equals `b * (a * c)` for all `c` in `S`.


theorem CategoryTheory.Iso.isZero_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C},
      (X ≅ Y) → (CategoryTheory.Limits.IsZero X ↔ CategoryTheory.Limits.IsZero Y) :=
  by sorry

This theorem states that in a category `C`, for any objects `X` and `Y`, if `X` is isomorphic to `Y` (denoted by `X ≅ Y`), then `X` is a zero object in the category if and only if `Y` is also a zero object. In category theory, a zero object is both an initial object and a terminal object. This theorem essentially shows that the property of being a zero object is preserved under isomorphism.

In a category, if two objects are isomorphic, then they are both zero objects if and only if they each are.


theorem Set.injOn_id : ∀ {α : Type u_1} (s : Set α), Set.InjOn id s := by sorry

This theorem states that for any set `s` of some type `α`, the identity function `id` is injective on `s`. In other words, if `x₁` and `x₂` are elements of `s` such that `id(x₁)` equals `id(x₂)`, then `x₁` must be equal to `x₂`. This injectivity property ensures that the identity function does not map distinct elements of `s` to the same element.

The identity function on a set `s` is a injection: if `x₁` and `x₂` are in `s` and `id(x₁) = id(x₂)`, then `x₁ = x₂`.


theorem Prod.fst_iSup :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : SupSet α] [inst_1 : SupSet β] (f : ι → α × β),
      (iSup f).1 = ⨆ i, (f i).1 :=
  by sorry

The theorem `Prod.fst_iSup` states that for any types `α`, `β`, and index type `ι`, and for any function `f` from `ι` to a pair of elements in `α` and `β` (given that `α` and `β` are both supremum sets), the first element of the indexed supremum of `f` is equal to the supremum of the first elements of `f` over all `ι`. In other words, it is asserting that the supremum operation is preserved when applied to the first component of a sequence of pairs.

For any type `α`, index type `ι`, and function `f` from `ι` to pairs `(a, b)` in `α × β`, where `α` and `β` are supremum sets, the supremum of the first components `a` of `f` is equal to the first component of the supremum of `f`.


theorem Filter.tendsto_eval_pi :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → Filter (α i)) (i : ι),
      Filter.Tendsto (Function.eval i) (Filter.pi f) (f i) :=
  by sorry

The theorem `Filter.tendsto_eval_pi` asserts that for any indexed family of filters `(f : (i : ι) → Filter (α i))` and an index `i`, the function evaluation `Function.eval i` (which evaluates a function at the index `i`) is a limit function from the product filter `Filter.pi f` (which is the product of the indexed family of filters) to the filter `f i`. In simpler terms, when you apply a function to an element from the product of an indexed family of filters, the result will "tend to" or "converge to" the filter associated with the specific index used in the function evaluation.

For any indexed family of filters `(f : (i : ι) → Filter (α i))`, the evaluation function `Function.eval : ∀ i, α i → α i` is a limit function from the product filter `Filter.pi f` to the filter `f i`.


theorem Polynomial.isPrimitive_iff_content_eq_one :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : NormalizedGCDMonoid R] {p : Polynomial R},
      Polynomial.IsPrimitive p ↔ Polynomial.content p = 1 :=
  by sorry

This theorem states that for any polynomial `p` over a type `R` (where `R` is a commutative ring, a domain, and a normalized GCD monoid), `p` is primitive if and only if the content of `p` is equal to one.

In more detail, a polynomial is primitive (as per the `Polynomial.IsPrimitive` definition) when the only constant polynomials that can divide it are units. The content of a polynomial (`Polynomial.content`) is defined as the greatest common divisor (GCD) of its coefficients. So, the theorem is saying that a polynomial has this property of being primitive if and only if the GCD of its coefficients is one.

A polynomial over a commutative ring is primitive if and only if its content (greatest common divisor of coefficients) is equal to 1.


theorem ProbabilityTheory.IsMeasurableRatCDF.measure_stieltjesFunction_univ :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ} (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α),
      ↑↑(StieltjesFunction.measure (ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction hf a)) Set.univ = 1 :=
  by sorry

This theorem states that for any measurable space 'α' and a function 'f' from 'α' to the real numbers that has the 'IsMeasurableRatCDF' property, when we extend 'f' to a Stieltjes function and subsequently associate a measure to it, the measure of the universal set (i.e., the set of all elements of 'α') is always equal to 1. In simple terms, this theorem asserts that the total probability of all events in our measurable space under this specific construction of a measure is 1, reflecting a fundamental property of probability measures.

For any measurable space 'α' and a measurable function 'f' from 'α' to the real numbers with 'IsMeasurableRatCDF' property, the measure of the universal set induced by the associated Stieltjes measure of 'f' is equal to 1.


Monotone.inf

/-- Pointwise infimum of two monotone functions is a monotone function.  -/
theorem Monotone.inf :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeInf β] {f g : α → β},
      Monotone f → Monotone g → Monotone (f ⊓ g) :=
  by sorry

The theorem `Monotone.inf` states that for any two functions `f` and `g` that map elements from a preordered set `α` to a semilattice `β`, if both `f` and `g` are monotone (meaning that for all `a` and `b` in `α`, if `a ≤ b` then `f(a) ≤ f(b)` and `g(a) ≤ g(b)`), then the pointwise infimum of `f` and `g` (the function that maps any element `x` in `α` to the lesser of `f(x)` and `g(x)`) is also a monotone function. This means that for all `a` and `b` in `α`, if `a ≤ b` then the minimum of `f(a)` and `g(a)` is less than or equal to the minimum of `f(b)` and `g(b)`.

If `f` and `g` are monotone functions mapping a preordered set to a semilattice, then their pointwise infimum is also a monotone function.


theorem sup_div_inf_eq_mabs_div :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a b : α),
      (a ⊔ b) / (a ⊓ b) = mabs (b / a) :=
  by sorry

This theorem states that for any type `α`, where `α` is a lattice and a commutative group, with a specific covariance property, and given any two elements `a` and `b` of this type `α`, the supremum (greatest lower bound) of `a` and `b` divided by the infimum (least upper bound) of `a` and `b` is equal to the absolute value of the fraction `b / a`. Here, the absolute value is defined as the supremum of an element and its inverse.

For any commutative lattice and group type `α` with the given covariance property, the absolute value of `b/a` equals the supremum of `a` and `b` divided by the infimum of `a` and `b`.


theorem CategoryTheory.IsSplitEpi.id_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [hf : CategoryTheory.IsSplitEpi f]
      {Z : C} (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.section_ f) (CategoryTheory.CategoryStruct.comp f h) = h :=
  by sorry

The theorem `CategoryTheory.IsSplitEpi.id_assoc` asserts that for any category `C`, any objects `X`, `Y`, and `Z` in `C`, any morphism `f` from `X` to `Y` that is a split epimorphism, and any morphism `h` from `Y` to `Z`, the composition of the section of `f` (a morphism from `Y` to `X`) with the composition of `f` and `h` (a morphism from `X` to `Z`) is equal to `h`. In other words, if `f` is a split epimorphism, then pre-composing `h` with `f` and its section is an identity operation on `h`.

For any category C, given objects X, Y, and Z, a split epimorphism f : X -> Y in C, and a morphism h : Y -> Z, the section of f and the composition of f and h are equal: section(f) . (f . h) = h.


theorem Ordinal.add_le_of_limit : ∀ {a b c : Ordinal.{u_4}}, Ordinal.IsLimit b → (a + b ≤ c ↔ ∀ b' < b, a + b' ≤ c) :=
  by sorry

The theorem `Ordinal.add_le_of_limit` states that for any three ordinals `a`, `b`, and `c` where `b` is a limit ordinal (i.e., not zero and not a successor), the sum of `a` and `b` is less than or equal to `c` if and only if for all `b'` less than `b`, the sum of `a` and `b'` is less than or equal to `c`. It essentially expresses a property about addition of ordinals in relation to limit ordinals.

For any limit ordinal `b` and ordinals `a` and `c`, `a + b <= c` if and only if `a + b' <= c` for all `b' < b`.


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

This theorem, `subset_of_ssubset`, states that for any type `α` that has a subset operation and a strict subset operation, and where these operations form a nonstrict-strict order, if `a` is a strict subset of `b` (denoted as `a ⊂ b`), then `a` is also a subset of `b` (denoted as `a ⊆ b`). This is a basic property of set theory, reflecting the intuitive idea that if a set `a` is strictly contained within another set `b`, then naturally every element in `a` is also present in `b`.

If `a` strictly contains `b`, then `a` is a subset of `b`. (In mathematical notation: `a ⊂ b` implies `a ⊆ b`.))


theorem Nat.iSup_lt_succ' :
    ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ),
      ⨆ k, ⨆ (_ : k < n + 1), u k = u 0 ⊔ ⨆ k, ⨆ (_ : k < n), u (k + 1) :=
  by sorry

This theorem states that for any type α that forms a complete lattice and a function `u` from natural numbers to α, the supremum (or greatest lower bound) of `u k` for all `k` less than `n + 1` is equal to the supremum of `u 0` and the supremum of `u (k + 1)` for all `k` less than `n`. In mathematical terms, it asserts that `sup_{k < n + 1} u(k) = u(0) ∨ sup_{k < n} u(k + 1)`.

For any function `u` from natural numbers to a complete lattice `α`, the supremum of `{u(k) | k < n+1}` equals the supremum of `{u(0)} ∪ {u(k+1) | k < n}`.


theorem TrivSqZeroExt.fst_inl :
    ∀ {R : Type u} (M : Type v) [inst : Zero M] (r : R), TrivSqZeroExt.fst (TrivSqZeroExt.inl r) = r := by sorry

The theorem `TrivSqZeroExt.fst_inl` states that for all types `R` and `M`, where `M` is an instance of the `Zero` type class, and for all elements `r` of type `R`, the first component (obtained by the `TrivSqZeroExt.fst` function) of the trivial square zero extension of `R` by `M` (obtained by the `TrivSqZeroExt.inl` function) applied to `r` is equal to `r`. In simpler terms, when you add zero from `M` to any element `r` from `R`, the result's first component is still `r`.

For all types R with an instance of Zero M, and all elements r in R, the first component of the trivial square zero extension of R by M applied to r is equal to r. In mathematical notation: `fst (TrivSqZeroExt.inl r) = r`.


theorem nhds_top_order :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : OrderTop α] [inst_3 : OrderTopology α],
      nhds ⊤ = ⨅ l, ⨅ (_ : l < ⊤), Filter.principal (Set.Ioi l) :=
  by sorry

This theorem states that for any type `α` that has a topological space structure, a preorder, a greatest element (`⊤`), and for which the order and the topology are compatible (an order topology), the neighborhood filter at the top element `⊤` is the infimum of the principal filter of the set of elements greater than `l`, for all `l` less than `⊤`. In other words, the neighborhoods of the greatest element in such a space are precisely the collections of sets containing a right-open interval `(l, ∞)` for some `l` less than `⊤`.

In a topological preorder space with a greatest element and compatible order topology, the neighborhood filter at the greatest element is the infimum of the principal filters of elements strictly less than it.


theorem Mathlib.Data.SetLike.Basic._auxLemma.6 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {S T : A}, (↑S ⊆ ↑T) = (S ≤ T) := by sorry

This theorem, `Mathlib.Data.SetLike.Basic._auxLemma.6`, states that for any two types `A` and `B`, given a `SetLike` instance `i` between `A` and `B`, and any two elements `S` and `T` of type `A`, the statement that the coercion of `S` is a subset of the coercion of `T` (expressed as `↑S ⊆ ↑T`) is equivalent to the statement that `S` is less than or equal to `T` (expressed as `S ≤ T`). Here, the `SetLike` instance provides a way to treat elements of `A` like sets, and `↑` is a coercion operator that turns elements of `A` into sets. The theorem expresses a fundamental property of ordered structures where the subset relation corresponds to the order relation.

For any type `A` with a `SetLike` instance and coercion `↑`, the statement `↑S ⊆ ↑T` is equivalent to `S ≤ T`.


theorem Mathlib.Logic.IsEmpty._auxLemma.4 : ∀ {α : Sort u_1}, (¬IsEmpty α) = Nonempty α := by sorry

This theorem from the Mathlib.Logic.IsEmpty library states that for any type `α`, the negation of `α` being empty is equivalent to `α` being nonempty. In other words, if it is not the case that there are zero elements of type `α`, then there must exist at least one element of type `α`.

The negation of a type being empty is equivalent to it being nonempty.


theorem Mathlib.Logic.IsEmpty._auxLemma.3 : ∀ {α : Sort u_1}, (¬Nonempty α) = IsEmpty α := by sorry

This theorem states that for any type `α`, the property that `α` is not nonempty (`¬Nonempty α`) is equivalent to the property that `α` is empty (`IsEmpty α`). In other words, if there are no elements of a given type `α`, then that type is considered empty. This theorem provides a formal equivalence between the negative statement of nonemptiness and the assertion of emptiness in the context of Lean's type theory.

The theorem asserts that the type `α` is empty if and only if it is not nonempty in Lean's type theory.


theorem MeasureTheory.Measure.count_apply_finite' :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α} (s_fin : Set.Finite s),
      MeasurableSet s → ↑↑MeasureTheory.Measure.count s = ↑(Set.Finite.toFinset s_fin).card :=
  by sorry

The theorem `MeasureTheory.Measure.count_apply_finite'` states that for any type `α` equipped with a measure space structure, and for any finite and measurable set `s` of `α`, the counting measure of `s` is equal to the cardinality of the `Finset` that represents `s`. In other words, the counting measure simply counts the number of elements in the finite set `s`, which is exactly the same as the number of elements in the corresponding `Finset`.

For any finite and measurable set `s` in a measure space `α`, the counting measure of `s` equals its cardinality.


theorem disjoint_iSup_iff :
    ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] {a : α} {f : ι → α},
      Disjoint a (⨆ i, f i) ↔ ∀ (i : ι), Disjoint a (f i) :=
  by sorry

The theorem `disjoint_iSup_iff` states that for any type `α` with a frame order and a function `f` from some index type `ι` to `α`, an element `a` of `α` is disjoint with the supremum (⨆ i, f i) of `f` over all `i` if and only if `a` is disjoint with each element `f i` for every `i` in `ι`. Here, two elements of the lattice `α` are considered disjoint if their infimum is the bottom element.

An element of a frame-ordered type `α` is disjoint with the supremum of a function from an index type to `α` if and only if it is disjoint with each image under the function.


theorem CategoryTheory.Quotient.functor_map_eq_iff :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (r : HomRel C) [h : CategoryTheory.Congruence r]
      {X Y : C} (f f' : X ⟶ Y),
      (CategoryTheory.Quotient.functor r).map f = (CategoryTheory.Quotient.functor r).map f' ↔ r f f' :=
  by sorry

The theorem `CategoryTheory.Quotient.functor_map_eq_iff` states that for any category `C`, given a homotopy relation `r` on the hom-sets of `C` and two morphisms `f` and `f'` from `X` to `Y` in `C`, the images of `f` and `f'` under the quotient functor associated with `r` are equal if and only if `f` and `f'` are related by `r`. This means that the quotient functor respects the relation `r` in the sense that it identifies any two morphisms that are related by `r`.

For any category `C` and homotopy relation `r` on its hom-sets, the quotient functor identifies morphisms related by `r`.


theorem mul_nonneg_iff_of_pos_left :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {b c : α}, 0 < c → (0 ≤ c * b ↔ 0 ≤ b) := by sorry

This theorem states that for any type `α` which is a `LinearOrderedSemiring`, and for any instances `b` and `c` of this type, if `c` is greater than 0, then `c * b` is non-negative if and only if `b` is non-negative. Essentially, this is stating that in a linear ordered semiring, positive numbers preserve the non-negativity when they multiply other numbers.

In a LinearOrderedSemiring, for all `α`, `c` (with `c > 0`), `c * b` is non-negative if and only if `b` is non-negative.


theorem Real.continuousAt_rpow : ∀ (p : ℝ × ℝ), p.1 ≠ 0 ∨ 0 < p.2 → ContinuousAt (fun p => p.1 ^ p.2) p := by sorry

The theorem states that for any pair of real numbers `(p : ℝ × ℝ)`, as long as either the first element of the pair is not equal to zero or the second element of the pair is greater than zero, the function which raises the first element of the pair to the power of the second element, i.e., `(fun p => p.1 ^ p.2)`, is continuous at the point `p`. In mathematical terms, it means that as we approach the point `p`, the value of the function `(fun p => p.1 ^ p.2)` approaches the value at the point `p`.

For any real numbers `p`, if `p.1 ≠ 0` or `p.2 > 0`, then the function `x ↦ x.1 ^ x.2` is continuous at `x = p`.


theorem FreeMagma.hom_ext :
    ∀ {α : Type u} {β : Type v} [inst : Mul β] {f g : FreeMagma α →ₙ* β},
      ⇑f ∘ FreeMagma.of = ⇑g ∘ FreeMagma.of → f = g :=
  by sorry

This theorem, "FreeMagma.hom_ext", states that for any two types α and β-- where β is a multiplication structure-- given any two functions `f` and `g` from the free magma of α to β, if the application of `f` after the "FreeMagma.of" function equals the application of `g` after the "FreeMagma.of" function, then `f` and `g` must be the same function. This theorem is a statement about function extensionality in the context of free magmas: two homomorphisms from a free magma to another structure are equal if they agree on the generator of the free magma.

In the context of free magmas, two functions from a free magma to a multiplication structure are equal if they map the same elements to the same image under the "FreeMagma.of" function.


theorem Ordinal.nmul_nadd_lt :
    ∀ {a b a' b' : Ordinal.{u}},
      a' < a →
        b' < b →
          Ordinal.nadd (Ordinal.nmul a' b) (Ordinal.nmul a b') < Ordinal.nadd (Ordinal.nmul a b) (Ordinal.nmul a' b') :=
  by sorry

This theorem states that for any four ordinals `a`, `b`, `a'`, and `b'`, where `a'` is less than `a` and `b'` is less than `b`, the ordinal resulting from performing a "natural addition" (also known as the Hessenberg sum) on the "natural multiplications" of `a'` and `b` and of `a` and `b'` is less than the ordinal resulting from the "natural addition" of the "natural multiplications" of `a` and `b` and of `a'` and `b'`.

For any ordinals `a`, `b`, `a'`, and `b'` with `a' < a` and `b' < b`, we have `(a' * b) + (a * b')` < `(a * b) + (a' * b')`.


MulLECancellable.Injective

theorem MulLECancellable.Injective :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : PartialOrder α] {a : α},
      MulLECancellable a → Function.Injective fun x => a * x :=
  by sorry

The theorem `MulLECancellable.Injective` states that for every type `α` that supports multiplication and has a partial order, and for any element `a` of that type, if `a` is `MulLECancellable` (meaning the function from `x` to `a * x` is order-reflecting), then the function that multiplies by `a` is injective (in other words, if `a * x = a * y` then `x = y`).

If `α` is a type with multiplication and a partial order, and `a` in `α` is `MulLECancellable`, then the multiplication-by-`a` function is injective.


theorem SlashAction.neg_slash :
    ∀ {β : Type u_1} {G : Type u_2} {α : Type u_3} {γ : Type u_4} [inst : Group G] [inst_1 : AddGroup α]
      [inst_2 : SMul γ α] [inst_3 : SlashAction β G α γ] (k : β) (g : G) (a : α),
      SlashAction.map γ k g (-a) = -SlashAction.map γ k g a :=
  by sorry

This theorem, `SlashAction.neg_slash`, states that for any types `β`, `G`, `α`, and `γ`, given `G` is a Group, `α` is an AddGroup, and multiplication between `γ` and `α` is defined, and given a `SlashAction` is defined between `β`, `G`, `α`, and `γ`, for any elements `k` from `β`, `g` from `G`, and `a` from `α`, the map of `SlashAction` applied to `k`, `g`, and the negation of `a`, equals the negation of the map of `SlashAction` applied to `k`, `g`, and `a`. In other words, the `SlashAction` map respects the negation operation from the `AddGroup` structure.

For any SlashAction of types `β`, `G`, `α`, and `γ` with `G` being a Group, `α` an AddGroup, and multiplication between `γ` and `α` defined, the map of SlashAction applied to `k` from `β`, `g` from `G`, and the negation of `a` from `α`, equals the negation of the map of SlashAction applied to `k`, `g`, and `a`.


theorem PowerBasis.degree_minpolyGen :
    ∀ {S : Type u_2} [inst : Ring S] {A : Type u_4} [inst_1 : CommRing A] [inst_2 : Algebra A S] [inst_3 : Nontrivial A]
      (pb : PowerBasis A S), Polynomial.degree (PowerBasis.minpolyGen pb) = ↑pb.dim :=
  by sorry

The theorem `PowerBasis.degree_minpolyGen` states that for any power basis `pb` over a commutative ring `A` and a ring `S`, where `A` has an algebra structure over `S` and `A` is nontrivial, the degree of the minimal polynomial of the generator of the power basis `pb` is equal to the dimension of the power basis `pb`. In other words, the highest power of `X` that appears in the minimal polynomial of the generator of the power basis is exactly the dimension of the power basis.

For any power basis `pb` over a commutative ring `A` with an algebra structure over a nontrivial ring `S`, the degree of the minimal polynomial of `pb`'s generator equals the dimension of `pb`.


AddSubgroup.Normal.comap

theorem AddSubgroup.Normal.comap :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {H : AddSubgroup N},
      AddSubgroup.Normal H → ∀ (f : G →+ N), AddSubgroup.Normal (AddSubgroup.comap f H) :=
  by sorry

The theorem `AddSubgroup.Normal.comap` states that for any two types `G` and `N` where both `G` and `N` are additive groups, and for any additive subgroup `H` of `N` that is normal, for any additive monoid homomorphism `f` from `G` to `N`, the preimage of `H` under `f`, which is an additive subgroup of `G`, is also normal. In other words, the preimage of a normal subgroup under an additive monoid homomorphism is still a normal subgroup.

If `G` and `N` are additive groups, `H` is a normal additive subgroup of `N`, and `f` is an additive monoid homomorphism from `G` to `N`, then the preimage of `H` under `f` is a normal additive subgroup of `G`.


theorem Matrix.dotProduct_assoc :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : NonUnitalSemiring α]
      (u : m → α) (w : n → α) (v : Matrix m n α),
      Matrix.dotProduct (fun j => Matrix.dotProduct u fun i => v i j) w =
        Matrix.dotProduct u fun i => Matrix.dotProduct (v i) w :=
  by sorry

The theorem `Matrix.dotProduct_assoc` states that for any types `m`, `n`, and `α` (where `α` is a non-unital semiring and `m` and `n` are finite), and any functions `u : m → α`, `w : n → α`, and `v : Matrix m n α`, the associative law of the dot product of matrices holds. In other words, you can change the order of operations in a nested dot product without changing the result. The mathematical notation would look like this:

Given vectors `u ∈ α^m`, `w ∈ α^n` and matrix `v ∈ α^(m×n)`, the dot product of `u` with the matrix-vector product `v·w` (where each entry of `v·w` is the dot product of a row of `v` with `w`) is equal to the dot product of `w` with the matrix-vector product `u·v` (where each entry of `u·v` is the dot product of `u` with a column of `v`).

In symbols:
`u · (v·w) = (u·v) · w`

For any non-unital semiring α and finite dimensions m and n, the dot product of a vector with the matrix-vector product of a matrix and another vector is equal to the matrix-vector product of the vector with the transpose of the original matrix and the second vector. In other words, `u · (v · w) = (u · v) · w`, where u is a vector in α^m, v is a matrix in α^(m×n), and w is a vector in α^n.


/-- **Alias** of `Summable.of_nat_of_neg`. -/
theorem summable_int_of_summable_nat :
    ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G] {f : ℤ → G},
      (Summable fun n => f ↑n) → (Summable fun n => f (-↑n)) → Summable f :=
  by sorry

The theorem `summable_int_of_summable_nat` states that for any function `f` from the integers to a topological additive group `G`, if the function `f` summed over the natural numbers is summable and the function `f` summed over the negative natural numbers is also summable, then the function `f` summed over all integers is summable. Here, summability means that there exists a limit to the infinite sum of the sequence produced by the function.

If a function from integers to a topological additive group is summable over natural numbers and negative natural numbers, then it is summable over all integers.


theorem Cardinal.mk_iUnion_le :
    ∀ {α ι : Type u} (f : ι → Set α), Cardinal.mk ↑(⋃ i, f i) ≤ Cardinal.mk ι * ⨆ i, Cardinal.mk ↑(f i) := by sorry

This theorem states that for any types `α` and `ι`, and for any function `f` that takes an element of type `ι` and returns a set of elements of type `α`, the cardinality (or size) of the union of all sets `f i` (for all `i` in `ι`) is less than or equal to the product of the cardinality of `ι` and the supremum of the cardinalities of all the sets `f i`. In simpler words, it's saying that the total number of unique elements in all the sets can't be more than the number of sets times the size of the biggest set.

For any function from a type `ι` to sets of type `α`, the cardinality of the union of all images is less than or equal to the cardinality of `ι` times the supremum of the cardinalities of the images.


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

This theorem states that in the context of category theory, given categories `C`, `D`, and `E`, and functors `F` from `C` to `D` and `G` from `D` to `E`, if the functor `F` is final and the composition of functors `F` and `G` is also final, then the functor `G` is final. In other words, if morphisms from any object to the object transformed by `F` and the composition of `F` and `G` determine a unique morphism, then morphisms from any object to the object transformed by `G` also determine a unique morphism.

If functors `F: C -> D` and `G: D -> E` have the property that `F` is final and the composite `G ∘ F` is final, then `G` is final.


theorem Hyperreal.infinitesimal_neg : ∀ {x : ℝ*}, Hyperreal.Infinitesimal (-x) ↔ Hyperreal.Infinitesimal x := by sorry

The theorem `Hyperreal.infinitesimal_neg` states that for any hyperreal number 'x', 'x' is infinitesimal if and only if '-x' is infinitesimal. In other words, a hyperreal number is infinitesimal if its negation is also infinitesimal, and if a hyperreal number is infinitesimal, then its negation must also be infinitesimal. This mirrors the concept in mathematics where a real number is close to zero if and only if its negation is close to zero.

For any hyperreal number x, x is infinitesimal if and only if -x is infinitesimal.


theorem Finset.sum_disj_sum :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : AddCommMonoid β] (s : Finset α) (t : Finset γ)
      (f : α ⊕ γ → β),
      (Finset.sum (Finset.disjSum s t) fun x => f x) =
        (Finset.sum s fun x => f (Sum.inl x)) + Finset.sum t fun x => f (Sum.inr x) :=
  by sorry

The theorem `Finset.sum_disj_sum` states that for any two finite sets `s` and `t` with elements of types `α` and `γ` respectively, and any function `f` from the disjoint union of `α` and `γ` to a type `β` which is equipped with an additive commutative monoid structure, the sum of `f` over the disjoint union of `s` and `t` is equal to the sum of `f` over `s` (where each element is included in the left part of the union) plus the sum of `f` over `t` (where each element is included in the right part of the union).

For any finite sets `s` and `t` and additive commutative monoid-valued function `f` on their disjoint union, the sum of `f` over the union equals the sum over `s` plus the sum over `t`.


theorem Subgroup.index_bot : ∀ {G : Type u_1} [inst : Group G], Subgroup.index ⊥ = Nat.card G := by sorry

This theorem states that for any given group `G`, the index of the trivial subgroup (denoted as `⊥`) is equal to the cardinality of the group `G`. In mathematical terms, for a group `G`, the number of left cosets of the trivial subgroup in `G` (which is the index of this subgroup), is equal to the number of elements in `G`. Note that the cardinality of a group is the number of elements in the group and here it's represented as a natural number using `Nat.card`. If the group `G` is infinite, both the index of the trivial subgroup and the cardinality of the group `G` would be zero, as per the definitions.

The index of the trivial subgroup in a group equals its cardinality. (If the group is infinite, both are zero.)


theorem Set.Ioc_subset_Ioo_right :
    ∀ {α : Type u_1} [inst : Preorder α] {a b₁ b₂ : α}, b₁ < b₂ → Set.Ioc a b₁ ⊆ Set.Ioo a b₂ := by sorry

The theorem `Set.Ioc_subset_Ioo_right` states that for any type `α` equipped with a preorder, and for any three elements `a`, `b₁`, and `b₂` of that type, if `b₁` is less than `b₂`, then the left-open right-closed interval from `a` to `b₁` (denoted `Set.Ioc a b₁`) is a subset of the left-open right-open interval from `a` to `b₂` (denoted `Set.Ioo a b₂`). In other words, if `b₁` is strictly less than `b₂`, any element `x` that is strictly greater than `a` and less than or equal to `b₁` is also strictly less than `b₂`.

For any type equipped with a preorder, if `a` is in the left-open right-closed interval `[a, b₁]` and `b₁` is strictly less than `b₂`, then `a` is also in the left-open right-open interval `[a, b₂]`.


theorem Irrational.of_rat_mul : ∀ (q : ℚ) {x : ℝ}, Irrational (↑q * x) → Irrational x := by sorry

This theorem states that for any rational number `q` and any real number `x`, if the product of the rational `q` and the real `x` (denoted by `↑q * x`) is an irrational number, then `x` must also be an irrational number. In other words, it establishes that the property of being irrational is preserved under multiplication by a rational number.

If a rational number times a real number results in an irrational number, then the real number is irrational.


theorem Nat.coprime_one_right : ∀ (n : ℕ), Nat.Coprime n 1 := by sorry

This theorem states that for every natural number `n`, `n` and `1` are coprime. The term "coprime" means that the greatest common divisor (gcd) of the two numbers is `1`. In other words, any natural number `n` shares no other common divisor with `1` except `1` itself.

For every natural number `n`, `gcd(n, 1) = 1`.


theorem inf_eq_min : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, a ⊓ b = min a b := by sorry

This theorem, `inf_eq_min`, states that for any type `α` which forms a linear order `inst`, the infimum (greatest lower bound) of any two elements `a` and `b` of type `α` is equal to the minimum of `a` and `b`. This essentially says that within a linear order, the concept of the infimum and the minimum of two elements coincide.

For any linear ordered type `α`, the infimum of `a` and `b` equals the minimum of `a` and `b`.


theorem Matrix.UnitaryGroup.toLin'_one :
    ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α],
      Matrix.UnitaryGroup.toLin' 1 = LinearMap.id :=
  by sorry

The theorem `Matrix.UnitaryGroup.toLin'_one` states that for any type `n` with decidable equality and finiteness, and for any commutative ring with a star operation `α`, the linear map corresponding to the matrix multiplication by the identity element of the unitary group (as defined by `Matrix.UnitaryGroup.toLin' 1`) is the same as the identity linear map (`LinearMap.id`). In other words, this theorem guarantees that applying the matrix multiplication by the identity matrix to vectors is equivalent to performing the identity operation on those vectors, preserving their values.

The theorem asserts that the linear map represented by the identity matrix in the unitary group of a commutative ring with a star operation, as defined in Lean, is equal to the identity linear map.


theorem isOpen_connectedComponent :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LocallyConnectedSpace α] {x : α},
      IsOpen (connectedComponent x) :=
  by sorry

The theorem `isOpen_connectedComponent` states that for any type `α` that is equipped with a topological space structure and a locally connected space structure, and for any point `x` of type `α`, the connected component of `x` is open in the ambient topological space. Here, the connected component of `x` is defined as the union of all preconnected sets containing `x`, and a set is considered open in a topological space if it belongs to the collection of open sets which defines the topology. This theorem is fundamental in the study of topological spaces and their properties.

For any topological space $(X,\tau)$ with a locally connected subspace structure, the connected component of a point $x\in X$ is an open set in $X$.


theorem Ideal.isCoprime_iff_add : ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J ↔ I + J = 1 :=
  by sorry

This theorem states that for any commutative semiring `R` and any two ideals `I` and `J` in `R`, `I` and `J` are coprime if and only if the sum of `I` and `J` equals 1. In mathematical terms, two ideals `I` and `J` in a commutative semiring `R` are considered coprime if there exist elements `a` and `b` such that `a * I + b * J = 1`. This theorem provides an equivalence between this definition of coprimeness and the property that the sum of the two ideals is 1.

In a commutative semiring, two ideals are coprime if and only if their sum equals the identity element.


theorem unitInterval.symm_one : unitInterval.symm 1 = 0 := by sorry

The theorem `unitInterval.symm_one` states that the central symmetry function of the unit interval, when applied to the endpoint 1, yields the opposite endpoint 0. In other words, the symmetry function reflects the unit interval about its center, and hence mapping 1 to 0.

The central symmetry function of the unit interval maps 1 to 0.


theorem EReal.preimage_coe_Ioi_bot : Real.toEReal ⁻¹' Set.Ioi ⊥ = Set.univ := by sorry

This theorem states that the preimage through the canonical inclusion map from real numbers to extended real numbers of the left-open right-infinite interval starting at the bottom (negative infinity) is the universal set of real numbers. In other words, every real number is mapped to an extended real number greater than negative infinity.

The canonical inclusion map from the real numbers to extended real numbers maps every real number to an extended real number greater than negative infinity.


theorem Mathlib.Topology.Order.PartialSups._auxLemma.2 :
    ∀ {ι : Type u_2} {π : ι → Type u_3} [inst : (i : ι) → SemilatticeSup (π i)] (f : ℕ → (i : ι) → π i) (n : ℕ) (i : ι),
      (partialSups fun x => f x i) n = (partialSups f) n i :=
  by sorry

The theorem, `Mathlib.Topology.Order.PartialSups._auxLemma.2`, states that for any type `ι`, any function `π` from `ι` to another type, and any function `f` from natural numbers to `π i` (where `i` is an instance of `ι`), the value of the partial supremum of `f` at index `n` for any given `i` is equal to the value at index `n` of the partial supremum of `f` for the same `i`. In other words, the partial supremum function commutes with the function `f`.

For any type `ι`, function `π` from `ι` to another type, and function `f` from natural numbers to `π i`, the partial supremum of `f` at index `n` is equal to the value of the partial supremum of `f` at index `n` for the same `i`.


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

This theorem states that in category theory, if we have categories C, D and E, with functors F from C to D and G from D to E, and if F and G are initial functors, then the composition of F and G (F followed by G) is also an initial functor. An initial functor is one that maps from an initial category, which is a category with exactly one morphism from each object to any other object.

If functors F from C to D and G from D to E are both initial functors with C being an initial category, then the composition F ∘ G is also an initial functor from C to E.


theorem IsGLB.biUnion_Ioi_eq :
    ∀ {α : Type v} [inst : LinearOrder α] {s : Set α} {a : α}, IsGLB s a → ⋃ x ∈ s, Set.Ioi x = Set.Ioi a := by sorry

This theorem states that for any type `α` that has a linear order structure, and for any set `s` of elements of type `α` and any element `a` of the same type, if `a` is a greatest lower bound of set `s`, then the union of all open intervals greater than each element `x` in the set `s` is equivalent to the open interval of all elements greater than `a`. In mathematical notation, for all `x` in `s`, the union of `(x, ∞)` equals to `(a, ∞)` if `a` is the greatest lower bound of `s`.

For any linearly ordered type `α` and set `s` of elements from `α` with greatest lower bound `a`, the union of all open intervals `(x, ∞)` for `x` in `s` equals the open interval `(a, ∞)`.


theorem segment_subset_Icc :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : OrderedAddCommMonoid E] [inst_2 : Module 𝕜 E]
      [inst_3 : OrderedSMul 𝕜 E] {x y : E}, x ≤ y → segment 𝕜 x y ⊆ Set.Icc x y :=
  by sorry

The theorem `segment_subset_Icc` asserts that for any ordered semiring `𝕜`, any ordered additively commutative monoid `E`, any module `E` over `𝕜`, and any ordered scalar multiplication of `𝕜` and `E`, if `x` and `y` are elements of `E` where `x` is less than or equal to `y`, then the segment from `x` to `y` is a subset of the closed interval `[x, y]`. In simpler terms, the line segment in a vector space from `x` to `y` is contained within the inclusive interval from `x` to `y`, assuming `x` and `y` are ordered such that `x` is less than or equal to `y`.

For any ordered semiring 𝕜, ordered additively commutative monoid E with an ordered scalar multiplication, and module E over 𝕜, if x ≤ y in E, then the segment from x to y (inclusive) is contained in the closed interval [x, y].


theorem MulAction.stabilizer_coe_finset :
    ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : DecidableEq α] (s : Finset α),
      MulAction.stabilizer G ↑s = MulAction.stabilizer G s :=
  by sorry

This theorem, `MulAction.stabilizer_coe_finset`, states that for any given finset `s` of a type `α` and a group `G` with a multiplicative action on `α`, if `α` has decidable equality, then the stabilizer of the co-domain of `s` under the group action is equal to the stabilizer of `s` itself under the same action. In other words, if `G` acts on `α` and `s` is a finite subset of `α`, the subgroup of elements in `G` that leave both `s` and its co-domain invariant under the action is the same. Here, `MulAction.stabilizer G a` is the subgroup of `G` that keeps an element `a` fixed under the action of `G`.

For a finset `s` of type `α` and a multiplicative group `G` acting on `α` with decidable equality, the stabilizer of `s` and the stabilizer of its co-domain under `G` are equal.


theorem Ordinal.div_zero : ∀ (a : Ordinal.{u_4}), a / 0 = 0 := by sorry

The theorem `Ordinal.div_zero` states that for any `Ordinal` `a`, the division of `a` by zero is zero. In other words, when any ordinal number is divided by zero, the result is always zero. This is a fundamental property of ordinal numbers in the context of division operations.

For any ordinal number `a`, `a / zero = zero`.


theorem Int.gc_coe_floor :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], GaloisConnection Int.cast Int.floor := by
  sorry

This theorem states that for any type `α`, if `α` is a `LinearOrderedRing` and a `FloorRing`, then there exists a Galois connection between the function `Int.cast` and `Int.floor`. In other words, the function `Int.cast`, which casts integers to type `α`, and the function `Int.floor`, which maps a number in `α` to the greatest integer less than or equal to it, form a pair of functions that satisfy the property of a Galois connection: for any integer `a` and any number `b` of type `α`, `Int.cast a ≤ b` if and only if `a ≤ Int.floor b`.

For any LinearOrderedRing and FloorRing type `α`, the functions `Int.cast` and `Int.floor` form a Galois connection between the integers and `α`, meaning `Int.cast a ≤ b` if and only if `a ≤ Int.floor b`.


/-- The characteristic of a finite ring cannot be zero.  -/
theorem CharP.char_ne_zero_of_finite :
    ∀ (R : Type u_1) [inst : NonAssocRing R] (p : ℕ) [inst : CharP R p] [inst : Finite R], p ≠ 0 := by sorry

This theorem states that the characteristic of a finite non-associative ring cannot be zero. In other words, for any finite non-associative ring R with characteristic p, it ensures that p cannot be zero. Here, a ring's characteristic is defined as the smallest positive integer for which the repeated addition of 1 (n times) gives 0 in the ring; for a finite ring, this characteristic must be a positive integer.

A finite non-associative ring has non-zero characteristic.


theorem nhdsWithin_Ioo_eq_nhdsWithin_Iio :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIicTopology α] {a b : α},
      a < b → nhdsWithin b (Set.Ioo a b) = nhdsWithin b (Set.Iio b) :=
  by sorry

This theorem states that for any type `α` that is a topological space, a linear order, and has a topology closed to the left (inclusive), if `a` and `b` are elements of `α` such that `a` is less than `b`, then the neighborhood within the open interval `(a, b)` at point `b` is equal to the neighborhood within the left-infinite open interval `(-∞, b)` at point `b`. In other words, the sets of neighborhoods of `b` that intersect with `(a, b)` and `(-∞, b)` respectively are the same when `a < b`.

For any topological space and linear order `α` with `a < b` in `α`, the neighborhood filters of `b` in the open intervals `(a, b)` and `(-\infty, b)` coincide.


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

This theorem states that for any type `α` and `β` with `β` being a commutative monoid, given a finite set `s` of type `α` and a function `f` mapping `α` to `β`, if for an element `a` in `s` the function `f` maps all other elements `b` in `s` to the identity element of the monoid (i.e., `1`), then the product of `f x` as `x` ranges over all elements of the set `s` (denoted as `Finset.prod s fun x => f x`) is equal to `f a`.

If `f : α → β` maps all elements in a finite set `s ⊆ α` except one to the identity element of a commutative monoid `β`, then `Finset.prod s fun x => f x = f (some x in s)`.


/-- At `-n` for `n ∈ ℕ`, the Gamma function is undefined; by convention we assign it the value 0.  -/
theorem Complex.Gamma_neg_nat_eq_zero : ∀ (n : ℕ), Complex.Gamma (-↑n) = 0 := by sorry

This theorem states that for any natural number `n`, the Gamma function of the negative of `n` (i.e., `-n`) is undefined, and by convention, we assign it the value of 0. In mathematical terms, it is saying that for all `n` in the set of natural numbers ℕ, the Gamma function Γ(-n) equals 0.

For all natural numbers `n`, the Gamma function Γ(-`n`) is undefined and is conventionally assigned the value 0.


theorem Asymptotics.isLittleO_iff_nat_mul_le_aux :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α},
      ((∀ (x : α), 0 ≤ ‖f x‖) ∨ ∀ (x : α), 0 ≤ ‖g x‖) → (f =o[l] g ↔ ∀ (n : ℕ), ∀ᶠ (x : α) in l, ↑n * ‖f x‖ ≤ ‖g x‖) :=
  by sorry

This theorem states that for all types `α`, `E`, and `F`, given a norm instance for `E` and `F`, and functions `f : α → E` and `g : α → F` with a specific filter `l`, either every `x` in `α` satisfies that the norm of `f(x)` is greater than or equal to 0 or every `x` in `α` satisfies that the norm of `g(x)` is greater than or equal to 0. If this is the case, then `f` is little-o of `g` with respect to filter `l` if and only if for every natural number `n`, eventually for every `x` in `α` in filter `l`, `n` times the norm of `f(x)` is less than or equal to the norm of `g(x)`. In the context of asymptotics, this theorem provides a characterization of the little-o notation in terms of the inequality involving the norms of functions `f` and `g`.

For types `α`, `E`, and `F` with norm instances, given functions `f : α → E` and `g : α → F`, and filter `l`, if for all `x` in `α` in `l`, either the norm of `f(x)` ≥ 0 or the norm of `g(x)` ≥ 0, then `f` is little-o of `g` with respect to `l` if and only if for all natural `n`, eventually for all `x` in `α` in `l`, `n·‖f(x)‖≤‖g(x)‖`.


theorem IsLindelof.compl_mem_coLindelof :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsLindelof s → sᶜ ∈ Filter.coLindelof X := by sorry

The theorem `IsLindelof.compl_mem_coLindelof` states that for any type `X` equipped with a topological space structure and any set `s` of type `X`, if `s` is a Lindelöf set (meaning that every nontrivial filter `f` with the countable intersection property that contains `s`, has a cluster point in `s`), then the complement of `s` is a member of the coLindelöf filter of `X`. The coLindelöf filter of `X` is defined as the filter generated by complements of all Lindelöf sets in `X`.

If a set `s` in a topological space `X` is Lindelöf, then the complement of `s` belongs to the filter generated by the complements of all Lindelöf sets in `X`.


theorem CategoryTheory.Subobject.inf_le_right :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A : C}
      (f g : CategoryTheory.Subobject A), (CategoryTheory.Subobject.inf.obj f).obj g ≤ g :=
  by sorry

The theorem `CategoryTheory.Subobject.inf_le_right` states that for any category `C` with pullbacks and any object `A` in `C`, for any two subobjects `f` and `g` of `A`, the infimum of `f` and `g` (where the infimum is computed using the "inf" functor from `Subobject A` to `Subobject A`) is less than or equal to `g`. This is a formalization of the universal property of the pullback in the category of subobjects of a given object in a category. In other words, when you compute the "greatest lower bound" or infimum of `f` and `g`, the result is a subobject that is "below" `g` in the partial order of subobjects of `A`.

For any category with pullbacks, the infimum of two subobjects of an object is less than or equal to the second subobject.


/-- Given an AddMonoidHom `f : M →+ N` and Submonoid `S ⊆ M` such that
`f(S) ⊆ AddUnits N`, for all `w, z : N` and `y ∈ S`, we have `z = w - f y ↔ z + f y = w`. -/
theorem AddSubmonoid.LocalizationMap.add_neg_right :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {f : M →+ N} (h : ∀ (y : ↥S), IsAddUnit (f ↑y)) (y : ↥S) (w z : N),
      z = w + ↑(-(IsAddUnit.liftRight (AddMonoidHom.restrict f S) h) y) ↔ z + f ↑y = w :=
  by sorry

This theorem states that for any additive commutative monoid `M`, a submonoid `S` of `M`, an additive commutative monoid `N`, and a monoid homomorphism `f` from `M` to `N` (written as `f : M →+ N`), such that the image of `S` under `f` lies within the additive units of `N`, the following holds: for any element `y` in `S` and any two elements `w` and `z` in `N`, `z` is equal to `w - f(y)` if and only if `z + f(y)` is equal to `w`.

In other words, one can switch between subtracting `f(y)` from `w` and adding `f(y)` to `z` without changing the equality. This theorem is a variant of the basic property of addition and subtraction in the context of additive units and homomorphisms.

For any additive commutative monoids M, N, monoid homomorphism f : M ->+ N with image of a submonoid S of M in additive units of N, if y is in S and w, z are in N with w = z + f(y), then w = z - f(y).


theorem Mathlib.ModelTheory.Semantics._auxLemma.45 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'}
      {t₁ t₂ : FirstOrder.Language.Term L α} {x : α → M},
      FirstOrder.Language.Formula.Realize (FirstOrder.Language.Term.equal t₁ t₂) x =
        (FirstOrder.Language.Term.realize x t₁ = FirstOrder.Language.Term.realize x t₂) :=
  by sorry

The theorem `Mathlib.ModelTheory.Semantics._auxLemma.45` states that for any first-order language `L`, any type `M` with a structure for `L`, and any type `α`, for any two terms `t₁` and `t₂` of the language `L` over `α` and any assignment `x` of values in `M` to variables in `α`, realizing the formula that expresses the equality of `t₁` and `t₂` under the assignment `x` is equivalent to the statement that the realization of `t₁` under `x` is equal to the realization of `t₂` under `x`. In other words, a formula expressing the equality of two terms is realized as true if and only if the two terms evaluate to the same value under the given variable assignment.

For any first-order language L, structure M for L, type α, terms t₁ and t₂ over α in L, and assignment x in M, the formula expressing the equality of t₁ and t₂ under x is true if and only if the realizations of t₁ and t₂ under x are equal.


theorem hasSum_lt :
    ∀ {ι : Type u_1} {α : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] [inst_3 : OrderClosedTopology α] {f g : ι → α} {a₁ a₂ : α} {i : ι},
      f ≤ g → f i < g i → HasSum f a₁ → HasSum g a₂ → a₁ < a₂ :=
  by sorry

This theorem states that for any types `ι` and `α`, where `α` is an ordered additive commutative group, a topological space, a topological additive group, and has an order-closed topology, if there are two functions `f` and `g` from `ι` to `α`, and two elements `a₁` and `a₂` of `α`, and an element `i` of `ι`, then if `f` is less than or equal to `g` everywhere, and `f` is strictly less than `g` at some point `i`, and if the sum of `f` is `a₁` and the sum of `g` is `a₂`, then `a₁` must be strictly less than `a₂`.

If `f` and `g` are functions from a type `ι` to an ordered additive commutative group `α` with order-closed topology, and `f ≤ g` everywhere, `f(i) < g(i)` for some `i`, and the sums of `f` and `g` are `a₁` and `a₂` respectively, then `a₁ < a₂`.


theorem Mathlib.ModelTheory.Semantics._auxLemma.22 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {θ : FirstOrder.Language.BoundedFormula L α (Nat.succ l)} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.ex θ) v xs =
        ∃ a, FirstOrder.Language.BoundedFormula.Realize θ v (Fin.snoc xs a) :=
  by sorry

This theorem in the Model Theory of First-Order Languages states that, for any first-order language `L`, any structure `M` of `L`, any type `α`, any natural number `l`, any bounded formula `θ` of `L` with `l + 1` variables, any function `v` from `α` to `M`, and any function `xs` from the first `l` natural numbers to `M`, the bounded formula obtained by prefixing `θ` with an existential quantifier is true under the realization function `v` and `xs` if and only if there exists an element `a` in `M` such that the original formula `θ` is true under `v` and the function obtained by extending `xs` with `a` at the last position.

In simpler terms, it states that an existential quantification in a first-order language corresponds to the existence of some element that makes the original formula true.

For any first-order language L, structure M, type α, natural number l, bounded formula θ of L with l + 1 variables, function v from α to M, and function xs from the first l natural numbers to M, the existential quantification of θ is true under realizations v and xs if and only if there exists an element a in M making θ true under v and xs extended with a.


theorem Polynomial.Monic.degree_le_zero_iff_eq_one :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.Monic p → (Polynomial.degree p ≤ 0 ↔ p = 1) := by
  sorry

The theorem `Polynomial.Monic.degree_le_zero_iff_eq_one` states that for any polynomial `p` over a semiring `R`, if `p` is a monic polynomial (i.e., its leading coefficient is 1), then the degree of `p` is less than or equal to 0 if and only if `p` is equal to 1. In other words, for a monic polynomial, having a degree that is zero or negative is equivalent to it being the polynomial 1.

A monic polynomial over a semiring has degree less than or equal to 0 if and only if it equals the constant polynomial 1.


theorem IsCompact.prod_nhdsSet_eq_biSup :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace Y] {K : Set Y},
      IsCompact K → ∀ (l : Filter X), l ×ˢ nhdsSet K = ⨆ y ∈ K, l ×ˢ nhds y :=
  by sorry

This theorem states that for all given types `X` and `Y` with `Y` a topological space and `K` a compact set in `Y`, and for any filter `l` on `X`, the product of the filter `l` and the filter of neighborhoods of the set `K` is equivalent to the supremum over all elements `y` in `K` of the product of the filter `l` and the filter of neighborhoods of `y`. In other words, the set of neighborhoods of a compact set is equivalent to the union of the set of neighborhoods of each of its points when considered in conjunction with a particular filter on another space.

For any compact set K in a topological space Y and filter l on X, the product filter of l and the filter of neighborhoods of K is equal to the supremum of the product of l and the filter of neighborhoods of each point in K.


/-- `s`, coerced to a type, is a nontrivial type if and only if `s` is a nontrivial set.  -/
theorem Set.nontrivial_coe_sort : ∀ {α : Type u} {s : Set α}, Nontrivial ↑s ↔ Set.Nontrivial s := by sorry

The theorem `Set.nontrivial_coe_sort` states that for any type `α` and a set `s` of type `α`, `s` is a nontrivial type if and only if `s` is a nontrivial set. In other words, the set `s` is considered nontrivial (having at least two distinct elements) as a type if and only if it is nontrivial in the set sense.

The theorem `Set.nontrivial_coe_sort` asserts that a type `α`'s set instance `s : α` is nontrivial as a type if and only if `s` is a nontrivial set.


theorem Asymptotics.IsBigO.trans_tendsto :
    ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E'']
      [inst_1 : NormedAddCommGroup F''] {f'' : α → E''} {g'' : α → F''} {l : Filter α},
      f'' =O[l] g'' → Filter.Tendsto g'' l (nhds 0) → Filter.Tendsto f'' l (nhds 0) :=
  by sorry

The theorem `Asymptotics.IsBigO.trans_tendsto` states that for any types `α`, `E''`, and `F''`, where `E''` and `F''` are normed additively commutative groups, if a function `f''` from `α` to `E''` is dominated by another function `g''` from `α` to `F''` (i.e., `f''` is Big-O of `g''`) at a filter `l`, and if the function `g''` tends to 0 at `l` (i.e., for every neighborhood of 0, the preimage of that neighborhood under `g''` is a neighborhood at `l`), then the function `f''` also tends to 0 at `l`. In other words, if `f''` is asymptotically smaller than `g''` and `g''` tends to zero, then `f''` must also tend to zero.

If a function `f''` is Big-O of another function `g''` at a filter `l` and `g''` tends to 0 at `l`, then `f''` tends to 0 at `l` (in the context of normed additively commutative groups).


theorem LowerSemicontinuous.lowerSemicontinuousWithinAt :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : Preorder β] {f : α → β},
      LowerSemicontinuous f → ∀ (s : Set α) (x : α), LowerSemicontinuousWithinAt f s x :=
  by sorry

The theorem `LowerSemicontinuous.lowerSemicontinuousWithinAt` states that for any type `α` with a topological space structure, any type `β` with a preorder structure, and any function `f` from `α` to `β`, if the function `f` is lower semicontinuous, then for any set `s` of type `α` and any element `x` of type `α`, `f` is lower semicontinuous at `x` within the set `s`. In more mathematical terms, if for any `ε > 0`, for all `x'` sufficiently close to `x`, `f(x')` is at least `f(x) - ε`, then this property still holds when we restrict our attention to `x'` values within a certain set `s`.

If `f` is a lower semicontinuous function from a topological space `α` to a preordered type `β`, then for any set `s` and any point `x` in `α`, `f` is lower semicontinuous at `x` within `s`, i.e., for every `ε > 0`, there exists a neighborhood `N` of `x` in `s` such that for all `x'` in `N`, `f(x') ≥ f(x) - ε`.


theorem ENNReal.le_of_forall_nnreal_lt : ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r < x → ↑r ≤ y) → x ≤ y := by sorry

The theorem `ENNReal.le_of_forall_nnreal_lt` states that for all extended nonnegative real numbers `x` and `y`, if for every nonnegative real number `r`, `r` is less than `x` implies that `r` is less than or equal to `y`, then `x` is less than or equal to `y`. In other words, if `x` is always greater than any given nonnegative real number that `y` is not less than, then `x` is at least as large as `y`.

If for all nonnegative real numbers r, r < x implies r <= y, then x <= y.


theorem PSet.equiv_iff :
    ∀ {x : PSet} {y : PSet},
      PSet.Equiv x y ↔
        (∀ (i : PSet.Type x), ∃ j, PSet.Equiv (PSet.Func x i) (PSet.Func y j)) ∧
          ∀ (j : PSet.Type y), ∃ i, PSet.Equiv (PSet.Func x i) (PSet.Func y j) :=
  by sorry

The theorem `PSet.equiv_iff` states that for any two pre-sets `x` and `y`, they are extensionally equivalent (denoted by `PSet.Equiv x y`) if and only if the following two conditions are met: Firstly, for every element `i` in the underlying type of the pre-set `x` (denoted by `PSet.Type x`), there exists an element `j` such that the pre-set derived from `x` at `i` (denoted by `PSet.Func x i`) is extensionally equivalent to the pre-set derived from `y` at `j` (denoted by `PSet.Func y j`). Secondly, for every element `j` in the underlying type of the pre-set `y` (denoted by `PSet.Type y`), there exists an element `i` such that the pre-set derived from `x` at `i` is extensionally equivalent to the pre-set derived from `y` at `j`. This theorem essentially sets up a bijective relationship between the elements of the underlying types of two extensionally equivalent pre-sets.

Two pre-sets are extensionally equivalent if and only if there exists a bijection between their underlying types such that the derived pre-sets at corresponding elements are extensionally equivalent.


theorem Ultrafilter.coe_map :
    ∀ {α : Type u} {β : Type v} (m : α → β) (f : Ultrafilter α), ↑(Ultrafilter.map m f) = Filter.map m ↑f := by sorry

This theorem states that for any function `m` from type `α` to type `β` and any ultrafilter `f` of type `α`, the result of mapping `m` over `f` and then casting it to a filter (`↑(Ultrafilter.map m f)`) is the same as first casting `f` to a filter and then mapping `m` over it (`Filter.map m ↑f`). In other words, it confirms that the operations of mapping a function over an ultrafilter and casting to a filter can be performed in either order without affecting the outcome.

For any function `m` and ultrafilter `f`, `Ultrafilter.map m (Ultrafilter.ofFilter (Filter.map m ( Filter.lift f )))` equals `Filter.map m f`.


theorem div_le_div_of_nonpos_of_le :
    ∀ {α : Type u_2} [inst : LinearOrderedField α] {a b c : α}, c ≤ 0 → b ≤ a → a / c ≤ b / c := by sorry

This theorem states that for any linearly ordered field `α`, and for any elements `a`, `b`, and `c` of `α`, if `c` is less than or equal to zero, and `b` is less than or equal to `a`, then the division of `a` by `c` is less than or equal to the division of `b` by `c`. In mathematical terms, if `c ≤ 0` and `b ≤ a`, then `a / c ≤ b / c`.

For any linearly ordered field `α` and elements `a`, `b`, `c` in `α` with `c ≤ 0` and `b ≤ a`, we have `a / c ≤ b / c`.


theorem AlgHom.fieldRange_le_normalClosure :
    ∀ {F : Type u_1} {K : Type u_2} {L : Type u_3} [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
      [inst_3 : Algebra F K] [inst_4 : Algebra F L] (f : K →ₐ[F] L), AlgHom.fieldRange f ≤ normalClosure F K L :=
  by sorry

The theorem `AlgHom.fieldRange_le_normalClosure` states that for any fields `F`, `K`, and `L` with `K` and `L` being algebraic extensions of `F`, and for any algebra homomorphism `f` from `K` to `L`, the range of `f` is contained within the normal closure of `K/F` in `L/F`. In other words, the set of all values that `f` can take in `L` (the field range of `f`) is a subset of the "largest" intermediate field that is normal and contains `K` (the normal closure of `K` over `F` in `L`).

For any field homomorphism f from a field K to a field L, where K and L are algebraic extensions of a base field F, the range of f is contained in the normal closure of K in L.


theorem Int.mul_ediv_cancel : ∀ (a : ℤ) {b : ℤ}, b ≠ 0 → a * b / b = a := by sorry

This theorem states that for any integer `a` and any non-zero integer `b`, the product of `a` and `b` divided by `b` equals `a`. In other words, when you multiply an integer by another integer and then divide the result by the same integer you multiplied with (which is not zero), you get back the original integer. This is a foundational property related to the cancellation law of multiplication and division in integer arithmetic.

For any integers `a` and `b` with `b ≠ 0`, we have `(a * b) / b = a`.


theorem Real.Gamma_one : Real.Gamma 1 = 1 := by sorry

This theorem states that the Gamma function of 1 (`Real.Gamma 1`) is equal to 1. In the context of real numbers, the Gamma function, denoted as Γ(s), is a special function that generalizes the factorial function. For this theorem, when the input to the Gamma function is 1, the output is also 1.

The Gamma function equals 1 for the input of 1, i.e., `Real.Gamma 1 = 1`.


theorem Set.IsWF.le_min_iff :
    ∀ {α : Type u_2} [inst : LinearOrder α] {s : Set α} {a : α} (hs : Set.IsWF s) (hn : Set.Nonempty s),
      a ≤ Set.IsWF.min hs hn ↔ ∀ b ∈ s, a ≤ b :=
  by sorry

This theorem states that for any set `s` of a given type `α`, where `α` is endowed with a linear order and `s` is both well-founded and non-empty, an element `a` of type `α` is less than or equal to the minimal element of `s` if and only if `a` is less than or equal to every element of `s`. In other words, if `s` is a set of elements with a certain order, and it's nonempty and well-founded (i.e., there is no infinite decreasing sequence of elements in `s`), then `a` being less than or equal to the smallest element in `s` is equivalent to `a` being less than or equal to all elements in `s`. This is a characterization of the minimum element in a well-founded and non-empty set with a linear order.

For any well-founded and non-empty set `s` with a linear order, an element `a` is the minimal element if and only if `a` is less than or equal to every element in `s`.


theorem variationOnFromTo.eq_neg_swap :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) (s : Set α)
      (a b : α), variationOnFromTo f s a b = -variationOnFromTo f s b a :=
  by sorry

The theorem `variationOnFromTo.eq_neg_swap` states that for any function `f` mapping from an arbitrary type `α` (with a linear order structure) to another type `E` (with a pseudo emetric space structure), and for any set `s` of elements of type `α`, and any two elements `a` and `b` of type `α`, the signed variation of the function `f` on the interval from `a` to `b` intersected with the set `s` is equal to the negative of the signed variation of `f` on the interval from `b` to `a` intersected with the same set `s`. This essentially reflects the concept that reversing the order of the interval endpoints changes the sign of the variation.

For any function `f` from a linearly ordered type `α` to a pseudo metric space `E`, and any set `s` and elements `a` and `b` in `α`, the signed variation of `f` on the interval `[a, b]` intersected with `s` equals the negative of the signed variation of `f` on the interval `[b, a]` intersected with `s`.


/-- Paste two pullback squares "horizontally" to obtain another pullback square.  -/
theorem CategoryTheory.IsPullback.paste_horiz :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X₁₁ X₁₂ X₁₃ X₂₁ X₂₂ X₂₃ : C} {h₁₁ : X₁₁ ⟶ X₁₂}
      {h₁₂ : X₁₂ ⟶ X₁₃} {h₂₁ : X₂₁ ⟶ X₂₂} {h₂₂ : X₂₂ ⟶ X₂₃} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₁₃ : X₁₃ ⟶ X₂₃},
      CategoryTheory.IsPullback h₁₁ v₁₁ v₁₂ h₂₁ →
        CategoryTheory.IsPullback h₁₂ v₁₂ v₁₃ h₂₂ →
          CategoryTheory.IsPullback (CategoryTheory.CategoryStruct.comp h₁₁ h₁₂) v₁₁ v₁₃
            (CategoryTheory.CategoryStruct.comp h₂₁ h₂₂) :=
  by sorry

This theorem states that in a category `C`, given two pairs of objects `(X₁₁, X₂₁)`, `(X₁₃, X₂₃)` and morphisms `h₁₁ : X₁₁ ⟶ X₁₂`, `h₁₂ : X₁₂ ⟶ X₁₃`, `h₂₁ : X₂₁ ⟶ X₂₂`, `h₂₂ : X₂₂ ⟶ X₂₃`, `v₁₁ : X₁₁ ⟶ X₂₁`, `v₁₂ : X₁₂ ⟶ X₂₂`, `v₁₃ : X₁₃ ⟶ X₂₃`. If we have pullback squares formed by `h₁₁, v₁₁, v₁₂, h₂₁` and `h₁₂, v₁₂, v₁₃, h₂₂`, then we can "paste" these two pullback squares "horizontally" to construct another pullback square. This new square is formed by the composite morphisms `h₁₁ ≫ h₁₂` and `h₂₁ ≫ h₂₂`, with `v₁₁` and `v₁₃` as the vertical morphisms.

Given pullback squares in a category with morphisms `h₁₁, h₁₂, h₂₁, h₂₂, v₁₁, v₁₂, v₁₃`, if the outer rectangle commutes, then the inner rectangle formed by composing the horizontal morphisms and using the vertical morphisms as the vertical morphisms in the new square, also forms a pullback square.


theorem ArithmeticFunction.ppow_apply :
    ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R} {k x : ℕ},
      0 < k → (ArithmeticFunction.ppow f k) x = f x ^ k :=
  by sorry

This theorem states that for any type `R` that forms a semiring, an arithmetic function `f` from natural numbers to `R`, and any two natural numbers `k` and `x` such that `k` is greater than 0, the application of the pointwise power function on `f` with exponent `k` to `x` is equal to the `k`th power of the application of `f` to `x`. In other words, the pointwise power function raises each output of the arithmetic function to the `k`th power.

For any semiring `R`, arithmetic function `f` from natural numbers to `R`, and natural numbers `k` > 0, the pointwise power of `f` with exponent `k` equals the `k`th power of the application of `f`: (ⁱⁱⁱf)(k)(x) = (ⁱⁱⁱf)(x)⁽ⁱk⁾ for all x ∈ ℕ.


theorem bit1_zero : ∀ {M : Type u} [inst : AddMonoid M] [inst_1 : One M], bit1 0 = 1 := by sorry

This theorem, named `bit1_zero`, states that for any type `M` that has an addition operation (satisfying the properties of a monoid) and a distinct element called `one`, the `bit1` function applied to zero yields `one`. The `bit1` function is defined as the operation of doubling a given value (using addition) and then adding one. Therefore, when `bit1` is applied to zero, the result is `one`.

For any monoid `M` with an element `one`, `bit1 0 = one`, where `bit1 x = x + x + 1`.


theorem Set.union_assoc : ∀ {α : Type u} (a b c : Set α), a ∪ b ∪ c = a ∪ (b ∪ c) := by sorry

The theorem `Set.union_assoc` states that for any type `α` and any three sets `a`, `b`, and `c` of type `α`, the union operation on sets is associative. In other words, taking the union of `a` with the union of `b` and `c` (`a ∪ (b ∪ c)`) is the same as taking the union of the union of `a` and `b` with `c` (`(a ∪ b) ∪ c`). This mirrors the associative property in algebra where the way in which operations are grouped does not change the result of the operation.

For any type `α` and sets `a`, `b`, and `c` of type `α`, the association of set union operations holds: `(a ∪ b) ∪ c` = `a ∪ (b ∪ c)`.


Collinear.coplanar

/-- Collinear points are coplanar.  -/
theorem Collinear.coplanar :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] {s : Set P}, Collinear k s → Coplanar k s :=
  by sorry

The theorem `Collinear.coplanar` states that for any division ring `k`, an additive commutative group `V`, a set of points `P` where `V` acts freely and transitively on `P` (a torsor under `V`), and a set `s` of elements from `P`, if the set `s` is collinear (i.e., the dimension of the vector span of `s` over `k` is at most `1`), then `s` is also coplanar (i.e., the dimension of the vector span of `s` over `k` is at most `2`). This statement reflects the geometric idea that any set of points lying on a straight line (collinear points) also lie within a plane (coplanar points).

If `s` is a set of points in a free and transitive action of an additive commutative group `V` over a division ring `k`, and `s` is collinear (i.e., the span of `s` over `k` has dimension at most 1), then `s` is coplanar (i.e., the span of `s` over `k` has dimension at most 2).


/-- An antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsInf` to the `Filter.limsup` of the image if the function is continuous at the `limsInf`
(and the filter is bounded from above and below).  -/
theorem Antitone.map_limsInf_of_continuousAt :
    ∀ {R : Type u_4} {S : Type u_5} [inst : ConditionallyCompleteLinearOrder R] [inst_1 : TopologicalSpace R]
      [inst_2 : OrderTopology R] [inst_3 : ConditionallyCompleteLinearOrder S] [inst_4 : TopologicalSpace S]
      [inst_5 : OrderTopology S] {F : Filter R} [inst_6 : Filter.NeBot F] {f : R → S},
      Antitone f →
        ContinuousAt f (Filter.limsInf F) →
          autoParam (Filter.IsBounded (fun x x_1 => x ≤ x_1) F) _auto✝ →
            autoParam (Filter.IsBounded (fun x x_1 => x ≥ x_1) F) _auto✝¹ → f (Filter.limsInf F) = Filter.limsup f F :=
  by sorry

This theorem states that for any antitone function `f` mapping between two (conditionally) complete linear ordered spaces `R` and `S`, if `f` is continuous at the least upper bound (`limsInf`) of a filter `F` in `R`, and if the filter `F` is bounded both above and below, then the image of the `limsInf` of `F` under `f` is equal to the greatest lower bound (`limsup`) of the image of `F` under `f`. This result holds under the assumptions that `R` and `S` are equipped with topological and order structures that are compatible, that `F` is not a trivial (bottom) filter, and that the boundedness conditions are given as automatic parameters.

For any antitone function between two conditionally complete linear ordered spaces with compatible topologies, if the function is continuous at the least upper bound of a bounded above and below filter and the filter is not trivial, then the image of the least upper bound is equal to the greatest lower bound of the function's image under the filter.


theorem Filter.eventually_pure : ∀ {α : Type u} {a : α} {p : α → Prop}, (∀ᶠ (x : α) in pure a, p x) ↔ p a := by sorry

This theorem, `Filter.eventually_pure`, states that for any type `α`, any element `a` of that type, and any property `p` applicable to elements of type `α`, the proposition "eventually for all `x` in the pure filter of `a`, property `p` holds for `x`" is equivalent to the proposition "property `p` holds for `a`". In simpler terms, it says that if a property holds eventually for all elements in a pure filter on `a`, it must hold for `a` itself, and vice versa. A pure filter in this context is a filter that contains only `a` and sets that include `a`.

For any type `α`, element `a` of type `α`, and property `p` applicable to `α`, `a` belongs to the eventual filter of `p` if and only if `p` holds for `a`.


theorem Mathlib.Order.BooleanAlgebra._auxLemma.6 :
    ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], (xᶜ = yᶜ) = (x = y) := by sorry

This theorem states that for any type `α` with a defined Boolean algebra structure, and any two elements `x` and `y` of that type, the claim that the Boolean complement of `x` is equal to the Boolean complement of `y` is equivalent to the claim that `x` is equal to `y`. In other words, two elements in this context are identical if and only if their complements are identical.

For any type `α` with a defined Boolean algebra structure, two elements `x` and `y` are equal if and only if their complements are equal.


theorem Mathlib.Order.BooleanAlgebra._auxLemma.1 :
    ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], (x \ y = x) = Disjoint x y := by sorry

This theorem states that for any type `α` that is a generalized Boolean algebra, and for any elements `x` and `y` of `α`, the condition that `x \ y` equals `x` is equivalent to `x` and `y` being disjoint. In the context of a generalized Boolean algebra, two elements `x` and `y` are considered disjoint if for all `x` such that `x` is less than or equal to `a` and `x` is less than or equal to `b`, `x` is also less than or equal to the bottom element `⊥`. This is a generalization of the concept of disjoint sets, where the intersection of the sets is empty.

In a generalized Boolean algebra, two elements are disjoint if and only if their difference equals one of them.


HasLineDerivWithinAt.smul

theorem HasLineDerivWithinAt.smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {s : Set E}
      {x v : E} {f' : F},
      HasLineDerivWithinAt 𝕜 f f' s x v → ∀ (c : 𝕜), HasLineDerivWithinAt 𝕜 f (c • f') s x (c • v) :=
  by sorry

This theorem, named `HasLineDerivWithinAt.smul`, states that for any type `𝕜` that forms a non-trivially normed field, type `F` that forms a normed add commutative group, type `E` that forms both an add commutative group and a `𝕜`-module, a function `f` from `E` to `F`, a set `s` of elements of type `E`, elements `x` and `v` of type `E`, and an element `f'` of type `F`, if `f` has a linear derivative at `x` within the set `s` in the direction of `v` with respect to `f'`, then for any scalar `c` from `𝕜`, `f` also has a linear derivative at `x` within the set `s` in the direction of `c • v` with respect to `c • f'`. In other words, the derivative of the function `f` at a point `x` within a set `s` scales linearly with both the derivative and the direction vector.

If `f` has a linear derivative at `x` within set `s` in direction `v` with respect to `f'` in a normed field `𝕜`, then it has a linear derivative at `x` within `s` in direction `cv` with respect to `cf'` for any scalar `c` from `𝕜`.


theorem PartialEquiv.image_eq_target_inter_inv_preimage :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {s : Set α},
      s ⊆ e.source → ↑e '' s = e.target ∩ ↑(PartialEquiv.symm e) ⁻¹' s :=
  by sorry

The theorem `PartialEquiv.image_eq_target_inter_inv_preimage` asserts that for any partial equivalence relation `e` of types `α` and `β`, and for any set `s` of type `α` that is a subset of the source of `e`, the image of `s` under `e` is equal to the intersection of the target of `e` and the preimage of `s` under the inverse of `e`. This theorem formalizes a basic property relating images and preimages under partial equivalences, which can be particularly useful in the study of relations and functions between different mathematical structures.

For any partial equivalence relation `e` on types `α` and `β`, and any subset `s` of `α` in the source of `e`, the image of `s` under `e` is equal to the intersection of the target of `e` and the preimage of `s` under the inverse of `e`.