/-- A monotone function is continuous to the right at a point if and only if its right limit
coincides with the value of the function.  -/
theorem Monotone.continuousWithinAt_Ioi_iff_rightLim_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f →
        ∀ {x : α} [inst_4 : TopologicalSpace α] [inst_5 : OrderTopology α],
          ContinuousWithinAt f (Set.Ioi x) x ↔ Function.rightLim f x = f x :=
  by sorry

The theorem states that for a function `f` mapping from a linearly ordered type `α` to a conditionally complete linearly ordered topological space `β`, the function is continuous to the right at a point `x` if and only if the right limit of the function at `x` is equal to the function's value at `x`. This is true if the function `f` is monotone. In other words, if the function does not decrease its value when its argument increases (i.e., it is monotone), then the function is continuous from the right at a point if, and only if, the value the function approaches when the argument goes beyond said point (the right limit) is the same as the function's value at that point.

For a monotone function `f` from a linearly ordered type `α` to a conditionally complete linearly ordered topological space `β`, continuity to the right at a point `x` is equivalent to the right limit of `f` at `x` being equal to `f(x)`.


theorem FirstOrder.Language.model_infiniteTheory_iff :
    ∀ (L : FirstOrder.Language) {M : Type w} [inst : FirstOrder.Language.Structure L M],
      M ⊨ FirstOrder.Language.infiniteTheory L ↔ Infinite M :=
  by sorry

The theorem `FirstOrder.Language.model_infiniteTheory_iff` states that for any first-order language `L` and any structure `M` of that language, `M` models the infinite theory of `L` if and only if `M` is infinite. In other words, a structure `M` satisfies all sentences in `L` stating that there exists more than `n` elements for all natural numbers `n` if and only if the cardinality of `M` is infinite.

A first-order structure is a model of the infinite theory of a language if and only if it has infinite cardinality.


theorem Multiset.lt_iff_cons_le : ∀ {α : Type u_1} {s t : Multiset α}, s < t ↔ ∃ a, a ::ₘ s ≤ t := by sorry

This theorem states that for any two multisets `s` and `t` of a type `α`, `s` is less than `t` if and only if there exists an element `a` of type `α` such that the multiset obtained by consing `a` onto `s` is less than or equal to `t`. In other words, a multiset `s` is less than another multiset `t` when there is an element `a` that can be added to `s` to create a multiset that is no greater than `t`. Here, `::ₘ` is the operation of adding an element to a multiset.

For any multisets `s` and `t` of type `α`, `s` is less than `t` if and only if there exists an `α` element `a` such that `s :: a ≤ t`.


theorem derivWithin_congr :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
      Set.EqOn f₁ f s → f₁ x = f x → derivWithin f₁ s x = derivWithin f s x :=
  by sorry

This theorem, named `derivWithin_congr`, states that for any field `𝕜` that is not trivially normed, any normed additive commutative group `F` over `𝕜`, any functions `f` and `f₁` from `𝕜` to `F`, any point `x` in `𝕜`, and any set `s` of elements of `𝕜`, if `f₁` and `f` are equal on the set `s` and at the point `x`, then the derivative of `f₁` at the point `x` within the set `s` is equal to the derivative of `f` at the point `x` within the set `s`.

In simple terms, if two functions are equal over a certain set and at a specific point, their derivatives are also equal at that point when considered within the same set.

If functions `f` and `f₁` are equal on a set `s` containing a point `x` and `f'(x)` and `f₁'(x)` exist within `s`, then `f'(x) = f₁'(x)`.


/-- The partial application of a constant to a covariant operator is monotone.  -/
theorem Covariant.monotone_of_const :
    ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} [inst : Preorder N]
      [inst_1 : CovariantClass M N μ fun x x_1 => x ≤ x_1] (m : M), Monotone (μ m) :=
  by sorry

The theorem `Covariant.monotone_of_const` states that for any two types `M` and `N`, a function `μ` from `M` to `N` to `N`, a preorder on `N`, and when `μ` is a covariant operator (meaning it respects the order), partially applying a constant `m` from `M` to the function `μ` results in a function that is monotone. In other words, if `a ≤ b`, then `μ m a ≤ μ m b`. This means that as the input to the partially applied function increases, the output also increases.

For any covariant function `μ` from type `M` to a preorder `N`, and constant `m` from `M`, the function `μ m : N` is monotone, i.e., for all `a ≤ b` in `M`, `μ m a ≤ μ m b` holds in `N`.


theorem VitaliFamily.FineSubfamilyOn.covering_disjoint :
    ∀ {α : Type u_1} [inst : MetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {v : VitaliFamily μ}
      {f : α → Set (Set α)} {s : Set α} (h : VitaliFamily.FineSubfamilyOn v f s),
      Set.PairwiseDisjoint (VitaliFamily.FineSubfamilyOn.index h) (VitaliFamily.FineSubfamilyOn.covering h) :=
  by sorry

The theorem `VitaliFamily.FineSubfamilyOn.covering_disjoint` states that for any fine subfamily `h` on a set `s` under function `f` with respect to a Vitali family `v`, the index of `h` is pairwise disjoint under the covering of `h`. In simpler terms, it says that the sets in the family, which form a covering of almost every element in `s`, are pairwise disjoint. This pairwise disjoint property ensures that no two distinct sets in this covering overlap. This theorem holds in the context of a metric space and a measurable space, with a measure defined on it.

In a metric measurable space, the index sets of a pairwise disjoint fine subfamily on a set, which covers almost every element with respect to a Vitali family, are disjoint.


theorem ge_antisymm : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → b ≤ a → b = a := by sorry

The theorem `ge_antisymm` states that for any type `α` that has a partial order, and any two elements `a` and `b` of that type, if `a` is less than or equal to `b`, and `b` is less than or equal to `a`, then `b` must be equal to `a`. This is a formalization of the antisymmetry property of partial orders.

For any type with a partial order, if `a` is less than or equal to `b` and `b` is less than or equal to `a`, then `a` and `b` are equal.


theorem GaloisConnection.isLeast_l :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {a : α}, IsLeast {b | a ≤ u b} (l a) :=
  by sorry

The theorem `GaloisConnection.isLeast_l` states that: For any types `α` and `β` that are preordered, any two functions `l : α → β` and `u : β → α` forming a Galois Connection, and any element `a` of type `α`, the image of `a` under `l` is a least element of the set of `b` in `β` such that `a` is less than or equal to `u b`. In other words, if you have a Galois Connection between two preordered sets, then for any element in the first set, the image of that element in the second set through the function `l` is the smallest element among those to which it is related by the Galois Connection.

For any Galois connection between preordered types `α` and `β` and any `α` element `a`, `l(a)` is the least `β` element greater than or equal to `u(b)` for all `β` elements `b` less than or equal to `a`.


theorem AddLECancellable.tsub_tsub_cancel_of_le :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b : α}, AddLECancellable (b - a) → a ≤ b → b - (b - a) = a :=
  by sorry

The theorem `AddLECancellable.tsub_tsub_cancel_of_le` states that for any type `α` that is equipped with an addition operation making it an additive commutative semigroup, a partial order `≤`, additive associativity, subtraction operation, and an ordered subtraction, if an element `b - a` of this type is 'add-Le-cancellable' (meaning order is preserved when an element is added), and if `a` is less than or equal to `b`, then the result of subtracting `(b - a)` from `b` is `a`. In simpler terms, if we assume that adding to `b - a` keeps the order, and `a` is not greater than `b`, then taking away `b - a` from `b` gives us `a`, which is a form of the subtraction cancellation law.

If `α` is an additive commutative semigroup with partial order `≤`, additive associativity, subtraction, and ordered subtraction, and if `a ≤ b` and `b - a` is add-Le-cancellable, then `b - (b - a) = a`.


theorem ENNReal.le_of_forall_pos_le_add : ∀ {a b : ENNReal}, (∀ (ε : NNReal), 0 < ε → b < ⊤ → a ≤ b + ↑ε) → a ≤ b := by
  sorry

This theorem states that for all extended nonnegative real numbers 'a' and 'b', if for every positive nonnegative real number 'ε', 'b' is less than infinity and 'a' is less than or equal to 'b' plus 'ε', then 'a' is less than or equal to 'b'. In other words, if 'a' is less than 'b' plus any small positive number and 'b' is finite, then 'a' is less than or equal to 'b'. This is a common type of limit argument in mathematical analysis.

If for all positive ε, a ≤ b + ε implies a ≤ b for extended nonnegative real numbers a and b with b finite, then a ≤ b.


theorem SimpleGraph.ComponentCompl.subset_hom :
    ∀ {V : Type u} {G : SimpleGraph V} {K L : Set V} (C : SimpleGraph.ComponentCompl G L) (h : K ⊆ L),
      ↑C ⊆ ↑(SimpleGraph.ComponentCompl.hom h C) :=
  by sorry

The theorem `SimpleGraph.ComponentCompl.subset_hom` states that for any type `V`, simple graph `G` of type `V`, and sets `K` and `L` of type `V`, given a component `C` that lies outside of set `L` in graph `G` and a proof `h` that set `K` is a subset of `L`, the component `C` is a subset of the component outside of `K` that contains all components outside of `L`. This theorem essentially demonstrates the relationship between two components that lie outside different sets in a simple graph, given a certain subset relationship between these sets.

Given a simple graph and sets K and L with C a component of the graph outside L, if K is a subset of L, then C is a subset of the component outside K containing all components outside L.


theorem tendstoLocallyUniformlyOn_iff_filter :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι} [inst_1 : TopologicalSpace α],
      TendstoLocallyUniformlyOn F f p s ↔ ∀ x ∈ s, TendstoUniformlyOnFilter F f p (nhdsWithin x s) :=
  by sorry

This theorem describes a property of the convergence of a sequence of functions. Specifically, it states that for any types `α`, `β`, and `ι`, and assuming `β` is a uniform space and `α` is a topological space, a sequence of functions `F` from `ι` to `α` to `β` tends to a function `f` from `α` to `β` locally uniformly on a set `s` with respect to a filter `p` if and only if for all `x` in `s`, `F` tends to `f` uniformly on the filter that is the intersection of the neighborhood of `x` and `s` with respect to `p`. In other words, the sequence `F` converges to `f` uniformly on each small neighborhood within `s`.

For any types `α`, `β`, and `ι`, if `β` is a uniform space and `α` is a topological space, a sequence of functions `F : ι → α → β` converges locally uniformly to a function `f : α → β` on a set `s` with respect to a filter `p` if and only if for all `x` in `s`, `F` converges uniformly to `f` on the filter of neighborhoods of `x` intersected with `s` with respect to `p`.


AnalyticAt.meromorphicAt

theorem AnalyticAt.meromorphicAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, AnalyticAt 𝕜 f x → MeromorphicAt f x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜` and any normed space `E` over `𝕜`, if a function `f` from `𝕜` to `E` is analytic at a point `x` in `𝕜`, then `f` is meromorphic at `x`. Here, a function `f` being analytic at a point `x` means that it admits a convergent power series expansion around `x`, while `f` being meromorphic at `x` signifies that it is analytic on a punctured neighbourhood of `x`, i.e., the function can be expressed as a power series except possibly at `x` itself.

If `f` is an analytic function from a nontrivially normed field `𝕜` to a normed space `E` over `𝕜` at a point `x` in `𝕜`, then `f` is meromorphic at `x`.


theorem edist_mul_right :
    ∀ {M : Type u} [inst : Mul M] [inst_1 : PseudoEMetricSpace M] [inst_2 : IsometricSMul Mᵐᵒᵖ M] (a b c : M),
      edist (a * c) (b * c) = edist a b :=
  by sorry

This theorem, `edist_mul_right`, states that for any type `M` that has a multiplication operation, is a pseudo emetric space, and has a right-side isometric scalar multiplication, the distance (measured with the extended metric `edist`) between the results of multiplying two elements `a` and `b` by a third element `c` is equal to the distance between `a` and `b` themselves. In mathematical terms, for any `a`, `b`, and `c` in `M`, `edist (a * c) (b * c) = edist a b`.

For any type `M` with a multiplication operation, a pseudo-metric `edist`, and right-isometric scalar multiplication, `edist (a * c) (b * c) = edist a b` for all `a, b, c` in `M`.


/-- Tower law: if `A` is a `K`-module and `K` is an extension of `F` then
$\operatorname{rank}_F(A) = \operatorname{rank}_F(K) * \operatorname{rank}_K(A)$.

The universe polymorphic version of `rank_mul_rank` below.  -/
theorem lift_rank_mul_lift_rank :
    ∀ (F : Type u) (K : Type v) (A : Type w) [inst : Ring F] [inst_1 : Ring K] [inst_2 : AddCommGroup A]
      [inst_3 : Module F K] [inst_4 : Module K A] [inst_5 : Module F A] [inst_6 : IsScalarTower F K A]
      [inst_7 : StrongRankCondition F] [inst_8 : StrongRankCondition K] [inst_9 : Module.Free F K]
      [inst_10 : Module.Free K A],
      Cardinal.lift.{w, v} (Module.rank F K) * Cardinal.lift.{v, w} (Module.rank K A) =
        Cardinal.lift.{v, w} (Module.rank F A) :=
  by sorry

This theorem, known as the "Tower Law", states that for any types `F`, `K`, and `A` -- where `F` and `K` are rings, `A` is an additive commutative group, and the module and scalar tower structure is given over these types -- the rank of the module `A` over the field `F` is equal to the product of the rank of the module `A` over the field `K` and the rank of the field `K` over the field `F`. This statement holds under the conditions that both `F` and `K` satisfy the strong rank condition, and both `K` and `A` are free modules. In formal language notation, this can be written as $\operatorname{rank}_F(A) = \operatorname{rank}_F(K) * \operatorname{rank}_K(A)$.

The rank of a free module over a field is multiplicatively equal to the rank of the module over an intermediate field times the rank of that field over the base field, given both fields satisfy the strong rank condition.


theorem CategoryTheory.Abelian.Pseudoelement.zero_eq_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C},
      ⟦CategoryTheory.Over.mk 0⟧ = 0 :=
  by sorry

This theorem states that for any category `C` that is also an Abelian category with objects `P` and `Q`, the equivalence class of the object obtained by using the `CategoryTheory.Over.mk` constructor on the zero morphism is equal to zero. In simpler words, in any Abelian category, the "over" object corresponding to the zero morphism is also considered as zero.

In any Abelian category, the over object of the zero morphism is equal to the zero object.


theorem Ideal.ramificationIdx_spec :
    ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] {f : R →+* S} {p : Ideal R} {P : Ideal S}
      {n : ℕ}, Ideal.map f p ≤ P ^ n → ¬Ideal.map f p ≤ P ^ (n + 1) → Ideal.ramificationIdx f p P = n :=
  by sorry

The theorem `Ideal.ramificationIdx_spec` states that for any given commutative rings `R` and `S`, a ring homomorphism `f` from `R` to `S`, ideals `p` of `R` and `P` of `S`, and a natural number `n`, if the image of the ideal `p` under the map `f` is contained in the `n`-th power of `P` and is not contained in the `(n+1)`-th power of `P`, then the ramification index of `P` over `p` under the map `f` is `n`. Here, the ramification index is the highest power `n` such that `P^n` contains the image of `p` under `f`.

If a ring homomorphism maps an ideal to a power of another ideal and not to a higher power, then the ramification index of the second ideal over the first is equal to the power.


theorem Ordinal.add_omega_opow :
    ∀ {a b : Ordinal.{u_1}}, a < Ordinal.omega ^ b → a + Ordinal.omega ^ b = Ordinal.omega ^ b := by sorry

The theorem `Ordinal.add_omega_opow` states that for any two ordinals `a` and `b`, if `a` is less than the omega ordinal raised to the power of `b` (i.e., `a < ω^b`), then the sum of `a` and `ω^b` is equal to `ω^b`. In other words, adding a smaller ordinal to `ω^b` does not change the value of `ω^b`. This result reflects the fundamental property of infinite ordinals where adding a smaller ordinal to an infinite ordinal doesn't increase the size of the infinite ordinal.

For all ordinals `a` and `b`, if `a < ω^b`, then `a + ω^b = ω^b`.


theorem UniformSpace.toTopologicalSpace_iInf :
    ∀ {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α},
      UniformSpace.toTopologicalSpace = ⨅ i, UniformSpace.toTopologicalSpace :=
  by sorry

This theorem states that for any type `α`, any sort `ι`, and any function `u` mapping `ι` to a uniform space over `α`, the topological space derived from the uniform space is equal to the infimum of topological spaces derived from the uniform spaces as per the function `u`. In other words, if you have a collection of uniform spaces indexed by `ι`, the topological space derived from the uniform space is the infimum of the topological spaces derived from each individual uniform space in the collection.

The topological space derived from a uniform space over a type `α`, indexed by sort `ι`, is equal to the infimum of the topologies derived from each uniform space in the collection.


Filter.EventuallyLE.inter

theorem Filter.EventuallyLE.inter :
    ∀ {α : Type u} {s t s' t' : Set α} {l : Filter α}, s ≤ᶠ[l] t → s' ≤ᶠ[l] t' → s ∩ s' ≤ᶠ[l] t ∩ t' := by sorry

The theorem `Filter.EventuallyLE.inter` states that for any type `α`, any sets `s`, `t`, `s'`, `t'` of type `α`, and any filter `l` over `α`, if `s` is eventually less than or equal to `t` under filter `l` and `s'` is eventually less than or equal to `t'` under filter `l`, then the intersection of `s` and `s'` is eventually less than or equal to the intersection of `t` and `t'` under the same filter `l`. In more intuitive terms, this theorem is about the relationship between two events that are both eventually true according to some filter: if each event individually implies another event, then the intersection of the original events implies the intersection of the resulting events.

If filters `l` make sets `s` eventually included in `t` and sets `s'` eventually included in `t'`, then the intersection of `s` and `s'` is eventually included in the intersection of `t` and `t'`.


/-- If `‖pₙ‖ rⁿ = O(1)`, as `n → ∞`, then the radius of `p` is at least `r`.  -/
theorem FormalMultilinearSeries.le_radius_of_isBigO :
    ∀ {𝕜 : 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]
      (p : FormalMultilinearSeries 𝕜 E F) {r : NNReal},
      ((fun n => ‖p n‖ * ↑r ^ n) =O[Filter.atTop] fun x => 1) → ↑r ≤ FormalMultilinearSeries.radius p :=
  by sorry

The theorem `FormalMultilinearSeries.le_radius_of_isBigO` states that for any formal multilinear series `p` over a normed field `𝕜`, if the norm of `pₙ` times `rⁿ` is of "big-O" notation equal to 1 as `n` tends to infinity (`‖pₙ‖ rⁿ = O(1)`, as `n → ∞`), then the radius of `p` is at least `r`. Here, `r` is a nonnegative real number (`NNReal`), and the "big-O" notation (`=O[Filter.atTop]`) refers to a bound that holds when `n` becomes sufficiently large (i.e., `n` goes to infinity).

If the norm of a formal multilinear series' `n`-th term times `r^n` is big-O(1) as `n` approaches infinity, then the radius of the series is at least `r`.


theorem Hyperreal.coe_eq_coe : ∀ {x y : ℝ}, ↑x = ↑y ↔ x = y := by sorry

This theorem states that for all real numbers `x` and `y`, the hyperreal representation of `x` (notated as ↑x) is equal to the hyperreal representation of `y` (notated as ↑y) if and only if `x` is equal to `y`. In other words, the function that maps real numbers to their hyperreal counterparts preserves equality.

For all real numbers x and y, ↑x = ↑y if and only if x = y.


theorem Mathlib.Data.Complex.Basic._auxLemma.11 : ∀ (r : ℝ), (↑r)⁻¹ = ↑r⁻¹ := by sorry

This theorem states that for every real number `r`, the reciprocal of the complex embedding of `r` is equal to the complex embedding of the reciprocal of `r`. In other words, taking the reciprocal before or after embedding a real number into the complex numbers yields the same result.

For all real numbers r, the complex embeddings of r and its reciprocal are equal. In Lean notation: `complex_abs r = complex_abs (1 / r)`.


theorem Matrix.dotProduct_cons :
    ∀ {α : Type u} {n : ℕ} [inst : AddCommMonoid α] [inst_1 : Mul α] (v : Fin (Nat.succ n) → α) (x : α) (w : Fin n → α),
      Matrix.dotProduct v (Matrix.vecCons x w) = Matrix.vecHead v * x + Matrix.dotProduct (Matrix.vecTail v) w :=
  by sorry

The theorem `Matrix.dotProduct_cons` states that for any type `α` with addition and multiplication structures, for any natural number `n`, and any vectors `v` of length `n+1` and `w` of length `n`, and any element `x` of type `α`, the dot product of `v` with a vector obtained by prepending `x` to `w` is equal to the product of the first element of `v` and `x`, plus the dot product of the remaining elements of `v` (after removing the first element) and `w`. In terms of mathematical notation, if `v = (v1, v2, ..., vn+1)` and `w = (w1, w2, ..., wn)`, then `v . (x, w) = v1*x + (v2, ..., vn+1) . w`.

For any type `α` with addition and multiplication structures, and vectors `v` of length `n+1` and `w` of length `n` over `α`, the dot product of `v` with the vector `(x :: w)` is equal to `v.1 * x + ⟨v.2, ..., v.n+1⟩ . w`.


theorem eq_of_inf_eq_sup_eq :
    ∀ {α : Type u} [inst : DistribLattice α] {a b c : α}, b ⊓ a = c ⊓ a → b ⊔ a = c ⊔ a → b = c := by sorry

This theorem states that in a distributive lattice represented by the generic type `α`, given three elements `a`, `b`, and `c`, if the infimum (greatest lower bound) of `b` and `a` equals the infimum of `c` and `a` and the supremum (least upper bound) of `b` and `a` equals the supremum of `c` and `a`, then `b` must equal `c`. It essentially asserts that in such a lattice, the combination of infimum and supremum relationships uniquely determines an element's identity.

In a distributive lattice, if the infimum of `a` and `b` equals the infimum of `a` and `c` and the supremum of `a` and `b` equals the supremum of `a` and `c`, then `b` equals `c`.


Relation.TransGen.tail'

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

This theorem states that for any type `α` and a relation `r` of type `α → α → Prop`, if there exists a reflexive and transitive closure of `r` from `a` to `b` and the relation `r` holds between `b` and `c`, then there is a transitive closure of `r` between `a` and `c`. In mathematical terms, if `a` is related to `b` via possibly multiple steps and `b` is directly related to `c`, then `a` is transitively related to `c`.

If `r` is a reflexive and transitive relation on type `α`, and there exists a path of `r` steps from `a` to `b` and a direct `r` relation from `b` to `c`, then there is a path of `r` steps from `a` to `c`.


theorem Set.inter_right_comm : ∀ {α : Type u} (s₁ s₂ s₃ : Set α), s₁ ∩ s₂ ∩ s₃ = s₁ ∩ s₃ ∩ s₂ := by sorry

This theorem, named `Set.inter_right_comm`, states that for any type `α` and for any three sets `s₁`, `s₂`, and `s₃` of this type, the intersection of `s₁` with the intersection of `s₂` and `s₃` is equal to the intersection of `s₁` with the intersection of `s₃` and `s₂`. In other words, the order in which we take the intersection of `s₂` and `s₃` does not affect the final result; this property is referred to as the right-commutativity of intersection on sets.

For any type `α` and sets `s₁`, `s₂`, and `s₃` of type `α`, `s₁ ∩ (s₂ ∩ s₃) = s₁ ∩ (s₃ ∩ s₂)`.


theorem Set.addCenter_subset_addCentralizer :
    ∀ {M : Type u_1} [inst : Add M] (S : Set M), Set.addCenter M ⊆ Set.addCentralizer S := by sorry

This theorem states that for any set `S` of a type `M` that has an addition operation (i.e., `M` is an additive magma), the center of `M` is a subset of the centralizer of `S`. In other words, every element in the center of the additive magma `M` (those elements `z` which commute with every element of `M` under addition) also belongs to the centralizer of the set `S` (those elements `c` for which, for every element `m` in `S`, addition of `m` and `c` commutes).

For any additive magma `M` and subset `S` of `M`, the center of `M` is contained in the centralizer of `S`.


theorem Ordinal.succ_lt_of_not_succ : ∀ {o b : Ordinal.{u_4}}, (¬∃ a, o = Order.succ a) → (Order.succ b < o ↔ b < o) :=
  by sorry

This theorem states that for any two ordinals 'o' and 'b', if 'o' is not the successor of any ordinal ('o' is not of the form 'Order.succ a' for any 'a'), then the successor 'b' is less than 'o' if and only if 'b' is less than 'o'. In other words, if 'o' is not a successor ordinal, then whether 'b' is less than 'o' is the same as whether the successor of 'b' is less than 'o'.

For any ordinals 'o' and 'b', if 'o' is not a successor ordinal then 'b' < 'o' if and only if Order.succ 'b' < 'o'.


theorem Set.image_mul_prod : ∀ {α : Type u_2} [inst : Mul α] {s t : Set α}, (fun x => x.1 * x.2) '' s ×ˢ t = s * t := by
  sorry

The theorem `Set.image_mul_prod` states that for any type `α` that has a multiplication operation, and any two sets `s` and `t` of this type, the set of all products of pairs of elements, where the first element is from `s` and the second is from `t`, is equal to the set obtained by multiplying `s` and `t` (where multiplication of sets is defined elementwise). In other words, forming the Cartesian product of `s` and `t`, then mapping each pair `(x, y)` to `x * y`, gives the same set as directly multiplying the sets `s` and `t`.

For any type `α` with multiplication and sets `s` and `t` of this type, the sets `s × t` and `{x * y | x ∈ s, y ∈ t}` are equal.


/-- The cosine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
adjacent side.  -/
theorem InnerProductGeometry.cos_angle_add_mul_norm_of_inner_eq_zero :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
      ⟪x, y⟫_ℝ = 0 → Real.cos (InnerProductGeometry.angle x (x + y)) * ‖x + y‖ = ‖x‖ :=
  by sorry

This theorem states that for any real inner product space, if the inner product of two vectors `x` and `y` is zero, then the cosine of the angle between `x` and `x + y` multiplied by the norm of `x + y` equals the norm of `x`. In terms of geometry, this corresponds to the situation where `x` and `y` are perpendicular (since their inner product is zero), and the theorem then gives a relationship involving the angle between `x` and `x + y`, which forms a right-angled triangle with `x` and `y`.

For any real inner product space, the cosine of the angle between two vectors `x` and `y` equals the norm of `x` divided by the norm of `x + y` if and only if `x` and `y` are orthogonal (have inner product equal to zero).


theorem Finset.sup_comm :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (s : Finset β)
      (t : Finset γ) (f : β → γ → α),
      (Finset.sup s fun b => Finset.sup t (f b)) = Finset.sup t fun c => Finset.sup s fun b => f b c :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and given that `α` is a semilattice with a least element `⊥`, the supremum of a function `f` applied to elements of two finite sets `s` and `t` is commutative. In other words, calculating the supremum over set `s` and then over set `t` is the same as calculating the supremum over set `t` and then over set `s`. Specifically, given a function `f` from `β` and `γ` to `α`, `(Finset.sup s fun b => Finset.sup t (f b))` equals to `(Finset.sup t fun c => Finset.sup s fun b => f b c)`.

For any semilattice `α` with least element `⊥`, and given finite sets `s` and `t`, the supremum of a function `f` applied to elements of `s` and then to `t` is equal to the supremum of the same function first applied to `t` and then to `s`. In other words, `Finset.sup s (λb, Finset.sup t (λc, f b c))` equals `Finset.sup t (λc, Finset.sup s (λb, f b c))`.


theorem CategoryTheory.Preadditive.epi_of_cokernel_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
      {f : X ⟶ Y} [inst_2 : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f 0)],
      CategoryTheory.Limits.cokernel.π f = 0 → CategoryTheory.Epi f :=
  by sorry

This theorem states that for any Category `C` that is preadditive (i.e., has binary products and coproducts, and for which the hom sets between objects form an abelian group), if `f` is a morphism from an object `X` to an object `Y` in `C`, and if `C` has a colimit for the parallel pair `f` and the zero morphism, then if the morphism from `Y` to the cokernel of `f` is the zero morphism, it follows that `f` is an epimorphism (i.e., a right cancellable morphism). In other words, if the cokernel of `f` is trivial, then `f` must be an epimorphism.

In a preadditive category with binary products, coproducts, and abelian hom sets, if a morphism has a trivial cokernel and the category has a colimit for the parallel pair of the morphism and the zero morphism, then the morphism is an epimorphism.


/-- Given a `(m × m)` diagonal matrix defined by a map `d : m → α`, if the reindexing map `e` is
injective, then the resulting matrix is again diagonal.  -/
theorem Matrix.submatrix_diagonal :
    ∀ {l : Type u_1} {m : Type u_2} {α : Type v} [inst : Zero α] [inst_1 : DecidableEq m] [inst_2 : DecidableEq l]
      (d : m → α) (e : l → m),
      Function.Injective e → Matrix.submatrix (Matrix.diagonal d) e e = Matrix.diagonal (d ∘ e) :=
  by sorry

The theorem states that for any types `l`, `m`, and `α`, where `α` has a zero element and `l` and `m` have decidable equality, given a diagonal matrix represented by a map `d : m → α` and a reindexing map `e : l → m`, if `e` is injective, then the submatrix of the original matrix created using `e` as the row and column selector is also a diagonal matrix. This resultant diagonal matrix is defined by the function composition `(d ∘ e)`. In other words, reindexing a diagonal matrix by an injective function still results in a diagonal matrix.

If `d : m → α` is a diagonal matrix, `e : l → m` is an injective function, then the submatrix of `d` obtained by using `e` as row and column selector is also a diagonal matrix, defined as `(d ∘ e)`.


theorem zpow_mul' : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), a ^ (m * n) = (a ^ n) ^ m := by sorry

This theorem states that for any type `α` that forms a division monoid, and for any element `a` of this type, along with integers `m` and `n`, the power of `a` raised to the product of `m` and `n` is equal to `a` raised to the power of `n`, which is in turn raised to the power of `m`. In LaTeX terms, this would read: \(a^{mn} = (a^n)^m\).

For any element `a` of a type `α` forming a division monoid and integers `m` and `n`, `a^(mn) = (a^n)^m`.


theorem Mathlib.Probability.Process.Stopping._auxLemma.17 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) := by sorry

This theorem states that for any two elements `a` and `b` of a certain type `α` that forms a partial order, the statement "`a` is less than `b`" is equivalent to the conjunction of "`a` is less than or equal to `b`" and "`a` is not equal to `b`". This is a fundamental property of partial orders, reflecting that "less than" means "less than or equal to" but not "equal to".

In a partial order, `a` is less than `b` if and only if `a` is strictly less than or equal to `b`.


theorem Mathlib.Probability.Process.Stopping._auxLemma.18 : ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) := by
  sorry

This theorem, named `Mathlib.Probability.Process.Stopping._auxLemma.18`, states that for any type `α`, any set `s` of type `α`, and any element `x` of type `α`, the statement that `x` is in the complement of `s` (denoted as `sᶜ`) is equivalent to the statement that `x` is not in `s` (denoted as `x ∉ s`). In other words, an element belongs to the complement of a set if and only if it does not belong to the original set.

The complement of a set is the set of all elements not in the original set.


theorem GeneralizedContinuedFraction.IntFractPair.stream_zero :
    ∀ {K : Type u_1} [inst : LinearOrderedField K] [inst_1 : FloorRing K] (v : K),
      GeneralizedContinuedFraction.IntFractPair.stream v 0 = some (GeneralizedContinuedFraction.IntFractPair.of v) :=
  by sorry

The theorem `GeneralizedContinuedFraction.IntFractPair.stream_zero` states that for any value `v` of type `K`, where `K` is a linear ordered field that also has a floor ring structure, the zeroth element in the sequence (or stream) of integer and fractional pairs of the generalised continued fraction of `v` is equal to the pair that's created with `v`'s integer and fractional part. In terms of mathematical notation, this means that for all `v` in `K` we have `GeneralizedContinuedFraction.IntFractPair.stream v 0 = some (GeneralizedContinuedFraction.IntFractPair.of v)`, where the function `stream` returns the sequence of integer and fractional parts and `IntFractPair.of v` returns a pair of `v`'s integer part and fractional part.

For any element `v` in a linear ordered field `K` with floor ring structure, the zeroth element of the generalized continued fraction sequence of `v` is equal to the pair of `v`'s integer and fractional parts.


theorem le_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] {a b : α},
      a < b → ∀ᶠ (x : α) in nhds b, a ≤ x :=
  by sorry

The theorem `le_mem_nhds` states that for any type `α` equipped with a topological space structure, a preorder structure, and an order topology, and for any two elements `a` and `b` of `α` such that `a` is less than `b`, all elements `x` in a neighborhood of `b` (as defined by the neighborhood filter `nhds b`) are greater than or equal to `a`. Essentially, this theorem asserts that in a topological space compatible with an order, if `a` is less than `b`, then there exists a neighborhood around `b` in which all elements are greater than or equal to `a`.

For any topological space `(α, top)` with order `≤` and `a ≤ b` in `α`, every neighborhood `N ∈ nhds(b)` satisfies `x ≥ a` for all `x ∈ N`.


theorem AddEquiv.apply_eq_iff_eq :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N) {x y : M}, e x = e y ↔ x = y := by
  sorry

This theorem states that for any two types `M` and `N` that are equipped with an addition operation (denoted by `Add M` and `Add N`), given an additive equivalence `e` between `M` and `N` (denoted by `e : M ≃+ N`), for any two elements `x` and `y` of `M`, `x` is equal to `y` if and only if their images under `e` are equal. Essentially, this theorem shows that the given additive equivalence `e` preserves the equality of elements.

For any additive equivalences `e : M ≃+ N` between types `M` and `N` equipped with addition operations, `x = y` in `M` if and only if `e x = e y` in `N`.


theorem Mathlib.LinearAlgebra.Determinant._auxLemma.3 :
    ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M]
      (f g : M →ₗ[A] M), LinearMap.det f * LinearMap.det g = LinearMap.det (f ∘ₗ g) :=
  by sorry

This theorem states that, for any two endomorphisms `f` and `g` of a module `M` over a commutative ring `A` (i.e., linear transformations from `M` to itself), the determinant of the composition of `f` and `g` is equal to the product of the determinant of `f` and the determinant of `g`. This is a statement of the multiplicative property of determinants in linear algebra. If `M` does not have a finite basis, then the determinant is defined to be `1`, and the theorem holds trivially.

For any two endomorphisms of a module over a commutative ring, the determinant of their composition equals the product of their determinants. If the module does not have a finite basis, then both determinants are equal to 1.


theorem AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.isoRestrict_hom_ofRestrict :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : AlgebraicGeometry.PresheafedSpace C}
      {f : X ⟶ Y} (H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.isoRestrict H).hom
          (AlgebraicGeometry.PresheafedSpace.ofRestrict Y ⋯) =
        f :=
  by sorry

This theorem states that for any two presheafed spaces `X` and `Y` in a category `C` with a morphism `f : X ⟶ Y` which is an open immersion, the composition of the homomorphism of the isoRestrict of `f` and the map from the restriction of the presheafed space `Y` is equal to `f`. In other words, we can recover the original morphism `f` by applying the isoRestrict operation to `f`, then composing with the restriction of `Y`. This reflects the notion that the process of restriction and then composing with the isoRestrict homomorphism is essentially an identity operation for open immersions in algebraic geometry.

For any open immersion of presheafed spaces $f : X \to Y$ in a category $C$, the composition of $f$ with the restriction map of $Y$ is equal to the isoRestrict homomorphism of $f$.


NormedAddGroupHom.isQuotientQuotient

/-- `S.normedMk` satisfies `IsQuotient`.  -/
theorem NormedAddGroupHom.isQuotientQuotient :
    ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M),
      NormedAddGroupHom.IsQuotient (AddSubgroup.normedMk S) :=
  by sorry

The theorem `NormedAddGroupHom.isQuotientQuotient` states that for any type `M` which is a seminormed additive commutative group and any additive subgroup `S` of `M`, the function `AddSubgroup.normedMk S` is a quotient morphism. In other words, `AddSubgroup.normedMk S` maps `M` to the quotient group `M/S` and preserves the group structure under the seminorm. This is a fundamental property in the theory of normed groups and their quotients.

The function `AddSubgroup.normedMk` on a seminormed additive commutative group `M` and its additive subgroup `S` is a quotient morphism, preserving the seminorm and group structure on `M/S`.


Asymptotics.IsLittleO.trans

theorem Asymptotics.IsLittleO.trans :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} {G : Type u_5} [inst : Norm E] [inst_1 : Norm F] [inst_2 : Norm G]
      {l : Filter α} {f : α → E} {g : α → F} {k : α → G}, f =o[l] g → g =o[l] k → f =o[l] k :=
  by sorry

This theorem states that given three functions `f`, `g`, and `k` that map from some type `α` to types `E`, `F`, and `G` respectively (all of which are equipped with a norm), and given a filter `l` on `α`, if `f` is little-o of `g` at filter `l` and `g` is little-o of `k` at filter `l`, then `f` is also little-o of `k` at filter `l`. In terms of asymptotic notation, if f = o(g) and g = o(k) under the filter `l`, then f = o(k) under the same filter. This establishes the transitivity property of the little-o notation.

If `f = o(g)` and `g = o(k)` for functions `f: α -> E`, `g: α -> F`, and `k: α -> G` under filter `l` on type `α`, then `f = o(k)` under the same filter.


theorem QPF.supp_eq_of_isUniform :
    ∀ {F : Type u → Type u} [inst : Functor F] [q : QPF F],
      QPF.IsUniform →
        ∀ {α : Type u} (a : (QPF.P F).A) (f : (QPF.P F).B a → α),
          Functor.supp (QPF.abs { fst := a, snd := f }) = f '' Set.univ :=
  by sorry

This theorem states that for any type constructor `F` that is a Quasi-Polynomial Functor (QPF) with a functor instance, if `F` is uniform (meaning all polynomial functors representing a single value have the same range), then for any type `α` and any function `f` from the object part of `F`'s polynomial functor to `α`, the support of the abstraction of the functor object `a` and `f` (which is the set of `α` values that the functor contains) is equal to the image of the entire set of `α` under the function `f`. This essentially means that all values of `α` are present in the QPF if it is uniform.

For any Quasi-Polynomial Functor `F` with a uniform instance, the image of `F`'s polynomial functor equals the set of values in the domain when mapping to any type `α`.


theorem MvPolynomial.isHomogeneous_monomial :
    ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (d : σ →₀ ℕ) (r : R) (n : ℕ),
      (Finset.sum d.support fun i => d i) = n → MvPolynomial.IsHomogeneous ((MvPolynomial.monomial d) r) n :=
  by sorry

The theorem `MvPolynomial.isHomogeneous_monomial` states that for any type `σ`, any type `R` with a commutative semiring structure, any function `d` from `σ` to natural numbers, any element `r` of `R`, and any natural number `n`, if the sum of the outputs of `d` over its support equals `n`, then the multivariate polynomial which is the monomial with coefficient `r` and exponents given by `d` is homogeneous of degree `n`. In simpler terms, this theorem guarantees that a monomial of a multivariate polynomial is of homogeneous degree `n` if the sum of its exponents equals `n`.

Given a commutative semiring R, a function d from σ to natural numbers with sum of outputs equal to n over its support, and r an element of R, the monomial x^d with coefficient r is a homogeneous multivariate polynomial of degree n.


/-- **Alias** of the forward direction of `strictMono_restrict`. -/
theorem StrictMono.of_restrict :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMono (Set.restrict s f) → StrictMonoOn f s :=
  by sorry

The theorem `StrictMono.of_restrict` states that for any given types `α` and `β` with preorders, a set `s` of type `α`, and a function `f` from `α` to `β`, if `f` is strictly monotone when its domain is restricted to the set `s` (i.e., `StrictMono (Set.restrict s f)`), then `f` is strictly monotone on the set `s` (i.e., `StrictMonoOn f s`). In more intuitive terms, if a function is strictly increasing when we only consider the values in a particular set, then the function is strictly increasing on that set.

If a function restricted to a set is strictly monotone, then it is strictly monotone on that set.


theorem PSet.Mem.congr_right : ∀ {x y : PSet}, PSet.Equiv x y → ∀ {w : PSet}, w ∈ x ↔ w ∈ y := by sorry

This theorem, `PSet.Mem.congr_right`, states that for any two pre-sets `x` and `y` that are extensionally equivalent, as defined by `PSet.Equiv x y`, any pre-set `w` is a member of `x` if and only if it is a member of `y`. In other words, if `x` and `y` are extensionally equivalent pre-sets, then their membership properties are congruent for any pre-set `w`.

If two pre-sets `x` and `y` are extensionally equivalent, then for all pre-set `w`, `w ∈ x` if and only if `w ∈ y`.


theorem CategoryTheory.ShortComplex.rightHomologyι_comp_fromOpcycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyι S)
          (CategoryTheory.ShortComplex.fromOpcycles S) =
        0 :=
  by sorry

This theorem states that for any type `C` which forms a category and has zero morphisms, given a `ShortComplex` `S` of `C` that has a right homology, the composition of the morphisms `rightHomologyι S` and `fromOpcycles S` in the category structure of `ShortComplex` is a zero morphism. In other words, in the category of short complexes, we always have `rightHomologyι S` followed by `fromOpcycles S` equals to zero morphism.

For any type `C` forming a category with zero morphisms and having right homology, the composition of `rightHomologyι` and `fromOpcycles` morphisms in the category of `ShortComplex` of `C` is the zero morphism.


theorem Rat.zero_of_num_zero : ∀ {q : ℚ}, q.num = 0 → q = 0 := by sorry

This theorem states that for any rational number `q`, if the numerator of `q` is zero, then `q` itself must be zero. In mathematical terms, if we have a rational number represented as `q = p/q`, and if `p = 0`, then `q` must also be 0, regardless of the value of `q`.

If the numerator of a rational number is zero, then the rational number is equal to zero.


theorem continuous_if :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {p : α → Prop}
      {f g : α → β} [inst_2 : (a : α) → Decidable (p a)],
      (∀ a ∈ frontier {x | p x}, f a = g a) →
        ContinuousOn f (closure {x | p x}) →
          ContinuousOn g (closure {x | ¬p x}) → Continuous fun a => if p a then f a else g a :=
  by sorry

The theorem `continuous_if` states that for any types `α` and `β` equipped with topological spaces, and any predicate `p : α → Prop`, if we have two functions `f, g : α → β` and each `α` has a decidable predicate `p`, then if `f` and `g` agree on the frontier of the set where `p` holds, and `f` is continuous on the closure of the set where `p` holds while `g` is continuous on the closure of the set where `p` does not hold, then the function which maps each `α` to `f a` if `p a` holds and `g a` otherwise is continuous. In simple terms, it is a theorem about the continuity of a function defined piecewise for two subsets of a topological space.

If functions `f` and `g` agree on the boundary and are continuous on the closures of the sets where their respective domain predicates hold, then the piecewise defined function `h : α → β` that maps `f a` to points in `α` where `p(a)` holds and `g a` to points in `α` where `p(a)` does not hold is continuous.


theorem Nat.unpair_left_le : ∀ (n : ℕ), (Nat.unpair n).1 ≤ n := by sorry

This theorem states that for every natural number `n`, the first component of the pair obtained by unpairing `n` using the `Nat.unpair` function is always less than or equal to `n`. In other words, if we represent the unpaired values of `n` as a tuple `(a, b)`, then `a` is always less than or equal to `n` for all natural numbers `n`.

For all natural numbers `n`, the first component of the unpaired representation `(a, _)` of `n` using `Nat.unpair` satisfies `a ≤ n`.


theorem Monotone.le_rightLim :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
      [inst_2 : TopologicalSpace β] [inst_3 : OrderTopology β] {f : α → β},
      Monotone f → ∀ {x y : α}, x ≤ y → f x ≤ Function.rightLim f y :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` has a linear order structure, `β` has a conditionally complete linear order and a topological space structure, and `β`'s order and topology are compatible (i.e., `β` is an order topology), given any monotone function `f` from `α` to `β` and any two elements `x` and `y` of `α` with `x ≤ y`, the value of `f` at `x` is less than or equal to the right limit of `f` at `y`. In mathematical terms, if $f: \alpha \rightarrow \beta$ is a monotone function and $x, y$ are elements in $\alpha$ such that $x \leq y$, then $f(x) \leq \lim_{t \rightarrow y^{+}}f(t)$ where the limit is evaluated from the right.

For any monotonic function $f: \alpha \to \beta$ between linearly ordered types $\alpha$ and conditionally complete linear order and topological space $\beta$ with compatible order and topology, and for any $x, y \in \alpha$ with $x \leq y$, we have $f(x) \leq \lim\limits_{t \to y^+} f(t)$.


SchwartzMap.continuous

/-- Every Schwartz function is continuous.  -/
theorem SchwartzMap.continuous :
    ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (f : SchwartzMap E F), Continuous ⇑f :=
  by sorry

This theorem states that every Schwartz function is continuous. Here, a Schwartz function, denoted as `f : SchwartzMap E F`, is a type of function between two normed spaces `E` and `F` over the real numbers. The spaces `E` and `F` are assumed to be normed add commutative groups. Therefore, for any Schwartz function `f`, the function application `⇑f` (i.e., applying `f` to its arguments) is guaranteed to be continuous.

Every Schwartz function between two normed spaces is continuous.


theorem MeasureTheory.Measure.snd_apply :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {ρ : MeasureTheory.Measure (α × β)} {s : Set β},
      MeasurableSet s → ↑↑(MeasureTheory.Measure.snd ρ) s = ↑↑ρ (Prod.snd ⁻¹' s) :=
  by sorry

The theorem `MeasureTheory.Measure.snd_apply` states that for any types `α` and `β`, which have associated measurable spaces, any measure `ρ` on the product space `α × β`, and any set `s` of `β` that is measurable, the measure of `s` under the marginal measure on `β` obtained from `ρ` (noted as `MeasureTheory.Measure.snd ρ s`) is equal to the measure under `ρ` of the preimage of `s` under the second projection function (`Prod.snd`). In other words, the measure of a set in the marginal distribution is the same as the measure of the set of pairs that map to that set in the original distribution.

For any measurable spaces (α, Σα) and (β, Σβ), measurable set s ∈ Σβ, and measure ρ on the product space (α × β) with Σα × Σβ-measurable second projection function p, the measure of s under the marginal measure on β (MeasureTheory.Measure.snd ρ s) equals the measure of p⁁⁻¹(s) under ρ.


theorem SetLike.mul_mem_graded :
    ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : SetLike S R] [inst_1 : Mul R] [inst_2 : Add ι] {A : ι → S}
      [inst_3 : SetLike.GradedMul A] ⦃i j : ι⦄ {gi gj : R}, gi ∈ A i → gj ∈ A j → gi * gj ∈ A (i + j) :=
  by sorry

This theorem states that for any types ι, R, and S, given that S is a set of R, R has a multiplication operation, and ι has an addition operation, and given a function A : ι → S that assigns each type ι instance to a set of R (where A supports a notion of graded multiplication), if gi is an element of A at index i and gj is an element of A at index j, then the product of gi and gj is an element of A at index (i + j). In simpler terms, it states that the product of two elements in a graded multiplication structure is also in the structure, at the index that is the sum of the original indices.

For any types ι, R, and S with R having multiplication and ι addition, given a graded multiplication structure A : ι → S, the product of two elements in A lies in A at the index of their sum.


theorem Mathlib.Combinatorics.SetFamily.Shadow._auxLemma.13 :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α},
      (t ∈ Finset.upShadow 𝒜) = ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t :=
  by sorry

The theorem `_auxLemma.13` in the `Mathlib.Combinatorics.SetFamily.Shadow` namespace states that for any type `α` with decidable equality and finite number of instances, and for any set of sets `𝒜` and set `t` of type `α`, `t` belongs to the upper shadow of `𝒜` if and only if there exists a set `s` in `𝒜` and an element `a` not in `s` such that inserting `a` into `s` yields `t`. The upper shadow of a set family `𝒜` is all sets we can get by adding one element to any set in `𝒜`.

For any type `α` with decidable equality and finite number of instances, and any set family `𝒜` and set `t` of type `α`, `t` is in the upper shadow of `𝒜` if and only if there exists a set `s` in `𝒜` and an element `a` not in `s` such that `t = s ∪ {a}`.


theorem eqOn_dslope_slope :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (f : 𝕜 → E) (a : 𝕜), Set.EqOn (dslope f a) (slope f a) {a}ᶜ :=
  by sorry

The theorem `eqOn_dslope_slope` states that for any non-trivial normed field `𝕜`, a normed add commutative group `E`, a normed space over `𝕜` and `E`, and a function `f` mapping from `𝕜` to `E`, the functions `dslope` and `slope` of `f` at a point `a` are equal on the complement of the set `{a}`. In other words, except at the point `a`, the slope of the function `f` on the interval `[a, b]` equals to the derivative of `f` at `a` when `a = b`, and equals to `(b - a)⁻¹ • (f b - f a)` when `a ≠ b`.

For any non-trivial normed field `𝕜`, normed add commutative group `E`, and function `f` from `𝕜` to `E`, the functions `dslope` and `slope` of `f` agree on the complement of the singleton set containing any point `a` in `𝕜`, where `dslope` is the difference quotient and `slope` is the derivative.


theorem Real.exp_le_exp_of_le : ∀ {x y : ℝ}, x ≤ y → Real.exp x ≤ Real.exp y := by sorry

This theorem states that for all real numbers `x` and `y`, if `x` is less than or equal to `y`, then the exponential of `x` is less than or equal to the exponential of `y`. The exponential function here is the real exponential function, which is defined as the real part of the complex exponential. In mathematical terms, it can be written as: for all $x, y \in \mathbb{R}$, if $x \leq y$ then $\exp(x) \leq \exp(y)$. This is a property of the exponential function ensuring that it is a monotonically increasing function in the real numbers.

For all real numbers x and y, if x <= y then exp(x) <= exp(y).


theorem Finset.filter_card_add_filter_neg_card_eq_card :
    ∀ {α : Type u_1} {s : Finset α} (p : α → Prop) [inst : DecidablePred p] [inst_1 : (x : α) → Decidable ¬p x],
      (Finset.filter p s).card + (Finset.filter (fun a => ¬p a) s).card = s.card :=
  by sorry

This theorem states that for any given type `α` and a finite set `s` of type `α`, along with a decidable predicate `p`, the sum of the cardinality of the subset of `s` for which `p` holds and the cardinality of the subset of `s` for which `p` does not hold (`¬p`) equals the cardinality of the original set `s`. This is essentially a partition of the finite set `s` based on whether the elements satisfy the predicate `p` or not, asserting that the size of the entire set is the sum of the sizes of the two partitions.

For any finite type `α` and decidable predicate `p` on `α`, the cardinality of `{x : α | p x}` plus the cardinality of `{x : α | ¬p x}` equals the cardinality of `α`.


theorem MvPolynomial.totalDegree_add :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (a b : MvPolynomial σ R),
      MvPolynomial.totalDegree (a + b) ≤ max (MvPolynomial.totalDegree a) (MvPolynomial.totalDegree b) :=
  by sorry

The theorem `MvPolynomial.totalDegree_add` states that for any commutative semiring `R`, and any set of variables indices `σ`, the total degree of the sum of two multivariate polynomials `a` and `b` (from `R` over `σ`) is less than or equal to the maximum of their respective total degrees.

Here, the total degree of a multivariate polynomial is defined as the maximum sum of exponents in all of its monomials. The theorem is essentially saying that adding two multivariate polynomials doesn't increase the degree beyond the degree of the polynomial with the highest degree in the addends.

The total degree of the sum of two multivariate polynomials over a commutative semiring is less than or equal to the maximum of their individual total degrees.


theorem Commute.symm_iff : ∀ {S : Type u_2} [inst : Mul S] {a b : S}, Commute a b ↔ Commute b a := by sorry

This theorem states that for any type `S` equipped with a multiplication operation (`Mul`), and for any two elements `a` and `b` of this type, `a` and `b` commute (i.e., `a * b = b * a`) if and only if `b` and `a` commute. In other words, the commutativity of two elements is symmetric: if `a` commutes with `b`, then `b` commutes with `a`, and vice versa.

For any type `S` with multiplication `Mul`, and for all `a` and `b` in `S`, `a` commutes with `b` if and only if `b` commutes with `a`.


theorem Function.Injective.preimage_surjective :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β}, Function.Injective f → Function.Surjective (Set.preimage f) := by sorry

The theorem `Function.Injective.preimage_surjective` states that for any types `α` and `β` and any function `f` from `α` to `β`, if `f` is injective (meaning that if `f x = f y` then `x = y`), then the function mapping each set of `β` elements to its preimage under `f` is surjective. In other words, every set of `α` elements is the preimage under `f` of some set of `β` elements. This can be read as "the preimage operation is surjective for any injective function."

If `f` is an injective function from type `α` to type `β`, then the preimage function ` f ⁁⁃¹` from `β` to `α` is surjective.


theorem Ordinal.aleph0_le_cof : ∀ {o : Ordinal.{u_2}}, Cardinal.aleph0 ≤ Ordinal.cof o ↔ Ordinal.IsLimit o := by sorry

This theorem, `Ordinal.aleph0_le_cof`, states that for any ordinal 'o', the smallest infinite cardinal, usually denoted as `ℵ₀` (aleph-null or aleph-zero), is less than or equal to the cofinality of 'o' if and only if 'o' is a limit ordinal. In other words, `ℵ₀` being less than or equal to the cofinality of an ordinal is both a necessary and sufficient condition for that ordinal to be a limit ordinal. In terms of set theory, the cofinality of an ordinal is the minimum cardinality of any unbounded subset of the ordinal, and a limit ordinal is an ordinal that is not zero and not a successor ordinal.

The smallest infinite cardinal `ℵ₀` is less than or equal to the cofinality of an ordinal `o` if and only if `o` is a limit ordinal.


/-- **First moment method**. A measurable function is smaller than its mean on a set of positive
measure.  -/
theorem MeasureTheory.measure_le_laverage_pos :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal}
      [inst : MeasureTheory.IsFiniteMeasure μ], μ ≠ 0 → AEMeasurable f μ → 0 < ↑↑μ {x | f x ≤ ⨍⁻ (a : α), f a ∂μ} :=
  by sorry

This theorem is known as the **First Moment Method**. It states that, for any type `α`, any measure space `m0` over `α`, any measure `μ` over `α`, and any function `f` from `α` to the extended nonnegative real numbers, given that the measure `μ` is finite and nonzero, and also that the function `f` is almost everywhere measurable with respect to `μ`, then the measure of the set of all elements `x` for which `f(x)` is less than or equal to the Lebesgue integral of `f` over `μ` is positive. In mathematical terms, if `μ ≠ 0` and `f` is almost everywhere measurable with respect to `μ`, then `0 < μ({x | f(x) ≤ ∫ (a : α), f(a) dμ})`.

For any measurable function `f` on a finite and nonzero measure space `(α, μ)`, the set of elements with `f(x)` less than or equal to the Lebesgue integral of `f` has positive measure.


theorem Polynomial.eval₂_neg :
    ∀ {R : Type u} [inst : Ring R] {p : Polynomial R} {S : Type u_1} [inst_1 : Ring S] (f : R →+* S) {x : S},
      Polynomial.eval₂ f x (-p) = -Polynomial.eval₂ f x p :=
  by sorry

This theorem, `Polynomial.eval₂_neg`, states that for any given ring `R` of type `u` and ring `S` of type `u_1`, for any polynomial `p` defined over the ring `R`, and any ring homomorphism `f` from `R` to `S`, and for any element `x` of the ring `S`, the evaluation of the negative of the polynomial `p` at `x` using `f` is equal to the negative of the evaluation of the polynomial `p` at `x` using `f`. In other words, negating the polynomial before evaluation is equivalent to negating the result of evaluation.

For any ring homomorphism `f` and any element `x`, the evaluation of the negative of a polynomial `p` at `x` using `f` equals the negative of the evaluation of `p` at `x` using `f`.


theorem inv_zpow' : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℤ), a⁻¹ ^ n = a ^ (-n) := by sorry

This theorem states that for any type `α` that forms a division monoid, and any element `a` of type `α` and an integer `n`, the inverse of `a` raised to the power of `n` equals `a` raised to the power of `-n`. In mathematical terms, if `a` is an element of a division monoid and `n` is an integer, then `(1/a)^n = a^(-n)`.

For any division monoid element `a` and integer `n`, `(1/a)^n = a^(-n)`.


theorem OrderIso.coe_toOrderEmbedding :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β), ⇑(OrderIso.toOrderEmbedding e) = ⇑e :=
  by sorry

This theorem states that for any two types `α` and `β` which have defined less than or equal to operations (`LE`), any order isomorphism `e` from `α` to `β` remains unchanged when reinterpreted as an order embedding. In other words, the function `OrderIso.toOrderEmbedding` does not modify the behavior of the order isomorphism when converting it to an order embedding. It simply changes the way it is viewed or used. This is expressed by the equality `⇑(OrderIso.toOrderEmbedding e) = ⇑e`, where `⇑` is the coercion function that applies the isomorphism or embedding to an element of `α`.

The order isomorphism between types `α` and `β` remains the same when converted from an order isomorphism to an order embedding using `OrderIso.toOrderEmbedding`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.7 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {s : Set ι}
      {f : ι → α} {g : ι → β}, AntivaryOn f g⁻¹ s = MonovaryOn f g s :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.7` states that for all types `ι`, `α`, and `β`, where `α` and `β` form ordered commutative groups, and for any set `s` of type `ι`, and functions `f : ι → α` and `g : ι → β`, the statement that `f` antivaries with the inverse of `g` on `s` is equivalent to the statement that `f` monovaries with `g` on `s`. In other words, `f` and `g⁻¹` varying in opposite directions on `s` is equivalent to `f` and `g` varying in the same direction on `s`.

The theorem states that for functions `f : ι → α` and `g : ι → β` defining ordered commutative groups `α` and `β`, the condition that `f` antivaries with the inverse of `g` on a set `s` is equivalent to `f` monovaries with `g` on `s`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.8 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {s : Set ι} {f : ι → α} {g : ι → β}, AntivaryOn f (-g) s = MonovaryOn f g s :=
  by sorry

This theorem, named `Mathlib.Algebra.Order.Monovary._auxLemma.8`, establishes an equivalence between two types of variations, namely antivariation and monovariation, under a specific condition. Specifically, it states that for any typology `ι`, and any ordered additive commutative groups `α` and `β`, a function `f : ι → α` antivaries with the negation of function `g : ι → β` on a set `s` if and only if `f` monovaries with `g` on the same set `s`. In other words, if for all `i, j ∈ s`, `g i < g j` implies `f j ≤ f i` (definition of antivariation with `-g`), it is equivalent to saying that `g i < g j` implies `f i ≤ f j` (definition of monovariation with `g`).

For any typology `ι`, ordered additive commutative groups `α` and `β`, and sets `s`, a function `f : ι → α` antivaries with the negation of `g : ι → β` on `s` if and only if `f` monovaries with `g` on `s`. That is, `g i < g j` implies `f j ≤ f i` (antivariation) if and only if `g i < g j` implies `f i ≤ f j` (monovariation).


theorem Mathlib.Algebra.Order.Monovary._auxLemma.5 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {s : Set ι}
      {f : ι → α} {g : ι → β}, MonovaryOn f g⁻¹ s = AntivaryOn f g s :=
  by sorry

This theorem states that for any types `ι`, `α`, and `β` with `α` and `β` being ordered commutative groups, and for any set `s` of type `ι`, and any functions `f` from `ι` to `α` and `g` from `ι` to `β`, the function `f` monovaries with the inverse function `g⁻¹` on the set `s` if and only if the function `f` antivaries with the function `g` on the set `s`. In other words, if for all `i, j ∈ s`, `g(i) < g(j)` implies `f(i) ≤ f(j)` when considering `g⁻¹`, then the same condition implies `f(j) ≤ f(i)` when considering `g`.

For types `ι`, `α` with `α` being an ordered commutative group, and functions `f: ι → α` and `g: ι → α⁇` from a set `s ∈ ι` with `g` order-preserving, `f` monovaries with `g⁻¹` on `s` if and only if `f` antivaries with `g` on `s`. Here, `α⁇` denotes the additive group inverse of `α`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.6 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn f (-g) s = AntivaryOn f g s :=
  by sorry

This theorem states that for any set `s` of some type `ι`, a function `f` from `ι` to an ordered additive commutative group `α`, and a function `g` from `ι` to another ordered additive commutative group `β`, the function `f` monovaries with the negation of `g` on `s` if and only if `f` antivaries with `g` on `s`. In other words, if `f` increases when `-g` increases, then `f` decreases when `g` increases, and vice versa. This bridges the concept of monovariation and antivariation in the context of ordered additive commutative groups.

For any functions $f : X \rightarrow (-\alpha, \infty), g : X \rightarrow \beta$ on ordered additive commutative groups, where $X$ is a set of some type, $f$ monovaries with the negation of $g$ if and only if $f$ antivaries with $g$.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.9 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {f : ι → α}
      {g : ι → β}, Monovary f⁻¹ g = Antivary f g :=
  by sorry

The theorem `Mathlib.Algebra.Order.Monovary._auxLemma.9` states that for all types `ι`, `α`, and `β`, if `α` and `β` are ordered commutative groups, and if `f` is a function from `ι` to `α` and `g` is a function from `ι` to `β`, then `f` is said to monovary inversely with `g` if and only if `f` antivaries with `g`. In mathematical terms, this means that for all elements `i` and `j` in `ι`, if `g(i) < g(j)` then `1/f(i) ≤ 1/f(j)` if and only if `f(j) ≤ f(i)`.

For functions $f:\ι\to\alpha$ and $g:\ι\to\β$ between ordered commutative groups $\alpha$ and $\beta$, $f$ monovaries inversely with $g$ if and only if $f$ antivaries with $g$, i.e., for all $i,j\in\ι$, $g(i)<g(j)$ implies $1/f(i)\leq1/f(j)$ if and only if $f(j)\leq f(i)$.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.3 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {s : Set ι}
      {f : ι → α} {g : ι → β}, AntivaryOn f⁻¹ g s = MonovaryOn f g s :=
  by sorry

This theorem states that for any types `ι`, `α`, and `β`, where `α` and `β` are ordered commutative groups, and any set `s` of type `ι`, the functions `f : ι → α` and `g : ι → β` antivary on `s` with respect to the inverse of `f` if and only if they monovary on `s` with respect to `f`. In other words, if for all `i, j` in `s`, `g(i) < g(j)` implies `1/f(j) ≤ 1/f(i)`, then it also implies `f(i) ≤ f(j)`, and vice versa.

For types `ι`, `α` with commutative ordered groups `α` and `β`, and functions `f : ι → α` and `g : ι → β` over `ι`, if `g` antivaries with respect to the inverse of `f` over a set `s`, then `f` and `g` monovary with respect to each other over `s`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.4 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {s : Set ι} {f : ι → α} {g : ι → β}, AntivaryOn (-f) g s = MonovaryOn f g s :=
  by sorry

This theorem states that for any set `s` of elements of type `ι`, and any two functions `f : ι → α` and `g : ι → β`, where `α` and `β` are both ordered additive commutative groups, the condition that `-f` antivaries with `g` on `s` is equivalent to `f` monovaries with `g` on `s`. In other words, `g` increasing while `-f` decreases is the same as `g` increasing while `f` also increases over the set `s`.

For sets `s` of elements, functions `f : ι → α` and `g : ι → β` from the same index type `ι` with values in ordered additive commutative groups `α` and `β`, respectively, the condition that `-f` antitones (or decreases) with `g` is equivalent to `f` cotones (or increases) with `g` on `s`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.1 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedCommGroup α] [inst_1 : OrderedCommGroup β] {s : Set ι}
      {f : ι → α} {g : ι → β}, MonovaryOn f⁻¹ g s = AntivaryOn f g s :=
  by sorry

The theorem states that for any set `s` of elements of type `ι`, and any two functions `f : ι → α` and `g : ι → β`, where `α` and `β` are types over which an ordered commutative group structure is defined, the function `f` inversely monovaries with `g` on `s` if and only if `f` antivaries with `g` on `s`. In other words, if for every pair of elements `i, j` in `s` such that `g(i) < g(j)`, we have `f(j) ≤ f(i)`, then for the same pair `i, j`, we have `(f⁻¹)(i) ≤ (f⁻¹)(j)`. Here, `f⁻¹` refers to the inverse function of `f` in the group structure.

For functions `f : ι → α` and `g : ι → β` defined on a set `s` with `α` and `β` having ordered commutative group structures, `f` inversely monovaries with `g` on `s` if and only if `f` antivaries with `g` on `s`, that is, for all `i, j` in `s` with `g(i) < g(j)`, we have `(f⁻¹)(i) ≤ (f⁻¹)(j)` if and only if `f(j) ≤ f(i)`.


theorem Mathlib.Algebra.Order.Monovary._auxLemma.2 :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommGroup α] [inst_1 : OrderedAddCommGroup β]
      {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn (-f) g s = AntivaryOn f g s :=
  by sorry

This theorem states that for any types `ι`, `α` and `β` and for any two functions `f : ι → α` and `g : ι → β` defined on a set `s` of elements of type `ι`, the condition that `-f` monovaries with `g` on `s` is equivalent to `f` antivaries with `g` on `s`. Here, `α` and `β` are ordered additive commutative groups, which give an ordering and addition operation on `α` and `β`. The term "monovary" means that as `g` increases, `-f` does not decrease, and "antivary" means that as `g` increases, `f` does not increase.

For functions `f : ι -> α` and `g : ι -> β` on a set `s` with `α` and `β` ordered additive commutative groups, `-f` monovaries with `g` if and only if `f` antivaries with `g`, that is, `g(x) > g(y) => -f(x) <= -f(y) <-> f(x) <= f(y)` for all `x, y in s`.


theorem AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.denom_not_mem :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      {𝒜 : ℕ → Submodule R A} [inst_3 : GradedAlgebra 𝒜] {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m)
      (q :
        ↑↑(AlgebraicGeometry.Spec.locallyRingedSpaceObj
                (CommRingCat.of (HomogeneousLocalization.Away 𝒜 f))).toPresheafedSpace),
      f ∉ AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.asIdeal f_deg hm q :=
  by sorry

This theorem states that for any commutative ring `R`, another ring `A` which is an algebra over `R`, a grading on `A` by natural numbers represented by `𝒜`, and any element `f` of `A` that belongs to the `m`-th graded part of `A` where `m` is positive, if we consider the spectrum of the localized ring at `f` as a locally ringed space, then `f` is not an element of the ideal associated with the carrier of the projective morphism from the spectrum of the top component of the localization of `A` at `f` to the spectrum of `R`. In other words, `f` is not in the ideal of the corresponding point in the projective scheme. This is a key property in the construction of projective schemes in algebraic geometry.

For any commutative ring `R`, an algebra `A` over `R` with a positive grading `𝒜`, and an element `f` in the `m`-th graded part of `A`, `f` is not in the ideal of the corresponding point in the projective scheme of `A` localized at `f`.


theorem Complex.tendsto_abs_tan_of_cos_eq_zero :
    ∀ {x : ℂ},
      Complex.cos x = 0 → Filter.Tendsto (fun x => Complex.abs (Complex.tan x)) (nhdsWithin x {x}ᶜ) Filter.atTop :=
  by sorry

This theorem asserts that for all complex numbers `x` where the complex cosine of `x` equals zero, the absolute value of the complex tangent function, when applied to `x`, tends to infinity. In other words, if you take a sequence of complex numbers converging to `x` and avoid `x` itself (this is what `nhdsWithin x {x}ᶜ` denotes), then the absolute values of their tangents increase without bound (indicated by `Filter.atTop`). This behavior is similar to the real tangent function, which also tends to infinity at the points where the cosine function equals zero.

For complex numbers `x` with cosine equal to zero, the absolute value of the tangent function approaches infinity in the neighborhood of `x`.


theorem MeasureTheory.measurePreserving_add_right :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Add G] [inst_2 : MeasurableAdd G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsAddRightInvariant μ] (g : G),
      MeasureTheory.MeasurePreserving (fun x => x + g) μ μ :=
  by sorry

This theorem states that for any type `G` that has a measurable space structure, an addition operation, and a measurable addition property, and for any measure `μ` on `G` that is add-right invariant, the function that adds any given element `g` of `G` to `x` is measure-preserving under `μ`. In simpler terms, adding a fixed element `g` to any element `x` from the measure space does not change the measure of the set.

For any measurable additive group `(G, +)` with a measure `μ` that is right-invariant, the translation map `x ↦ x + g` is a measure-preserving function for all `g ∈ G`.


theorem Function.argminOn_le :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LinearOrder β] (h : WellFounded fun x x_1 => x < x_1)
      (s : Set α) {a : α} (ha : a ∈ s) (hs : optParam (Set.Nonempty s) ⋯), f (Function.argminOn f h s hs) ≤ f a :=
  by sorry

The theorem `Function.argminOn_le` states that for any types `α` and `β`, a function `f` from `α` to `β`, and a non-empty set `s` of `α`, if `β` has a linear order and well-foundedness property, then the function value at the element of `s` that minimizes the function `f` (determined by `Function.argminOn`) is less than or equal to the function value at any other element of `s`. This means that for any given element `a` in the set `s`, the value of `f` at `Function.argminOn f h s hs` is always less than or equal to the value of `f` at `a`.

For any non-empty set `s` and function `f` from a type `α` to a linearly ordered and well-founded type `β`, the minimum value of `f` in `s` (as defined by `Function.argminOn`) is less than or equal to the value of `f` at any other element in `s`.


theorem Rat.norm_cast_real : ∀ (r : ℚ), ‖↑r‖ = ‖r‖ := by sorry

This theorem states that for every rational number `r`, the norm (or absolute value) of `r` as a real number (indicated by `↑r`) is equal to the norm of `r` as a rational number. In other words, casting a rational number to a real number doesn't change its norm.

For every rational number `r`, the absolute value of `r` as a real number equals the absolute value of `r` as a rational number. (i.e., `|↑r| = |r|`)


theorem List.rotate'_cons_succ :
    ∀ {α : Type u} (l : List α) (a : α) (n : ℕ), List.rotate' (a :: l) (Nat.succ n) = List.rotate' (l ++ [a]) n := by
  sorry

The theorem `List.rotate'_cons_succ` states that for any list `l` of elements of an arbitrary type `α`, any element `a` of type `α`, and any natural number `n`, rotating the list obtained by prepending `a` to `l` by `n+1` places (using the `rotate'` function) is the same as first appending `a` to the end of `l` and then rotating the resultant list by `n` places. In other words, it's just as effective to rotate the list after moving the first element to the end as it is to rotate the list first and then move the element.

For any list `l` of length `n+1` over type `α`, rotating `l` by `n+1` places using `rotate'` after appending an element `a` to the end is equivalent to first appending `a` to `l` and then rotating it by `n` places. In Lean notation: `(a :: l) ++ List.rotate l n = List.rotate (a :: l) (n + 1)`.


CategoryTheory.Functor.IsCoverDense.ext

theorem CategoryTheory.Functor.IsCoverDense.ext :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_6, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
      (G : CategoryTheory.Functor C D) [inst_2 : CategoryTheory.Functor.IsCoverDense G K]
      (ℱ : CategoryTheory.SheafOfTypes K) (X : D) {s t : ℱ.val.obj (Opposite.op X)},
      (∀ ⦃Y : C⦄ (f : G.obj Y ⟶ X), ℱ.val.map f.op s = ℱ.val.map f.op t) → s = t :=
  by sorry

The theorem `CategoryTheory.Functor.IsCoverDense.ext` states that for any categories `C` and `D`, Grothendieck topology `K` on `D`, a functor `G` from `C` to `D` which is cover dense, a sheaf of types `ℱ` on `K`, and two sections `s` and `t` of the sheaf `ℱ` over some object `X` in `D`, if for all objects `Y` in `C` and for all morphisms `f` from `G(Y)` to `X`, the image of `s` under the mapping `ℱ.val.map f.op` equals the image of `t` under the same mapping, then `s` and `t` must be equal.

In simpler terms, it indicates that if two sections of a sheaf coincide when mapped under any morphism from the image of `G`, then the two sections are identical. This theorem is a generalization of the uniqueness property of sections in the category of sheaves.

If `G` is a cover dense functor from category `C` to category `D` with Grothendieck topology `K`, and `s` and `t` are sections of sheaf `ℱ` on `K` over object `X` in `D` such that for all morphisms `f : G(Y) → X` from `C`, `ℱ.val.map f.op s = ℱ.val.map f.op t`, then `s = t`.


theorem Valued.valuedCompletion_apply :
    ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀]
      (x : K), Valued.v (↑K x) = Valued.v x :=
  by sorry

This theorem states that for any field `K` and any type `Γ₀` which is a linear ordered commutative group with zero, if `K` is a valued field with respect to `Γ₀`, then for any element `x` of `K`, the valuation of the canonical map applied to `x` is equal to the valuation of `x`. In other words, the valuation function is preserved under the completion, and this holds for any element in the field.

For any field `K` with a linear ordered commutative group structure `Γ₀` as its value group, and for any `x` in `K`, the valuation of `x` under the canonical map is equal to the valuation of `x` in `K` if `K` is a valued field with respect to `Γ₀`.


theorem Metric.ball_union_sphere :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ},
      Metric.ball x ε ∪ Metric.sphere x ε = Metric.closedBall x ε :=
  by sorry

This theorem, `Metric.ball_union_sphere`, states that for any type `α` that is equipped with a `PseudoMetricSpace` structure, and for any point `x` of type `α` and any real number `ε`, the union of the open ball centered at `x` with radius `ε` and the sphere centered at `x` with radius `ε` is equal to the closed ball centered at `x` with radius `ε`. In mathematical terms, this means that if you take all points `y` such that the distance from `y` to `x` is less than `ε` (which forms the open ball) and add the set of all points `y` such that the distance from `y` to `x` equals `ε` (which forms the sphere), you get the set of all points `y` such that the distance from `y` to `x` is less than or equal to `ε` (which forms the closed ball).

For any `PseudoMetricSpace` `α` and point `x` in `α` with real number `ε`, the closed ball centered at `x` with radius `ε` equals the union of the open ball centered at `x` with radius `ε` and the sphere centered at `x` with radius `ε`.


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

This theorem states that for any type `α` that is equipped with a topology, a preorder relationship, an order with a least element (denoted by `⊥`), and an order topology, the neighborhood filter at the least element `⊥` is equal to the infimum of filters generated by left-infinite right-open intervals `Set.Iio l` for all elements `l` such that `⊥` is less than `l`. In simpler terms, the neighborhoods of the least element `⊥` are the smallest open sets that contain all elements smaller than some `l`, where `l` is every element that is greater than `⊥`.

The neighborhood filter of the least element in a topological preorder with a least element is equal to the infimum of filters generated by left-infinite right-open intervals containing elements greater than the least element.


theorem Int.le_max_left : ∀ (a b : ℤ), a ≤ max a b := by sorry

This theorem, `Int.le_max_left`, states that for any two integers `a` and `b`, `a` is less than or equal to the maximum of `a` and `b`. In other words, no matter what two integers you choose, the first integer will always be less than or equal to whichever one is larger.


theorem le_iff_exists_mul : ∀ {α : Type u} [inst : CanonicallyOrderedCommMonoid α] {a b : α}, a ≤ b ↔ ∃ c, b = a * c :=
  by sorry

This theorem states that for any canonically ordered commutative monoid `α`, and any elements `a` and `b` of `α`, `a` is less than or equal to `b` if and only if there exists an element `c` in `α` such that `b` equals `a` multiplied by `c`. In other words, in this type of monoid, an element `a` is not greater than another element `b` exactly when `b` is a multiple of `a`.

For any commutative monoid equipped with a canonical order, element `a` is less than or equal to `b` if and only if `b` is a multiple of `a`.


theorem IsAddGroupHom.mem_ker :
    ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup H] (f : G → H) {x : G}, x ∈ IsAddGroupHom.ker f ↔ f x = 0 := by
  sorry

This theorem states that for any two types `G` and `H` where `H` is an additive group, and for any function `f` from `G` to `H` and any element `x` of `G`, the element `x` belongs to the kernel of `f` if and only if the function `f` applied to `x` equals the additive identity (0) in `H`. In mathematical terms, it states that for a function `f: G → H`, an element `x` is in the kernel of `f` (the preimage of the trivial subgroup of `H`) if and only if `f(x) = 0`.

For any additive group `H` and function `f` from a type `G` to `H`, an element `x` in `G` belongs to the kernel of `f` if and only if `f(x) = 0`.


theorem xor_true : Xor' True = Not := by sorry

The theorem `xor_true` states that the exclusive or function `Xor'` applied to the proposition `True` is equivalent to the negation function `Not`. In other words, if either of two propositions is true, but not both, and one of those propositions is `True`, this is equivalent to saying that the other proposition is false.

The theorem `xor_true` asserts that `Xor' True False ≡ Not False`.


theorem ContDiffAt.congr_of_eventuallyEq :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f f₁ : E → F}
      {x : E} {n : ℕ∞}, ContDiffAt 𝕜 n f x → f₁ =ᶠ[nhds x] f → ContDiffAt 𝕜 n f₁ x :=
  by sorry

This theorem states that if a function `f` is continuously differentiable at a point `x` in a given normed vector space over non-trivially normed field `𝕜`, and if there is another function `f₁` that is equal to `f` in the neighborhood of `x`, then `f₁` is also continuously differentiable at `x`. In other words, the property of being continuously differentiable at a certain point is preserved under changes to the function that are local to that point.

If a continuously differentiable function `f` at a point `x` in a normed vector space over a non-trivially normed field is equal to a function `f₁` in a neighborhood of `x`, then `f₁` is also continuously differentiable at `x`.


theorem Polynomial.natDegree_comp :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] {p q : Polynomial R},
      Polynomial.natDegree (Polynomial.comp p q) = Polynomial.natDegree p * Polynomial.natDegree q :=
  by sorry

The theorem `Polynomial.natDegree_comp` states that for any semiring `R` that has no zero divisors, and for any two polynomials `p` and `q` over `R`, the natural degree of the composition of `p` and `q` is equal to the product of the natural degree of `p` and the natural degree of `q`. The natural degree of a polynomial is the degree forced to be a natural number, with the degree of the zero polynomial defined as zero. The composition of two polynomials is a new polynomial achieved by substituting `q` into `p`.

For polynomials $p$ and $q$ over a semiring $R$ without zero divisors, the natural degree of their composition $p \circ q$ is equal to the product of the natural degrees of $p$ and $q$.


theorem Localization.add_mk_self :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (a : R) (b : ↥M) (c : R),
      Localization.mk a b + Localization.mk c b = Localization.mk (a + c) b :=
  by sorry

This theorem, `Localization.add_mk_self`, states that for any given commutative semiring `R`, a submonoid `M` of `R`, an element `a` of `R`, an element `b` of `M`, and an element `c` of `R`, the sum of the localized elements `Localization.mk a b` and `Localization.mk c b` is equal to the localized element `Localization.mk (a + c) b`. In other words, this theorem establishes the addition operation's behavior in the localization of a commutative semiring at a submonoid, showing that the addition of localized elements corresponds to the localization of their sum in the original semiring.

For any commutative semiring R, submonoid M, and elements a, b, c in R, the localization of a + c at b in R equals the localization of a at b plus the localization of c at b.


theorem Filter.smallSets_bot : ∀ {α : Type u_1}, Filter.smallSets ⊥ = pure ∅ := by sorry

The theorem `Filter.smallSets_bot` states that for any type `α`, the filter `smallSets` applied to the bottom filter (notated as `⊥`, which is the smallest filter or the trivial filter that only contains the whole set) is equal to the pure filter of the empty set. In other words, the largest filter containing all powersets of members of the smallest filter in a given type is the pure filter of the empty set.

For any type α, the filter of small sets applied to the bottom filter is equal to the pure filter of the empty set.


theorem CategoryTheory.MorphismProperty.RespectsIso.epimorphisms :
    ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C],
      CategoryTheory.MorphismProperty.RespectsIso (CategoryTheory.MorphismProperty.epimorphisms C) :=
  by sorry

This theorem states that in any category `C`, the property of being an epimorphism (a morphism such that any two morphisms that compose with it to equal morphisms are themselves equal) is preserved under composition with isomorphisms. More specifically, if a morphism `f` is an epimorphism, then for any isomorphism `e`, the morphisms obtained by composing `e` and `f` either on the left or on the right are also epimorphisms.

In any category, if a morphism is an epimorphism, then so is its composition with any isomorphism.


theorem norm_sum_le_of_le :
    ∀ {ι : Type u_4} {E : Type u_6} [inst : SeminormedAddCommGroup E] (s : Finset ι) {f : ι → E} {n : ι → ℝ},
      (∀ b ∈ s, ‖f b‖ ≤ n b) → ‖Finset.sum s fun b => f b‖ ≤ Finset.sum s fun b => n b :=
  by sorry

The theorem `norm_sum_le_of_le` states that for any finite set `s` of elements of type `ι`, if each element `b` in `s` is such that the norm of `f(b)` is less than or equal to `n(b)`, then the norm of the sum of `f(b)` over all `b` in `s` is less than or equal to the sum of `n(b)` over all `b` in `s`. Here, `f` is a function mapping `ι` to a seminormed add commutative group `E`, and `n` is a function mapping `ι` to real numbers.

For any finite set `s` and function `f` from a type `ι` to a seminormed add commutative group `E`, and function `n` from `ι` to the real numbers, if `||f(b)|| ≤ n(b)` for all `b` in `s`, then `||∑(b ∈ s) f(b)|| ≤ ∑(b ∈ s) n(b)`.


theorem Finsupp.neLocus_comm :
    ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] (f g : α →₀ N),
      Finsupp.neLocus f g = Finsupp.neLocus g f :=
  by sorry

The theorem `Finsupp.neLocus_comm` states that for any two finitely supported functions `f` and `g` from a type `α` to a type `N` where `N` has a zero and `α` and `N` have decidable equality, the set of elements where `f` and `g` differ (denoted by `Finsupp.neLocus f g`) is the same as the set of elements where `g` and `f` differ (denoted by `Finsupp.neLocus g f`). In other words, the `Finsupp.neLocus` operation is commutative.

For any two finitely supported functions `f` and `g` from type `α` to type `N` with `N` having a zero and `α` and `N` having decidable equality, `Finsupp.neLocus f g` equals `Finsupp.neLocus g f`.


theorem IsAbsoluteValue.abv_add :
    ∀ {S : Type u_5} [inst : OrderedSemiring S] {R : Type u_6} [inst_1 : Semiring R] (abv : R → S)
      [inst_2 : IsAbsoluteValue abv] (x y : R), abv (x + y) ≤ abv x + abv y :=
  by sorry

This theorem states that for any ordered semiring `S` and any semiring `R`, given an absolute value function `abv` from `R` to `S`, and any elements `x` and `y` from `R`, the absolute value of the sum of `x` and `y` is less than or equal to the sum of the absolute values of `x` and `y`. This is a generalization of the triangle inequality in the context of absolute values in semirings.

For any ordered semirings S and semiring R, and absolute value function abv from R to S, |x + y| ≤ |x| + |y| holds for all x, y in R.


HasFPowerSeriesOnBall.continuousOn

/-- If a function admits a power series expansion on a disk, then it is continuous there.  -/
theorem HasFPowerSeriesOnBall.continuousOn :
    ∀ {𝕜 : 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 : ENNReal},
      HasFPowerSeriesOnBall f p x r → ContinuousOn f (EMetric.ball x r) :=
  by sorry

The theorem `HasFPowerSeriesOnBall.continuousOn` states that for any function `f` mapping from a normed space `E` over a nontrivially normed field `𝕜` to a normed space `F` over the same field, if the function `f` has a power series expansion `p` on a disk in `E` centered at a point `x` with a non-negative extended real number radius `r`, then the function `f` is continuous on the disk. Here, the disk is defined as the set of all points whose extended metric distance to the center `x` is less than the radius `r`.

If a function `f` from a normed space `E` to a normed space `F` over a nontrivially normed field has a convergent power series expansion on the disk centered at `x` with radius `r`, then `f` is continuous on the disk.


/-- `K` and `Kᗮ` have trivial intersection.  -/
theorem Submodule.orthogonal_disjoint :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (K : Submodule 𝕜 E), Disjoint K Kᗮ :=
  by sorry

The theorem states that for any field `𝕜`, and any inner product space `E` over `𝕜`, the intersection of any submodule `K` of `E` and its orthogonal complement `Kᗮ` is trivial. The term "trivial" in this context refers to the situation where the greatest element that belongs to both `K` and `Kᗮ` is the bottom element of the lattice, as defined in the `Disjoint` function. This is analogous to the idea of disjoint sets in set theory, where the intersection of disjoint sets is the empty set.

For any field `𝕜` and inner product space `E` over `𝕜`, the intersection of a submodule `K` of `E` and its orthogonal complement `Kᗮ` is the zero submodule.


/-- If every functor `yoneda.obj X` is a `J`-sheaf, then `J` is subcanonical.  -/
theorem CategoryTheory.Sheaf.Subcanonical.of_yoneda_isSheaf :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
      (∀ (X : C), CategoryTheory.Presieve.IsSheaf J (CategoryTheory.yoneda.obj X)) →
        CategoryTheory.Sheaf.Subcanonical J :=
  by sorry

The theorem `CategoryTheory.Sheaf.Subcanonical.of_yoneda_isSheaf` states that for any category `C` and any Grothendieck topology `J` on `C`, if every object `X` in `C` satisfies the condition that the functor `yoneda.obj X` is a `J`-sheaf, then `J` is subcanonical. In other words, if all representable functors (given by the Yoneda embedding) are `J`-sheaves, then the topology `J` is smaller than or equal to the canonical topology, and thus is considered subcanonical.

If every representable functor in a category with a Grothendieck topology is a sheaf for that topology, then the topology is subcanonical.


theorem UpperHalfPlane.continuous_coe : Continuous UpperHalfPlane.coe := by sorry

This theorem states that the canonical embedding of the upper half-plane into the complex numbers, denoted as `UpperHalfPlane.coe`, is continuous. In other words, it guarantees that for every point in the upper half-plane, small changes in the input result in small changes in the output when mapped to the complex numbers using the function `UpperHalfPlane.coe`. This is a fundamental requirement in topology and complex analysis.

The function `UpperHalfPlane.coe` mapping the upper half-plane to the complex numbers is continuous.


theorem orderOf_eq_zero_iff : ∀ {G : Type u_1} [inst : Monoid G] {x : G}, orderOf x = 0 ↔ ¬IsOfFinOrder x := by sorry

The theorem `orderOf_eq_zero_iff` states that for any type `G` that forms a monoid, and any element `x` of that monoid, the order of `x` is zero if and only if `x` is not of finite order. In other words, if `x` is an element of a monoid that does not satisfy the property of having a finite order (i.e., there does not exist a positive integer `n` such that `x^n=1`), then by definition, the order of `x` is zero. Conversely, if the order of `x` is zero, it means that `x` does not have a finite order.

For any monoid element x, its order is zero if and only if x is of infinite order.


theorem MeasureTheory.Measure.restrict_restrict' :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasurableSet t → (μ.restrict t).restrict s = μ.restrict (s ∩ t) :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` over `α`, any measure `μ` on that measurable space, and any two sets `s` and `t` of the type `α`, if `t` is a measurable set, then the restriction of the restriction of the measure `μ` to the set `t` to the set `s` is equivalent to the restriction of the measure `μ` to the intersection of the sets `s` and `t`. In other words, restricting a measure twice in a row is the same as restricting it once to the intersection of the two sets.

For any measurable space `(α, m0)`, measure `μ`, and sets `s` and `t` of type `α` with `t` measurable, the restriction of `μ` to `s` restricted to `t` equals the restriction of `μ` to `s ∩ t`.


theorem ContDiff.comp₂ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {G : Type uG} [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {n : ℕ∞}
      {E₁ : Type u_3} {E₂ : Type u_4} [inst_5 : NormedAddCommGroup E₁] [inst_6 : NormedAddCommGroup E₂]
      [inst_7 : NormedSpace 𝕜 E₁] [inst_8 : NormedSpace 𝕜 E₂] {g : E₁ × E₂ → G} {f₁ : F → E₁} {f₂ : F → E₂},
      ContDiff 𝕜 n g → ContDiff 𝕜 n f₁ → ContDiff 𝕜 n f₂ → ContDiff 𝕜 n fun x => g (f₁ x, f₂ x) :=
  by sorry

The theorem `ContDiff.comp₂` states that for any non-trivially normed field 𝕜, two functions `f₁` and `f₂` from a normed add commutative group F to normed add commutative groups E₁ and E₂ respectively, and a function `g` from the Cartesian product of E₁ and E₂ to a normed add commutative group G, if `g`, `f₁`, and `f₂` are continuously differentiable up to order `n`, then the composition function `x => g (f₁ x, f₂ x)` is also continuously differentiable up to order `n`.

If two continuously differentiable up to order `n` functions from a normed add commutative group to other normed add commutative groups have values in the domain of a third continuously differentiable up to order `n` function, then their composition is also continuously differentiable up to order `n`.


theorem Set.eq_empty_of_isEmpty : ∀ {α : Type u} [inst : IsEmpty α] (s : Set α), s = ∅ := by sorry

The theorem `Set.eq_empty_of_isEmpty` states that for any type `α`, if `α` is an empty type (i.e., there are no elements of type `α`), then any set `s` of type `α` is necessarily equal to the empty set. This follows because there are no elements to include in the set `s`.

If a type `α` is empty, then any set `s` of type `α` is the empty set.


theorem intervalIntegral.integral_comp_mul_right :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b c : ℝ} (f : ℝ → E),
      c ≠ 0 → ∫ (x : ℝ) in a..b, f (x * c) = c⁻¹ • ∫ (x : ℝ) in a * c..b * c, f x :=
  by sorry

This theorem states that for any normed additive commutative group `E` that is also a normed space over the real numbers, given any real numbers `a`, `b` and `c` and a function `f` from the real numbers to `E`, if `c` is not zero, then the interval integral from `a` to `b` of `f` applied to `x * c` equals `c` inverse scaled by the interval integral from `a * c` to `b * c` of `f x`. In other words, it describes a property of interval integrals where the scaling of the variable of integration can be moved outside of the integral.

For any normed additive commutative group `E` over the real numbers, if `f` is a function from the real numbers to `E`, and `a`, `b`, and `c` are real numbers with `c ≠ 0`, then ∫[a, b] (`x ↦ f(x * c)`) dx = (1/`c`) ∫[a*c, b*c] (`x ↦ f x`) dx.