theorem BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion :
    ∀ {ι : Type u_1} [inst : Fintype ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box ι) (c : NNReal),
      Filter.HasBasis (BoxIntegral.IntegrationParams.toFilterDistortion l I c) (BoxIntegral.IntegrationParams.RCond l)
        fun r => {π | BoxIntegral.IntegrationParams.MemBaseSet l I c r π} :=
  by sorry

This theorem, `BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion`, states that for any finite-dimensional type `ι`, any integration parameters `l`, any box `I`, and any nonnegative real number `c`, the filter derived from `l`, `I` and `c`, `BoxIntegral.IntegrationParams.toFilterDistortion l I c`, has a basis which is characterized by the predicate `BoxIntegral.IntegrationParams.RCond l`. The elements of this basis are those functions `r` which satisfy the property that all of the tagged partitions `π` belong to the base set `BoxIntegral.IntegrationParams.MemBaseSet l I c r π`. In simpler terms, the theorem defines the conditions under which a function belongs to the basis of a specific filter in the context of Box Integration.

For any finite-dimensional type `ι`, integration parameters `l`, box `I`, and nonnegative real number `c`, the filter derived from `l`, `I`, and `c` in Box Integration has a basis consisting of functions `r` that satisfy `BoxIntegral.IntegrationParams.RCond l` and belong to the base set `BoxIntegral.IntegrationParams.MemBaseSet l I c π` for all tagged partitions `π`.


theorem ONote.omega_le_oadd :
    ∀ (e : ONote) (n : ℕ+) (a : ONote), Ordinal.omega ^ ONote.repr e ≤ ONote.repr (ONote.oadd e n a) := by sorry

The theorem `ONote.omega_le_oadd` states that for any ordinal number `e`, a natural number `n` greater than zero, and another ordinal number `a`, the ordinal ω (omega), raised to the ordinal denoted by `e`, is less than or equal to the ordinal denoted by the ONote that adds `e`, `n`, and `a`. In other words, ω^e ≤ the ordinal represented by oadd(e, n, a). Here, ω represents the first infinite ordinal, defined as the order type of natural numbers. ONote is a structure used to denote ordinals in Lean 4, and ONote.repr returns the ordinal denoted by a given ONote.

For any ordinal numbers `e`, `n` > 0, and `a`, the ordinal ω^e is less than or equal to the ordinal represented by ONote.oadd(e, n, a).


theorem MeasureTheory.integral_sum_measure :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {ι : Type u_7}
      {x : MeasurableSpace α} {f : α → G} {μ : ι → MeasureTheory.Measure α},
      MeasureTheory.Integrable f (MeasureTheory.Measure.sum μ) →
        ∫ (a : α), f a ∂MeasureTheory.Measure.sum μ = ∑' (i : ι), ∫ (a : α), f a ∂μ i :=
  by sorry

This theorem states that, for any type `α`, a type `G` that forms a normed addition commutative group and also a normed space over real numbers, a type `ι` (which is used as an index type for a family of measures), a measurable space `x`, a function `f` from `α` to `G`, and a family of measures `μ` indexed by `ι`: if the function `f` is integrable with respect to the sum of the measures `μ`, then the integral of `f` with respect to the sum of the measures `μ` is equal to the sum (taken over all `i` in `ι`) of the integral of `f` with respect to each measure `μ i`. In other words, the integral of a function over a sum of measures is equal to the sum of integrals of the function over each measure, as long as the function is integrable over the sum of measures.

If `f` is an integrable function from a type `α` to a normed additive commutative group `G` over real numbers, and `μ` is a family of measures indexed by `ι`, then the integral of `f` with respect to the sum of `μ` equals the sum of integrals of `f` with respect to each `μ_i`.


theorem Real.ediam_Ioo : ∀ (a b : ℝ), EMetric.diam (Set.Ioo a b) = ENNReal.ofReal (b - a) := by sorry

The theorem `Real.ediam_Ioo` states that for any two real numbers `a` and `b`, the diameter of the set of real numbers which is strictly greater than `a` and strictly less than `b` (known as a left-open right-open interval, or `Set.Ioo a b` in Lean) is equal to the nonnegative part of the difference `b - a`. In mathematical terms, we can interpret this theorem as saying that the "diameter" of the interval $(a, b)$ in the real numbers is simply the length of that interval, i.e., $b - a$ if $b > a$, and $0$ otherwise.

The theorem `Real.ediam_Ioo` asserts that the diameter of the real interval `(a, b)` is equal to `abs (b - a)`.


theorem Set.ncard_insert_of_not_mem :
    ∀ {α : Type u_1} {s : Set α} {a : α},
      a ∉ s → autoParam (Set.Finite s) _auto✝ → Set.ncard (insert a s) = Set.ncard s + 1 :=
  by sorry

This theorem states that for a given set `s` of some type `α` and an element `a` of type `α`, if `a` is not already a member of `s` and `s` is a finite set (this condition is automatically inferred by the Lean prover), then the cardinality (number of elements) of the set obtained by inserting `a` into `s` is equal to the cardinality of `s` plus one. In other words, inserting a new element into a finite set increases its size by one.

For a finite set `s` of type `α` and an element `a` not in `s` of type `α`, |s ∪ {a}| = |s| + 1.


IsLeftRegular.mul

/-- In a semigroup, the product of left-regular elements is left-regular.  -/
theorem IsLeftRegular.mul :
    ∀ {R : Type u_1} [inst : Semigroup R] {a b : R}, IsLeftRegular a → IsLeftRegular b → IsLeftRegular (a * b) := by
  sorry

In a semigroup structure, the theorem `IsLeftRegular.mul` states that for any given type `R` equipped with a semigroup structure and any two elements `a` and `b` of that type, if `a` and `b` are both left-regular (meaning that multiplication on the left by either of these elements is an injective function), then the product of `a` and `b` is also left-regular. Simplified, if multiplying any element by `a` or `b` on the left always gives distinct results for distinct inputs, the same property holds true for the product of `a` and `b`.

If `a` and `b` are left-regular elements in a semigroup `R`, then the product `a * b` is also left-regular in `R`.


theorem isPreconnected_Ioc :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a b : α}, IsPreconnected (Set.Ioc a b) :=
  by sorry

The theorem `isPreconnected_Ioc` states that for any type `α` that has a conditionally complete linear order, a topological space structure, an order topology structure, and a densely ordered structure, and for any two elements `a` and `b` in this type `α`, the left-open right-closed interval from `a` to `b` (denoted as `(a, b]` in mathematical notation), is a preconnected set.

In simpler terms, this theorem says that in a properly ordered and topologically structured set, any interval that is open on the left and closed on the right is a preconnected set. A preconnected set is one where there is no non-trivial open partition, meaning we cannot divide it into two non-empty open sets that are disjoint and their union is the set itself.

In a type equipped with a conditionally complete linear order, topological space structure, and densely ordered structure, every left-open right-closed interval is a preconnected set.


theorem isPreconnected_Ioo :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a b : α}, IsPreconnected (Set.Ioo a b) :=
  by sorry

The theorem `isPreconnected_Ioo` states that for any type `α` that is a conditionally complete linear order, has a topological space structure, an order topology, and is densely ordered, the left-open right-open interval `(a, b)` (i.e., the set of elements `x` such that `a < x < b`) is preconnected. In terms of topology, a preconnected set is one where there is no non-trivial open partition, meaning it cannot be expressed as the union of two disjoint non-empty open sets. Thus, the theorem says that any open interval in such a space cannot be split into two disjoint non-empty open sets.

In a densely ordered, conditionally complete linear order `α` with a topology making it a topological space, the left-open right-open interval `(a, b)` is preconnected, meaning it cannot be expressed as the union of two disjoint non-empty open sets.


theorem Submodule.IsOrtho.mono_left :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {U₁ U₂ V : Submodule 𝕜 E}, U₂ ≤ U₁ → U₁ ⟂ V → U₂ ⟂ V :=
  by sorry

This theorem, `Submodule.IsOrtho.mono_left`, states that for any types 𝕜 and E, given 𝕜 is a ring-like structure, E is a normed additive commutative group, and E has an inner product structure over 𝕜, if we have two submodules U₁ and U₂ of E over 𝕜, and another submodule V of E over 𝕜, then if U₂ is a subset of U₁ and U₁ is orthogonal to V, it can be deduced that U₂ is also orthogonal to V. In mathematical terms, this states that orthogonality is preserved under taking subsets.

If submodule U₂ is a subset of orthogonal submodule U₁ in a normed additive commutative group E over a ring-like structure 𝕜 with an inner product structure, then U₂ is orthogonal to V if U₁ is.


theorem Nat.pow_lt_pow_of_lt : ∀ {a n m : ℕ}, 1 < a → n < m → a ^ n < a ^ m := by sorry

This theorem states that for any natural numbers `a`, `n`, and `m`, if `a` is greater than 1 and `n` is less than `m`, then `a` raised to the power `n` is less than `a` raised to the power `m`. In other words, for positive natural numbers, raising a larger base to a power results in a greater number, and similarly, raising a base to a larger exponent also results in a greater number.

For all natural numbers `a`, `n`, and `m` where `a` is greater than 1 and `n` is less than `m`, the inequality `a^n < a^m` holds.


theorem Filter.HasBasis.prod_same_index :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : Filter α} {sa : ι → Set α} {lb : Filter β} {p : ι → Prop}
      {sb : ι → Set β},
      Filter.HasBasis la p sa →
        Filter.HasBasis lb p sb →
          (∀ {i j : ι}, p i → p j → ∃ k, p k ∧ sa k ⊆ sa i ∧ sb k ⊆ sb j) →
            Filter.HasBasis (la ×ˢ lb) p fun i => sa i ×ˢ sb i :=
  by sorry

The theorem `Filter.HasBasis.prod_same_index` states that for any two types `α` and `β`, an index set `ι`, filters `la` and `lb` on `α` and `β` respectively, and collections of sets `sa`, `sb` indexed by `ι` and a predicate `p` on `ι`, if `la` and `lb` have a basis indexed by `ι` where for `la` the basis sets are given by `sa` and for `lb` the basis sets are given by `sb` such that the predicate `p` holds for the indices of these basis sets, and for any indices `i` and `j` where `p` holds, there exists an index `k` such that `p` holds for `k` and the `k`-th set in `sa` is a subset of the `i`-th set in `sa` and the `k`-th set in `sb` is a subset of the `j`-th set in `sb`, then the product filter `la ×ˢ lb` also has a basis indexed by `ι` where the basis sets are given by the product of the `i`-th set in `sa` and `sb`.

If filters `la` and `lb` on types `α` and `β` respectively, indexed by `ι`, have bases `sa` and `sb` satisfying certain conditions, then their product filter `la ×ˢ lb` also has a basis given by the product of the corresponding basis sets `sa` and `sb`.


theorem Primrec.of_equiv : ∀ {α : Type u_1} [inst : Primcodable α] {β : Type u_4} {e : β ≃ α}, Primrec ⇑e := by sorry

This theorem states that for any types `α` and `β`, if `α` is primitive encodable, and there exists a bijective function (or an equivalence) `e` from `β` to `α`, then the function represented by `e` (denoted by `⇑e`) is primitive recursive. In other words, if you can map every element of `β` to a unique element of `α` and vice versa, and `α` has a primitive encoding, then you can compute the function `e` in a primitive recursive manner.

If `α` is a primitive encodable type and there exists a bijective function `e : β → α`, then the function representation `⇑e` is primitive recursive.


theorem Finset.disjoint_val : ∀ {α : Type u_1} {s t : Finset α}, Multiset.Disjoint s.val t.val ↔ Disjoint s t := by
  sorry

The theorem `Finset.disjoint_val` states that for any two finite sets `s` and `t` of any arbitrary type `α`, the multiset values of `s` and `t` are disjoint if and only if the finite sets `s` and `t` themselves are disjoint. Here, two multisets are considered disjoint if they have no elements in common, and two elements of a lattice are disjoint if their infimum is the bottom element.

For any finite sets `s` and `t` of type `α` in Lean, their multisets have no common elements if and only if `s` and `t` are disjoint.


theorem MonoidAlgebra.support_mul :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Mul G] [inst_2 : DecidableEq G]
      (a b : MonoidAlgebra k G), (a * b).support ⊆ a.support * b.support :=
  by sorry

The theorem `MonoidAlgebra.support_mul` states that for any semiring `k` and any type `G` that has both multiplication and decidable equality, if `a` and `b` are elements of the monoid algebra of `G` over `k`, then the support of the product of `a` and `b` is a subset of the product of the supports of `a` and `b`. In mathematical terms, given $\alpha, \beta \in G \rightarrow k$ (elements of the monoid algebra), the support of $\alpha\beta$ is contained within the set product of the supports of $\alpha$ and $\beta$. The support of a function in this context is the set of points where the function is non-zero.

For any semiring `k` and type `G` with multiplication and decidable equality, the support of the product of two elements in the monoid algebra of `G` over `k` is contained in the product of their supports.


theorem PowerSeries.monomial_zero_eq_C_apply :
    ∀ {R : Type u_1} [inst : Semiring R] (a : R), (PowerSeries.monomial R 0) a = (PowerSeries.C R) a := by sorry

This theorem states that for any semiring `R` and any element `a` of this semiring, the zeroth monomial with coefficient `a` in the formal power series over `R` is equal to the constant formal power series with coefficient `a` over `R`. This means that both these power series representations, namely the zeroth monomial and the constant series, are equivalent when their coefficients are the same.

For any semiring `R` and its element `a`, the zeroth monomial `x⁰` in the formal power series over `R` with coefficient `a` is equal to the constant formal power series over `R` with coefficient `a`. In other words, `x⁰ = ∑₀ i, a : R` in the formal power series over `R`.


theorem Set.mulIndicator_eq_one :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {s : Set α} {f : α → M},
      (Set.mulIndicator s f = fun x => 1) ↔ Disjoint (Function.mulSupport f) s :=
  by sorry

This theorem states that for any set `s` of type `α` and any function `f` from `α` to `M` where `M` is a type with an identity element, the "multiplicative indicator function" of `s` and `f` is equal to the constant function returning the identity element if and only if the "multiplicative support" of `f` (the set of points `x` where `f(x)` is not the identity) is disjoint from `s`. Here, two sets are considered disjoint if their infimum is the "bottom" element, which in this context means that there is no element that is in both sets.

For any set `s` of type `α` and function `f` from `α` to a type `M` with an identity element, the multiplicative indicator function of `s` and `f` equals the constant function returning the identity element if and only if the support of `f` and `s` are disjoint.


theorem MeasureTheory.IsFundamentalDomain.sum_restrict_of_ac :
    ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
      {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableSMul G α]
      [inst_5 : MeasureTheory.SMulInvariantMeasure G α μ] [inst_6 : Countable G] {ν : MeasureTheory.Measure α},
      MeasureTheory.IsFundamentalDomain G s μ →
        MeasureTheory.Measure.AbsolutelyContinuous ν μ → (MeasureTheory.Measure.sum fun g => ν.restrict (g • s)) = ν :=
  by sorry

This theorem, "MeasureTheory.IsFundamentalDomain.sum_restrict_of_ac", states that for any Group `G`, any type `α` under the action of `G`, any measurable space `α`, any set `s` of elements of type `α`, any measure `μ` on `α`, assuming `G` is a measurable space and has a measurable scalar multiplication with `α`, `μ` is a scalar multiplication invariant measure, and `G` is countable, then for any measure `ν` on `α`, if `s` is a fundamental domain of `μ` under the action of `G` and `ν` is absolutely continuous with respect to `μ`, then the sum of the measures `ν` restricted to the orbit of `s` under the action of `G` is equal to `ν`.

In simpler terms, if you have a measure that is absolutely continuous with respect to a measure that is invariant under a certain group action, then when you sum over the measures of the group-translated copies of a fundamental domain, you get back the original measure.

If `G` is a countable measurable group acting on a measurable space `(α, μ)` with invariant measure `μ`, `s` is a fundamental domain, and `ν` is an absolutely continuous measure with respect to `μ`, then the sum of `ν` over the orbit of `s` under `G` equals `ν`.


theorem Rat.normalize_mul_left :
    ∀ {d : ℕ} {n : ℤ} {a : ℕ} (d0 : d ≠ 0) (a0 : a ≠ 0), Rat.normalize (↑a * n) (a * d) ⋯ = Rat.normalize n d d0 := by
  sorry

The theorem `Rat.normalize_mul_left`, states that for every integer `n`, and non-zero natural numbers `d` and `a`, the result of normalizing the rational number whose numerator is `a * n` and denominator is `a * d` is the same as the result of normalizing the rational number whose numerator is `n` and denominator is `d`. In other words, multiplication of the numerator and denominator of a rational number by a non-zero natural number `a` does not change the normalized value of the rational number. Here, normalization refers to the process of dividing the numerator and denominator by their greatest common divisor to ensure the resulting rational number is in its simplest form.

For any integer `n`, non-zero natural number `d`, and rational number `a/b`, normalizing the rational number `a * (n/d)` equals normalizing `(a/b) * n/d`.


theorem ConvexOn.convex_epigraph :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] [inst_5 : OrderedSMul 𝕜 β] {s : Set E}
      {f : E → β}, ConvexOn 𝕜 s f → Convex 𝕜 {p | p.1 ∈ s ∧ f p.1 ≤ p.2} :=
  by sorry

This theorem states that, for any ordered semiring `𝕜`, any type `E` with an additive commutative monoid structure and a `𝕜`-module structure, any type `β` with an ordered additive commutative monoid structure, a `𝕜`-module structure, and an ordered `𝕜`-scalar multiplication structure, a subset `s` of `E`, and a function `f` from `E` to `β`, if the function `f` is convex on the set `s` (`ConvexOn 𝕜 s f`), then the epigraph of `f` on `s` (the set of points `(x, y)` such that `x` is in `s` and `y` is greater or equal to `f(x)`) is a convex set in `𝕜`.

For any ordered semiring `𝕜`, if `f` is a convex function on a subset `s` of an additive commutative monoid `E` endowed with a `𝕜`-module and an ordered `𝕜`-scalar multiplication structure, then the epigraph of `f` on `s` is a convex set in `E × ℝ`.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.47 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α}, (0 ≤ dist x y) = True := by sorry

This theorem states that in any pseudometric space `α`, the distance between any two points `x` and `y` in `α` is always non-negative. In more mathematical terms, for every `α` which is a PseudoMetricSpace, and for every `x` and `y` in `α`, `0 ≤ dist x y` will always be true. This is a basic property of distances in pseudometric spaces, reflecting the intuitive idea that distance cannot be a negative value.

In any pseudometric space, the distance between any two points is non-negative.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.66 :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {p : α → Prop}, (∃ a ∈ Set.range f, p a) = ∃ i, p (f i) := by sorry

This theorem states that for any type `α` and any sort `ι`, if we have a function `f` mapping `ι` to `α` and a property `p` that an element of `α` might satisfy, then there exists an element `a` in the range of `f` that satisfies `p` if and only if there exists an `i` such that the application of `f` to `i` satisfies `p`. Essentially, it says that an element in the range of `f` satisfies a property if and only if the element is the image of some input under `f` that satisfies the property.

For any function `f` from sort `ι` to type `α`, and property `p` on `α`, the existence of an `i` in `ι` such that `f i` satisfies `p` is equivalent to the existence of an `a` in the range of `f` that satisfies `p`.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.65 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {a : α}, (a ∈ closure s) = ∀ ε > 0, ∃ b ∈ s, dist a b < ε :=
  by sorry

This theorem states that for any type `α`, which is a pseudometric space, any set `s` of type `α`, and any element `a` of type `α`, the element `a` belongs to the closure of `s` if and only if for every real number `ε` greater than 0, there exists an element `b` in `s` such that the distance between `a` and `b` is less than `ε`. In essence, it's saying that a point is in the closure of a set in a pseudometric space if, for any given positive distance, we can find a point in the set that's less than that distance away.

In a pseudometric space, an element belongs to the closure of a set if and only if for every positive real number ε, there exists an element in the set within distance ε.


IsAntichain.eq'

theorem IsAntichain.eq' :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsAntichain r s → ∀ {a b : α}, a ∈ s → b ∈ s → r b a → a = b := by
  sorry

The theorem `IsAntichain.eq'` states that for any type `α`, relation `r`, and set `s` of elements of type `α`, if `s` is an antichain with respect to the relation `r`, then for any elements `a` and `b` in `s`, if `r b a` holds, then `a` must be equal to `b`. In other words, in an antichain, no two distinct elements are related in the reverse order.

In an antichain, if element `a` is related to element `b` (`r b a`), then `a` equals `b`.


theorem solvable_of_ker_le_range :
    ∀ {G : Type u_1} [inst : Group G] {G' : Type u_3} {G'' : Type u_4} [inst_1 : Group G'] [inst_2 : Group G'']
      (f : G' →* G) (g : G →* G''),
      MonoidHom.ker g ≤ MonoidHom.range f → ∀ [hG' : IsSolvable G'] [hG'' : IsSolvable G''], IsSolvable G :=
  by sorry

The theorem `solvable_of_ker_le_range` asserts that for any three groups `G`, `G'`, and `G''`, and any two group homomorphisms `f: G' -> G` and `g: G -> G''`, if the kernel of `g` is a subset of the range of `f`, then if `G'` and `G''` are solvable, it follows that `G` is also solvable. Here, a group is solvable if it has a series of normal subgroups such that each factor group is abelian.

If groups G, G', and G'' have homomorphisms f : G' -> G and g : G -> G'' such that the kernel of g is contained in the image of f, and G' and G'' are solvable, then so is G.


theorem UniqueDiffWithinAt.mono_nhds :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} {s t : Set E},
      UniqueDiffWithinAt 𝕜 s x → nhdsWithin x s ≤ nhdsWithin x t → UniqueDiffWithinAt 𝕜 t x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜` and a normed additively commutative group `E`, which is also a normed space over `𝕜`, if there exists a unique tangent differential at a point `x` within a set `s` and the neighborhood within `s` at `x` is a subset of the neighborhood within another set `t` at `x`, then there also exists a unique tangent differential at `x` within the set `t`. In other words, if we can uniquely differentiate within a certain 'neighbourhood' (defined by set `s`) of `x`, and that neighbourhood is included within a larger neighbourhood defined by set `t`, then we can also uniquely differentiate within the larger neighbourhood.

If a normed space `E` over a non-trivially normed field `𝕜`, with unique tangent differentials at a point `x` in sets `s` and `t` (where `s` is a subset of `t`), then the tangent differential at `x` in `E` with respect to `𝕜` is unique.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.19 :
    ∀ {α : Type u} [inst : LT α] {x y : α}, (x > y) = (y < x) := by sorry

This theorem, from Mathlib about Topology and Metric Spaces, states that for any type `α` with an order relation `LT` (less than), and for any two elements `x` and `y` of that type, `x` is greater than `y` if and only if `y` is less than `x`. In other words, it confirms the relationship between "greater than" and "less than" operations in an ordered set. This type of reflexivity is fundamental to the definition of ordered sets, and is a commonly assumed axiom in fields such as mathematics and computer science.

For all types `α` with a total order `LT`, `x LT y` if and only if `yLTx`.


theorem PiTensorProduct.smul_tprodCoeff' :
    ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {R₁ : Type u_5} {s : ι → Type u_7}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] [inst_5 : SMulCommClass R₁ R R] (r : R₁) (z : R) (f : (i : ι) → s i),
      r • PiTensorProduct.tprodCoeff R z f = PiTensorProduct.tprodCoeff R (r • z) f :=
  by sorry

This theorem states that for any types `ι`, `R`, `R₁`, and a function `s` mapping `ι` to another type, along with certain conditions on `R`, `R₁`, and `s` (such as `R` being a commutative semiring, each `s i` being an additive commutative monoid and a module over `R`, and `R₁` being a monoid that distributes over the multiplication action on `R`), the scalar multiplication of `r` from `R₁` and the tensor product coefficient of `R`, `z` from `R` and function `f` from `ι` to `s i`, is equal to the tensor product coefficient of `R`, the scalar multiplication of `r` and `z`, and `f`. In mathematical terms, it asserts that `r • (z ⊗ₜ f) = (r • z) ⊗ₜ f` where `•` denotes scalar multiplication and `⊗ₜ` represents the tensor product.

For any commutative semiring `R`, monoid `R₁`, type `ι`, and function `s : ι → Type`, if `s i` is an additive commutative monoid and a module over `R` for each `i`, and `R₁` distributes over the multiplication action on `R`, then for all `r in R₁` and `z in R` and `f : ι → s i`, we have `r • (z ⊗ₜ f) = (r • z) ⊗ₜ f`, where `•` denotes scalar multiplication and `⊗ₜ` represents the tensor product.


theorem Ideal.neg_mem_iff : ∀ {α : Type u} [inst : Ring α] (I : Ideal α) {a : α}, -a ∈ I ↔ a ∈ I := by sorry

The theorem `Ideal.neg_mem_iff` states that for any type `α`, which forms a ring under the given operations, and for any ideal `I` of `α`, an element `a` of `α` belongs to `I` if and only if its negation `-a` belongs to `I`. In other words, in the context of a ring, an element and its opposite always have the same membership status in a given ideal.

For any ring `α` and ideal `I` of `α`, an element `a` belongs to `I` if and only if its additive inverse `-a` belongs to `I`.


/-- A family `𝓕 : ι → X → α` is equicontinuous at `x₀` within `S` iff the function
`swap 𝓕 : X → ι → α` is continuous at `x₀` within `S`
*when `ι → α` is equipped with the topology of uniform convergence*. This is very useful for
developping the equicontinuity API, but it should not be used directly for other purposes.  -/
theorem equicontinuousWithinAt_iff_continuousWithinAt :
    ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_7} [tX : TopologicalSpace X] [uα : UniformSpace α] {F : ι → X → α}
      {S : Set X} {x₀ : X},
      EquicontinuousWithinAt F S x₀ ↔ ContinuousWithinAt (⇑UniformFun.ofFun ∘ Function.swap F) S x₀ :=
  by sorry

The theorem `equicontinuousWithinAt_iff_continuousWithinAt` states that for a family of functions `F : ι → X → α` (indexed by ι), it is equicontinuous at a point `x₀` within a set `S` if and only if the function `swap 𝓕 : X → ι → α` (which swaps the order of arguments) is continuous at `x₀` within `S`, where the function space `ι → α` is equipped with the topology of uniform convergence. This result is particularly useful in developing the equicontinuity API, but it's recommended not to use it directly for other purposes. Note that the topological space structure is on `X` and the uniform space structure is on `α`.

A family of functions \(F : ι → X → α\) is equicontinuous at a point \(x\_0 ∈ S \subseteq X\) if and only if the function \(swap 𝓕 : X → ι → α\) is continuous at \(x\_0\) within \(S\) with respect to the uniform convergence topology on \(ι → α\).


theorem Matrix.charpoly_degree_eq_dim :
    ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
      [inst_3 : Nontrivial R] (M : Matrix n n R), Polynomial.degree (Matrix.charpoly M) = ↑(Fintype.card n) :=
  by sorry

This theorem states that for any commutative ring `R`, any type `n` which has decidable equality and is finite, and any nontrivial element of `R`, the degree of the characteristic polynomial of a `n` by `n` matrix `M` with entries in `R` is equal to the cardinality (number of elements) of the type `n` (which represents the dimension of the matrix `M`). In mathematical terms, this theorem conveys that the degree of the characteristic polynomial of a square matrix is equal to the dimension of the matrix.

For any commutative ring with decidable equality and finite type `n`, the degree of the characteristic polynomial of a `n` by `n` matrix over that ring equals the cardinality of `n`.


theorem VitaliFamily.filterAt_basis_closedBall :
    ∀ {α : Type u_1} [inst : MetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (v : VitaliFamily μ)
      (x : α),
      Filter.HasBasis (VitaliFamily.filterAt v x) (fun x => 0 < x) fun x_1 =>
        {a | a ∈ v.setsAt x ∧ a ⊆ Metric.closedBall x x_1} :=
  by sorry

This theorem states that for any vitali family `v` and any element `x` of type `α` in a metric space with a measurable space and a measure, the filter at `x` created by `v` has a basis consisting of the sets of `v` at `x` that are contained within a closed ball centered at `x` with a positive radius. The basis condition provided is that the radius of the closed ball is positive. In other words, any neighborhood of `x` in the generated filter can be represented by a union of sets of `v` at `x` that are wholly contained in some closed ball around `x` with a positive radius.

For any vitali family `v` and element `x` in a metric space with a measurable space and measure, the filter at `x` generated by `v` has a basis consisting of sets of `v` at `x` contained in closed balls centered at `x` with positive radii.


/-- If an arrow set contains a split epi, it generates the maximal sieve.  -/
theorem CategoryTheory.Sieve.generate_of_contains_isSplitEpi :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {R : CategoryTheory.Presieve X} (f : Y ⟶ X)
      [inst_1 : CategoryTheory.IsSplitEpi f], R f → CategoryTheory.Sieve.generate R = ⊤ :=
  by sorry

The theorem `CategoryTheory.Sieve.generate_of_contains_isSplitEpi` states that for any category `C`, given two objects `X` and `Y` in `C`, a presieve `R` on `X`, and an arrow `f` from `Y` to `X` that is a split epimorphism. If `f` is contained in the presieve `R`, then the sieve generated by `R` is the maximal sieve. In other words, if a set of arrows contains a split epimorphism, it generates the largest possible sieve.

Given a category `C`, an object `X`, a presieve `R` on `X`, and an arrow `f` from `Y` to `X` that is a split epimorphism contained in `R`, the sieve generated by `R` is the maximal sieve.


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

This is the First Moment Method theorem in measure theory. It states that for any measurable space `α` with a measure `μ` and an integrable function `f : α → ℝ`, assuming `μ` is a finite measure and not equal to zero, the measure of the set of elements `x` such that `f(x)` is less than or equal to the mean of `f` with respect to measure `μ`, is positive. This essentially means that an integrable function is less than its mean on a set of positive measure.

For any measurable space with a finite, non-zero measure and an integrable function, the set of elements where the function value is less than or equal to the function's mean has positive measure.


IsLeftRegular.pow

/-- Any power of a left-regular element is left-regular.  -/
theorem IsLeftRegular.pow :
    ∀ {R : Type u_1} {a : R} [inst : Monoid R] (n : ℕ), IsLeftRegular a → IsLeftRegular (a ^ n) := by sorry

This theorem states that any power of a left-regular element remains left-regular. In more detail, let `R` be a type with a multiplication operation forming a monoid. If `a` is an element of `R` that is left-regular (i.e., multiplication on the left by `a` is injective), then for any natural number `n`, `a` raised to the power `n` is also left-regular.

If `a` is a left-regular element in a monoid `R`, then for all natural numbers `n`, `a^n` is also left-regular.


/-- Dense Gδ sets are residual.  -/
theorem residual_of_dense_Gδ :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsGδ s → Dense s → s ∈ residual X := by sorry

The theorem states that in any topological space, if a set is both a Gδ set and dense, then it is residual. In other words, if a set is a countable intersection of open sets (Gδ set) and any point in the space is a limit point of this set (dense), then this set is a countable intersection of dense open sets (residual).

In any topological space, a set that is both a Gδ set and dense is residual.


ContinuousOn.aemeasurable

/-- A function which is continuous on a set `s` is almost everywhere measurable with respect to
`μ.restrict s`.  -/
theorem ContinuousOn.aemeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : MeasurableSpace β] [inst_4 : TopologicalSpace β]
      [inst_5 : BorelSpace β] {f : α → β} {s : Set α} {μ : MeasureTheory.Measure α},
      ContinuousOn f s → MeasurableSet s → AEMeasurable f (μ.restrict s) :=
  by sorry

The theorem states that if a function `f` is continuous on a set `s`, then `f` is almost everywhere measurable with respect to the measure `μ` restricted to `s`. Here, being "almost everywhere measurable" means that `f` is equal almost everywhere to a measurable function. This applies to functions `f` from a measurable space `α` to a Borel space `β`, where `α` is also a topological space and `β` is also a measurable space. The set `s` must be a measurable set within the measurable space `α`.

If `f: α → β` is a continuous function on the measurable set `s ⊆ α` in the measurable space `α`, then `f` is almost everywhere equal to a measurable function on `s`.


theorem Subsemigroup.not_mem_bot : ∀ {M : Type u_1} [inst : Mul M] {x : M}, x ∉ ⊥ := by sorry

This theorem states that for any type `M` with a multiplication operation (denoted by `Mul M`), any element `x` of `M` is not a member of the bottom element (denoted by `⊥`). In other words, no element of a multiplicative subsemigroup is part of the smallest subsemigroup.

For any type equipped with a multiplication operation, no element is in the bottom element of the multiplicative subsemigroup.


theorem Finset.prod_insertNone :
    ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] (f : Option α → M) (s : Finset α),
      (Finset.prod (Finset.insertNone s) fun x => f x) = f none * Finset.prod s fun x => f (some x) :=
  by sorry

The theorem `Finset.prod_insertNone` states that for any given type `α` and a type `M` that forms a commutative monoid, and any function `f` from the optional type `Option α` to `M`, the product of the function `f` applied over the entire set obtained by inserting `none` into a finite set `s` of type `α` is equal to the product of `f none` and the product of `f` applied over the set `s` with every element wrapped into `some`. In other words, if we add a `none` value to a finite set and take the product over the whole set, it is the same as multiplying the function applied to `none` and the product over the original set with the function applied to each element wrapped into `some`.

For any commutative monoid type M and function f from Option α to M, the product of f applied to the optional finite set obtained by inserting none into set s of type α is equal to the product of f none and the product of f applied to each some(x) in s, where x is an element of s.


theorem Function.mulSupport_one' : ∀ {α : Type u_1} {M : Type u_5} [inst : One M], Function.mulSupport 1 = ∅ := by sorry

The theorem `Function.mulSupport_one'` states that for all types `α` and `M`, with `M` being equipped with an instance of `One` (a structure with a default element usually representing 'one' in some sense), the `mulSupport` of the function that constantly returns one is an empty set. In mathematical terms, it says that for any types `α` and `M` with `M` having a defined 'one', there are no elements in `α` for which the constant function 1 returns a value different from 'one'. Thus, the set of such elements, `mulSupport 1`, is empty.

For all types `α` and `M` with a `One` instance, the set of elements `x` in `α` such that the constant function `λ (x : α), 1` does not equal `1` is empty.


theorem WithZero.coe_one : ∀ {α : Type u} [inst : One α], ↑1 = 1 := by sorry

This theorem states that for any type `α` that has an instance of the `One` typeclass (meaning it has a designated "one" element), the "one" element of `α` when coerced into the `WithZero` type becomes the "one" element of the `WithZero` type. In other words, the "one" of any type is preserved when you map that type into the `WithZero` type.

For any type `α` with a `One` instance, the coercion of its one element is equal to the one element of the `WithZero` type.


/-- For every directed family of closed sets whose intersection avoids a compact set,
there exists a single element of the family which itself avoids this compact set.  -/
theorem IsCompact.elim_directed_family_closed :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {ι : Type v} [hι : Nonempty ι],
      IsCompact s →
        ∀ (t : ι → Set X),
          (∀ (i : ι), IsClosed (t i)) → s ∩ ⋂ i, t i = ∅ → Directed (fun x x_1 => x ⊇ x_1) t → ∃ i, s ∩ t i = ∅ :=
  by sorry

The theorem `IsCompact.elim_directed_family_closed` states that for any compact set `s` in a topological space `X`, given a directed family of closed sets `t` (where the directed relation is defined by subset inclusion), if the intersection of `s` and the intersection of all sets in the family `t` is empty, then there exists a single set within the family `t` whose intersection with `s` is also empty. In other words, if a compact set avoids the intersection of a directed family of closed sets, then it also avoids at least one member of that family.

If a compact set in a topological space intersects empty with the intersection of a directed family of closed sets, then it intersects empty with some set in the family.


theorem Fin.tail_cons :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α (Fin.succ i)), Fin.tail (Fin.cons x p) = p := by
  sorry

The theorem `Fin.tail_cons` states that for any natural number `n` and any type function `α` from `Fin (n + 1)` to a type `u`, given an element `x` of type `α 0` and a function `p : (i : Fin n) → α (Fin.succ i)`, the tail of the tuple obtained by adding `x` at the beginning of the `n`-tuple created by `p` is equal to `p` itself. In other words, the function `Fin.tail` applied to the `n+1`-tuple created by `Fin.cons x p` is equal to the original function `p`.

For any natural number `n` and function `p : Fin (n + 1) → α`, the tail of the list `[x] @ map Fin.succ p` is equal to `p`.


theorem MeasureTheory.DominatedFinMeasAdditive.of_measure_le :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7}
      [inst : SeminormedAddCommGroup β] {T : Set α → β} {C : ℝ} {μ' : MeasureTheory.Measure α},
      μ ≤ μ' → MeasureTheory.DominatedFinMeasAdditive μ T C → 0 ≤ C → MeasureTheory.DominatedFinMeasAdditive μ' T C :=
  by sorry

This theorem states that, given a set function `T` from a set `α` to a seminormed additive commutative group `β`, if `μ` and `μ'` are measures on `α` such that `μ` is less than or equal to `μ'`, and `T` is a dominated and finite measure additive with respect to `μ` with a non-negative constant `C`, then `T` is also dominated and finite measure additive with respect to `μ'` with the same constant `C`. Here, a dominated and finite measure additive function is one where the norm of the function on any measurable set is less than or equal to the product of a constant and the measure of the set, and the function satisfies the conditions of finite measure additivity.

Given a set function `T` from a set `α` to a seminormed additive commutative group `β`, if `T` is dominated and finite measure additive with respect to a measure `μ` with constant `C` and `μ` is less than or equal to `μ'`, then `T` is dominated and finite measure additive with respect to `μ'` with the same constant `C`.


theorem Equiv.Perm.toCycle_eq_toList :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (f : Equiv.Perm α) (hf : Equiv.Perm.IsCycle f) (x : α),
      f x ≠ x → Equiv.Perm.toCycle f hf = ↑(Equiv.Perm.toList f x) :=
  by sorry

This theorem states that for a given type `α` with finite instances and a decidable equality, if `f` is a cycle permutation on `α` (meaning it is a bijection from `α` to itself where any two points which aren't fixed by the permutation are related through repeated application of the permutation), then for any element `x` of `α` which is not fixed by `f`, the cycle produced by the `toCycle` function on `f` is equivalent to the list generated by the `toList` function on `f` starting from `x`. In other words, the cycle representation of the permutation is the same as the list representation when starting from an element not fixed by the permutation.

For a finite type `α` with decidable equality, if `f:` `α` `-->` `α` is a cycle permutation, then for any `x:` `α` not fixed by `f`, the cycle `toCycle f x` is equal to the list `toList f` starting at `x`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.40 :
    ∀ {E : Type u_6} [inst : SeminormedGroup E] (a : E), ‖a‖ = dist a 1 := by sorry

This theorem, `Mathlib.Analysis.Normed.Group.Basic._auxLemma.40`, states that for any element `a` of a seminormed group `E`, the norm of `a` is equal to the distance between `a` and `1`. In mathematical terms, this theorem asserts that for all `a` in `E`, ‖`a`‖ = dist(`a`, `1`). This relationship holds in any seminormed group, which is a group that is equipped with a seminorm, a generalization of the absolute value function that measures the "size" or "length" of elements in the group.

In a seminormed group, the seminorm of an element is equal to its distance to the identity.


theorem Summable.tendsto_atTop_zero :
    ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G] {f : ℕ → G},
      Summable f → Filter.Tendsto f Filter.atTop (nhds 0) :=
  by sorry

The theorem `Summable.tendsto_atTop_zero` states that for any summable function `f` from the natural numbers to a topological add group `G`, the function `f` tends towards 0 as its argument tends towards infinity. In other words, if `f` is a sequence of elements in `G` such that the series `f(0) + f(1) + f(2) + ...` converges, then for any neighborhood of 0 in `G`, there exists a point beyond which all the terms of the sequence `f` stay within that neighborhood. This is a formalization of one of the properties of convergence of series in analysis.

For any summable function from natural numbers to a topological add group, the sequence tends to 0 at infinity, meaning for any neighborhood of 0, there exists a natural number beyond which all terms remain in the neighborhood.


theorem List.Sublist.exists_perm_append :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → ∃ l, List.Perm l₂ (l₁ ++ l) := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then there exists a list `l` such that `l₂` is a permutation of the concatenation of `l₁` and `l`. In other words, if some elements of `l₁` also appear in `l₂` in the same order, we can rearrange `l₂` such that it starts with `l₁`, followed by some other elements `l`.

For any type `α` and lists `l₁`, `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then there exists a list `l` such that `l₂` is a permutation of `l₁ ++ l`.


theorem normalizedGCDMonoidOfLCM.proof_1 :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (lcm : α → α → α),
      (∀ {a b c : α}, c ∣ a → b ∣ a → lcm c b ∣ a) → ∀ (a b : α), lcm a b ∣ normalize (a * b) :=
  by sorry

The theorem `normalizedGCDMonoidOfLCM.proof_1` states that for all types `α` which have a cancel commutative monoid with zero structure and a normalization monoid structure, if you have a function `lcm` (least common multiple), and for all `a`, `b`, and `c` of type `α`, if `c` divides `a` and `b` also divides `a`, then `lcm c b` divides `a`, then for all `a` and `b` of type `α`, the `lcm` of `a` and `b` divides the normalized product of `a` and `b`. Here, normalization is performed by the `normalize` function, which chooses an element from each associate class by multiplying with the norm unit.

For all types `α` with a cancel commutative monoid, zero structure, and normalization monoid structure, if `lcm` is a function satisfying the given divisibility condition, then `lcm (normalize a) (normalize b)` divides `normalize (a * b)` for all `a, b` in `α`.


theorem MeasureTheory.measure_diff_lt_of_lt_add :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      MeasurableSet s → s ⊆ t → ↑↑μ s ≠ ⊤ → ∀ {ε : ENNReal}, ↑↑μ t < ↑↑μ s + ε → ↑↑μ (t \ s) < ε :=
  by sorry

This theorem is a statement in measure theory. It states that for any type `α`, measurable space `m`, measure `μ`, and two sets `s` and `t` of type `α`, if `s` is a measurable set that is a subset of `t`, and the measure of `s` is not infinite, then for any extended nonnegative real number `ε`, if the measure of `t` is less than the sum of the measure of `s` and `ε`, then the measure of the set difference `t \ s` (i.e., those elements of `t` that are not in `s`) is less than `ε`. This is a formal statement about the difference of measures of two sets in a measure space.

If `s` is a finite measurable subset of measurable space `(α, m)` with measure `μ` and `t` is any measurable set containing `s` such that `μ(t) < μ(s) + ε`, then `μ(t \ s) < ε`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.32 :
    ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, (0 < ‖a‖) = (a ≠ 0) := by sorry

This theorem is a statement about normed add groups in the field of analysis. It says that for any element `a` in a normed add group `E`, the norm of `a` is greater than zero if and only if `a` is not equal to zero. This basically means that the only element in `E` with a norm of zero is the zero element itself, which is a fundamental property of normed spaces.

In a normed add group, the only element with norm equal to zero is the additive identity.


theorem Ideal.bot_isMaximal : ∀ {K : Type u} [inst : DivisionSemiring K], Ideal.IsMaximal ⊥ := by sorry

This theorem states that for any division semiring `K`, the bottom ideal (`⊥`) is maximal. In other words, in the context of algebra, there is no other ideal that properly contains the bottom ideal in any division semiring. Here, a division semiring is a structure similar to a ring but without the requirement for the existence of additive inverses.

In any division semiring, the bottom ideal is the maximal ideal.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.24 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) := by
  sorry

This theorem states that for any pseudometric space `α`, and given any two points `x` and `y` in `α` and a real number `ε`, the point `y` belongs to the closed ball centered at `x` with radius `ε` if and only if the distance between `y` and `x` is less than or equal to `ε`. This means that the `Metric.closedBall` function is correctly defined as the set of all points at a distance less than or equal to `ε` from the center point.

For any pseudometric space `α` and points `x, y ∈ α`, the point `y` belongs to the closed ball centered at `x` with radius `ε` if and only if the distance `d(x, y) ≤ ε`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.22 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem states that for any types `α` and `β`, a function `f` from `α` to `β`, a set `s` of type `β`, and an element `a` of type `α`, the statement "element `a` is in the preimage of set `s` under function `f`" is equivalent to the statement "the result of applying function `f` to element `a` is in set `s`". In mathematical terms, we can express this as $a \in f^{-1}(s) \Leftrightarrow f(a) \in s$.

For any functions $f: \alpha \to \beta$ and sets $s \subseteq \beta$, the elements $a \in \alpha$ satisfy $a \in f^{-1}(s) \Leftrightarrow f(a) \in s$.


/-- In a real vector space, a convex set with nonempty interior is a set of unique
differentiability at every point of its closure.  -/
theorem uniqueDiffWithinAt_convex :
    ∀ {G : Type u_4} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {s : Set G},
      Convex ℝ s → Set.Nonempty (interior s) → ∀ {x : G}, x ∈ closure s → UniqueDiffWithinAt ℝ s x :=
  by sorry

This theorem states that in a real vector space, if a set is convex and its interior is nonempty, then any point in the closure of this set is a point of unique differentiability within the set. In other words, for such a set in a normed addative commutative group that also forms a normed space over the real numbers, every point in the closure of the set has a unique tangent space and a unique derivative, if the derivative exists, within the set. This property of unique differentiability is captured by the mathematical concept of 'UniqueDiffWithinAt'.

In a real normed additive commutative group, if a convex set with nonempty interior has a point in its closure, then every point in the closure is uniquely differentiable within the set.


FreeGroup.Red.sublist

/-- If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of `w₁`.  -/
theorem FreeGroup.Red.sublist : ∀ {α : Type u} {L₁ L₂ : List (α × Bool)}, FreeGroup.Red L₁ L₂ → List.Sublist L₂ L₁ := by
  sorry

The theorem `FreeGroup.Red.sublist` states that for any type `α` and for any two lists `L₁` and `L₂` of pairs of `α` and `Bool`, if the list `L₁` reduces to the list `L₂` under the reflexive-transitive closure of the `FreeGroup.Red.Step` relation (denoted as `FreeGroup.Red`), then `L₂` is a sublist of `L₁`. This means that `L₂` can be obtained from `L₁` by deleting some elements, with the remaining elements retaining their original order.

If two lists of pairs `L₁` and `L₂` of type `α × Bool` reduce to each other under the reflexive-transitive closure of `FreeGroup.Red.Step` in the FreeGroup algebra, then `L₂` is a sublist of `L₁`.


theorem Mathlib.Analysis.Normed.Group.Basic._auxLemma.17 :
    ∀ {E : Type u_6} [inst : SeminormedGroup E] (a b : E), ‖a / b‖ = dist a b := by sorry

This theorem, `Mathlib.Analysis.Normed.Group.Basic._auxLemma.17`, states that for any type `E` that is a semi-normed group, the norm of the ratio of any two elements `a` and `b` of `E` is equal to the distance between `a` and `b`. In mathematical notation, this is represented as ‖a / b‖ = dist(a, b).

For any semi-normed group `E`, the norm of the quotient of two of its elements `a` and `b` is equal to the distance between `a` and `b`. That is, ‖a / b‖ = dist(a, b).


theorem MeasurableEmbedding.comap_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
      MeasurableEmbedding f → MeasurableSpace.comap f inst_1 = inst :=
  by sorry

The theorem `MeasurableEmbedding.comap_eq` asserts that for any two types `α` and `β` equipped with measurable spaces, and a function `f : α → β`, if `f` is a measurable embedding, then the reverse image of the measurable space under the function `f` is the same as the original measurable space on `α`. In other words, if we take the measurable space of `β` and map it back along `f` to `α`, we get the same measurable space that `α` started with. This is significant in the context of measure theory, where measurable spaces are used to define measures.

If `f : α → β` is a measurable embedding between measurable spaces `(α, Σα)` and `(β, Σβ)`, then `f⁻¹(Σβ) = Σα`.


theorem Equiv.Perm.sign_extendDomain :
    ∀ {α : Type u} [inst : DecidableEq α] {β : Type v} [inst_1 : Fintype α] [inst_2 : DecidableEq β]
      [inst_3 : Fintype β] (e : Equiv.Perm α) {p : β → Prop} [inst_4 : DecidablePred p] (f : α ≃ Subtype p),
      Equiv.Perm.sign (Equiv.Perm.extendDomain e f) = Equiv.Perm.sign e :=
  by sorry

The theorem `Equiv.Perm.sign_extendDomain` states that for any types `α` and `β` with decidable equality, and for any finite types `α` and `β`, given a permutation `e` of `α`, a decidable predicate `p` on `β`, and a bijection `f` between `α` and the subtype of `β` that satisfies `p`, the sign or parity of the permutation obtained by extending the domain of `e` using `f` is the same as the sign of `e`. In other words, extending the domain of a permutation does not change its parity.

For any finite types `α` and `β` with decidable equality, given a permutation `e` of `α`, a bijection `f` from `α` to a subtype of `β` satisfying a decidable predicate `p`, the sign of the permutation obtained by extending `e` using `f` equals the sign of `e`.


theorem TopologicalRing.of_addGroup_of_nhds_zero :
    ∀ {R : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : TopologicalSpace R] [inst_2 : TopologicalAddGroup R],
      Filter.Tendsto (Function.uncurry fun x x_1 => x * x_1) (nhds 0 ×ˢ nhds 0) (nhds 0) →
        (∀ (x₀ : R), Filter.Tendsto (fun x => x₀ * x) (nhds 0) (nhds 0)) →
          (∀ (x₀ : R), Filter.Tendsto (fun x => x * x₀) (nhds 0) (nhds 0)) → TopologicalRing R :=
  by sorry

This theorem states that for any type `R` which has a structure of a non-unital, non-associative ring, a topological space, and a topological additive group, if three conditions are met, `R` is a topological ring. The conditions are as follows:

1. The function that takes two arguments from `R` and multiplies them, when viewed as a function on `R × R`, is continuous at `(0,0)`. In other words, for every neighborhood of 0 in `R`, the preimage of this neighborhood under this multiplication function contains a neighborhood of `(0,0)` in `R × R`.

2. For every element `x₀` of `R`, the function that multiplies `x₀` by its argument is continuous at `0`.

3. For every element `x₀` of `R`, the function that multiplies its argument by `x₀` is continuous at `0`.

In this specific context, continuity at `0` means that for every neighborhood of `0` in `R`, the preimage of this neighborhood under the function contains a neighborhood of `0`.

If `R` is a non-unital, non-associative ring endowed with a topology making it a topological space and a topological additive group, such that the multiplication function is continuous at `(0,0)` and the functions `x₀ × _` and `_ × x₀` are continuous at `0` for each `x₀ ∈ R`, then `R` is a topological ring.


theorem Asymptotics.isBigOWith_snd_prod :
    ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} [inst : SeminormedAddCommGroup E']
      [inst_1 : SeminormedAddCommGroup F'] {f' : α → E'} {g' : α → F'} {l : Filter α},
      Asymptotics.IsBigOWith 1 l g' fun x => (f' x, g' x) :=
  by sorry

The theorem `Asymptotics.isBigOWith_snd_prod` states that for any type `α`, any two types `E'` and `F'` that form semi-normed additive commutative groups, any two functions `f'` and `g'` from `α` to `E'` and `F'` respectively, and any filter `l` on `α`, the function `g'` is Big O of the function that takes `x` from `α` and returns the pair `(f' x, g' x)`. Here, the Big O notation is being used with a constant factor of 1. In other words, for values that are eventually reached when applying the filter `l`, the norm of `g'(x)` does not exceed the norm of the pair `(f'(x), g'(x))`.

For any type `α`, given semi-normed additive commutative groups `E'` and `F'`, functions `f': α -> E'` and `g': α -> F'`, and a filter `l` on `α`, the function `g'` is Big O of the function that maps `x` in `α` to the pair `(f' x, g' x)` with respect to the norm.


theorem kstar_mul_le_self : ∀ {α : Type u_1} [inst : KleeneAlgebra α] {a b : α}, a * b ≤ b → KStar.kstar a * b ≤ b := by
  sorry

The theorem `kstar_mul_le_self` states that for all types `α` that are instances of the `KleeneAlgebra`, and for all elements `a` and `b` of this type `α`, if `a * b` is less than or equal to `b`, then the `kstar` of `a` multiplied by `b` is also less than or equal to `b`. Here, `KStar.kstar a` refers to the operation `kstar` applied to `a`, where `kstar` is a function associated with the `KStar` class in the Kleene algebra context, often representing the reflexive-transitive closure in the language of regular expressions or formal language theory.

For all types `α` in the Kleene Algebra and all elements `a, b` of `α`, if `a * b ≤ b`, then `KStar.kstar a * b ≤ b`.


theorem ContinuousMap.coe_injective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
      Function.Injective DFunLike.coe :=
  by sorry

The theorem `ContinuousMap.coe_injective` states that for any two types `α` and `β`, given the topology on both, the function `DFunLike.coe`, which is a coercion from some type `F` to a function, is injective. In other words, if two continuous maps from a topological space `α` to another topological space `β` are the same as functions (i.e., they map any element of `α` to the same element of `β`), then they are the same continuous maps.

If two functions between topological spaces, when considered as continuous maps, are equal as functions, then they are equal as continuous maps.


theorem le_of_mul_le_mul_right' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LE α]
      [i : ContravariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      b * a ≤ c * a → b ≤ c :=
  by sorry

This theorem, named `le_of_mul_le_mul_right'`, asserts that for any type `α` that has a multiplication operation (`Mul α`), an order relation (`LE α`), and satisfies the contravariant property with respect to multiplication and this order (expressed by `ContravariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1`), if the product of `b` and `a` is less than or equal to the product of `c` and `a`, then `b` is less than or equal to `c`. In other words, if multiplying `a` with `b` results in a value that is not larger than multiplying `a` with `c`, then `b` is not larger than `c`, given that multiplication and order relation follow the described contravariant property.

If `α` is a type with multiplication and order relation satisfying the given contravariance property, and `a` is an element of `α`, then `b ≤ c` if and only if `a * b ≤ a * c`.


IsLUB.bddAbove

/-- If `s` has a least upper bound, then it is bounded above.  -/
theorem IsLUB.bddAbove : ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, IsLUB s a → BddAbove s := by sorry

The theorem `IsLUB.bddAbove` states that for any type `α` with a preorder structure, for any set `s` of elements of this type, and for any element `a` of this type, if `a` is a least upper bound of the set `s`, then the set `s` is bounded from above. In other words, if there exists an element that is the smallest element greater than or equal to every element in the set, then there exists an element that is greater than or equal to every element in the set.

For any preordered type `α` and set `s` of elements in `α`, if `a` is the least upper bound of `s`, then `s` is bounded above by `a`.


theorem Composition.sizeUpTo_length :
    ∀ {n : ℕ} (c : Composition n), Composition.sizeUpTo c (Composition.length c) = n := by sorry

This theorem states that for any natural number `n` and a composition `c` of `n`, the sum of the sizes of the blocks in the composition up to the length of the composition (i.e., the number of blocks in the composition) is equal to `n`. In other words, if you sum the sizes of all the blocks in a composition, you get the number that the composition is of. This is a fundamental property of compositions in combinatorics.

For any natural number `n` and its composition `c`, the sum of the sizes of the blocks in `c` equals `n`.


theorem MeasureTheory.Lp.coeFn_sub :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)),
      ↑↑(f - g) =ᶠ[MeasureTheory.Measure.ae μ] ↑↑f - ↑↑g :=
  by sorry

This theorem states that for any two members `f` and `g` of the `MeasureTheory.Lp` space over a measurable space `α` with measure `μ`, normed add commutative group `E`, and extended non-negative real number `p`, the difference of `f` and `g` under the norm operator is almost everywhere equal to the difference of `f` and `g` individually under the norm operator. In simpler terms, this means that the difference between the norms of `f` and `g` is the same no matter where you measure it, except for a set of measure zero.

For measurable functions `f` and `g` in the `Lp` space over a measurable space `(α, μ)` with norm `∥.∥_p`, the almost everywhere equality `∥f - g∥_p = ∥f - g∥_p AlmostEverywhere` holds.


theorem Ideal.le_pow_ramificationIdx :
    ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] {f : R →+* S} {p : Ideal R} {P : Ideal S},
      Ideal.map f p ≤ P ^ Ideal.ramificationIdx f p P :=
  by sorry

This theorem states that, for any commutative rings `R` and `S`, and any ring homomorphism `f` from `R` to `S`, and any ideals `p` in `R` and `P` in `S`, the ideal obtained by mapping the ideal `p` under `f` (denoted by `Ideal.map f p`) is a subset of the `P` raised to the power of the ramification index of `P` over `p` (denoted by `P ^ Ideal.ramificationIdx f p P`). The ramification index in this case is the largest exponent `n` such that `p` is contained in `P^n`. If there is no such `n` (because `p` is not contained in any power of `P`), then the ramification index is defined to be 0.

For any commutative rings R and S, ring homomorphism f from R to S, and ideals p in R and P in S, Ideal.map f p is contained in P ^ Ideal.ramificationIdx f p P.


ConformalAt.comp

theorem ConformalAt.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : NormedAddCommGroup X] [inst_1 : NormedAddCommGroup Y]
      [inst_2 : NormedAddCommGroup Z] [inst_3 : NormedSpace ℝ X] [inst_4 : NormedSpace ℝ Y] [inst_5 : NormedSpace ℝ Z]
      {f : X → Y} {g : Y → Z} (x : X), ConformalAt g (f x) → ConformalAt f x → ConformalAt (g ∘ f) x :=
  by sorry

The theorem `ConformalAt.comp` states that for three types `X`, `Y`, and `Z`, all of which are normed additive commutative groups and normed spaces over the real numbers, if `f` is a map from `X` to `Y` and `g` is a map from `Y` to `Z`, then if `g` is conformal at `f(x)` and `f` is conformal at `x`, the composition of `g` and `f` is also conformal at `x`. In other words, the conformality property is preserved under function composition.

If `f: X → Y` and `g: Y → Z` are conformal at `x ∈ X` with respect to normed additive commutative groups and normed spaces over the real numbers, then `g ∘ f` is conformal at `x`.


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

This theorem states that for any type `α` that forms a Heyting algebra, and for any two elements `a` and `b` of this type, the double negation of the infimum (greatest lower bound, denoted by `⊓`) of `a` and `b` is equal to the infimum of the double negations of `a` and `b`. In mathematical terms, we can express this as `(a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ` for all `a` and `b` in `α`.

For any type `α` that forms a Heyting algebra and any `a, b` in `α`, the double negation of their infimum equals the infimum of the double negations: `(a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ`.


/-- For `m ≤ n`, `(n, m)` is in the reflexive-transitive closure of `~` if `succ i ~ i`
for all `i` between `n` and `m`.  -/
theorem reflTransGen_of_succ_of_ge :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [inst_2 : IsSuccArchimedean α] (r : α → α → Prop)
      {n m : α}, (∀ i ∈ Set.Ico m n, r (Order.succ i) i) → m ≤ n → Relation.ReflTransGen r n m :=
  by sorry

This theorem states that, for any partially ordered type `α` with a successor function that satisfies Archimedean property, and any relation `r` on `α`, if `m ≤ n` and for every `i` in the half-open interval from `m` to `n` (`m` included, `n` excluded), `r` holds between the successor of `i` and `i`, then the pair `(n, m)` lies in the reflexive-transitive closure of the relation `r`. The reflexive-transitive closure of a relation is the smallest relation that contains the original and is both reflexive and transitive. The Archimedean property in this context means there is no infinite descending chain in the order.

If `α` is a partially ordered type with a successor function satisfying the Archimedean property, and `r` is a relation on `α` such that `r` holds between `i` and `i'` for all `i` and `i'` with `m ≤ i < n`, then `(n, m)` is in the reflexive-transitive closure of `r`.


theorem CompleteLattice.IsCompactElement.exists_finset_of_le_iSup :
    ∀ (α : Type u_2) [inst : CompleteLattice α] {k : α},
      CompleteLattice.IsCompactElement k → ∀ {ι : Type u_3} (f : ι → α), k ≤ ⨆ i, f i → ∃ s, k ≤ ⨆ i ∈ s, f i :=
  by sorry

The theorem `CompleteLattice.IsCompactElement.exists_finset_of_le_iSup` states that for any type `α` that forms a complete lattice, and any element `k` of `α` that is a "compact element" (also known as "finite" or "S-compact"), and for any function `f` from another type `ι` to `α`, if `k` is less than or equal to the supremum (denoted by `⨆`) of the range of `f`, then there exists a finite subset `s` of `ι` such that `k` is less than or equal to the supremum of the range of `f` restricted to `s`. This theorem shows that in a complete lattice, the supremum of an infinite set can be approximated by the supremum of a finite subset if the compactness condition is satisfied.

Given a complete lattice `α`, a compact element `k` of `α`, and a function `f` from a type `ι` to `α` such that `k` is less than or equal to the supremum of `f`, there exists a finite subset `s` of `ι` such that `k` is less than or equal to the supremum of `f` restricted to `s`.


Dilation.uniformInducing

/-- A dilation from a metric space is a uniform inducing map  -/
theorem Dilation.uniformInducing :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F), UniformInducing ⇑f :=
  by sorry

The theorem `Dilation.uniformInducing` states that for any types `α`, `β`, and `F`, if `α` and `β` are pseudo emetric spaces (generalization of the concept of a metric space where distances can be infinite), `F` is a function-like from `α` to `β`, and `F` satisfies the conditions of the `DilationClass`, then for any function `f` of type `F`, the function `f` induces a uniform structure on `α`. In simpler words, the application of the function `f` results in uniformly distributed points in `α`.

Given types `α`, `β`, and a function-like `F` from `α` to `β` between pseudo-metric spaces `α` and `β`, if `F` satisfies the conditions of `DilationClass`, then `F` induces a uniform structure on `α`.


theorem sup_sub_inf_eq_abs_sub :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α), a ⊔ b - a ⊓ b = |b - a| :=
  by sorry

The theorem `sup_sub_inf_eq_abs_sub` states that for all types `α` that form a lattice and an additive commutative group, and additionally satisfy a covariance property (specifically, for all elements `x` and `x_1` of the type, `x + x_1` implies `x ≤ x_1`), the difference between the supremum (`a ⊔ b`) and the infimum (`a ⊓ b`) of any two elements `a` and `b` of the type is equal to the absolute value of the difference between `b` and `a`.

For all types `α` that form a lattice and an additive commutative group with the covariance property, the supremum and infimum of any two elements `a` and `b` satisfy `|a - b| = a ⊔ b - a ⊓ b`.


theorem CategoryTheory.Center.comp_f :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      {X Y Z : CategoryTheory.Center C} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).f = CategoryTheory.CategoryStruct.comp f.f g.f :=
  by sorry

This theorem, `CategoryTheory.Center.comp_f`, states that for any category `C` with structure of a monoidal category, and any three objects `X`, `Y`, and `Z` in the Drinfeld center of `C`, if we have a morphism `f` from `X` to `Y` and a morphism `g` from `Y` to `Z`, then the function component of the composition of `f` and `g` is equal to the composition of the function components of `f` and `g`. In other words, the theorem states an equality between the function part of the composed morphisms and the composition of the function parts of the morphisms, in the context of the Drinfeld center of a monoidal category.

In the Drinfeld center of a monoidal category, the function component of the composition of two morphisms is equal to the composition of their function components.


theorem CategoryTheory.Functor.eventualRange_mapsTo :
    ∀ {J : Type u} [inst : CategoryTheory.Category.{u_1, u} J] (F : CategoryTheory.Functor J (Type v)) {i j : J}
      [inst_1 : CategoryTheory.IsCofilteredOrEmpty J] (f : j ⟶ i),
      Set.MapsTo (F.map f) (CategoryTheory.Functor.eventualRange F j) (CategoryTheory.Functor.eventualRange F i) :=
  by sorry

This theorem states that for any category `J` and any functor `F` from `J` to some type `v`, given any two objects `i` and `j` in `J` and a morphism `f` from `j` to `i`, the map induced by `f` via the functor `F` has the property that it sends the eventual range of `F` at `j` into the eventual range of `F` at `i`.

To elaborate, the eventual range of `F` at an object `j` is defined as the intersection of the ranges of all maps `F.map f` where `f` varies over all morphisms to `j` from any object in `J`. The theorem asserts that this set at `j` is mapped into the corresponding set at `i` by `F.map f`.

This is under the assumption that `J` satisfies the condition of being cofiltered or empty, which is a kind of completeness condition for categories.

For any cofiltered category J and functor F from J to a type, given objects i and j in J and a morphism f from j to i, the image of the eventual range of F at j under F.map f is contained in the eventual range of F at i.


theorem le_trans' : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, b ≤ c → a ≤ b → a ≤ c := by sorry

This theorem, `le_trans'`, states that for any preorder `α`, and any three elements `a`, `b`, and `c` from `α`, if `b` is less than or equal to `c` and `a` is less than or equal to `b`, then `a` is less than or equal to `c`. In other words, it formalizes the concept of transitivity in a preordered set. If you can go from `a` to `b` and from `b` to `c` in the order, then you can go directly from `a` to `c`.

If `α` is a preorder and `a`, `b`, `c` are elements of `α` with `a ≤ b` and `b ≤ c`, then `a ≤ c`.


theorem Zsqrtd.norm_zero : ∀ {d : ℤ}, Zsqrtd.norm 0 = 0 := by sorry

The theorem `Zsqrtd.norm_zero` states that for all integers `d`, the norm of the complex number `0` in the integer ring `ℤ[√d]` is `0`. This norm is calculated as the real part of the number squared minus `d` times the imaginary part of the number squared. In other words, for any integer `d`, the norm function `Zsqrtd.norm` when applied to the complex number `0`, always yields `0`.

The norm of the complex number 0 in the ring of integers ℤ[√d] is 0.


/-- In a commutative monoid, an element `a` divides an element `b` iff all
left associates of `a` divide `b`. -/
theorem IsUnit.mul_left_dvd : ∀ {α : Type u_1} [inst : CommMonoid α] {a b u : α}, IsUnit u → (u * a ∣ b ↔ a ∣ b) := by
  sorry

This theorem states that in a commutative monoid, given three elements `a`, `b`, and `u`, if `u` is a unit (meaning that it has a two-sided inverse), then `u` times `a` divides `b` if and only if `a` divides `b`. In other words, multiplying a unit `u` to `a` doesn't change its divisibility property with respect to `b`.

In a commutative monoid, if a unit `u` exists such that `a` divides `b`, then `u * a` divides `b` if and only if `a` divides `b`.


theorem sInf_eq_top : ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α}, sInf s = ⊤ ↔ ∀ a ∈ s, a = ⊤ := by sorry

This theorem states that for any type `α` that forms a complete lattice, and any set `s` of elements of that type, the infimum of `s` (denoted `sInf s`) is equal to the top element of the lattice (denoted `⊤`) if and only if every element `a` in `s` is equal to `⊤`. In other words, in a complete lattice, a set's infimum is the top element exactly when all the set's elements are the top element.

In a complete lattice, a set's infimum is the top element if and only if every element in the set is the top element.


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

This theorem states that for any two types `α` and `β` with preorder structures and a function `f` from `α` to `β`, the function `f` is strictly monotone if and only if the composition of `f` with the identity function on the `OrderDual` of `α` is strictly antitone.

In other words, a function `f` is strictly increasing (`StrictMono`) if reversing the order of its input (`OrderDual.ofDual`) makes it strictly decreasing (`StrictAnti`). So, if you reverse the order of the inputs, and the order of the outputs also gets reversed, then the original function was strictly increasing. This theorem establishes the connection between strict monotonicity and strict anti-monotonicity under the effect of dual ordering.

For functions between preordered types, a function is strictly monotone if and only if the reverse function composed with the order dual is strictly antitone.


theorem mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_upperBounds :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Monotone (Function.swap f b)) →
        (∀ (a : α), Antitone (f a)) → a ∈ lowerBounds s → b ∈ upperBounds t → f a b ∈ lowerBounds (Set.image2 f s t) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, with preorder relations defined on them, and any sets `s` of type `α` and `t` of type `β`, if you have a binary function `f : α → β → γ` such that for every `β`, swapping the arguments of `f` gives a monotone function, and for every `α`, `f` is an antitone function, then if `a` is a lower bound of `s` and `b` is an upper bound of `t`, the result of the function `f a b` is a lower bound of the image of the function `f` applied to `s` and `t`. In simpler terms, if `a` is a lower bound for a set and `b` is an upper bound for another set, and `f` is a function that increases as one argument increases and decreases as the other argument increases, the value `f a b` will be a lower bound for all possible values of `f` over the two sets.

If `α` and `β` are types with preorders, `s` is a set of type `α`, `t` is a set of type `β`, `f : α → β → γ` is a function such that `f` is monotone in the second argument for every fixed first argument and antitone in the first argument for every fixed second argument, and `a` is a lower bound of `s` and `b` is an upper bound of `t`, then `f a b` is a lower bound of the image of `f` on `s × t`.


theorem PosNum.lt_to_nat : ∀ {m n : PosNum}, ↑m < ↑n ↔ m < n := by sorry

This theorem states that for all positive numbers `m` and `n`, the natural number representation of `m` is less than the natural number representation of `n` if and only if `m` is less than `n`. In other words, the relative ordering of two positive numbers remains the same whether we consider them as positive numbers or as their natural number counterparts.

For all positive integers m and n, m < n if and only if m.to Nat < n.to Nat in Lean's type Nat, where to Nat is a conversion from the type of positive numbers to the type of natural numbers.


theorem iInf_of_isEmpty :
    ∀ {α : Type u_9} {ι : Sort u_10} [inst : InfSet α] [inst_1 : IsEmpty ι] (f : ι → α), iInf f = sInf ∅ := by sorry

The theorem `iInf_of_isEmpty` states that for any type `α` with an infimum on sets (`InfSet α`) and any type `ι` that is empty (`IsEmpty ι`), for any function `f` from `ι` to `α`, the indexed infimum of `f` (`iInf f`) is equal to the supremum of an empty set (`sInf ∅`). In other words, if we are taking the infimum over an indexed family, and that index set is empty, then the result is the same as taking the infimum of the empty set.

For any type `α` with an infimum on sets, any empty type `ι`, and any function `f` from `ι` to `α`, the indexed infimum `iInf f` is equal to the supremum of the empty set `sInf ∅`.


theorem star_pow : ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star (x ^ n) = star x ^ n :=
  by sorry

This theorem, `star_pow`, states that for any type `R` that has a monoid structure and a star-multiplication structure, given any element `x` of `R` and any natural number `n`, the star of `x` raised to the power `n` is equal to the star of `x` raised to the power `n`. In mathematical terms, if `*` denotes the star operation and `^` denotes exponentiation, this states that `(x^n)* = (x*)^n` for all `x` in `R` and `n` in ℕ. This is a property relating the star operation and exponentiation in any star-multiplicative monoid.

For any star-multiplicative monoid `(R, *, *)`, and for all `x ∈ R` and `n ∈ ℕ`, `(x^n)^* = (x*)^n`.


theorem add_pow_char_pow_of_commute :
    ∀ (R : Type u_1) [inst : Semiring R] {p n : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (x y : R),
      Commute x y → (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n :=
  by sorry

The theorem `add_pow_char_pow_of_commute` states that for any semiring `R` of characteristic `p`, where `p` is a prime number, and for any elements `x` and `y` of `R` that commute with each other (i.e., `x * y = y * x`), the power of the sum of `x` and `y` to the power of `p` raised to `n` is equal to the sum of the powers of `x` and `y` each to the power of `p` raised to `n`. In mathematical notation, this can be expressed as `(x + y) ^ p^n = x ^ p^n + y ^ p^n`. This property holds only when `x` and `y` commute, meaning that the order in which they are multiplied does not affect the result.

For any semiring of characteristic `p` and commuting elements `x` and `y`, `(x + y) ^ p^n = x ^ p^n + y ^ p^n`.


/-- For a concrete category `(A, s)` where the forgetful functor `s : A ⥤ Type v` preserves limits and
reflects isomorphisms, and `A` has limits, an `A`-valued presheaf `P : Cᵒᵖ ⥤ A` is a sheaf iff its
underlying `Type`-valued presheaf `P ⋙ s : Cᵒᵖ ⥤ Type` is a sheaf.

Note this lemma applies for "algebraic" categories, eg groups, abelian groups and rings, but not
for the category of topological spaces, topological rings, etc since reflecting isomorphisms doesn't
hold.
 -/
theorem CategoryTheory.Presheaf.isSheaf_iff_isSheaf_forget :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A' : Type u₂}
      [inst_1 : CategoryTheory.Category.{max v₁ u₁, u₂} A'] (J : CategoryTheory.GrothendieckTopology C)
      (P' : CategoryTheory.Functor Cᵒᵖ A') (s : CategoryTheory.Functor A' (Type (max v₁ u₁)))
      [inst_2 : CategoryTheory.Limits.HasLimits A'] [inst_3 : CategoryTheory.Limits.PreservesLimits s]
      [inst_4 : CategoryTheory.ReflectsIsomorphisms s],
      CategoryTheory.Presheaf.IsSheaf J P' ↔ CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.Functor.comp P' s) :=
  by sorry

In the context of a concrete category `(A, s)`, where the forgetful functor `s : A ⥤ Type v` both preserves limits and reflects isomorphisms, and `A` has limits, this theorem states that an `A`-valued presheaf `P : Cᵒᵖ ⥤ A` is a sheaf if and only if its underlying `Type`-valued presheaf `P ⋙ s : Cᵒᵖ ⥤ Type` is a sheaf. It's important to note that this lemma is applicable for "algebraic" categories, such as groups, abelian groups, and rings. However, it doesn't apply to the category of topological spaces, topological rings, and similar, since the property of reflecting isomorphisms doesn't hold for these.

In a concrete category with a preserving and reflecting forgetful functor, an `A`-valued presheaf is a sheaf if and only if its underlying `Type`-valued presheaf is a sheaf (applicable to algebraic categories).


theorem MvPowerSeries.mul_inv_cancel :
    ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] (φ : MvPowerSeries σ k),
      (MvPowerSeries.constantCoeff σ k) φ ≠ 0 → φ * φ⁻¹ = 1 :=
  by sorry

The theorem `MvPowerSeries.mul_inv_cancel` states that for any given type `σ`, another type `k` which is a field, and a multivariate power series `φ` of type `σ` with coefficients in `k`, if the constant coefficient of the power series `φ` is not zero, then the product of the power series `φ` and its multiplicative inverse `φ⁻¹`, is equal to 1. In simpler terms, if the constant term of a multivariate power series is not zero, then the power series is invertible, following the standard rule of multiplicative inverses where any non-zero number multiplied by its inverse gives 1.

If `φ` is a multivariate power series over a field `k` with non-zero constant coefficient, then `φ * φ⁻¹ = 1`.


theorem Cubic.eq_sum_three_roots :
    ∀ {F : Type u_3} {K : Type u_4} {P : Cubic F} [inst : Field F] [inst_1 : Field K] {φ : F →+* K} {x y z : K},
      P.a ≠ 0 →
        Cubic.roots (Cubic.map φ P) = {x, y, z} →
          Cubic.map φ P =
            { a := φ P.a, b := φ P.a * -(x + y + z), c := φ P.a * (x * y + x * z + y * z),
              d := φ P.a * -(x * y * z) } :=
  by sorry

The theorem `Cubic.eq_sum_three_roots` states that given two fields `F` and `K`, a cubic polynomial `P` in field `F`, a ring homomorphism `φ` from `F` to `K`, and three elements `x`, `y`, and `z` in field `K`, if the leading coefficient of `P` is non-zero and the roots of the cubic polynomial `P` mapped to `K` are `x`, `y`, and `z`, then the mapped cubic polynomial can be expressed in terms of the coefficients of `P` and the roots `x`, `y`, and `z`. Specifically, the coefficients of the mapped cubic polynomial are `φ(P.a)`, `φ(P.a) * -(x + y + z)`, `φ(P.a) * (x * y + x * z + y * z)`, and `φ(P.a) * -(x * y * z)`, respectively.

Given a field extension `φ: F → K`, a non-zero cubic polynomial `P` over `F` with roots `x`, `y`, and `z` in `K`, the coefficients of the mapped cubic polynomial are `φ(P.a)`, `φ(P.a) * (-(x + y + z))`, `φ(P.a) * (xy + xz + yz)`, and `φ(P.a) * (-xyz)`.


theorem AddSubgroup.relindex_eq_zero_of_le_right :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K L : AddSubgroup G},
      K ≤ L → AddSubgroup.relindex H K = 0 → AddSubgroup.relindex H L = 0 :=
  by sorry

This theorem states that, for any group `G` with an associated addition operation, and given three subgroups `H`, `K`, and `L` of `G`, if `K` is a subset of `L` and the relative index of `H` and `K` is zero, then the relative index of `H` and `L` will also be zero. The relative index of two subgroups here is defined as the index of the intersection subgroup of `H` and `K` in `K`, or it is zero if the relative index is infinite.

If subgroup `H` of group `G` has zero relative index with respect to a larger subgroup `K`, and `K` is contained in another subgroup `L` of `G`, then `H` has zero relative index with respect to `L`.


theorem Set.MapsTo.countable_of_injOn :
    ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {f : α → β},
      Set.MapsTo f s t → Set.InjOn f s → Set.Countable t → Set.Countable s :=
  by sorry

This theorem states that for any two sets `s` of type `α` and `t` of type `β`, and a function `f` that maps `α` to `β`, if `f` maps every element of `s` into `t` (`Set.MapsTo f s t`), and `f` is injective (one-to-one) on `s` (`Set.InjOn f s`), and if `t` is countable (`Set.Countable t`), then `s` must also be countable (`Set.Countable s`).

In other words, if we have a function that is injective on a set and maps it into a countable set, then the original set is also countable. This is a logical consequence of the definition of countability – a set is countable if there exists an injective function from the set to the natural numbers. If we have an injective function to another countable set, we can compose this with the injection from that countable set to the natural numbers to get an injection from our original set to the natural numbers.

If a function that maps a set `s` injectively into a countable set `t` exists, then `s` is countable.


theorem Sigma.lex_iff :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} {a b : (i : ι) × α i},
      Sigma.Lex r s a b ↔ r a.fst b.fst ∨ ∃ (h : a.fst = b.fst), s b.fst (h ▸ a.snd) b.snd :=
  by sorry

This theorem states that for any types `ι` and `α`, where `α` is a type dependent on `ι`, and any relations `r` on `ι` and `s` on `α` dependent on `ι`, and any pairs `a` and `b` of type `ι` and `α` dependent on `ι`, the lexicographic order `Sigma.Lex` of `a` and `b` is equivalent to either `r` being true for the first elements of `a` and `b`, or there exists an equality between the first elements of `a` and `b` for which `s` holds for the second element of `a` (after substituting the equality) and the second element of `b`.

For any type-dependent types `α: ι → Type`, relations `r: ι → ι → Prop` and `s: ι → α(ι) → α(ι) → Prop` on `ι` and `α` respectively, if `a` and `b` are pairs of type `(ι, α(ι))` such that `Sigma.Lex a < Sigma.Lex b` if and only if either `r a.0 b.0` holds or there exists an equality `a.0 = b.0` such that `s a.1 (a.0 = b.0) (a.1)` and `s b.1 (a.0 = b.0) (b.1)` hold.


Asymptotics.IsTheta.inv

theorem Asymptotics.IsTheta.inv :
    ∀ {α : Type u_1} {𝕜 : Type u_14} {𝕜' : Type u_15} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜'] {l : Filter α}
      {f : α → 𝕜} {g : α → 𝕜'}, f =Θ[l] g → (fun x => (f x)⁻¹) =Θ[l] fun x => (g x)⁻¹ :=
  by sorry

This theorem states that for any types `α`, `𝕜`, and `𝕜'`, and given that `𝕜` and `𝕜'` are normed fields, for any filter `l` of type `α`, and functions `f : α → 𝕜` and `g : α → 𝕜'`, if `f` and `g` are asymptotically equivalent at `l` (i.e., `f =Θ[l] g`), then the functions defined by the reciprocals of `f` and `g` (i.e., `(fun x => (f x)⁻¹)` and `(fun x => (g x)⁻¹)`) are also asymptotically equivalent at `l`. In other words, the asymptotic equivalence relationship is preserved under taking reciprocals of the functions.

If `f` and `g` are asymptotically equivalent functions from type `α` to normed fields `𝕜` and `𝕜'`, respectively, then the reciprocal functions `(fun x => (f x)⁻¹)` and `(fun x => (g x)⁻¹)` are asymptotically equivalent at any filter `l` on `α`.


theorem LE.le.not_gf : ∀ {x y : SetTheory.PGame}, x ≤ y → ¬SetTheory.PGame.LF y x := by sorry

This theorem states that for any two pre-games `x` and `y` in set theory, if `x` is less than or equal to `y`, then it is not the case that `y` is less fuzzy than `x`. In other words, if `x` is less than or equal to `y`, then Left cannot win `x` as the first player when playing `y`. This is a fundamental property connecting the less-or-equal and less fuzzy relations in the theory of pre-games.

For any pre-games x and y in set theory, if x <= y then y is not less fuzzy than x (i.e., Left cannot win x as the first player when playing y).


/-- The sine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
opposite side.  -/
theorem InnerProductGeometry.sin_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.sin (InnerProductGeometry.angle x (x + y)) * ‖x + y‖ = ‖y‖ :=
  by sorry

This theorem states that for any two vectors `x` and `y` in an inner product space over the real numbers, if the inner product of `x` and `y` is zero, then the sine of the angle between `x` and `x+y` multiplied by the magnitude (norm) of `x+y` equals the magnitude of `y`. This is analogous to the geometric principle in a right-angled triangle where the length of the opposite side equals the length of the hypotenuse times the sine of the included angle.

In an inner product space over the real numbers, the norm of `x + y` times the sine of the angle between `x` and `y` equals the norm of `y` when the inner product of `x` and `y` is zero.


theorem hasFDerivWithinAt_inter :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s t : Set E},
      t ∈ nhds x → (HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x) :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, and normed space `𝕜 E`, along with another normed additive commutative group `F` and normed space `𝕜 F`, and for a given function `f` mapping `E` to `F` along with its derivative `f'` at point `x` in `E`, and sets `s` and `t` of `E`, if `t` is a neighborhood of `x` (i.e., `t` belongs to the neighborhood filter of `x`), then the function `f` has a derivative within the intersection of `s` and `t` at `x` if and only if `f` has a derivative within `s` at `x`. In mathematical terms, we can say that the existence of the Frechet derivative of a function at a point within a set is invariant under intersection with a neighborhood of the point.

For any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, normed spaces `𝕜 E` and `𝕜 F`, function `f : E → F` with derivative `f'` at `x ∈ E`, and sets `s` and `t` that are neighborhoods of `x` in `E`, if `t` is a subset of `s`, then `f` has a derivative at `x` within `s` if and only if it has a derivative at `x` within the intersection of `s` and `t`.


theorem List.length_rotate' : ∀ {α : Type u} (l : List α) (n : ℕ), List.length (List.rotate' l n) = List.length l := by
  sorry

The theorem `List.length_rotate'` states that for any type `α`, any list `l` of type `α`, and any natural number `n`, the length of the list obtained by rotating `l` `n` times (using the `rotate'` function) is equal to the length of the original list `l`. Essentially, it means that rotating a list does not change its length.

For any type `α` and natural number `n`, the length of the list obtained by rotating a list `l` of type `α` by `n` positions is equal to the original list length.


theorem ball_zero_eq : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (r : ℝ), Metric.ball 0 r = {x | ‖x‖ < r} := by
  sorry

The theorem `ball_zero_eq` states that for any real number `r` and for any semi-normed additive group `E`, the metric ball of radius `r` centered at zero is exactly the set of all elements `x` in `E` such that the norm of `x` is less than `r`. In other words, it equates the concept of a metric ball at the origin in a semi-normed additive group with the set of points whose norm is less than a given radius.

In a semi-normed additive group, the metric ball centered at the origin with radius `r` is equal to the set of elements with norm less than `r`.


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

This theorem states that for any given partial homeomorphism `e` between two topological spaces `X` and `Y`, the inverse of `e` maps the target of `e` into its source. In other words, if `e` is a partial homeomorphism function from a subset of `X` to a subset of `Y`, then the inverse function of `e`, denoted as `e^-1` or `PartialHomeomorph.symm e`, maps any point in the target subset of `Y` back to the original subset in `X`. This is a property usually expected from the concept of inverse functions.

If `e` is a partial homeomorphism from a subset of `X` to a subset of `Y`, then `e^-1` (or `PartialHomeomorph.symm e`) maps the target of `e` back to its source in `X`.


theorem Function.invFunOn_apply_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Nonempty α] {s : Set α} {f : α → β} {a : α},
      a ∈ s → f (Function.invFunOn f s (f a)) = f a :=
  by sorry

This theorem states that for any types `α` and `β`, along with a nonempty instance of `α`, a set `s` of elements of type `α`, a function `f` mapping `α` to `β`, and an element `a` of type `α`, if `a` is in the set `s`, then applying the function `f` to the inverse of function `f` on the set `s` evaluated at `f(a)` gives `f(a)`. In other words, if `a` is in `s`, then the inverse function on `s` is truly a right inverse of `f` at `f(a)`. This means that applying `f` to the result of applying the inverse of `f` to `f(a)` leads us back to `f(a)`.

For any sets `S` of type `α`, function `f : α → β`, and `a : α` in `S`, `f (invFunOnS a) = f a`, where `invFunOnS` is the inverse function of `f` restricted to `S`.


Set.BijOn.mk

theorem Set.BijOn.mk :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β},
      Set.MapsTo f s t → Set.InjOn f s → Set.SurjOn f s t → Set.BijOn f s t :=
  by sorry

This theorem establishes the conditions under which a function `f` is bijective from one set `s` to another set `t`. Specifically, it states that for any types `α` and `β`, and for any sets `s` of type `α` and `t` of type `β`, if the function `f` maps `s` into `t`, the function `f` is injective on `s`, and `f` is surjective from `s` to `t`, then `f` is bijective from `s` to `t`. In other words, every element of `s` is mapped to a unique element in `t` by `f`, and every element of `t` is the image of some element in `s` under `f`.

If a function `f` maps a set `s` to another set `t` and is both injective on `s` and surjective from `s` to `t`, then `f` is a bijection from `s` to `t`.


theorem Set.offDiag_nonempty : ∀ {α : Type u_1} {s : Set α}, Set.Nonempty (Set.offDiag s) ↔ Set.Nontrivial s := by sorry

The theorem `Set.offDiag_nonempty` states that for any set `s` of a certain type `α`, the off-diagonal of `s` is nonempty if and only if `s` is nontrivial. Here, the off-diagonal of `s` is defined as the set of all pairs `(a, b)` such that `a` and `b` are in `s` and `a` is not equal to `b`. A set `s` is said to be nontrivial if it contains at least two distinct elements. So, in essence, the theorem states that a set has at least two distinct elements if and only if there exist two elements in the set that form a pair in the off-diagonal.

A set of type `α` has a nonempty off-diagonal if and only if it contains at least two distinct elements.


theorem Rel.preimage_mono :
    ∀ {α : Type u_1} {β : Type u_2} (r : Rel α β) {s t : Set β}, s ⊆ t → Rel.preimage r s ⊆ Rel.preimage r t := by sorry

This theorem, "Rel.preimage_mono", states that for any relation 'r' between two types 'α' and 'β', and any two sets 's' and 't' of type 'β', if set 's' is a subset of set 't', then the preimage of 's' under relation 'r' is a subset of the preimage of 't' under 'r'. In other words, if we have a relation that maps elements from 'α' to 'β', and we have two sets in 'β' such that one is a subset of the other, the set of elements in 'α' that map to the smaller set is a subset of the elements that map to the larger set.

If relation r : α → β makes s ⊆ t, then r⁻¹(s) ⊆ r⁻¹(t).


/-- Two sets are at zero Hausdorff edistance if and only if they have the same closure.  -/
theorem EMetric.hausdorffEdist_zero_iff_closure_eq_closure :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α},
      EMetric.hausdorffEdist s t = 0 ↔ closure s = closure t :=
  by sorry

This theorem states that in any pseudo-emetric space (a generalization of metric spaces which allows infinite distances), two sets have zero Hausdorff distance if and only if they have the same closure. The Hausdorff distance is a way to define a distance between sets of points, and in this case, zero distance implies that each set is contained within the infinitesimal neighborhood of the other. The closure of a set is the smallest closed set that contains the set, adding in limit points. Thus, if two sets have the same closure, then they are "effectively" the same set from the viewpoint of the Hausdorff distance.

In a pseudo-metric space, two sets have zero Hausdorff distance if and only if they have equal closures.


theorem Int.mul_div_cancel' : ∀ {a b : ℤ}, a ∣ b → a * Int.div b a = b := by sorry

This theorem states that for any two integers `a` and `b`, if `a` divides `b` then multiplying `a` by the result of dividing `b` by `a` gives us back `b`. In other words, `a * (b / a) = b` when `a` is a divisor of `b`. It's a specific case of a property about integer division, showing that the normal cancellation law holds when the divisor is a factor of the dividend.

For integers `a` and `b`, if `a` divides `b`, then `a * (b / a) = b`.