theorem MeasureTheory.submartingale_of_set_integral_le_succ :
    ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
      [inst : MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ},
      MeasureTheory.Adapted 𝒢 f →
        (∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) →
          (∀ (i : ℕ) (s : Set Ω), MeasurableSet s → ∫ (ω : Ω) in s, f i ω ∂μ ≤ ∫ (ω : Ω) in s, f (i + 1) ω ∂μ) →
            MeasureTheory.Submartingale f 𝒢 μ :=
  by sorry

The theorem `MeasureTheory.submartingale_of_set_integral_le_succ` states the following in plain English:

Given a type `Ω` with a `measurable space` structure `m0` and a measure `μ`, along with a filtration `𝒢` over the natural numbers in `m0` and a sequence of functions `f` from the natural numbers to real-valued functions on `Ω`, if `f` is adapted to `𝒢` (meaning that each `f i` is `𝒢 i`-measurable), and each `f i` is integrable with respect to `μ`, and for every natural number `i` and measurable set `s`, the integral of `f i` over `s` is less than or equal to the integral of `f (i+1)` over `s`, then `f` is a submartingale with respect to `𝒢` and `μ`.

In mathematical terms, this theorem is about the property of submartingales, which are sequences of random variables or functions that have the property that the expected value of the next term in the sequence, given all the previous terms, is less than or equal to the current term.

If `Ω` is a measurable space with measure `μ`, `𝒢` is a filtration over the natural numbers in `m0`, `f` is an adapted, integrable sequence of real-valued `𝒢`-measurable functions on `Ω` such that for all `i` and measurable sets `s`, `∫(s, μ) (fi) ≤ ∫(s, μ) (f (i+1)),` then `f` is a submartingale with respect to `𝒢` and `μ`.


theorem Equiv.subtypeEquiv.proof_2 :
    ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (e : α ≃ β),
      (∀ (a : α), p a ↔ q (e a)) → ∀ (b : { b // q b }), p (e.symm ↑b) :=
  by sorry

This theorem states that for any types `α` and `β`, and predicates `p` and `q` on `α` and `β` respectively, given an equivalence `e` from `α` to `β`, if for all `a` in `α`, `p a` if and only if `q (e a)`, then for every `b` in the subtype `{ b // q b }` (that is, for every `b` that satisfies the predicate `q`), `p (e.symm ↑b)` holds true. This essentially shows that a property `p` is preserved under the inverse of the equivalence `e` when applied to the elements of the subtype defined by `q`.

If `e: α ↔ β` is an equivalence and `p: α → Prop` and `q: β → Prop` are predicates such that `p a ↔ q (e a)` for all `a: α`, then for every `b: {b // q b}`, `p (e.symm ↑b)` holds.


theorem le_mabs_self : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] (a : α), a ≤ mabs a := by sorry

The theorem `le_mabs_self` states that for any type `α` that is both a lattice and a group, any element `a` of this type is less than or equal to the absolute value of `a`. Here, the absolute value of `a`, denoted as `mabs a`, is defined as the supremum of `a` and its inverse.

For all lattice and group types `α` and elements `a` in `α`, we have `a ≤ mabs a`, where `mabs a` is the supremum of `a` and its inverse.


theorem Mathlib.Data.Fin.Basic._auxLemma.15 : ∀ {n : ℕ} [inst : NeZero n], (1 = 0) = (n = 1) := by sorry

This theorem, `Mathlib.Data.Fin.Basic._auxLemma.15`, states that for every natural number `n` which is not zero (`NeZero n`), the equality `1 = 0` is equivalent to `n = 1`. In other words, asserting that one is equal to zero (which is obviously false in the standard natural number system) is the same as asserting that the non-zero natural number `n` is equal to one.

For any non-zero natural number `n`, the equality `1 = 0` holds if and only if `n = 1`.


theorem Ideal.comap_isMaximal_of_surjective :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Ring S] [inst_2 : FunLike F R S]
      [inst_3 : RingHomClass F R S] (f : F),
      Function.Surjective ⇑f → ∀ {K : Ideal S} [H : Ideal.IsMaximal K], Ideal.IsMaximal (Ideal.comap f K) :=
  by sorry

This theorem, `Ideal.comap_isMaximal_of_surjective`, states the following: For any types `R`, `S`, and `F` which are rings, where `F` is function-like from `R` to `S`, and if we have a ring homomorphism `f : F`, if `f` is surjective, then for any maximal ideal `K` of `S`, the preimage of `K` under `f` (denoted as `Ideal.comap f K`) is a maximal ideal in `R`. In simpler terms, the preimage of a maximal ideal under a surjective ring homomorphism is also a maximal ideal.

If `f : R -> S` is a surjective ring homomorphism between rings `R` and `S`, and `K` is a maximal ideal in `S`, then `Ideal.comap f K` is a maximal ideal in `R`.


IsAntichain.flip

theorem IsAntichain.flip : ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsAntichain r s → IsAntichain (flip r) s :=
  by sorry

The theorem `IsAntichain.flip` states that for any type `α`, any binary relation `r` on `α`, and any set `s` of `α`, if `s` is an antichain with respect to `r`, it is also an antichain with respect to the flipped relation of `r`. In other words, if no two distinct elements in `s` are related by `r`, then no two distinct elements are related by the flipped (reverse) `r` either. This theorem is about the invariance of the property of being an antichain under the operation of flipping the order of arguments in the relation.

If `s` is an antichain of a binary relation `r` on type `α`, then `s` is also an antichain of the flipped relation of `r`.


/-- A function `f` on `Fin (n + 1)` is monotone if and only if `f i ≤ f (i + 1)` for all `i`.  -/
theorem Fin.monotone_iff_le_succ :
    ∀ {n : ℕ} {α : Type u_1} [inst : Preorder α] {f : Fin (n + 1) → α},
      Monotone f ↔ ∀ (i : Fin n), f (Fin.castSucc i) ≤ f (Fin.succ i) :=
  by sorry

The theorem `Fin.monotone_iff_le_succ` states that for any natural number `n` and for any type `α` that has a preorder, a function `f` from `Fin(n+1)` to `α` is monotone if and only if for all `i` of type `Fin n`, `f(i)` is less than or equal to `f(i + 1)`. Here, `Fin(n+1)` and `Fin n` are types representing finite sets of `n+1` and `n` natural numbers, respectively. The functions `Fin.castSucc` and `Fin.succ` are used to embed `i : Fin n` in `Fin (n+1)` and to increment a value in `Fin n`, respectively.

A function from the finite set of natural numbers up to n+1 to a preordered type is monotone if and only if its restriction to the finite set of natural numbers up to n satisfies i ≤ i' implies f i ≤ f i'.


theorem measurable_of_restrict_of_restrict_compl :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β} {s : Set α},
      MeasurableSet s → Measurable (Set.restrict s f) → Measurable (Set.restrict sᶜ f) → Measurable f :=
  by sorry

The theorem `measurable_of_restrict_of_restrict_compl` states for any two types `α` and `β`, a measurable space `m` over `α`, a measurable space `mβ` over `β`, a function `f` from `α` to `β`, and a set `s` of type `α`, if the set `s` is measurable, and the restrictions of the function `f` to the set `s` and its complement `sᶜ` are both measurable, then the original function `f` is measurable. In terms of measure theory, this means that the measurability of a function over a certain domain can be determined by checking its measurability over a subset of the domain and its complement.

If `m` is a measurable space over `α`, `mβ` is a measurable space over `β`, `f: α → β` is a measurable function, `s ⊆ α` is measurable, and the restrictions of `f` to `s` and `sᶜ` are measurable, then `f` is measurable.


theorem RingHom.isIntegral_of_surjective :
    ∀ {R : Type u_1} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S),
      Function.Surjective ⇑f → RingHom.IsIntegral f :=
  by sorry

This theorem states that for any two types `R` and `S` which are both commutative rings, if a ring homomorphism `f` from `R` to `S` is surjective (meaning that every element of `S` is the image of some element of `R` under `f`), then `f` is integral. In other words, every element of `S` is integral with respect to the map `f`. In mathematical terms, this theorem states that if every element of a commutative ring `S` is the image of an element of another commutative ring `R` under a ring homomorphism `f`, then every element of `S` satisfies a polynomial equation with coefficients in `R` via `f`.

If `f` is a surjective ring homomorphism from a commutative ring `R` to another commutative ring `S`, then every element of `S` is integral over `R` via `f`.


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

The theorem `SimpleGraph.Walk.reverse_append` states that for any type `V`, any simple graph `G` of type `V`, and any vertices `u`, `v`, `w` of type `V`, if there is a walk `p` from `u` to `v` and a walk `q` from `v` to `w` in the graph `G`, then reversing the walk that is the append of `p` and `q` is the same as appending the reverse of `q` and the reverse of `p`. In simpler terms, if you reverse a path made by appending two walks, it's the same as appending the reverses of the original walks, but in the opposite order.

For any simple graph `G` and vertices `u`, `v`, `w` in its type `V`, if there exist walks `p` from `u` to `v` and `q` from `v` to `w`, then the walk obtained by reversing `p` and appending it to the reversed `q` is equal to the walk obtained by reversing `q` and appending it to the reversed `p`.


theorem MeasureTheory.OuterMeasure.coe_fn_injective : ∀ {α : Type u_1}, Function.Injective fun μ s => ↑μ s := by sorry

This theorem states that for any type `α`, the function that takes a measure `μ` and a set `s` and returns the measure of the set `s` with respect to the measure `μ`, is injective. That means, if the measure of two different sets `s1` and `s2` with respect to the same measure `μ` are equal, then the sets `s1` and `s2` must be the same. In mathematical terms, for all `μ, s1, s2`, if `μ(s1) = μ(s2)`, then `s1 = s2`. This is a property of measures in measure theory.

For any measure `μ` in measure theory, the measure function is injective, that is, `μ(s1) = μ(s2)` implies `s1 = s2` for all sets `s1` and `s2`.


theorem Finset.pairwise_disjoint_powersetCard :
    ∀ {α : Type u_1} (s : Finset α), Pairwise fun i j => Disjoint (Finset.powersetCard i s) (Finset.powersetCard j s) :=
  by sorry

The theorem `Finset.pairwise_disjoint_powersetCard` states that for any type `α` and any finset `s` of type `α`, the property `Pairwise` holds for two subsets of `s` generated by `Finset.powersetCard`. In other words, any two distinct subsets of `s` of given cardinalities are `Disjoint`. This means that for any element of the powerset of `s` with cardinality `i` and any element of the powerset of `s` with cardinality `j`, where `i` and `j` are distinct, the greatest element that is less than or equal to both subsets is the bottom element of the lattice structure, i.e., they have no common elements.

For any type `α` and finset `s` of `α`, any two distinct subsets of `s` with different cardinalities have no common elements.


theorem Finsupp.single_eq_set_indicator :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a : α} {b : M}, (⇑fun₀ | a => b) = Set.indicator {a} fun x => b :=
  by sorry

The theorem `Finsupp.single_eq_set_indicator` states that for any types `α` and `M` with `M` having a zero element, and for any elements `a` of type `α` and `b` of type `M`, the function provided by the single-element finite support function at `a` with value `b` is equivalent to the set indicator function applied on a set containing only `a` and mapping each element `x` to `b`. In other words, the function that maps `a` to `b` and everything else to `0` is the same whether it's implemented with a finite support function or a set indicator function.

For any types `α` and `M` with `M` having a zero element, and for any `a : α` and `b : M`, the single-element finite support function at `a` with value `b` equals the set indicator function of the singleton set `{a}`, both mapping everything outside `a` to `0`.


theorem MeasureTheory.Measure.prod_def :
    ∀ {α : Type u_7} {β : Type u_8} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      (μ : MeasureTheory.Measure α) (ν : MeasureTheory.Measure β),
      MeasureTheory.Measure.prod μ ν = MeasureTheory.Measure.bind μ fun x => MeasureTheory.Measure.map (Prod.mk x) ν :=
  by sorry

This theorem states that for any two measurable spaces `α` and `β`, and for any two measures `μ` on `α` and `ν` on `β`, the binary product of the two measures `μ` and `ν` is equal to the measure resulting from binding the measure `μ` to a function that maps each element `x` of `α` to the measure of `β` obtained by pushing forward `ν` via the function `Prod.mk x` (which pairs `x` with each point in `β`). This relationship holds for arbitrary measures, but properties are mostly proven assuming that at least one of the measures is sigma-finite.

For any measurable spaces `α` and `β` and measures `μ` on `α` and `ν` on `β`, `μ ⊤ (x ↓ᵢ β) = ∫ᵢxβ ν`, where `x ↓ᵢ β` is the fiber measure of `β` over `x` and `μ ⊤` is the outer measure induced by `μ`.


theorem Mathlib.NumberTheory.Liouville.LiouvilleWith._auxLemma.11 :
    ∀ {p x : ℝ}, LiouvilleWith p (-x) = LiouvilleWith p x := by sorry

The theorem `Mathlib.NumberTheory.Liouville.LiouvilleWith._auxLemma.11` states that for any real numbers `p` and `x`, a real number `-x` is a Liouville number with exponent `p` if and only if `x` is a Liouville number with exponent `p`. In other words, the property of being a Liouville number with a given exponent is invariant under negation of the number.

The theorem `Mathlib.NumberTheory.Liouville.LiouvilleWith._auxLemma.11` asserts that negating a Liouville number with exponent `p` results in another Liouville number with the same exponent.


theorem Real.toNNReal_le_nat_cast : ∀ {r : ℝ} {n : ℕ}, Real.toNNReal r ≤ ↑n ↔ r ≤ ↑n := by sorry

This theorem states that for all real numbers `r` and natural numbers `n`, the non-negative real number representation of `r` is less than or equal to the real number representation of `n` if and only if `r` is less than or equal to the real number representation of `n`. In mathematical notation, this is saying that for all $r \in \mathbb{R}$ and $n \in \mathbb{N}$, $\max(r, 0) \leq n$ if and only if $r \leq n$.

For all real numbers $r$ and natural numbers $n$, $\max(r, 0) \leq n$ if and only if $r \leq n$.


theorem Metric.inductiveLimitDist.proof_1 : ∀ {X : ℕ → Type u_1} (x y : (n : ℕ) × X n), x.fst ≤ max x.fst y.fst := by
  sorry

This theorem states that for any function `X` from natural numbers to some type `u_1`, and any two ordered pairs `x` and `y` where each pair consists of a natural number and an element of the type at that natural number, the natural number in pair `x` is less than or equal to the maximum of the natural numbers in pairs `x` and `y`. In mathematical terms, for all `x, y` in the product set of natural numbers and `X n`, `x.fst` is less than or equal to the maximum of `x.fst` and `y.fst`.

For all functions `X` from natural numbers to some type `u_1` and all pairs `x` and `y` in the product set of natural numbers and `X` where `x.1` and `y.1` are natural numbers, `x.1` ≤ max `x.1` and `y.1`.


theorem mul_ball_one :
    ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (s : Set E), s * Metric.ball 1 δ = Metric.thickening δ s :=
  by sorry

The theorem `mul_ball_one` states that for any subset `s` of a semi-normed commutative group `E` and any real number `δ`, the product of `s` and the set of all points within distance `δ` from the identity element is the same as the `δ`-thickening of `s`. In other words, the set of all elements obtained by multiplying an element of `s` with another element that is within a distance `δ` from the identity element in `E`, is the same as the set of all elements in `E` that are within a distance `δ` from some element in `s`.

For any semi-normed commutative group E and subset s, the set of products of an element in s with another element within distance δ from the identity in E is equal to the δ-thickening of s.


theorem SupClosed.finsetSup'_mem :
    ∀ {α : Type u_2} [inst : SemilatticeSup α] {ι : Type u_4} {f : ι → α} {s : Set α} {t : Finset ι},
      SupClosed s → ∀ (ht : t.Nonempty), (∀ i ∈ t, f i ∈ s) → Finset.sup' t ht f ∈ s :=
  by sorry

This theorem states that for all types `α` and `ι` with `α` being a join-semilattice, and given a function `f` from `ι` to `α`, a set `s` of type `α`, and a nonempty finite set `t` of type `ι`, if the set `s` is sup-closed (i.e., for any two elements `a` and `b` in `s`, their supremum also belongs to `s`), and every element of `t` mapped via `f` is in `s`, then the supremum of the image of `t` under `f` also belongs to `s`. In other words, if a set `s` is sup-closed, then it also contains the supremum of any nonempty finite subset of `s` under a function `f`.

If `α` is a join-semilattice, `f` is a function from a nonempty finite set `ι` to `α`, `s` is a sup-closed subset of `α`, and for all `i` in `t`, `f(i)` is in `s`, then the supremum of `f``(t)` is in `s`.


theorem Filter.HasBasis.cauchy_iff :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {ι : Sort u_1} {p : ι → Prop} {s : ι → Set (α × α)},
      Filter.HasBasis (uniformity α) p s →
        ∀ {f : Filter α}, Cauchy f ↔ Filter.NeBot f ∧ ∀ (i : ι), p i → ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s i :=
  by sorry

This theorem states that for any type `α` equipped with a uniform space structure, and given a basis of the uniformity filter of `α` indexed by some type `ι` with a predicate `p` and a function `s` mapping to sets of `α × α`, a filter `f` on `α` is Cauchy if and only if it is not the bottom filter and for any index `i` satisfying the predicate `p`, there exists a set `t` in the filter such that for any two elements `x` and `y` in `t`, the pair `(x, y)` is in the set `s i`. This is a generalization of the notion of Cauchy sequences in terms of filters and uniform spaces.

A filter on a uniform space is Cauchy if and only if it is not the bottom filter and for each basis element, there exists a set in the filter containing two elements with that basis element as their uniform distance.


theorem totallyBounded_subset :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {s₁ s₂ : Set α}, s₁ ⊆ s₂ → TotallyBounded s₂ → TotallyBounded s₁ :=
  by sorry

The theorem `totallyBounded_subset` states that, for any type `α` equipped with a uniform space structure, and given two sets `s₁` and `s₂` of type `α`, if `s₁` is a subset of `s₂` and `s₂` is totally bounded, then `s₁` is also totally bounded. In other words, the property of being totally bounded is preserved under taking subsets. A set is called totally bounded if, for every entourage (a certain kind of subset of the product `α × α`), there exists a finite set of points such that every element of the original set is close (in the sense defined by the entourage) to at least one point in this finite set.

If `α` is a uniform space, `s₁` is a subset of totally bounded set `s₂` in `α`, then `s₁` is also totally bounded.


theorem IsPrimitiveRoot.pow_ne_one_of_pos_of_lt :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k l : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → 0 < l → l < k → ζ ^ l ≠ 1 := by
  sorry

This theorem states that for any type 'M' that is a commutative monoid, given two natural numbers 'l' and 'k', and an element 'ζ' of 'M' that is a primitive root of 'k', if 'l' is positive and less than 'k', then the 'l'-th power of 'ζ' is not equal to one. In mathematical terms, if ζ is a primitive root of order 'k', then any power 'l' of ζ, where 0 < l < k, is not one.

For any commutative monoid M and primitive root ζ of order k in M, if l is a positive natural number less than k, then ζ^l ≠ 1.


theorem Multiset.mem_singleton_self : ∀ {α : Type u_1} (a : α), a ∈ {a} := by sorry

This theorem, `Multiset.mem_singleton_self`, states that for any type `α` and any element `a` of that type, `a` is an element of the singleton multiset that only contains `a`. In mathematical terms, for all `a` in `α`, `a` is in the multiset `{a}`. This is a fundamental property of singleton multisets, and it holds true for any type `α`.

For any type `α` and element `a` in `α`, `a` belongs to the singleton multiset `{a}`.


/-- The (open) thickening `Metric.thickening δ E` of a fixed subset `E` is an increasing function of
the thickening radius `δ`.  -/
theorem Metric.thickening_mono :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ₁ δ₂ : ℝ},
      δ₁ ≤ δ₂ → ∀ (E : Set α), Metric.thickening δ₁ E ⊆ Metric.thickening δ₂ E :=
  by sorry

The theorem `Metric.thickening_mono` states that for any pseudo emetric space `α` and any fixed subset `E` of this space, the thickening of `E` is an increasing function of the thickening radius `δ`. In other words, if `δ₁` and `δ₂` are two real numbers such that `δ₁` is less than or equal to `δ₂`, then the δ₁-thickening of the subset `E` is a subset of the δ₂-thickening of `E`. This is essentially saying that as we increase the radius, the thickening (which consists of points that are at a distance less than the radius from some point of the subset `E`) includes more points.

For any pseudo metric space `α` and subset `E`, the thickening function of `E` is monotone increasing with respect to the thickening radius.


ContDiffWithinAt.differentiableWithinAt

theorem ContDiffWithinAt.differentiableWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {n : ℕ∞}, ContDiffWithinAt 𝕜 n f s x → 1 ≤ n → DifferentiableWithinAt 𝕜 f s x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, normed additive commutative group `E` and `F`, and a function `f` from `E` to `F`, if the function `f` is continuously differentiable within a set `s` at a point `x` up to any order `n` that is greater than or equal to 1, then `f` is differentiable at the point `x` within the set `s`. This means that the function `f` admits a derivative at `x`, which may not be unique.

If a continuously differentiable function `f` from a normed additive commutative group `E` to another normed additive commutitative group `F`, over a nontrivially normed field, is differentiable up to order `n` (`n >= 1`) at a point `x` within a set `s`, then `f` is differentiable at `x` within `s`.


theorem WithSeminorms.withSeminorms_eq :
    ∀ {𝕜 : Type u_1} {E : Type u_5} {ι : Type u_8} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
      [inst_2 : Module 𝕜 E] [inst_3 : Nonempty ι] {p : SeminormFamily 𝕜 E ι} [t : TopologicalSpace E],
      WithSeminorms p → t = ModuleFilterBasis.topology (SeminormFamily.moduleFilterBasis p) :=
  by sorry

This theorem, named `WithSeminorms.withSeminorms_eq`, states that for every type `𝕜` equipped with a norm field structure, type `E` equipped with an additive commutative group structure and a 𝕜-module structure, and type `ι` with at least one element, given a family `p` of seminorms indexed by `ι` on the vector space `E` over `𝕜`, and a topological space structure `t` on `E`, if `E` is equipped with the seminorms from `p` (`WithSeminorms p`), then the topology `t` is equal to the topology associated to the module filter basis induced by the filter basis of the seminorms in `p` (`ModuleFilterBasis.topology (SeminormFamily.moduleFilterBasis p)`). In simpler terms, this theorem expresses that the topological structure on a vector space with seminorms is given by the module filter basis induced by these seminorms.

The topology on a normed vector space equipped with a family of seminorms is equal to the topology induced by the filter basis of these seminorms.


theorem mul_one_add :
    ∀ {α : Type u} [inst : Add α] [inst_1 : MulOneClass α] [inst_2 : LeftDistribClass α] (a b : α),
      a * (1 + b) = a + a * b :=
  by sorry

This theorem, `mul_one_add`, states that for all types `α`, that have addition, multiplication with a multiplicative identity, and left-distributive properties, the result of a number `a` multiplied by the sum of `1` and another number `b` is equal to `a` added to the product of `a` and `b`. In mathematical terms, it's establishing that `a * (1 + b) = a + a * b` for all `a` and `b` in type α, which is a generalization of the distributive law of multiplication over addition.

For all types `α` with additions, multiplications, and left-distributive properties, `a * (1 + b) = a + a * b` for all `a, b` in `α`.


theorem RatFunc.ofFractionRing_injective :
    ∀ {K : Type u} [inst : CommRing K], Function.Injective RatFunc.ofFractionRing := by sorry

The theorem `RatFunc.ofFractionRing_injective` states that for any type `K` that has a commutative ring structure, the function `RatFunc.ofFractionRing` is injective. In other words, if this function applied to two elements of `K` gives the same result, then those two elements were actually the same to begin with.

If two elements of a commutative ring `K` map to the same element under the function `RatFunc.ofFractionRing`, then those elements are equal in `K`.


MeromorphicAt.inv

theorem MeromorphicAt.inv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {f : 𝕜 → 𝕜} {x : 𝕜}, MeromorphicAt f x → MeromorphicAt f⁻¹ x :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, for any function `f : 𝕜 → 𝕜`, and any value `x` in `𝕜`, if `f` is meromorphic at `x`, then the reciprocal function `f⁻¹` is also meromorphic at `x`.

In mathematical terms, being meromorphic means that the function can be written as a ratio of two analytic functions (with the denominator not identically zero) in a punctured neighborhood of `x`, i.e., a neighborhood of `x` without the point `x` itself. The theorem asserts that this property is preserved under taking reciprocals, i.e., if `f` is meromorphic at a point, then so is `1/f`, provided `f` is not zero at that point.

If `f : 𝕜 -> 𝕜` is a meromorphic function at `x` in a nontrivially normed field `𝕜` with `f(x) != 0`, then the reciprocal function `f⁻¹` is also meromorphic at `x`.


theorem LinearOrderedField.cutMap_nonempty :
    ∀ {α : Type u_2} (β : Type u_3) [inst : LinearOrderedField α] [inst_1 : LinearOrderedField β]
      [inst_2 : Archimedean α] (a : α), Set.Nonempty (LinearOrderedField.cutMap β a) :=
  by sorry

The theorem `LinearOrderedField.cutMap_nonempty` asserts that for any given type `α` with a linear ordered field structure, another type `β` with a linear ordered field structure as well, and an element `a` of type `α` under the assumption that `α` is Archimedean, the set of elements of type `β` that are less than `a` (obtained via the `cutMap` function) is nonempty. In other words, there is always at least one element of type `β` that is less than any given element of type `α` in an Archimedean linearly ordered field.

In an Archimedean linearly ordered field, the set of elements of another linearly ordered field that are strictly less than any given element is nonempty.


theorem lp.norm_eq_ciSup :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E ⊤)),
      ‖f‖ = ⨆ i, ‖↑f i‖ :=
  by sorry

This theorem, `lp.norm_eq_ciSup`, states that for any type `α`, a type `E` that varies with `α` , and any instance `inst` of the `NormedAddCommGroup` class for `E` such that `f` is an element of the `lp` space (with the supremum norm), the norm of `f` is equal to the supremum of the norms of the elements of `f`. In mathematical terms, this is stating that ‖f‖ = sup_{i} ‖f(i)‖ for f in the L^∞ space (the space of bounded sequences).

For any type `α`, any `E` varying with `α` that is an `NormedAddCommGroup` with `lp` space element `f` having finite supremum norm, the norm of `f` equals the supremum of the norms of its elements.


theorem Trivialization.mk_symm :
    ∀ {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      [inst_2 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_3 : (x : B) → Zero (E x)]
      (e : Trivialization F Bundle.TotalSpace.proj) {b : B},
      b ∈ e.baseSet →
        ∀ (y : F),
          { proj := b, snd := Trivialization.symm e b y } = ↑(PartialHomeomorph.symm e.toPartialHomeomorph) (b, y) :=
  by sorry

The theorem `Trivialization.mk_symm` asserts that for any given set `B` with a topological structure, a set `F` also with a topological structure, a set `E` which is a function space from `B` to some other set with each element of `B` having an associated zero in `E`, a trivialization `e` of the bundle space with projection `Bundle.TotalSpace.proj`, and any element `b` of `B` that belongs to the base set of the trivialization `e`, for any `y` in `F`, the pair `(b, y)` after being transformed by the inverse of the partial homeomorphism associated with `e`, is equal to a pair whose first element is `b` and the second element is the result of applying the inverse of the trivialization `e` at `b` to `y`. This theorem essentially gives a condition under which the inverse of a given trivialization can be fully defined.

Given a bundle `B x F` with projection `Bundle.TotalSpace.proj`, a trivialization `e` with inverse `e⁻¹`, and an element `b ∈ B` and `y ∈ F`, the pairs `(b, y)` and `(b, e⁻¹ (e (b, y)))` are equal.


SBtw.sbtw.btw

/-- **Alias** of `btw_of_sbtw`. -/
theorem SBtw.sbtw.btw : ∀ {α : Type u_1} [inst : CircularPreorder α] {a b c : α}, sbtw a b c → btw a b c := by sorry

This theorem, `SBtw.sbtw.btw`, establishes that for any type `α` following a circular preorder, if a value `b` is strictly between `a` and `c` (denoted as `sbtw a b c`), then `b` is also between `a` and `c` (denoted as `btw a b c`). In essence, it shows that strict betweenness implies betweenness in a circular preorder setting.

In a circular preorder, if `b` strictly lies between `a` and `c` (`sbtw a b c`), then `b` also lies between `a` and `c` (`btw a b c`).


theorem Equiv.pointReflection_involutive :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [inst_1 : AddTorsor G P] (x : P),
      Function.Involutive ⇑(Equiv.pointReflection x) :=
  by sorry

The theorem `Equiv.pointReflection_involutive` states that for any type `G` and `P`, where `G` has an additive group structure and `P` is an additive torsor over `G`, the point reflection operation at any point `x` of `P` is an involutive function. In other words, applying the point reflection operation twice returns the original point, which is equivalent to saying that the point reflection operation is its own inverse.

For any additive group `G` and additive torsor `P` over `G`, the point reflection function on `P` is an involution.


theorem Cardinal.card_le_of : ∀ {α : Type u} {n : ℕ}, (∀ (s : Finset α), s.card ≤ n) → Cardinal.mk α ≤ ↑n := by sorry

The theorem `Cardinal.card_le_of` states that for any type `α` and any natural number `n`, if every finite set `s` of type `α` has a cardinality that is less than or equal to `n`, then the cardinal number of the type `α` is less than or equal to the cardinality of `n`. In other words, if all finite sets from a certain type do not exceed a certain size, then the cardinality of the entire type does not exceed that size.

If every finite subset of type `α` has cardinality less than or equal to `n`, then the cardinality of `α` is less than or equal to `n`.


theorem Monotone.of_map_inf :
    ∀ {α : Type u} {β : Type v} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {f : α → β},
      (∀ (x y : α), f (x ⊓ y) = f x ⊓ f y) → Monotone f :=
  by sorry

The theorem `Monotone.of_map_inf` states that for any two types `α` and `β` with a semilattice structure (i.e., a structure with a binary operation that is associative, commutative, idempotent and has an order relation compatible with the operation), if a function `f` from `α` to `β` preserves the infimum operation (that is, applying `f` to the infimum of `x` and `y` is the same as taking the infimum of `f x` and `f y`), then `f` is a monotone function. In other words, if `a ≤ b` then `f a ≤ f b`.

If `f` is a function between semilattices that preserves the infimum operation, then `f` is monotone.


theorem IsOfFinOrder.mem_powers_iff_mem_zpowers :
    ∀ {G : Type u_1} [inst : Group G] {x y : G}, IsOfFinOrder x → (y ∈ Submonoid.powers x ↔ y ∈ Subgroup.zpowers x) :=
  by sorry

The theorem `IsOfFinOrder.mem_powers_iff_mem_zpowers` states that for any group `G` and any elements `x` and `y` of the group, if `x` is of finite order (meaning there exists a non-zero integer `n` such that `x` raised to the power of `n` equals the identity element), then `y` belongs to the submonoid generated by `x` if and only if `y` belongs to the subgroup generated by `x`. The submonoid generated by `x` is the set of all elements that can be obtained by multiplying `x` with itself some number of times, and the subgroup generated by `x` is the set of all elements that can be obtained by multiplying `x` or its inverse with itself some number of times.

For any group `G` and elements `x` of finite order in `G`, `x` generates the same subgroup and submonoid, i.e., `y` is in the submonoid generated by `x` if and only if `y` is in the subgroup generated by `x`.


theorem SimpleGraph.top_adj : ∀ {V : Type u} (v w : V), ⊤.Adj v w ↔ v ≠ w := by sorry

This theorem states that for any two vertices 'v' and 'w' of an arbitrary type 'V', they are adjacent in the complete graph (denoted by ⊤) if and only if 'v' is not equal to 'w'. In other words, in a complete graph, any two distinct vertices are connected by an edge.

In a complete graph, any two distinct vertices are connected by an edge.


theorem CategoryTheory.ShortComplex.rightHomologyMap_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasRightHomology S₂]
      [inst_4 : CategoryTheory.ShortComplex.HasRightHomology S₃] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
      CategoryTheory.ShortComplex.rightHomologyMap (CategoryTheory.CategoryStruct.comp φ₁ φ₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap φ₁)
          (CategoryTheory.ShortComplex.rightHomologyMap φ₂) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.rightHomologyMap_comp` states that for any category `C` that has zero morphisms, and for any three short complexes `S1`, `S2`, and `S3` (all in the category `C`) that have right homology maps, the right homology map of the composition of two morphisms `φ1 : S1 ⟶ S2` and `φ2 : S2 ⟶ S3` is equal to the composition of the right homology maps of `φ1` and `φ2`. In other words, the right homology map respects the composition in the category, which is a characteristic property of functorial behavior in category theory.

For any three short complexes `S1`, `S2`, `S3` in a category `C` with zero morphisms, and morphisms `φ1 : S1 ⟶ S2` and `φ2 : S2 ⟶ S3` having right homology maps, the right homology map of their composition is equal to the composition of their right homology maps.


theorem Mathlib.Algebra.Star.SelfAdjoint._auxLemma.19 : ∀ {S : Type u_2} [inst : Mul S] (a : S), Commute a a = True :=
  by sorry

The theorem `Mathlib.Algebra.Star.SelfAdjoint._auxLemma.19` states that for any type `S` equipped with a multiplication operation, and for any element `a` of `S`, it is always true that `a` commutes with itself. In other words, for any element `a` in a structure that supports multiplication, the product of `a` with itself is the same regardless of the order of multiplication, i.e., `a * a = a * a`.

For any type equipped with multiplication, the self-multiplication of any element is commutative, i.e., `a * a = a * a` for all `a` in the type.


theorem Mathlib.Algebra.Star.SelfAdjoint._auxLemma.17 :
    ∀ {R : Type u_1} [inst : AddCommGroup R] [inst_1 : StarAddMonoid R] {x : R}, (x ∈ skewAdjoint R) = (star x = -x) :=
  by sorry

The theorem `Mathlib.Algebra.Star.SelfAdjoint._auxLemma.17` states that for any type `R` equipped with the structure of an additive commutative group and a star additive monoid, and for any element `x` of `R`, `x` belongs to the skew-adjoint elements of `R` if and only if the star of `x` equals the additive inverse of `x`. Here, "skew-adjoint elements" refers to elements whose "star" (a certain unary operation) equals their own negatives in the additive sense.

For any element `x` in a type `R` with an additive commutative group and a star additive monoid structure, `x` is skew-adjoint if and only if the star of `x` is equal to the additive inverse of `x`.


theorem Matrix.vec3_eq :
    ∀ {α : Type u} {a₀ a₁ a₂ b₀ b₁ b₂ : α}, a₀ = b₀ → a₁ = b₁ → a₂ = b₂ → ![a₀, a₁, a₂] = ![b₀, b₁, b₂] := by sorry

This theorem states that for any type `α`, given pairs of elements `a₀, a₁, a₂` and `b₀, b₁, b₂` of type `α`, if `a₀` equals `b₀`, `a₁` equals `b₁`, and `a₂` equals `b₂`, then the vector formed from `a₀, a₁, a₂` is equal to the vector formed from `b₀, b₁, b₂`. Each pair of elements forms the corresponding entries of the two vectors, so this theorem essentially ensures that two vectors are equal if and only if their corresponding entries are equal.

For any type `α`, if `(a₀, a₁, a₂) = (b₀, b₁, b₂)` are equal tuples of elements of type `α`, then the vectors `[a₀, a₁, a₂]` and `[b₀, b₁, b₂]` are equal.


theorem CategoryTheory.strongEpi_of_epi :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : C} [inst_1 : CategoryTheory.StrongEpiCategory C]
      (f : P ⟶ Q) [inst_2 : CategoryTheory.Epi f], CategoryTheory.StrongEpi f :=
  by sorry

This theorem states that in a category 'C' with objects 'P' and 'Q', and where 'C' is a Strong Epi Category, if a morphism 'f' from 'P' to 'Q' is an epimorphism, then 'f' is also a strong epimorphism. In category theory, an epimorphism is a morphism which is right-cancellative, and a strong epimorphism is a generalization of this concept.

In a Strong Epi Category 'C', every epimorphism is a strong epimorphism.


theorem RingHom.rangeRestrict_surjective :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S),
      Function.Surjective ⇑(RingHom.rangeRestrict f) :=
  by sorry

The theorem `RingHom.rangeRestrict_surjective` states that for all rings `R` and `S`, and for every ring homomorphism `f` from `R` to `S`, the function obtained by restricting `f` to its range (i.e., the `rangeRestrict` function) is surjective. In terms of Mathematics, a function is said to be surjective if for every element in the codomain, there is at least one element in the domain of the function that maps to it. Hence, this theorem is essentially stating that every element in the range of the restricted ring homomorphism can be obtained by applying this homomorphism to some element in `R`.

For any ring homomorphism between rings `R` and `S`, the restriction of the homomorphism to its range is a surjective function.


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

The theorem `CategoryTheory.MorphismProperty.RespectsIso.isomorphisms` states that for any type `C` that forms a category, the property of being an isomorphism is preserved when composed with an isomorphism. In other words, if a morphism in the category `C` is an isomorphism, then its composition with any isomorphism (either on the left or on the right) also has the property of being an isomorphism.

In any category, the composition of an isomorphism with another isomorphism is an isomorphism.


theorem Set.preimage_neg_Icc :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), -Set.Icc a b = Set.Icc (-b) (-a) := by sorry

The theorem `Set.preimage_neg_Icc` states that for any ordered additive commutative group `α` and any two elements `a` and `b` from `α`, the negation of the closed interval from `a` to `b` is equal to the closed interval from `-b` to `-a`. In simpler terms, if you have a closed interval between two numbers, flipping this interval around zero (negating all the values in the interval) results in a new closed interval that runs from the negation of the original upper bound to the negation of the original lower bound.

For any ordered additive commutative group α and elements a, b ∈ α, the negation of the closed interval Icc (a, b) equals Icc (-b, -a).


theorem Complex.normSq_neg : ∀ (z : ℂ), Complex.normSq (-z) = Complex.normSq z := by sorry

The theorem `Complex.normSq_neg` states that for every complex number `z`, the norm squared of the negation of `z` is equal to the norm squared of `z` itself. In mathematical terms, if we denote the norm squared function as `||.||²`, this property can be written as `||-z||² = ||z||²` for all complex numbers `z`. This implies that negating a complex number does not change its norm squared.

The norm squared of the negation of a complex number equals the norm squared of the number itself. That is, `||-z||² = ||z||²` for all complex numbers `z`.


Function.IsFixedPt.map

/-- If `g` (semi)conjugates `fa` to `fb`, then it sends fixed points of `fa` to fixed points
of `fb`.  -/
theorem Function.IsFixedPt.map :
    ∀ {α : Type u} {β : Type v} {fa : α → α} {fb : β → β} {x : α},
      Function.IsFixedPt fa x → ∀ {g : α → β}, Function.Semiconj g fa fb → Function.IsFixedPt fb (g x) :=
  by sorry

The theorem `Function.IsFixedPt.map` states that if a function `g` semiconjugates another function `fa` to a function `fb`, then `g` maps the fixed points of `fa` to the fixed points of `fb`. Here, a function `fa` from a type `α` to itself has a fixed point `x` if applying `fa` to `x` results in `x` itself. Similarly, a function `fb` from a type `β` to itself has a fixed point `y` if applying `fb` to `y` results in `y` itself. A function `g` from `α` to `β` semiconjugates `fa` to `fb` if for every `x` in `α`, applying `g` after `fa` to `x` results in the same value as applying `fb` after `g` to `x`.

If function `g` semiconjugates `fa` to `fb`, then `g` maps the fixed points of `fa` to the fixed points of `fb`. In other words, for all fixed points `x` of `fa`, `g(x)` is a fixed point of `fb`.


theorem Finset.powerset_univ : ∀ {α : Type u_1} [inst : Fintype α], Finset.powerset Finset.univ = Finset.univ := by
  sorry

This theorem states that, for any finite type `α`, the powerset of the universal set (denoted as `Finset.univ`) is equivalent to the universal set itself. In mathematical terms, if we consider all subsets (the powerset operation) of a universal set (which contains all objects of a particular type `α`), we end up with the universal set itself.

For any finite type `α`, the powerset of `Finset.univ` (universal set) equals `Finset.univ`.


ContinuousWithinAt.prod

theorem ContinuousWithinAt.prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {f : α → β} {g : α → γ} {s : Set α} {x : α},
      ContinuousWithinAt f s x → ContinuousWithinAt g s x → ContinuousWithinAt (fun x => (f x, g x)) s x :=
  by sorry

The theorem `ContinuousWithinAt.prod` states that for any types `α`, `β`, and `γ` equipped with topological space structures, given two functions `f: α → β` and `g: α → γ`, and a set `s` of type `α` with a particular element `x` in `α`; if the function `f` is continuous within the set `s` at the point `x` and similarly the function `g` is also continuous within `s` at `x`, then the function that maps `x` to the ordered pair `(f x, g x)` is also continuous within `s` at the point `x`. In other words, the product of two continuous functions remains continuous within the same subset.

If functions `f: α → β` and `g: α → γ` are continuous at a point `x` in `α` within a set `s` subsets of `α`, then the function `(f, g): α → β × γ` mapping `x` to `(f x, g x)` is continuous at `x`.


theorem isUpperSet_compl : ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsUpperSet sᶜ ↔ IsLowerSet s := by sorry

The theorem `isUpperSet_compl` states that for any type `α` with a less than or equal to order and any set `s` of type `α`, the complement of `s` is an upper set if and only if `s` is a lower set. In other words, a set is a lower set (downward-closed set) if any element less than one of its members is also a member of the set, then the complement of that set is an upper set (upward-closed set), meaning any element greater than one of the elements in the complement set is also a member of the complement set, and vice versa.

For any type `α` with a total order and set `s` of type `α`, the complement of `s` is an upper set if and only if `s` is a lower set.


/-- **Riesz's theorem**: a locally compact normed vector space is finite-dimensional.  -/
theorem FiniteDimensional.of_locallyCompactSpace :
    ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace 𝕜] [inst_4 : LocallyCompactSpace E], FiniteDimensional 𝕜 E :=
  by sorry

**Riesz's theorem**: This theorem states that any locally compact normed vector space is also a finite-dimensional vector space. Specifically, given any type `𝕜` which forms a non-trivially normed field and a type `E` which forms a normed additively commutative group and a normed space over `𝕜`, if `𝕜` is a complete space and `E` is a locally compact space, then `E` is a finite-dimensional vector space over `𝕜`.

Any locally compact, normed vector space over a complete, non-trivially normed field is finite-dimensional.


/-- `eq_of_testBit_eq` allows proving two natural numbers are equal
if their bits are all equal.
 -/
theorem Nat.eq_of_testBit_eq : ∀ {x y : ℕ}, (∀ (i : ℕ), Nat.testBit x i = Nat.testBit y i) → x = y := by sorry

The theorem `Nat.eq_of_testBit_eq` states that for any two natural numbers `x` and `y`, if their respective bits at all positions are equal (as determined by the `Nat.testBit` function), then `x` and `y` are equal. In other words, two natural numbers are deemed equal if their binary representations are the same.

If for all i, Nat.testBit x i = Nat.testBit y i, then x = y.


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

This theorem states that for any category `C` that has pullbacks and any object `A` in `C`, if we have two subobjects `f` and `g` of `A`, then the infimum of `f` and `g` (denoted by `(CategoryTheory.Subobject.inf.obj f).obj g`) is less than or equal to `f`. The infimum here refers to the greatest lower bound or "meet" of these two subobjects. In other words, any common lower bound of `f` and `g` in the partial order of subobjects of `A` must be less than or equal to the infimum of `f` and `g`.

For any category with pullbacks and any object `A` in it, the infimum of subobjects `f` and `g` of `A` satisfies `f ⊆ (CategoryTheory.Subobject.inf.obj f).obj g`.


theorem AkraBazziRecurrence.GrowsPolynomially.pow :
    ∀ {f : ℝ → ℝ} (p : ℕ),
      AkraBazziRecurrence.GrowsPolynomially f →
        (∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x) → AkraBazziRecurrence.GrowsPolynomially fun x => f x ^ p :=
  by sorry

The theorem `AkraBazziRecurrence.GrowsPolynomially.pow` states that for any real function `f` and natural number `p`, if `f` grows polynomially (in the sense defined by `AkraBazziRecurrence.GrowsPolynomially`), and `f(x)` is nonnegative for all sufficiently large `x` (expressed as "eventually at top", denoted by `∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x`), then the function `f(x)^p` also grows polynomially. The growth of `f` is measured according to the Akra-Bazzi recurrence relation condition, i.e., there exist positive constants `c₁` and `c₂` such that `c₁ g(n) ≤ g(u) ≤ c₂ g(n)`, for `u` between `b*n` and `n` for any constant `b` in the open interval `(0,1)`.

If `f` is a real function that grows polynomially and is nonnegative for all sufficiently large `x`, then `f(x)^p` also grows polynomially with the same polynomial degree as `f`.


theorem DihedralGroup.one_def : ∀ {n : ℕ}, 1 = DihedralGroup.r 0 := by sorry

This theorem states that for all natural numbers 'n', the identity element (1) of the Dihedral Group is defined as the rotation by 0 degrees. The `DihedralGroup.r 0` in the statement represents a rotation by 0 degrees in the Dihedral Group.

For all natural numbers n, the identity element in the Dihedral Group is the rotation by 0 degrees. Equivalently, DihedralGroup.r 0 = id.


theorem right_mem_segment :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : MulActionWithZero 𝕜 E] (x y : E), y ∈ segment 𝕜 x y :=
  by sorry

This theorem, named `right_mem_segment`, states that for any ordered semiring `𝕜` and an additive commutative monoid `E` that also allows multiplication by zero, every element `y` in `E` is in the segment between any element `x` and `y` itself. In other words, given any two elements in the vector space (or more generally, in the module), the segment between them always includes the second element. This can be visualized as a line segment on a number line: if you were to draw a line between any two points `x` and `y`, the point `y` is always a part of that line segment.

For any ordered semiring 𝕜 and an additive commutative monoid E with multiplication by zero, every element y in E is contained in the segment between any two elements x and y.


theorem MeasurableSpace.comap_id : ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSpace.comap id m = m := by sorry

This theorem states that for any type `α` and any measurable space `m` of type `α`, the reverse image (or preimage) of `m` under the identity function is equal to `m` itself. In other words, if we apply the identity function to every set in the measurable space, we get the same measurable space back. This highlights that the identity function, which leaves every element unchanged, also leaves the structure of the measurable space unchanged when applied to each element.

For any measurable space (α, m), the preimage of m under the identity function is equal to m.


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

The theorem `AddLECancellable.le_tsub_iff_left` states that for any type `α` that has an addition operation forming a commutative semigroup, a partial order, an existence of an addition operation that respects this order, a subtraction operation, and an ordered subtraction operation, and for any elements `a`, `b`, and `c` of this type, if `a` is `AddLECancellable` (which means that addition with `a` is order-reflecting) and `a` is less than or equal to `c`, then `b` is less than or equal to `c - a` if and only if `a + b` is less than or equal to `c`. This theorem essentially relates the order of elements in this type with their sum and difference, under the premise that addition with a certain element reflects the order.

For any commutative semigroup with addition, partial order, order-reflecting additive element `a`, and ordered subtraction, if `a` is less than or equal to `c` and `a` is AddLECancellable, then `b` is less than or equal to `c - a` if and only if `a + b` is less than or equal to `c`.


/-- If there is a primitive `n`-th root of unity in `K`, then `cyclotomic' n K` comes from a
monic polynomial with integer coefficients.  -/
theorem Polynomial.int_coeff_of_cyclotomic' :
    ∀ {K : Type u_2} [inst : CommRing K] [inst_1 : IsDomain K] {ζ : K} {n : ℕ},
      IsPrimitiveRoot ζ n →
        ∃ P,
          Polynomial.map (Int.castRingHom K) P = Polynomial.cyclotomic' n K ∧
            Polynomial.degree P = Polynomial.degree (Polynomial.cyclotomic' n K) ∧ Polynomial.Monic P :=
  by sorry

The theorem states that, if `K` is a commutative ring with 1 that is also a domain, and there exists a primitive `n`-th root of unity (denoted by `ζ`) in `K`, then there exists a monic polynomial `P` with integer coefficients such that when `P` is mapped from the integers to `K` using the integer casting ring homomorphism, it equals the `n`-th modified cyclotomic polynomial with coefficients in `K`. Additionally, the degree of `P` and the degree of the `n`-th cyclotomic polynomial are the same.

In simpler terms, this theorem is saying that if a certain mathematical condition (specifically, the existence of a primitive `n`-th root of unity) holds in a given ring, then the `n`-th cyclotomic polynomial in that ring can be derived from a polynomial with integer coefficients that has some particular properties (specifically, being monic and having the same degree as the cyclotomic polynomial).

Given a commutative ring with 1 that is also a domain `K` and contains a primitive `n`-th root of unity `ζ`, there exists a monic polynomial `P` with integer coefficients in `K` such that `P` is the `n`-th modified cyclotomic polynomial when mapped from the integers to `K` using the integer casting ring homomorphism, and the degrees of `P` and the `n`-th cyclotomic polynomial are equal.


Ordnode.node.injEq

theorem Ordnode.node.injEq :
    ∀ {α : Type u} (size : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α) (size_1 : ℕ) (l_1 : Ordnode α) (x_1 : α)
      (r_1 : Ordnode α),
      (Ordnode.node size l x r = Ordnode.node size_1 l_1 x_1 r_1) = (size = size_1 ∧ l = l_1 ∧ x = x_1 ∧ r = r_1) :=
  by sorry

This theorem, `Ordnode.node.injEq`, states that for any type `α`, two ordered nodes of type `α` are equal if and only if their sizes, left and right child nodes, and values are all respectively equal. Here, an ordered node is represented by `Ordnode.node` with size of type ℕ, left and right child nodes of type `Ordnode α`, and value of type `α`. The theorem asserts equality between two such nodes by comparing all their constituent elements.

For any type α and ordered nodes x and y of type Ordnode.node α, x = y if and only if their sizes, left child nodes, and values are equal.


IsChain.insert

theorem IsChain.insert :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
      IsChain r s → (∀ b ∈ s, a ≠ b → r a b ∨ r b a) → IsChain r (insert a s) :=
  by sorry

The theorem `IsChain.insert` states that for any type `α`, any binary relation `r` on `α`, any set `s` of elements of type `α`, and any element `a` of type `α`, if `s` forms a chain with respect to `r` and for every element `b` in `s` such that `a` is not equal to `b`, either `r a b` or `r b a` holds, then the set obtained by inserting `a` into `s` also forms a chain with respect to `r`. In other words, inserting a new element into a chain, which relates to every element in the chain, preserves the chain property.

If `s` is a chain with respect to `r` and `a` is not in `s`, then `s ∪ {a}` is a chain with respect to `r` if and only if for all `b` in `s`, either `r(a, b)` or `r(b, a)` holds.


theorem ContinuousWithinAt.closure_le :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderClosedTopology α]
      [inst_2 : TopologicalSpace β] {f g : β → α} {s : Set β} {x : β},
      x ∈ closure s → ContinuousWithinAt f s x → ContinuousWithinAt g s x → (∀ y ∈ s, f y ≤ g y) → f x ≤ g x :=
  by sorry

This theorem, `ContinuousWithinAt.closure_le`, states that for any two functions `f` and `g` from a topological space `β` to a preordered, topologically closed space `α`, along with a subset `s` of `β` and a point `x` in the closure of `s`, if both `f` and `g` are continuous at `x` within `s`, and `f y` is less than or equal to `g y` for all `y` in `s`, then `f x` is less than or equal to `g x`.

If `f` and `g` are continuous at a point `x` in the closure of a subset `s` of a topological space, `β`, such that `f(y) ≤ g(y)` for all `y` in `s`, then `f(x) ≤ g(x)`.


theorem neg_pow :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : HasDistribNeg R] (a : R) (n : ℕ), (-a) ^ n = (-1) ^ n * a ^ n := by
  sorry

This theorem, `neg_pow`, states that for any type `R` that is a monoid and has the ability to distribute over negation (i.e., has an operation `-` that distributes over `*`), and for any element `a` of type `R` and any natural number `n`, the `n`th power of `-a` is equal to the `n`th power of `-1` multiplied by the `n`th power of `a`. In mathematical notation, this would be expressed as `(-a)^n = (-1)^n * a^n`.

For any monoid `R` with distributive negation and for all `a` in `R` and natural number `n`, `(-a)^n = (-1)^n * a^n`.


theorem PadicInt.isUnit_iff : ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ_[p]}, IsUnit z ↔ ‖z‖ = 1 := by sorry

The theorem `PadicInt.isUnit_iff` states that for any natural number `p` which is a prime number, and any `z` which is a p-adic integer, `z` is a unit (i.e., it has a two-sided inverse) if and only if the norm of `z` (`‖z‖`) is equal to `1`.

A p-adic integer `z` is a unit if and only if its norm equals 1 in a p-adic number system, where p is a prime number.


theorem UniformInducing.isComplete_range :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : CompleteSpace α]
      {f : α → β}, UniformInducing f → IsComplete (Set.range f) :=
  by sorry

The theorem `UniformInducing.isComplete_range` states that for any two types `α` and `β`, which are equipped with uniform spaces, and given that `α` is a complete space, any function `f` from `α` to `β` which induces a uniform structure is a complete set. In other words, for a function `f: α → β`, if it is a uniform inducing function, the range (or the image) of the function `f`, denoted as `Set.range f`, forms a complete set. Here, a set is considered complete if any Cauchy filter on the set has a limit in the set itself.

If `α` is a complete uniform space and `f: α → β` is a uniformly continuous function, then the range `Set.range f` of `f` is a complete set.


theorem Fin.rev_last : ∀ (n : ℕ), Fin.rev (Fin.last n) = 0 := by sorry

This theorem states that for any natural number `n`, if you reverse `Fin.last n`, you get `0`. `Fin.last n` refers to the greatest value of `Fin (n+1)`, and `Fin.rev` is a function that maps `0` to `n-1`, `1` to `n-2`, ..., `n-1` to `0`. Therefore, if the greatest value of `Fin(n+1)` is reversed, it gives `0`.

For any natural number `n`, the greatest element in `Fin (n+1)` is equal to `0` when reversed using the `Fin.rev` function.


theorem Mathlib.LinearAlgebra.Quotient._auxLemma.1 :
    ∀ {R : Type u_1} {M : Type u_2} {x : M} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (p : Submodule R M), (Submodule.Quotient.mk x = 0) = (x ∈ p) :=
  by sorry

This theorem states that for any ring `R`, additive commutative group `M`, and submodule `p` of `M`, an element `x` of `M` maps to zero in the quotient module `M / p` (that is, `Submodule.Quotient.mk x = 0`) if and only if `x` belongs to the submodule `p` (that is, `x ∈ p`). In other words, the kernel of the quotient map is precisely the submodule `p`.

The kernel of the quotient map from a module `M` to its submodule `p` is equal to `p` itself.


/-- A non-quantitative version of Markov inequality for integrable functions: the measure of points
where `‖f x‖ ≥ ε` is finite for all positive `ε`.  -/
theorem MeasureTheory.Integrable.measure_norm_ge_lt_top :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Integrable f μ → ∀ {ε : ℝ}, 0 < ε → ↑↑μ {x | ε ≤ ‖f x‖} < ⊤ :=
  by sorry

This theorem, known as a non-quantitative version of the Markov inequality for integrable functions, states that for any measurable space `α`, any normed additive commutative group `β`, any measure `μ` on `α`, and any function `f` from `α` to `β` that is integrable with respect to `μ`, for all real number `ε` greater than 0, the measure of the set of points `x` where the norm of `f(x)` is greater than or equal to `ε` is finite.

For any measurable space `α`, normed additive commutative group `β`, measure `μ` on `α`, and integrable function `f` from `α` to `β`, the set of points `x` in `α` with `||f(x)||_β ≥ ε` has finite measure under `μ` for any `ε > 0`.


theorem SetLike.not_le_iff_exists :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, ¬p ≤ q ↔ ∃ x ∈ p, x ∉ q := by sorry

This theorem states that for any two sets 'p' and 'q' of a type 'A' that behaves like a set of a type 'B', 'p' is not a subset of 'q' if and only if there exists an element 'x' in 'p' that is not in 'q'. Here, 'SetLike A B' is a typeclass assumption which means 'A' behaves like a 'set' over 'B'. The '≤' operator denotes subset or substructure relationship in this context.

For sets 'p' and 'q' of type 'A' that have the set behavior over 'B', 'p' is strictly subset of 'q' if and only if there is no element in 'p' that is in 'q'.


theorem Matrix.l2_opNorm_conjTranspose_mul_self :
    ∀ {𝕜 : Type u_1} {m : Type u_2} {n : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype m] [inst_2 : Fintype n]
      [inst_3 : DecidableEq n] (A : Matrix m n 𝕜), ‖Matrix.conjTranspose A * A‖ = ‖A‖ * ‖A‖ :=
  by sorry

The theorem `Matrix.l2_opNorm_conjTranspose_mul_self` states that for any type `𝕜` that behaves like a ring or a field (indicated by `RCLike 𝕜`), types `m` and `n` which are finite (indicated by `Fintype m` and `Fintype n`) and have decidable equality (indicated by `DecidableEq n`), and a matrix `A` with entries in `𝕜` and dimensions indexed by `m` and `n`, the L2 operator norm (the square root of the largest eigenvalue of `A* A`) of the product of the conjugate transpose of `A` and `A` is equal to the product of the L2 operator norm of `A` and itself. Here, `Matrix.conjTranspose` is a function that computes the conjugate transpose of a matrix, `‖A‖` denotes the L2 operator norm of `A`, and '*' denotes matrix multiplication.

For any ring or field `𝕜`, finite types `m` and `n` with decidable equality, and matrix `A` of dimension `m x n` over `𝕜`, the L2 norm of `A` multiplied by the L2 norm of its conjugate transpose equals the L2 norm of `A` multiplied by itself. In Lean notation: `∀ 𝕜: Type u | RCLike 𝕜, (∀ m n: Nat, Fintype m → Fintype n → DecidableEq n → Matrix 𝕜 m n → Real = ‖A⟩.‖ * ‖Matrix.conjTranspose A⟩.‖ = ‖A⟩.‖ * ‖A⟩.‖`.`


theorem TopCat.Presheaf.isSheaf_iff_isSheaf_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v, u₂} D] (G : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.ReflectsIsomorphisms G] [inst_3 : CategoryTheory.Limits.HasLimits C]
      [inst_4 : CategoryTheory.Limits.PreservesLimits G] {X : TopCat} (F : TopCat.Presheaf C X),
      TopCat.Presheaf.IsSheaf F ↔ TopCat.Presheaf.IsSheaf (CategoryTheory.Functor.comp F G) :=
  by sorry

This theorem states that for any two categories `C` and `D`, given a functor `G` from `C` to `D` that reflects isomorphisms and preserves limits, and assuming `C` has all (small) limits, a `C`-valued presheaf `F` on a topological space `X` is a sheaf if and only if the composed functor `F` followed by `G` is a sheaf. Here, a sheaf is a presheaf that satisfies certain gluing conditions for sections over open sets.

Given a functor `G` from category `C` to `D` that reflects isomorphisms and preserves limits over a category `C` with all limits, a `C`-valued presheaf `F` is a sheaf if and only if the composed functor `F ∘ G` is a sheaf.


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

This theorem states that for any type `α`, any indexing type `ι`, any element `x` of type `α`, and any family of sets `s` indexed by `ι`, the membership of `x` in the union of all sets in the family `s` is equivalent to the existence of an index `i` such that `x` is a member of the set `s` at index `i`. In mathematical terms, this theorem states that $x \in \bigcup_{i} s_i$ if and only if there exists an $i$ such that $x \in s_i$.

For any type `α`, indexing type `ι`, element `x` of type `α`, and set family `s` indexed by `ι`, `x` is in the union of `s` if and only if there exists an `i` such that `x` is in `s` at index `i`. In mathematical notation, this is expressed as `x ∈ ⋃i. si ↔ ∃i, x ∈ si`.


theorem Mathlib.GroupTheory.DoubleCoset._auxLemma.4 :
    ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a b : α},
      (b ∈ Doset.doset a s t) = ∃ x ∈ s, ∃ y ∈ t, b = x * a * y :=
  by sorry

This theorem states that for any type `α` equipped with a multiplication operation, any two sets `s` and `t` of type `α`, and any two elements `a` and `b` of type `α`, the condition that `b` is in the double coset of `a` with respect to `s` and `t` is equivalent to the existence of an element `x` in `s` and an element `y` in `t` such that `b` is equal to the product of `x`, `a`, and `y` in that order. In mathematical terms, we could write the result as $b \in s \cdot \{a\} \cdot t \iff \exists x \in s, y \in t: b = x \cdot a \cdot y$.

For any type `α` with multiplication, sets `s` and `t` of `α`, and elements `a`, `b` in `α`, `b` is in the double coset of `a` with respect to `s` and `t` if and only if there exist `x` in `s` and `y` in `t` such that `b = x * a * y`.


theorem Mathlib.Data.Finset.NAry._auxLemma.7 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
      (Finset.image f s ⊆ t) = ∀ x ∈ s, f x ∈ t :=
  by sorry

This theorem, `Mathlib.Data.Finset.NAry._auxLemma.7`, states that for all types `α` and `β`, given a function `f` from `α` to `β`, a finite set `s` of type `α`, and a finite set `t` of type `β`, with `β` having decidable equality, the forward image of `s` under `f` being a subset of `t` is equivalent to the statement that for every element `x` in `s`, the function `f` applied to `x` is an element of `t`. In other words, every element of the image of `s` under `f` must belong to `t`.

For all types `α` and `β` with decidable equality, given a function `f` from `α` to `β`, a finite set `s` of type `α`, and a finite set `t` of type `β`, the image of `s` under `f` is a subset of `t` if and only if for all `x` in `s`, `f(x)` is in `t`.


theorem MeasureTheory.measure_biUnion₀ :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set β} {f : β → Set α},
      Set.Countable s →
        Set.Pairwise s (MeasureTheory.AEDisjoint μ on f) →
          (∀ b ∈ s, MeasureTheory.NullMeasurableSet (f b) μ) → ↑↑μ (⋃ b ∈ s, f b) = ∑' (p : ↑s), ↑↑μ (f ↑p) :=
  by sorry

The theorem `MeasureTheory.measure_biUnion₀` states that for any types `α` and `β`, given a measurable space on `α` (denoted by `m`), a measure `μ` on `α`, a set `s` of elements of type `β`, and a function `f` mapping elements of `β` to sets of `α`, if the set `s` is countable, the measure `μ` is almost everywhere disjoint on the function `f` mapped over the set `s`, and for every element `b` in the set `s`, the set `f(b)` is null measurable with respect to the measure `μ`, then the measure `μ` of the union of all the sets `f(b)`, where `b` is in the set `s`, is equal to the sum of the measures of the sets `f(b)` for all `b` in the set `s`.

In mathematical terms, this theorem is saying that if we have a countable set of null measurable sets that are pairwise almost everywhere disjoint, then the measure of the union of these sets is equal to the sum of their individual measures.

Given a countable family of null measurable, pairwise almost everywhere disjoint sets in a measurable space with respect to a measure, the measure of their union equals the sum of the measures of the individual sets.


AnalyticOn.continuousOn

theorem AnalyticOn.continuousOn :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {s : Set E},
      AnalyticOn 𝕜 f s → ContinuousOn f s :=
  by sorry

This theorem states that if a function `f` from a normed additive commutative group `E` to another normed additive commutative group `F`, both of which have a normed space structure over a nontrivially normed field `𝕜`, is analytic on a set `s` of `E`, then `f` is also continuous on `s`. In other words, any function that is analytic on a set (which means it is analytic around every point of the set) is also continuous on that set (which means it is continuous at every point of the set).

If a function between two normed additive commutative groups is analytic on a set, then it is continuous on that set.


theorem IsMax.Ici_eq : ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, IsMax a → Set.Ici a = {a} := by sorry

The theorem `IsMax.Ici_eq` states that for any partially ordered type `α` and any element `a` of that type, if `a` is a maximal element (meaning that no other element is strictly greater than `a`), then the set of all elements that are greater than or equal to `a` (denoted by `Set.Ici a`) is simply the set containing the element `a` itself. In other words, there are no elements in the set that are strictly greater than `a`, so the only element in the set is `a`.

For any partially ordered type `α` and its maximal element `a`, the set of elements greater than or equal to `a` (`Set.Ici a`) equals the singleton set `{a}` if `a` is maximal.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.13 :
    ∀ {V : Type u} {G : SimpleGraph V} {a b : V} {s : Set (SimpleGraph.Subgraph G)},
      (sInf s).Adj a b = ((∀ G' ∈ s, G'.Adj a b) ∧ G.Adj a b) :=
  by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.13`, states that for any type `V`, a simple graph `G` of type `V`, and any two vertices `a` and `b` from `V`, along with a set `s` of subgraphs of `G`, the adjacency in the infimum of `s` between vertices `a` and `b` is equal to the conjunction of the adjacency in all subgraphs `G'` in `s` between `a` and `b`, and the adjacency in graph `G` between `a` and `b`. In simpler terms, two vertices `a` and `b` are considered adjacent in the infimum of a set of subgraphs of `G` if and only if they are adjacent in every subgraph within the set and also in the original graph `G`.

The adjacency relation in the infimum of a set of subgraphs of a simple graph is the conjunction of the adjacency relations in each subgraph and the graph itself.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.12 :
    ∀ {V : Type u} {G : SimpleGraph V} {a b : V} {s : Set (SimpleGraph.Subgraph G)},
      (sSup s).Adj a b = ∃ G_1 ∈ s, G_1.Adj a b :=
  by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.12`, states that for any type `V`, any Simple Graph `G` of type `V`, and any two vertices `a` and `b` of type `V`, and for any set `s` of subgraphs of `G`, the adjacency of `a` and `b` in the supergraph of `s` is equivalent to the existence of a subgraph `G_1` in `s` where `a` and `b` are adjacent. In other words, two vertices are adjacent in the supergraph if and only if there exists a subgraph within the set where those two vertices are also adjacent.

For any simple graph G, vertices a and b are adjacent in the supergraph of a set S of subgraphs if and only if there exists a subgraph in S with a and b as adjacent vertices.


theorem isPreirreducible_singleton : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, IsPreirreducible {x} := by
  sorry

The theorem `isPreirreducible_singleton` states that for any type `X` equipped with a topology (a topological space), every singleton set (a set containing exactly one element) `{x}` is a preirreducible set. In mathematical terms, this means if we take any two open sets `u` and `v` in `X` such that the intersection of `u` or `v` with the singleton `{x}` is nonempty, then the intersection of `u`, `v`, and `{x}` is also nonempty. This is to say, there are no non-trivial pair of disjoint open sets in the singleton `{x}`.

For any topological space (X, top X) and any point x ∈ X, the singleton set {x} is a preirreducible open set, i.e., for all open sets U, V ∈ top X with x ∈ U ∩ V, we have U ∩ V ∩ {x} ≠ ∅.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.10 :
    ∀ {V : Type u} {G : SimpleGraph V} {a b : V}, ⊤.Adj a b = G.Adj a b := by sorry

This theorem from the Mathlib library in Lean 4 states that for any type `V`, any simple graph `G` of vertices of type `V`, and any two vertices `a` and `b` of that type, the adjacency of `a` and `b` in the topmost, or complete, subgraph (represented by `⊤`) is equal to the adjacency of `a` and `b` in the original graph `G`. In other words, `a` and `b` are adjacent in the complete subgraph if and only if they are adjacent in `G`.

For any simple graph `G` and vertices `a` and `b` of type `V` in `G`, `a` and `b` are adjacent in the complete subgraph `⊤` if and only if they are adjacent in `G`.


theorem pow_bit0_pos : ∀ {R : Type u_3} [inst : LinearOrderedRing R] {a : R}, a ≠ 0 → ∀ (n : ℕ), 0 < a ^ bit0 n := by
  sorry

This theorem, `pow_bit0_pos`, states that for any type `R` which is a linearly ordered ring, and for any nonzero element `a` of `R`, for any natural number `n`, the nth power of `a` using the `bit0` function (which essentially doubles the input) is always positive. In mathematical terms, given a ≠ 0, it asserts that 0 < a^(2n) for all natural numbers n.

For any nonzero element `a` in a linearly ordered ring `R`, `a` raised to the power of any natural number `n` results in a positive element, i.e., `0 < a^(2n)`.


theorem Int.comap_cast_atTop :
    ∀ {R : Type u_2} [inst : StrictOrderedRing R] [inst_1 : Archimedean R],
      Filter.comap Int.cast Filter.atTop = Filter.atTop :=
  by sorry

The theorem `Int.comap_cast_atTop` states that for any strict ordered ring `R` that is also Archimedean, the preimage (comap) of the filter `atTop` (representing the limit going to infinity) under the canonical homomorphism `Int.cast` from the integers `ℤ` to `R` is also `atTop`. In other words, in such a mathematical structure, casting integers to `R` and then considering sequences going to infinity behaves the same as considering sequences of integers going to infinity.

For any Archimedean strict ordered ring R, the preimage of the filter atTop under Int.cast from ℤ is equal to atTop.


theorem Real.hasStrictDerivAt_arctan : ∀ (x : ℝ), HasStrictDerivAt Real.arctan (1 / (1 + x ^ 2)) x := by sorry

This theorem states that for every real number `x`, the function `arctan` (which is the inverse of the tangent function) has a strict derivative at the point `x`. The value of this derivative is `1 / (1 + x ^ 2)`. In other words, the derivative of the `arctan` function at any point `x` is calculated as the reciprocal of the sum of 1 and the square of `x`. This is a strict derivative, which means the function is smooth or continuously differentiable at that point.

The derivative of the real function `arctan` is `1 / (1 + x^2)` for all real `x`.


theorem Polynomial.sum_def :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : AddCommMonoid S] (p : Polynomial R) (f : ℕ → R → S),
      Polynomial.sum p f = Finset.sum (Polynomial.support p) fun n => f n (Polynomial.coeff p n) :=
  by sorry

The theorem `Polynomial.sum_def` states that for any semiring `R`, additively commutative monoid `S`, polynomial `p` over `R`, and function `f` from a pair of natural number and `R` to `S`, the sum obtained by applying `f` to each coefficient of the polynomial `p` is equal to the sum of `f` applied to each element `n` and its corresponding coefficient in the polynomial, where `n` ranges over the support of the polynomial `p`. Here, the support of a polynomial is the set of all exponents such that the corresponding coefficient is non-zero.

For any semiring `R`, additively commutative monoid `S`, polynomial `p` over `R` with support `N`, and function `f : ℕ × R → S`, the application of `f` to the coefficient-wise sum of the polynomial `p` is equal to the sum of `f(n, p(n))` for all `n` in the support `N` of `p`.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.21 : ∀ (p : Prop), (True ∧ p) = p := by sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.21`, states that for any proposition `p`, the boolean conjunction (i.e., AND operation) of `True` and `p` is equivalent to `p` itself. In other words, it says if `True` and `p` are both true, then `p` is true - which holds for any proposition `p`. This theorem is fundamental in boolean logic within the Lean Theorem Prover.

The theorem asserts that `True` and any proposition `p` are logically equivalent.


theorem not_nontrivial : ∀ (α : Type u_3) [inst : Subsingleton α], ¬Nontrivial α := by sorry

This theorem states that for every type `α`, if `α` is a subsingleton, then `α` is not nontrivial. In other words, there cannot exist a nontrivial structure on a type which is a subsingleton. Recall that a type is a subsingleton when it has at most one element, and a type is nontrivial when there are at least two distinct elements in it.

A subsingleton type, having at most one element, cannot be nontrivial, which requires the presence of at least two distinct elements.


theorem Ultrafilter.le_nhds_lim :
    ∀ {X : Type u} [inst : TopologicalSpace X] [inst_1 : CompactSpace X] (F : Ultrafilter X),
      ↑F ≤ nhds (Ultrafilter.lim F) :=
  by sorry

This theorem states that for any type `X` with a topological space structure and a compact space structure, and for any ultrafilter `F` on `X`, the ultrafilter `F` is less than or equal to the neighborhood filter at the limit of `F`. In other words, every set in the ultrafilter `F` is also in the neighborhood filter at the limit of `F`. Note that the limit of an ultrafilter, if it exists, is a certain element of the underlying type `X`.

For any compact topological space `(X, τ)` and an ultrafilter `F` on `X`, the ultrafilter `F` is contained in the neighborhood filter of the limit of `F`.


theorem ProbabilityTheory.kernel.lintegral_map :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
      {mγ : MeasurableSpace γ} {f : β → γ} (κ : ↥(ProbabilityTheory.kernel α β)) (hf : Measurable f) (a : α)
      {g' : γ → ENNReal},
      Measurable g' → ∫⁻ (b : γ), g' b ∂(ProbabilityTheory.kernel.map κ f hf) a = ∫⁻ (a : β), g' (f a) ∂κ a :=
  by sorry

This theorem states that for any measurable spaces `α`, `β`, and `γ`, given a `κ` kernel from `α` to `β`, a measurable function `f` from `β` to `γ`, and a measurable function `g'` from `γ` to the extended nonnegative real numbers (usually denoted as `[0, ∞]`), the integral of `g'` with respect to the measure derived from mapping `κ` through `f` at a given point `a` in `α` is equal to the integral of the composition of `g'` and `f` with respect to `κ` at `a`. In other words, it asserts that the measure transformation by `f` can be interchanged with the process of integration. This is a version of the change of variables formula in the context of measure theory.

For any measurable spaces `α`, `β`, and `γ`, given measurable functions `κ` from `α` to `β`, `f` from `β` to `γ`, and `g'` from `γ` to $[0, ∞]$, the integral of `g'` with respect to the pushforward measure of `κ` by `f` equals the integral of `g' ∘ f` with respect to `κ`.


theorem addOrderOf_eq_card_of_forall_mem_zmultiples :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Fintype α] {g : α},
      (∀ (x : α), x ∈ AddSubgroup.zmultiples g) → addOrderOf g = Fintype.card α :=
  by sorry

The theorem `addOrderOf_eq_card_of_forall_mem_zmultiples` states that for any type `α` that has an additive group structure and is finite (`Fintype`), given an element `g` of `α`, if every element `x` of `α` is in the subgroup generated by `g` (i.e., `x` is an integer multiple of `g`), then the order of `g`, denoted by `addOrderOf g` (the smallest positive integer `n` such that `n` times `g` equals the additive identity, or `0` if no such `n` exists), is equal to the total number of elements in `α`, given by `Fintype.card α`.

For any finite additive group `α` and any element `g` in `α` such that every element in `α` is a multiple of `g`, the order of `g` equals the cardinality of `α`.


theorem WithZero.coe_inj : ∀ {α : Type u} {a b : α}, ↑a = ↑b ↔ a = b := by sorry

This theorem, `WithZero.coe_inj`, states that for any given type `α` and any two elements `a` and `b` of that type, the statement that the coersion of `a` to `WithZero α` is equal to the coersion of `b` to `WithZero α` is equivalent to the statement that `a` is equal to `b`. In other words, the coersion to `WithZero α` is an injective (or one-to-one) function.

The coersion function from a type to `WithZero` is an injection.


theorem Mathlib.Algebra.Lie.Abelian._auxLemma.5 :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] (m : M),
      (m ∈ LieModule.maxTrivSubmodule R L M) = ∀ (x : L), ⁅x, m⁆ = 0 :=
  by sorry

This theorem, from the Mathlib library for Lean, states that for any types `R`, `L`, and `M`, under the conditions that `R` is a commutative ring, `L` is a Lie ring, `M` is an additive commutative group and a module over `R`, `M` is a Lie ring module for `L`, and `M` is a Lie module for `R` and `L`, an element `m` of `M` belongs to the maximal trivial submodule of the Lie module if and only if for all elements `x` of `L`, the Lie bracket of `x` and `m` is zero.

In mathematical terms, this theorem is about the structure of Lie algebras, a key concept in the theory of algebraic structures. Specifically, it characterizes the elements of the maximal trivial submodule of a Lie module in terms of the Lie bracket operation.

An element of a Lie module over a commutative ring is in the maximal trivial submodule if and only if the Lie bracket of any element in the Lie algebra with that element is zero.


theorem Submodule.mem_sup_right :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {S T : Submodule R M} {x : M}, x ∈ T → x ∈ S ⊔ T :=
  by sorry

This theorem, `Submodule.mem_sup_right`, states that for any semiring `R`, additively commutative monoid `M`, and module `M` over `R`, and for any two submodules `S` and `T` of `M`, if a member `x` belongs to submodule `T`, then `x` also belongs to the supremum of `S` and `T`, denoted as `S ⊔ T`. In the context of module theory, the supremum of two submodules is the smallest submodule that includes both submodules.

For any semiring `R`, additively commutative monoid `M`, and module `M` over `R`, if `x` is an element of submodule `T` of `M`, then `x` belongs to the supremum `S ⊔ T` of submodules `S` and `T` of `M`.


theorem minpoly.ne_zero_of_finite :
    ∀ (A : Type u_1) {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] (e : B)
      [inst_3 : FiniteDimensional A B], minpoly A e ≠ 0 :=
  by sorry

This theorem states that for any type `A` which forms a field, and any type `B` which forms a ring and an algebra over `A`, if `B` is also a finite dimensional vector space over `A`, then the minimal polynomial of any element `e` of `B` over `A` is nonzero. In other words, if `B` is a finite-dimensional algebra over the field `A`, then the minimal polynomial of any element in `B` cannot be the zero polynomial.

In a finite-dimensional algebra over a field, every non-zero element has a non-zero minimal polynomial.


theorem IsAdjoinRoot.aequiv_map :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {f : Polynomial R}
      {T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T] (h : IsAdjoinRoot S f) (h' : IsAdjoinRoot T f)
      (z : Polynomial R), (IsAdjoinRoot.aequiv h h') (h.map z) = h'.map z :=
  by sorry

This theorem states that for any two types `R` and `S` which are commutative rings, and an algebra `A` defined over `R` and `S`, and given a polynomial `f` over `R`, if the roots of `f` adjoin `S` and `T` (where `T` is another type with a commutative ring and an algebra over `R`), then for any polynomial `z` over `R`, the mapping of `z` under the `aequiv` function (which transforms between the adjoined roots of `S` and `T`) results in the same value as directly mapping `z` under the roots adjoined with `T`. This theorem is important as it ensures the consistency of the `aequiv` function with the `map` function of the adjoined roots when dealing with polynomials over the same ring.

For commutative rings R, S, T, and an algebra A over R in S and T, if the roots of a polynomial f over R are the same when adjoined to S and T, then the mapping of any z over R under the aequiv function for the adjoined roots is equal to directly mapping z under the roots adjoined with T.


theorem Cardinal.lift_sum :
    ∀ {ι : Type u} (f : ι → Cardinal.{v}),
      Cardinal.lift.{w, max v u} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w, v} (f i) :=
  by sorry

The theorem `Cardinal.lift_sum` states that for any type ι and a function `f` from ι to the set of cardinal numbers, lifting the cardinality of the indexed sum (the disjoint union of the sets indexed by ι) to a larger universe is the same as taking the indexed sum of the cardinals of the sets after individually lifting them to the larger universe. In more mathematical terms, for any ι and a function `f : ι → Cardinal`, we have `Cardinal.lift (Cardinal.sum f) = Cardinal.sum (λ i => Cardinal.lift (f i))`. This theorem essentially shows that lifting to a larger universe commutes with taking an indexed sum in the context of cardinal numbers.

The theorem asserts that lifting the cardinality of the indexed sum of a function from a type to cardinal numbers, to a larger universe, is equivalent to summing the individually lifted cardinals.


theorem AddMonoidHom.range_top_iff_surjective :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_7} [inst_1 : AddGroup N] {f : G →+ N},
      AddMonoidHom.range f = ⊤ ↔ Function.Surjective ⇑f :=
  by sorry

This theorem states that for any given additive group `G`, another additive group `N`, and an additive monoid homomorphism `f` from `G` to `N`, the range of `f` is the entire group `N` (denoted as `⊤`) if and only if `f` is a surjective function. In other words, `f` maps every element of `G` onto every element of `N` if and only if every element of `N` is the image of some element of `G` under the function `f`.

For an additive group homomorphism from an additive group to an additive group, the image of the homomorphism is the entire group if and only if the homomorphism is surjective.


theorem AlgebraicGeometry.PresheafedSpace.id_c_app :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (X : AlgebraicGeometry.PresheafedSpace C)
      (U : (TopologicalSpace.Opens ↑↑X)ᵒᵖ),
      (CategoryTheory.CategoryStruct.id X).c.app U = X.presheaf.map (CategoryTheory.CategoryStruct.id U) :=
  by sorry

This theorem states that for any category `C` and any pre-sheafed space `X` over `C`, and for any open set `U` in the topological space underlying `X`, the morphism corresponding to the identity on `X` (when applied to `U`) is equal to the map induced by the presheaf on `X` when applied to the identity on `U`. In other words, the identity morphism on the pre-sheafed space behaves as expected when acting on elements of the category.

For any pre-sheafed space X over a category C and open set U in X, the identity morphism on X induced by the identity on U is equal to the morphism induced by the presheaf on X when applied to the identity on U.


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

The theorem `fderiv_add_const` states that for any non-trivially normed field `𝕜`, any normed additive commutative groups `E` and `F` which are also normed spaces over `𝕜`, any function `f` from `E` to `F`, any element `x` of `E`, and any constant `c` of `F`, the Fréchet derivative at `x` of the function `y` mapping to `f(y) + c` is equal to the Fréchet derivative at `x` of the function `f`. In simpler terms, adding a constant to a function does not change its derivative.

The Fréchet derivative of the constant function `c => f(x) + c` is equal to the Fréchet derivative of `f` at `x`, for any normed field `𝕜`, normed additive commutative groups `E` and `F` over `𝕜`, function `f` from `E` to `F`, and element `x` of `E`.


theorem Complex.normSq_pos : ∀ {z : ℂ}, 0 < Complex.normSq z ↔ z ≠ 0 := by sorry

The theorem `Complex.normSq_pos` states that for any complex number `z`, the norm squared function `Complex.normSq z` is positive if and only if `z` is not equal to zero. This theorem encapsulates the result that a complex number's square of the norm (or magnitude) is strictly greater than zero if the complex number itself is not zero.

For any complex number z, the square of its norm is positive if and only if z is non-zero.


theorem MeasureTheory.Measure.MutuallySingular.measurableSet_nullSet :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
      (h : MeasureTheory.Measure.MutuallySingular μ ν),
      MeasurableSet (MeasureTheory.Measure.MutuallySingular.nullSet h) :=
  by sorry

The theorem `MeasureTheory.Measure.MutuallySingular.measurableSet_nullSet` asserts that for any two measures `μ` and `ν` over a measurable space `α`, if `μ` and `ν` are mutually singular, then the null set associated with this mutual singularity is a measurable set. In other words, there exists a set that can be measured such that it is null under the measure `μ`, and its complement is null under the measure `ν`.

If measures `μ` and `ν` over measurable space `α` are mutually singular, then their associated null sets are measurable.


theorem Set.pairwise_insert_of_symmetric_of_not_mem :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
      Symmetric r → a ∉ s → (Set.Pairwise (insert a s) r ↔ Set.Pairwise s r ∧ ∀ b ∈ s, r a b) :=
  by sorry

The theorem `Set.pairwise_insert_of_symmetric_of_not_mem` states that for any type `α`, any binary relation `r` on `α`, any set `s` of type `α`, and any element `a` of type `α`, if the relation `r` is symmetric and the element `a` is not in the set `s`, then the property of the relation `r` holding pairwise on the set resulting from the insertion of `a` into `s` is equivalent to the conjunction of the property of the relation `r` holding pairwise on the original set `s` and the property that for all elements `b` in the set `s`, the relation `r` holds between `a` and `b`. In other words, the relation `r` holds pairwise on the set with an extra element `a` (who wasn't originally in the set) if and only if the relation held pairwise on the original set and it also holds between `a` and all elements of the original set, given `r` is symmetric.

For any type `α`, binary relation `r` on `α`, set `s` of `α`, and element `a` not in `s`, if `r` is symmetric then `r` holds pairwise between all elements in `s ∪ {a}` if and only if `r` holds pairwise in `s` and `r(a, b)` holds for all `b` in `s`.


theorem Valuation.map_add_eq_of_lt_left :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
      {x y : R}, v y < v x → v (x + y) = v x :=
  by sorry

This theorem states that for any ring `R` and any linearly ordered commutative group with zero `Γ₀`, given a valuation `v` from `R` to `Γ₀` and any two elements `x` and `y` from `R`, if the valuation of `y` is less than the valuation of `x`, then the valuation of the sum of `x` and `y` is equal to the valuation of `x`. In mathematical terms, if `v : R → Γ₀` is a valuation and `v(y) < v(x)`, then `v(x + y) = v(x)`.

For any valuation `v` from a ring `R` to a linearly ordered commutative group with zero `Γ₀`, if `x`, `y` are in `R` with `v(y) < v(x)`, then `v(x + y) = v(x)`.


theorem Monoid.Coprod.swap_surjective :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
      Function.Surjective ⇑(Monoid.Coprod.swap M N) :=
  by sorry

The theorem `Monoid.Coprod.swap_surjective` states that for any types `M` and `N` that have multiplication and unity (i.e., they are instances of the `MulOneClass`), the function `Monoid.Coprod.swap M N`, which swaps the elements of the pairs `(M,N)` to `(N,M)`, is surjective. In other words, for every pair `(n, m)` in `N x M`, there exists a pair `(m, n)` in `M x N` such that applying `Monoid.Coprod.swap M N` to `(m, n)` results in the pair `(n, m)`.

For any types `M` and `N` with multiplication and unity, the function swapping elements of pairs in the product `M x N` is a surjection.


theorem Function.update_inf :
    ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → SemilatticeInf (π i)]
      (f : (i : ι) → π i) (i : ι) (a b : π i),
      Function.update f i (a ⊓ b) = Function.update f i a ⊓ Function.update f i b :=
  by sorry

This theorem asserts that for any type `ι`, any type function `π : ι → Type`, given that equality is decidable for `ι` and each `π i` forms a semilattice with respect to an infimum operation, and for any function `f : (i : ι) → π i`, and any element `i : ι`, and any two elements `a, b : π i`, updating `f` at `i` with the infimum of `a` and `b` is the same as taking the infimum of `f` updated at `i` with `a` and `f` updated at `i` with `b`. In other words, the function update operation respects the infimum operation.

For any type `ι`, type function `π : ι → Type` with decidable equality and each `π i` a semilattice with respect to an infimum operation, the infimum of `f i` updated with `a` and `b` equals the infimum of `f` updated at `i` with `a` and `b`, for any function `f : ι → π i` and elements `a, b : π i`.


theorem GaloisInsertion.isAtom_of_u_bot :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderBot α]
      [inst_3 : OrderBot β] {l : α → β} {u : β → α},
      GaloisInsertion l u → u ⊥ = ⊥ → ∀ {b : β}, IsAtom (u b) → IsAtom b :=
  by sorry

The theorem `GaloisInsertion.isAtom_of_u_bot` states that for any two types `α` and `β`, each equipped with a partial order and a least element (`OrderBot`), and two functions `l : α → β` and `u : β → α` forming a Galois insertion (i.e., `l` is left adjoint to `u`), if the image of the least element of `β` under `u` is also the least element of `α`, then any element `b` of `β` such that `u b` is an atom of `α` (i.e., `u b` is an element with no other element between it and the least element of `α`, and `u b` is not the least element of `α`), is also an atom of `β`. In other words, if an element becomes an atom when mapped from `β` to `α` by `u`, it was already an atom in `β`.

If `l : α -> β` and `u : β -> α` form a Galois insertion with `OrderBot` elements `b0 : β` and `a0 : α` such that `u (b0) = a0`, then any atom `a` of `α` with `u a = b` is an atom of `β`.


theorem Antitone.map_max :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {a b : α},
      Antitone f → f (max a b) = min (f a) (f b) :=
  by sorry

The theorem `Antitone.map_max` states that for any types `α` and `β` with a linear order, and any function `f` from `α` to `β` which is antitone (meaning that if `a ≤ b` then `f b ≤ f a`), when this function `f` is applied to the maximum of two elements `a` and `b` from `α`, it gives the minimum of the function `f` applied to `a` and `b`. In other words, if `f` is an antitone function, then `f` of max(`a`,`b`) is equal to min(`f(a)`,`f(b)`).

For any antitone function $f$ between linearly ordered types $\alpha$ and $\beta$, we have $f(\max(a, b)) = \min(f(a), f(b))$.


ContDiffAt.continuousAt

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

The theorem `ContDiffAt.continuousAt` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and function `f` mapping from `E` to `F`, if the function `f` is continuously differentiable at a point `x` of order `n`, then `f` is also continuous at the point `x`. In other words, continuous differentiability at a point implies continuity at that point.

If a function `f` is continuously differentiable of order `n` at a point `x`, then it is continuous at `x` in the non-trivially normed fields `𝕜`, for normed additive commutative groups `E` and `F`.


theorem Set.Ioo_infinite :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : DenselyOrdered α] {a b : α}, a < b → Set.Infinite (Set.Ioo a b) := by
  sorry

This theorem states that for any type `α` that has a preorder and is densely ordered, and for any two elements `a` and `b` of this type such that `a` is less than `b`, the left-open right-open interval between `a` and `b` (denoted as `(a,b)`) is infinite. In other words, there are infinitely many elements in the type `α` that are strictly greater than `a` and strictly less than `b`.

For any densely ordered type `α` with a preorder, the interval `(a, b)` between any `a < b` in `α` is infinite.


theorem Set.preimage_neg_Ioo :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a b : α), -Set.Ioo a b = Set.Ioo (-b) (-a) := by sorry

The theorem `Set.preimage_neg_Ioo` states that for any ordered additive commutative group `α`, and any two elements `a` and `b` of `α`, the negation of the interval `(a, b)` (that is, all elements `x` in the group such that `a < x < b`) is equal to the interval `(-b, -a)`. In other words, if you take all the elements between `a` and `b` and negate them, you get all the elements between `-b` and `-a`.

For any ordered additive commutative group `α` and elements `a` and `b` in `α`, the negation of the interval `(a, b)` equals the interval `(-b, -a)`.