theorem Composition.sizeUpTo_succ :
    ∀ {n : ℕ} (c : Composition n) {i : ℕ} (h : i < Composition.length c),
      Composition.sizeUpTo c (i + 1) = Composition.sizeUpTo c i + List.get c.blocks { val := i, isLt := h } :=
  by sorry

The theorem `Composition.sizeUpTo_succ` states that for any natural number `n` and any composition `c` of `n`, and for any natural number `i` which is less than the length of the composition `c`, the sum of the sizes of the blocks in the composition up to `i + 1` is equal to the sum of the sizes of the blocks up to `i` plus the size of the block at position `i`. In other words, if you add another block to the sum, the total sum increases by the size of the new block.

For any natural number `n` and composition `c` of `n`, and any `i` less than `c.size`, the sum of the sizes of the first `i+1` blocks in `c` equals the sum of the sizes of the first `i` blocks plus the size of the `i+1`th block.


theorem ClusterPt.of_le_nhds :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {f : Filter X},
      f ≤ nhds x → ∀ [inst_1 : Filter.NeBot f], ClusterPt x f :=
  by sorry

The theorem `ClusterPt.of_le_nhds` states that for any type `X` endowed with a topological space structure, any point `x` of type `X`, and any filter `f` on `X`, if `f` is less than or equal to the neighborhood filter at `x` and `f` is not the bottom filter, then `x` is a cluster point of `f`. In other words, if a filter `f` is contained within the neighborhood of a point `x` and `f` is not the trivial (empty) filter, then `x` is an accumulation point of `f`. Here, the neighborhood filter is the filter consisting of all neighborhoods of `x`, and a point is called a cluster point of a filter if the intersection of the neighborhood filter of the point and the filter is not the bottom filter.

If a filter on a topological space is contained in the neighborhood filter of a point and is not the bottom filter, then that point is a cluster point of the filter.


theorem AlgebraicGeometry.universallyClosed_eq :
    @AlgebraicGeometry.UniversallyClosed =
      CategoryTheory.MorphismProperty.universally (AlgebraicGeometry.MorphismProperty.topologically @IsClosedMap) :=
  by sorry

The theorem `AlgebraicGeometry.universallyClosed_eq` states that a morphism in algebraic geometry is universally closed if and only if it satisfies the property of being universally a topologically closed map. In other words, a morphism `f: X ⟶ Y` in the category of algebraic geometry schemes is universally closed if for every pullback of `f` over any map `f': X' ⟶ Y'`, the underlying topological map of the pullback is a closed map, meaning that the image of any closed set `U` in `X` under this map is a closed set in `Y`.

A morphism in algebraic geometry is universally closed if and only if the topological map induced by each pullback is closed.


theorem Finset.univ_sum_single :
    ∀ {I : Type u_1} [inst : DecidableEq I] {Z : I → Type u_2} [inst_1 : (i : I) → AddCommMonoid (Z i)]
      [inst_2 : Fintype I] (f : (i : I) → Z i), (Finset.sum Finset.univ fun i => Pi.single i (f i)) = f :=
  by sorry

The theorem `Finset.univ_sum_single` states that for any type `I` with decidable equality, a function `Z` mapping from `I` to another type, an additive commutative monoid structure on `Z i` for each `i` in `I`, a `Fintype` instance for `I`, and a function `f` mapping from `I` to `Z i`, the sum, over all elements in the universal finite set of `I`, of the function 'single' applied to `i` and `f(i)`, is equal to `f`. The function 'single' here is defined as the function which takes a value `x` at `i` and `0` elsewhere. In mathematical terms, this theorem is stating that the sum of a function over all elements in a finite set is equal to the function itself when the function is equal to a given constant at only one point in the set and zero elsewhere.

For any finite type `I` with decidable equality, a function `Z : I -> AddMonoid a`, a Fintype instance for `I`, and a function `f : I -> Z i`, the sum of the constant function `single i 0` over `I` is equal to `f` if `f` is constant on `I` with value `0` everywhere except for `i`.


TopologicalSpace.IsSeparable.image

theorem TopologicalSpace.IsSeparable.image :
    ∀ {α : Type u} [t : TopologicalSpace α] {β : Type u_2} [inst : TopologicalSpace β] {s : Set α},
      TopologicalSpace.IsSeparable s → ∀ {f : α → β}, Continuous f → TopologicalSpace.IsSeparable (f '' s) :=
  by sorry

The theorem `TopologicalSpace.IsSeparable.image` in Lean 4 states that, given a topological space `α`, another topological space `β`, a set `s` of elements of `α`, and a function `f` from `α` to `β` which is continuous, if the set `s` is separable in the topological space `α`, then the image of the set `s` under the function `f`, denoted by `f '' s`, is separable in the topological space `β`. Note that a set is called separable in a topological space if it is contained in the closure of a countable set.

If `α` is a topological space, `β` is another topological space, `s ⊆ α` is separable, and `f : α → β` is a continuous function, then the image `f '' s` of `s` under `f` is separable in `β`.


theorem AlgebraicClosure.spanEval_ne_top : ∀ (k : Type u) [inst : Field k], AlgebraicClosure.spanEval k ≠ ⊤ := by sorry

The theorem `AlgebraicClosure.spanEval_ne_top` states that for any type `k` which has a field structure, the span of the evaluation of `x_f` across monic irreducible polynomials `f`, where `x_f` is an indeterminate, is not equal to the whole ideal (denoted by `⊤`) of the multivariable polynomial over the algebraic closure of monic irreducible polynomials over `k`. In other words, the set of all values obtained by evaluating `x_f` across all monic irreducible polynomials `f` does not span the entire ideal in the multivariate polynomial ring.

For any field `k`, the span of evaluations of an indeterminate `x_f` over monic irreducible polynomials `f` does not equal the whole ideal in the multivariate polynomial ring over the algebraic closure of `k`.


theorem Mathlib.Topology.UniformSpace.Basic._auxLemma.24 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
      Filter.Tendsto f a (Filter.comap g c) = Filter.Tendsto (g ∘ f) a c :=
  by sorry

This theorem, `Mathlib.Topology.UniformSpace.Basic._auxLemma.24`, states that for all types `α`, `β`, `γ`, all functions `f` from `α` to `β` and `g` from `β` to `γ`, and all filters `a` on `α` and `c` on `γ`, the condition that `f` tends towards the preimage filter of `g` under `c` when filtered by `a` is equivalent to the condition that the composition of `g` and `f` tends towards `c` when filtered by `a`. In other words, we have commutativity of function composition and filter transformation in the context of the limit of a function.

For filters `a` on a type `α`, `c` on a type `γ`, functions `f: α → β`, and `g: β → γ`, the filters `f''^(-1)'[c]` and `(g ∘ f)''[a]` are equal if and only if `f` tends towards the preimage of `g` under `c` when filtered by `a`, and `g` tends towards `c` when filtered by `a`.


/-- A sequence of functions `Fₙ` converges uniformly on a set `s` to a limiting function `f` w.r.t.
filter `p` iff the function `(n, x) ↦ (f x, Fₙ x)` converges along `p ×ˢ 𝓟 s` to the uniformity.
In other words: one knows nothing about the behavior of `x` in this limit besides it being in `s`.
 -/
theorem tendstoUniformlyOn_iff_tendsto :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {p : Filter ι}
      {s : Set α},
      TendstoUniformlyOn F f p s ↔
        Filter.Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ Filter.principal s) (uniformity β) :=
  by sorry

This theorem states that a sequence of functions `Fₙ` converges uniformly on a set `s` to a limiting function `f` with respect to a filter `p` if and only if the function `(n, x) ↦ (f x, Fₙ x)` converges from the product of the filter `p` and the principal filter of `s` to the uniformity. In simpler terms, it's stating a condition under which we can say that a sequence of functions is converging uniformly on a particular set to a limit function. The condition is essentially that a certain map, which takes a pair consisting of an index and an element of the set, and produces a pair of the limit function evaluated at the element, and the indexed function evaluated at the element, is converging to the uniformity of the codomain.

A sequence of functions `Fₙ : X → Y` converges uniformly to `f : X → Y` with respect to filter `p` on `X` if and only if the function `(n, x) ↦ (f x, Fₙ x) : p × principalFilter X → Y × Y` converges to the uniformity on the product `p × principalFilter X`.


theorem Mathlib.Algebra.Order.Ring.Defs._auxLemma.26 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, (0 < -a) = (a < 0) :=
  by sorry

This theorem, referred to as `_auxLemma.26` under the `Mathlib.Algebra.Order.Ring.Defs` namespace, states that for any type `α` satisfying the properties of an additive group and an ordered set (with the order compatible with the group operation), the assertion that zero is less than the negation of an element `a` from this type is equivalent to the assertion that `a` is less than zero. In mathematical terms, this theorem says that for all `a` in a certain type of ordered group, `0 < -a` if and only if `a < 0`.

In an ordered additive group, the elements `0` and `-a` are order-equivalent if and only if `a` and `0` are.


theorem Mathlib.Algebra.Order.Ring.Defs._auxLemma.27 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, (0 ≤ -a) = (a ≤ 0) :=
  by sorry

This theorem, labelled as `Mathlib.Algebra.Order.Ring.Defs._auxLemma.27` in Lean 4, states that for any type `α` that has an addition group structure and an order relation, and the addition operation is covariant with respect to this order, then for any element 'a' of this type, the inequality '0 is less than or equal to negative a' is equivalent to the inequality 'a is less than or equal to 0'. In other words, an element is non-positive if and only if its negation is non-negative.

For any type endowed with an additive structure and a compatible order relation, the element 'a' is non-positive if and only if -'a' is non-negative.


theorem BoxIntegral.Box.nonempty_coe : ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), Set.Nonempty ↑I := by sorry

This theorem states that for any given box `I` of type `BoxIntegral.Box ι`, where `ι` is any type, the set corresponding to `I` (denoted by `↑I`) is not empty. In other words, the theorem asserts that there always exists some element in the set corresponding to the box `I`.

For any `BoxIntegral.Box ι I`, the set `↑I` is non-empty.


theorem Disjoint.sup_left :
    ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] {a b c : α},
      Disjoint a c → Disjoint b c → Disjoint (a ⊔ b) c :=
  by sorry

The theorem `Disjoint.sup_left` states that for all types `α` which are under a distributive lattice and have a least element (`OrderBot α`), and for any three elements `a`, `b` and `c` of `α`, if `a` and `c` are disjoint and `b` and `c` are disjoint, then the supremum of `a` and `b` (`a ⊔ b`) and `c` are also disjoint. In other words, in a distributive lattice, if two elements are both disjoint with a third one, then their supremum is also disjoint with the third one.

In a distributive lattice with a least element, if two elements are disjoint from a third element, then their supremum is also disjoint from that element.


theorem Cardinal.lt_univ' :
    ∀ {c : Cardinal.{max (u + 1) v}}, c < Cardinal.univ.{u, v} ↔ ∃ c', c = Cardinal.lift.{max (u + 1) v, u} c' := by
  sorry

The theorem `Cardinal.lt_univ'` states that for any cardinal number `c` in either the `u + 1` or `v` universe, `c` is less than the cardinality of the universe (`Cardinal.univ`) if and only if there exists another cardinal number `c'` such that `c` is the universe lift of `c'`. In other words, a cardinal number `c` is smaller than the cardinality of the universe if and only if `c` can be obtained by lifting a cardinal number from a smaller universe to the current universe. This theorem is a characterization of the order relationship between a cardinal number and the cardinality of the universe in terms of the universe lift operation on cardinals.

A cardinal number `c` is smaller than the cardinality of the universe if and only if it is the universe lift of some cardinal number in a smaller universe.


theorem Subsingleton.eq_zero : ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Subsingleton α] (a : α), a = 0 := by sorry

This theorem, `Subsingleton.eq_zero`, states that for any type `α` which has a zero element (as per the `Zero` typeclass) and is a subsingleton (meaning it has at most one distinct element, as per the `Subsingleton` typeclass), any element `a` of type `α` equals zero. Essentially, in a subsingleton type that has a zero element, all elements are equal to zero.

In a subsingleton type with a zero element, all elements equal zero.


theorem vadd_iterate :
    ∀ {G : Type u_3} {H : Type u_4} [inst : AddMonoid G] (a : G) (n : ℕ) [inst_1 : AddAction G H],
      (fun x => a +ᵥ x)^[n] = fun x => n • a +ᵥ x :=
  by sorry

This theorem states that for any type `G` with an `AddMonoid` structure (a set equipped with an associative addition operation and an additive identity element), a term `a` of type `G`, and a natural number `n`, along with any type `H` that has an `AddAction` of `G` on `H` (a representation of the concept of scalar multiplication), iterating the function `(fun x => a +ᵥ x)` `n` times is equivalent to the function that maps `x` to the scalar multiple `n • a +ᵥ x`. In simpler terms, it says that adding `a` to `x` `n` times is the same as multiplying `a` by `n` and then adding the result to `x`.

For any additive monoid `G`, any `a : G`, natural number `n`, and any type `H` with an additive action of `G` on `H`, the function `(fun x => a +ᵥ x)` applied `n` times is equivalent to the function that maps `x` to `n • a +ᵥ x`. In other words, `(a +ᵥ _) ^ n = (fun x => n • a +ᵥ x)`.


theorem lebesgue_number_lemma_of_metric :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {ι : Sort u_3} {c : ι → Set α},
      IsCompact s → (∀ (i : ι), IsOpen (c i)) → s ⊆ ⋃ i, c i → ∃ δ > 0, ∀ x ∈ s, ∃ i, Metric.ball x δ ⊆ c i :=
  by sorry

The Lebesgue number lemma for a metric space is stated as follows: for any metric space `α`, any compact set `s` within that space, and any indexed collection `{c i}` of open sets, if the set `s` is covered by the union of these open sets, then there exists a positive real number `δ` such that for every point `x` in the set `s`, there is an index `i` such that the open ball of radius `δ` centered at `x` is a subset of the open set `c i`. In other words, `δ` is a measure of the "size" of the open sets in the cover relative to the set `s` they are covering.

For any compact set in a metric space and any open cover, there exists a positive number δ such that for each point in the set, there is an open set in the cover containing a ball of radius δ around that point.


/-- See also `Fintype.card_zmultiples`. -/
theorem Nat.card_zmultiples :
    ∀ {α : Type u_3} [inst : AddGroup α] (a : α), Nat.card ↥(AddSubgroup.zmultiples a) = addOrderOf a := by sorry

The theorem `Nat.card_zmultiples` states that for any additively group-structured type `α` and any element `a` of `α`, the cardinality of the subgroup generated by `a` is equal to the additive order of `a`. In mathematical terms, this means that the number of distinct elements obtained by repeatedly adding `a` to itself (including the zero element) is equal to the least positive integer `n` such that adding `a` to itself `n` times yields the zero element. If no such `n` exists (i.e., `a` is of infinite order), both the cardinality of the subgroup and the additive order are defined to be zero.

The cardinality of the subgroup generated by an element `a` in an additively group-structured type `α` equals the additive order of `a`.


theorem Polynomial.monic_X_add_C :
    ∀ {R : Type u} [inst : Semiring R] (x : R), Polynomial.Monic (Polynomial.X + Polynomial.C x) := by sorry

This theorem states that for any type `R` which is a semiring, and any value `x` of type `R`, the polynomial `X + Cx` is monic. In other words, if we add a polynomial variable `X` and a constant polynomial `Cx` in a semiring `R`, the leading coefficient of the resulting polynomial is 1, which is the definition of a monic polynomial.

For any semiring `R` and `x` in `R`, the polynomial `X + Cx` is monic (has a leading coefficient of 1).


theorem ValuationSubring.valuation_le_one :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (a : ↥A), (ValuationSubring.valuation A) ↑a ≤ 1 := by sorry

This theorem states that for any field `K` and any valuation subring `A` of `K`, the valuation of any element `a` from the valuation subring `A`, under the natural valuation induced by `A` on `K`, is less than or equal to one. In mathematical terms, if `K` is a field and `A` is a valuation subring of `K`, then for all `a` in `A`, the valuation of `a` in `K` (denoted as `(ValuationSubring.valuation A) ↑a`) is less than or equal to 1.

For any field `K` and its valuation subring `A`, the valuation of every element `a` in `A` under the induced valuation on `K` is less than or equal to 1.


theorem ArithmeticFunction.isMultiplicative_zeta : ArithmeticFunction.IsMultiplicative ArithmeticFunction.zeta := by
  sorry

This theorem states that the ζ-arithmetic function, also known as the Riemann zeta function, is multiplicative. In mathematical terms, an arithmetic function `f` is defined to be multiplicative if `f(1) = 1` and for any two coprime natural numbers `m` and `n`, `f(m * n) = f(m) * f(n)`. Here, the Riemann zeta function is defined such that `ζ(0) = 0` and `ζ(x) = 1` for all other `x`. This theorem asserts that this ζ-function satisfies the properties of a multiplicative arithmetic function.

The Riemann zeta function, defined as 0 for 0 and 1 for all other natural numbers, and multiplicatively for coprime numbers, is a multiplicative arithmetic function.


theorem Int.sign_eq_neg_one_of_neg : ∀ {a : ℤ}, a < 0 → Int.sign a = -1 := by sorry

The theorem `Int.sign_eq_neg_one_of_neg` states that for any integer `a`, if `a` is less than zero, then the sign of `a` is `-1`. This is expressed in terms of the `Int.sign` function, which assigns an integer "sign" to any given integer: `1` for positive numbers, `0` for zero, and `-1` for negative numbers. Thus, this theorem formalizes the intuitive understanding that the sign of a negative number is `-1`.

For any integer `a`, if `a` is negative then `Int.sign a = -1`.


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

This theorem, `mul_kstar_le_self`, states that for any type `α` that is a Kleene algebra, and for any elements `a` and `b` of that type, if the multiplication of `b` and `a` is less than or equal to `b`, then the multiplication of `b` and the `kstar` of `a` (a method from the Kleene algebra involving `a`) is also less than or equal to `b`.

For any Kleene algebra type `α` and elements `a, b` of `α`, if `b` * `a` ≤ `b`, then `b` * (`kstar` `a`) ≤ `b`.


theorem zero_min : ∀ {α : Type u} [inst : CanonicallyLinearOrderedAddCommMonoid α] (a : α), min 0 a = 0 := by sorry

This theorem states that for all types `α` that form a "Canonically Linear Ordered Additive Commutative Monoid", the minimum of `0` and any element `a` of type `α` is always `0`. In mathematical terms, given any canonically linearly ordered additive commutative monoid (which is a structure that combines properties of an ordered set, a commutative group, and a monoid), this theorem asserts the property that zero is less than or equal to any element of the set, or equivalently, for any element `a`, `min(0, a) = 0`.

In any canonically linearly ordered additive commutative monoid, the minimum element is 0.


Filter.Tendsto.neBot

theorem Filter.Tendsto.neBot :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x : Filter α} {y : Filter β},
      Filter.Tendsto f x y → ∀ [hx : Filter.NeBot x], Filter.NeBot y :=
  by sorry

The theorem `Filter.Tendsto.neBot` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any filters `x` on `α` and `y` on `β`, if `f` tends to transform `x` into `y` (i.e., `Filter.Tendsto f x y`), and if `x` is a filter that is not the bottom filter (i.e., `Filter.NeBot x`), then `y` must also be a filter that is not the bottom filter (i.e., `Filter.NeBot y`). In mathematical terms, if a function has a limit within a non-empty neighborhood, the limit itself is also in a non-empty neighborhood.

If a function transforms a non-bottom filter into a limit, then the limit is a non-bottom filter.


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

This theorem states that for all real numbers `x` and `y`, if `x` is less than or equal to `y`, then the square root of `x` is less than or equal to the square root of `y`. In other words, the function that sends a real number to its square root is a non-decreasing function.

For all real numbers x and y, if x ≤ y then √x ≤ √y.


theorem Function.eq_update_iff :
    ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {a : α} {b : β a} {f g : (a : α) → β a},
      g = Function.update f a b ↔ g a = b ∧ ∀ (x : α), x ≠ a → g x = f x :=
  by sorry

The theorem `Function.eq_update_iff` states that for any types `α` and `β` where `β` is a type dependent on `α`, given a decidable equality on `α`, and any elements `a` of type `α` and `b` of type `β a`, and any two functions `f, g : (a : α) → β a`, the function `g` is equal to the function `f` updated at `a` with `b` if and only if the value of `g` at `a` is `b` and for all `x` in `α` such that `x` is not equal to `a`, the value of `g` at `x` is equal to the value of `f` at `x`. In other words, this theorem states the condition under which a function equals another function with one of its values updated.

For functions `f` and `g` over a type `α` where `β` is type dependent on `α`, `g` equals `f` updated at `a` with `b` if and only if `g a = b` and for all `x ≠ a`, `g x = f x`.


theorem Multiset.toList_eq_nil : ∀ {α : Type u_1} {s : Multiset α}, Multiset.toList s = [] ↔ s = 0 := by sorry

This theorem states that for any type `α` and any multiset `s` of type `α`, the list derived from `s` using `Multiset.toList` is empty if and only if `s` itself is the zero multiset. In other words, a multiset `s` is considered empty (equivalent to the zero multiset) if the list obtained from `s` is an empty list.

For any type `α`, the multiset `s` of type `α` is the zero multiset if and only if `Multiset.toList s` is an empty list.


theorem le_of_strongLT :
    ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → Preorder (π i)] {a b : (i : ι) → π i}, StrongLT a b → a ≤ b :=
  by sorry

This theorem, `le_of_strongLT`, states that for any type `ι` and for any type mapping `π : ι → Type`, given a preorder relation (a binary relation that is reflexive and transitive) on each `π i`, for any two functions `a` and `b` of type `(i : ι) → π i`, if `a` is strongly less than `b` (meaning the value of `a i` is strictly less than `b i` for every `i`), then `a` is also less than or equal to `b`.

If `π : ι → Type` is a type mapping and `≤_π : ∀ i, π i → π i → Prop` is a preorder on each `π i`, and `a, b : ι → π i` are functions such that `a i < b i` for all `i`, then `a i ≤ b i` for all `i`.


theorem even_op_iff : ∀ {α : Type u_2} [inst : Add α] {a : α}, Even (AddOpposite.op a) ↔ Even a := by sorry

This theorem, `even_op_iff`, states that for any type `α` which supports addition (denoted by `[inst : Add α]`), and any element `a` of that type, `a` is even if and only if its additive opposite (given by `AddOpposite.op a`) is even. In other words, an element and its additive opposite have the same "evenness". Here, "evenness" is defined in terms of additive doubling: an element `a` is even if there exists some `r` such that `a = r + r`.

For any type `α` with additation and for all `a` in `α`, `a` is even if and only if its additive inverse is even, where evenness is defined as having a representation as a sum of two equals.


theorem Set.Ico_union_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a ≤ b → Set.Ico a b ∪ {b} = Set.Icc a b := by sorry

The theorem `Set.Ico_union_right` states that for any type `α` that has a partial order, and any two elements `a` and `b` of that type where `a` is less than or equal to `b`, the union of the left-closed right-open interval from `a` to `b` and the set containing `b` alone is equal to the left-closed right-closed interval from `a` to `b`. In other words, if we have an interval from `a` to `b` that includes `a` but not `b`, and we add `b` to this set, we get the interval from `a` to `b` that includes both `a` and `b`. In mathematical terms, given $a \leq b$, then $[a, b) \cup \{b\} = [a, b]$ where $[a, b)$ and $[a, b]$ denote left-closed right-open and left-closed right-closed intervals respectively.

For any type `α` with a partial order, and `a ≤ b`, the union of the left-closed right-open interval `[a, b)` and the singleton set `{b}` equals the left-closed right-closed interval `[a, b]`. In mathematical notation: `[a, b) ∪ {b} = [a, b]`.


theorem Mathlib.Topology.Order.Lattice._auxLemma.1 :
    ∀ {α : Type u_2} {β : Type u_3} {C : β → Type u_7} [inst : (b : β) → SemilatticeSup (C b)] {s : Finset α}
      (H : s.Nonempty) (f : α → (b : β) → C b) (b : β), (Finset.sup' s H fun a => f a b) = Finset.sup' s H f b :=
  by sorry

This theorem states that for any types `α`, `β`, and a type family `C : β → Type`, where each `C b` forms a join-semilattice, along with a nonempty finite set `s` of type `α`, a function `f : α → (b : β) → C b`, and any `b : β`, the supremum of the images of elements in `s` under the function `(λa, f a b)` is equal to the supremum of the images of elements in `s` under the function `f` evaluated at `b`. In other words, the order of applying the function `f` and taking the supremum does not matter.

For any type families `C : β → Type` forming join-semilattices, type `α`, finite nonempty set `s : α`, function `f : α → β → C β`, and `b : β`, the image of the supremum of `s` under `λa, f a b` is equal to the supremum of the images of elements in `s` under `f` at `b`.


theorem Mathlib.Topology.Order.Lattice._auxLemma.2 :
    ∀ {α : Type u_2} {β : Type u_3} {C : β → Type u_7} [inst : (b : β) → SemilatticeSup (C b)]
      [inst_1 : (b : β) → OrderBot (C b)] (s : Finset α) (f : α → (b : β) → C b) (b : β),
      (Finset.sup s fun a => f a b) = Finset.sup s f b :=
  by sorry

This theorem states that for any types `α`, `β` and function `C : β → Type`, given a semilattice structure and an order bot structure on `C b` for each `b : β`, a finite set `s : Finset α`, a function `f : α → (b : β) → C b`, and an element `b : β`, the supremum of the set of values `f a b` (where `a` is an element of `s`) is equal to the supremum of the set of values `f b` (where `f` is applied to each element of `s`).

In simpler terms, it says that the order of applying the function `f` and taking the supremum does not matter: we can either first apply `f` to each element of the set and then take the supremum, or take the supremum first and then apply `f`. This can be thought of as a kind of "commutativity property" of the supremum computation with respect to function application.

For any semilattice `C` with order bot structures on `C b` for each `b`, given a finite set `s`, function `f : α → β → C`, and `b : β`, the supremum of `{f a b | a ∈ s}` is equal to the supremum of `{f b | b ∈ set.image b s}` (where `set.image b s` is the image of `s` under the function `b`).


theorem Fin.val_rev : ∀ {n : ℕ} (i : Fin n), ↑(Fin.rev i) = n - (↑i + 1) := by sorry

This theorem, `Fin.val_rev`, states that for any natural number `n` and any element `i` of the type `Fin n`, the numerical value of the reversed version of `i` (obtained through the function `Fin.rev`) is equal to `n` minus the numerical value of `i` minus one. In other words, the function `Fin.rev` flips the order of the set `{0, 1, ..., n-1}` by mapping each number `i` to `n - i - 1`.

For any natural number `n` and element `i` of finite type `Fin n`, the value of `i` in the reversed finite sequence `Fin.rev` equals `n - i - 1`.


theorem Quaternion.coe_mul_eq_smul : ∀ {R : Type u_3} [inst : CommRing R] (r : R) (a : Quaternion R), ↑r * a = r • a :=
  by sorry

This theorem states that for any type `R` that forms a commutative ring (denoted by `CommRing R`), and for any real number `r` within that type `R` and any quaternion `a` over type `R` (i.e., `a` is a quaternion whose components are elements of `R`), the operation of multiplying the real number `r` (coerced to a quaternion using the `↑r` notation) with the quaternion `a` (expressed as `↑r * a`) is equivalent to the operation of scaling the quaternion `a` by the real number `r` (expressed as `r • a`). In other words, for any commutative ring `R`, the multiplication of a real number and a quaternion is the same as the scalar multiplication of that real number and the quaternion.

For any commutative ring `R`, the multiplication of a real number `r` in `R` with a quaternion `a` over `R` is equivalent to scaling the quaternion `a` by the real number `r`.


theorem inv_atTop₀ :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : OrderTopology 𝕜],
      Filter.atTop⁻¹ = nhdsWithin 0 (Set.Ioi 0) :=
  by sorry

This theorem states that for any type `𝕜` that is a linearly ordered field with a topological space structure and an order topology, the inverse of the filter `atTop` (representing the limit towards positive infinity) is equal to the neighborhood within the set `(0, ∞)` at `0`. This effectively means that taking the inverse of elements going to positive infinity gives us the neighborhood of `0` excluding `0` itself and including all positive numbers.

For a linearly ordered field `𝕜` with a topology and order topology, the filter of elements going to positive infinity `atTop` equals the neighborhood filter of `0` excluding `0` in `(0, ∞)`, and their inverses are equal.


theorem Polynomial.Separable.of_mul_left :
    ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R},
      Polynomial.Separable (f * g) → Polynomial.Separable f :=
  by sorry

This theorem states that for any commutative semiring `R` and for any two polynomials `f` and `g` with coefficients in `R`, if the product of `f` and `g` is a separable polynomial, then `f` itself is also a separable polynomial.

In mathematical terms, a separable polynomial is one that is coprime with its derivative. That is, a polynomial is separable if there is no non-unit common divisor for the polynomial and its derivative.

If `R` is a commutative semiring and `f` and `g` are polynomials over `R` with separable product `fg`, then each of the polynomials `f` and `g` is separable.


theorem MeasureTheory.isProbabilityMeasure_map :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      [inst_1 : MeasureTheory.IsProbabilityMeasure μ] {f : α → β},
      AEMeasurable f μ → MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.map f μ) :=
  by sorry

The theorem `MeasureTheory.isProbabilityMeasure_map` states that for any types `α` and `β`, given a measurable space on `α`, a measurable space on `β`, a probability measure `μ` on the measurable space of `α`, and a function `f` from `α` to `β` that is almost everywhere measurable, the pushforward measure of `μ` under the function `f` is also a probability measure. This essentially means that if a function is almost everywhere measurable, then transforming a probability measure via this function will still result in a probability measure.

Given measurable spaces (α, Σα) and (β, Σβ), a probability measure μ on (α, Σα), a measurable function f : α → β, and ν = μ ∘ f, then ν is a probability measure.


theorem Dioph.lt_dioph : ∀ {α : Type} {f g : (α → ℕ) → ℕ}, Dioph.DiophFn f → Dioph.DiophFn g → Dioph {v | f v < g v} :=
  by sorry

The theorem `Dioph.lt_dioph` states that for any type `α` and any two functions `f` and `g` from `α → ℕ` to `ℕ`, if `f` and `g` are both Diophantine functions (meaning their graphs are Diophantine sets), then the set of functions `v` such that `f v` is less than `g v` is also a Diophantine set. In other words, the set of all functions where the value of `f` at a given function is less than the value of `g` at the same function is Diophantine if `f` and `g` themselves are Diophantine. This is a property about the preservation of Diophantineness under the operation of "less than".

If `f` and `g` are Diophantine functions from type `α` to `ℕ`, then the set {`v` | `f v` < `g v`} is a Diophantine set.


theorem Int.card_Icc : ∀ (a b : ℤ), (Finset.Icc a b).card = Int.toNat (b + 1 - a) := by sorry

The theorem `Int.card_Icc` states that for any two integers `a` and `b`, the cardinality (or the number of elements) of the finite set that includes all integers `x` such that `a ≤ x` and `x ≤ b` (represented by `Finset.Icc a b`), is equal to the natural number equivalent of the integer result of the operation `(b + 1 - a)`. If `b + 1 - a` is negative, the cardinality will be treated as zero, as negative integers are converted to zero when they are turned into a natural number using the `Int.toNat` function.

The cardinality of the finite set of integers between `a` and `b` (inclusive) is equal to `(b - a + 1)`. If `b < a`, the cardinality is considered zero.


IsIntegralClosure.isNoetherian

theorem IsIntegralClosure.isNoetherian :
    ∀ (A : Type u_2) (K : Type u_3) [inst : CommRing A] [inst_1 : Field K] [inst_2 : IsDomain A] [inst_3 : Algebra A K]
      [inst_4 : IsFractionRing A K] (L : Type u_4) [inst_5 : Field L] (C : Type u_5) [inst_6 : CommRing C]
      [inst_7 : Algebra K L] [inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : Algebra C L]
      [inst_11 : IsIntegralClosure C A L] [inst_12 : Algebra A C] [inst_13 : IsScalarTower A C L]
      [inst_14 : FiniteDimensional K L] [inst_15 : IsSeparable K L] [inst_16 : IsIntegrallyClosed A]
      [inst_17 : IsNoetherianRing A], IsNoetherian A C :=
  by sorry

The theorem `IsIntegralClosure.isNoetherian` states that for any commutative ring `A`, which is also a Noetherian ring and an integrally closed domain, if `K` is the field of fractions of `A`, and `L` is a field such that `A`, `K` and `L` form a scalar tower, and `C` is the integral closure of `A` in `L`, then `A` and `C` form a Noetherian ring. This theorem also assumes `K` and `L` form a finite dimensional, separable extension. Essentially, this theorem is about the preservation of the Noetherian property under integral closure in a separable, finite dimensional extension.

If `A` is a Noetherian, integrally closed domain in a commutative ring, then its integral closure in a finite dimensional, separable extension field forms a Noetherian ring with `A`.


theorem Submodule.comap_mono :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {F : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂] {f : F}
      {q q' : Submodule R₂ M₂}, q ≤ q' → Submodule.comap f q ≤ Submodule.comap f q' :=
  by sorry

The theorem `Submodule.comap_mono` states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `σ₁₂` from `R` to `R₂`, a function `f` of type `F` that acts like a function from `M` to `M₂`, and a semilinear map from `M` to `M₂` over `R` and `R₂` via `σ₁₂` and `f`, if a submodule `q` of the module `M₂` over `R₂` is a subset of another submodule `q'`, then the preimage of `q` under `f` is a subset of the preimage of `q'` under `f`. Here, the preimage of a submodule under a function is the set of all elements in the domain that map to elements in the submodule. This theorem demonstrates the "monotonicity" of the `comap` (preimage) operation.

If `f` is a semilinear map from an additive commutative `R`-module `M` to an additive commutative `R₂`-module `M₂`, `σ₁₂` is a ring homomorphism from `R` to `R₂`, `q` is a submodule of `M₂`, and `q'` is a submodule of `M₂` containing `q`, then `f⁻¹(q)` is a submodule of `M` and is contained in `f⁻¹(q')`.


theorem FirstOrder.Language.card_eq_card_functions_add_card_relations :
    ∀ {L : FirstOrder.Language},
      FirstOrder.Language.card L =
        (Cardinal.sum fun l => Cardinal.lift.{v, u} (Cardinal.mk (L.Functions l))) +
          Cardinal.sum fun l => Cardinal.lift.{u, v} (Cardinal.mk (L.Relations l)) :=
  by sorry

This theorem states that for any first-order language `L`, the cardinality of `L` is equal to the sum of the cardinalities of the functions and relations in `L`. Specifically, the cardinality of `L` is the sum of the cardinality of the set of functions in `L` (each lifted to a higher universe level), and the cardinality of the set of relations in `L` (each also lifted to a higher universe level). The cardinalities of the sets of functions and relations are calculated as the indexed sum of their respective cardinalities, which is the cardinality of their indexed disjoint union, represented by the sigma type.

The cardinality of a first-order language is the sum of the cardinalities of all functions and relations in it, each lifted to higher universe levels and represented as the indexed sum of their disjoint unions.


/-- Transfer `IsBigOWith` over a `PartialHomeomorph`.  -/
theorem PartialHomeomorph.isBigOWith_congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {E : Type u_3}
      [inst_2 : Norm E] {F : Type u_4} [inst_3 : Norm F] (e : PartialHomeomorph α β) {b : β},
      b ∈ e.target →
        ∀ {f : β → E} {g : β → F} {C : ℝ},
          Asymptotics.IsBigOWith C (nhds b) f g ↔
            Asymptotics.IsBigOWith C (nhds (↑(PartialHomeomorph.symm e) b)) (f ∘ ↑e) (g ∘ ↑e) :=
  by sorry

This theorem states that the big-O notation for functions `f` and `g` with respect to a constant `C` and a neighborhood filter at a point `b` in the target of a partial homeomorphism `e` is preserved under the inverse of this homeomorphism. In other words, if `f` is big-O of `g` at `b`, then the composition of `f` and `g` with the inverse of the homeomorphism also maintains this relationship at the point that maps to `b` under the inverse homeomorphism, assuming that the norms on the codomains of `f` and `g` and the topologies on their domains are given. The big-O notation `IsBigOWith C (nhds b) f g` means that the norm of `f` divided by the norm of `g` is eventually (at points close to `b`) bounded by `C`.

If `f` is big-O of `g` at `b` under a partial homeomorphism `e`, then `e.symm ∘ f` is big-O of `g ∘ e.symm` at `e.target b`.


theorem Complex.mem_slitPlane_iff : ∀ {z : ℂ}, z ∈ Complex.slitPlane ↔ 0 < z.re ∨ z.im ≠ 0 := by sorry

This theorem states that a complex number `z` belongs to the slit plane if and only if its real part is positive or its imaginary part is not equal to zero. In other words, the slit plane consists of all complex numbers whose real component is greater than zero or whose imaginary component is different from zero.

A complex number `z` lies in the slit complex plane if and only if its real part is positive or its imaginary part is non-zero.


theorem Set.restrict_dite :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} [inst : (x : α) → Decidable (x ∈ s)] (f : (a : α) → a ∈ s → β)
      (g : (a : α) → a ∉ s → β), (Set.restrict s fun a => if h : a ∈ s then f a h else g a h) = fun a => f ↑a ⋯ :=
  by sorry

This theorem, `Set.restrict_dite`, states that for any types `α` and `β`, any set `s` of type `α`, and any two functions `f` and `g` of type `(a: α) → a ∈ s → β` and `(a: α) → a ∉ s → β` respectively, the restriction of the function `(a: α) => if h: a ∈ s then f a h else g a h` to the set `s` is equal to the function `(a: α) => f ↑a ` followed by ellipsis (⋯). Here, the function `f` is defined for elements in the set `s`, and the function `g` is defined for elements not in the set `s`. The theorem essentially explains how to restrict a piecewise-defined function to a set in terms of its defining functions.

For any sets `α` and `β`, and functions `f` and `g` defined on `α`, the restriction of the piecewise function `a mapsto if a ∈ s then f a else g a` to the set `s` is equal to the function `a mapsto f (interior_of s a)`.


theorem mul_inv_le_of_le_mul :
    ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] {a b c : α}, a ≤ b * c → a * c⁻¹ ≤ b := by sorry

This theorem states that for any linearly ordered commutative group with zero, specifically for any elements `a`, `b`, and `c` in this group, if `a` is less than or equal to the product of `b` and `c`, then the product of `a` and the inverse of `c` is less than or equal to `b`. This kind of result would often be used in algebraic manipulations in the field of order theory or group theory.

If `a` is less than or equal to the product of `b` and `c` in a linearly ordered commutative group with zero, then `a * b^-1` is less than or equal to `c`.


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

The theorem `Function.mulSupport_one` states that for any type `α` and any type `M` that has an instance of the `One` typeclass (i.e., has a defined "one" or identity element), the multiplicative support of the constant function that maps every element of `α` to `1` in `M` is the empty set. This is because the multiplicative support of a function consists of all values `x` for which the function applied to `x` is not equal to `1`, but in this case, the function is defined to always return `1` for all inputs. Therefore, there are no values in `α` for which the function does not return `1`, and the multiplicative support is empty.

The constant function mapping every element of a type `α` to `1` in a commutative monoid `M` with a defined one element has an empty multiplicative support.


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

The theorem `Irrational.of_mul_rat` states that for every rational number `q` and for every real number `x`, if the product of `x` and `q` is an irrational number, then `x` itself is an irrational number. In other words, if multiplying `x` by the rational number `q` produces an irrational number, then `x` must have been irrational to begin with.

If the product of a rational number and a real number is an irrational number, then the real number is irrational.


theorem frontier_Iic :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMaxOrder α] {a : α}, frontier (Set.Iic a) = {a} :=
  by sorry

The theorem `frontier_Iic` states that for any type `α` that is a topological space, has a linear order, is densely ordered, and has no maximum element, the frontier (the set of points between the closure and interior) of the set of all elements less than or equal to a given element `a` is simply the set containing the element `a`. In other words, for any such `α` and `a`, the only point that lies between the closure and interior of the set of all elements less than or equal to `a` is `a` itself. This is in the context of topology, where the frontier of a set is defined as the points which are neither in the interior nor the exterior of the set.

For any topological space with a dense linear order and no maximum element, the frontier of the set of elements less than or equal to an element is equal to that element itself.


theorem Nat.isLeast_nth :
    ∀ {p : ℕ → Prop} {n : ℕ},
      (∀ (hf : Set.Finite (setOf p)), n < (Set.Finite.toFinset hf).card) →
        IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n) :=
  by sorry

The theorem `Nat.isLeast_nth` states that for any predicate `p` on natural numbers and for any natural number `n`, given that for every finite set built from `p`, the cardinality of the finite set is greater than `n`, then `Nat.nth p n` is a least element of the set `{i | p i ∧ ∀ k < n, Nat.nth p k < i}`. In other words, `Nat.nth p n` belongs to the set `{i | p i ∧ ∀ k < n, Nat.nth p k < i}` and it is smaller than or equal to all other elements in the set. Here, `Nat.nth p n` refers to the `n`-th natural number that satisfies predicate `p` (or `0` if no such number exists), and `{i | p i ∧ ∀ k < n, Nat.nth p k < i}` is the set of natural numbers which satisfy `p` and are greater than every natural number from the first to the `(n-1)`-th one that satisfies `p`.

If for all finite sets built from a predicate `p` on natural numbers, the cardinality of the set of natural numbers satisfying `p` and strictly less than `n` is greater than `n`, then `Nat.nth p n` is the smallest natural number in the set `{i | p i ∧ ∀ k < n, Nat.i < i}`.


theorem Mathlib.Algebra.Module.Submodule.Basic._auxLemma.12 :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] {module_M : Module R M} (p : Submodule R M)
      {x : M}, (x ∈ Submodule.toAddSubgroup p) = (x ∈ p) :=
  by sorry

This theorem states that for any type `R` of ring, any type `M` of additive commutative group and any `p` which is a submodule of type `M` over the ring `R`, an element `x` of type `M` belongs to the additive subgroup corresponding to the submodule `p` if and only if `x` belongs to the submodule `p`. In other words, it guarantees that the set of elements contained in a submodule, when viewed as an additive subgroup, remains unchanged.

For any ring R, additive commutative group M, and submodule p of M, the submodule p and the additive subgroup generated by p are equal.


Finset.measurableSet

theorem Finset.measurableSet :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (s : Finset α),
      MeasurableSet ↑s :=
  by sorry

The theorem `Finset.measurableSet` states that for any given finite set `s` of elements of type `α`, if `α` forms a measurable space and a measurable singleton class, then the set `s` is a measurable set. Here, "measurable" means that it can be meaningfully assigned a measure in the ambient measure space defined over `α`.

If `α` is a measurable space and a measurable singleton class, then any finite set `s` of elements of type `α` is a measurable set.


theorem Ordinal.type_ne_zero_iff_nonempty :
    ∀ {α : Type u} {r : α → α → Prop} [inst : IsWellOrder α r], Ordinal.type r ≠ 0 ↔ Nonempty α := by sorry

The theorem `Ordinal.type_ne_zero_iff_nonempty` states that for any type `α` and any relation `r` on `α`, if `α` is a well-ordered set under the relation `r` (as expressed by the instance `IsWellOrder α r`), then the order type of the well order (i.e., `Ordinal.type r`) is not equal to zero if and only if `α` is a nonempty set. In other words, a well-ordered set has a non-zero order type if and only if the set itself is not empty.

A well-ordered set is non-empty if and only if its order type is non-zero.


IsUpperSet.image

theorem IsUpperSet.image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
      IsUpperSet s → ∀ (f : α ≃o β), IsUpperSet (⇑f '' s) :=
  by sorry

The theorem `IsUpperSet.image` states that for any two types `α` and `β` which are both pre-ordered sets, and a set `s` in `α` which is an upper set, if there is an order-preserving bijection `f` from `α` to `β`, then the image of `s` under `f` is also an upper set in `β`. In other words, the image of an upper set under an order-preserving bijection remains an upper set.

If `α` and `β` are pre-ordered sets, `s` is an upper set in `α`, and `f` is an order-preserving bijection from `α` to `β`, then the image `f''(s)` is an upper set in `β`.


FirstOrder.Language.Theory.Model.mono

theorem FirstOrder.Language.Theory.Model.mono :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      {T T' : FirstOrder.Language.Theory L}, M ⊨ T' → T ⊆ T' → M ⊨ T :=
  by sorry

This theorem states that for any given first-order language `L`, and a set `M` with the structure of `L`, if `M` is a model of a theory `T'` (i.e., `M` satisfies all sentences in `T'`), and if all sentences of a theory `T` are included in `T'` (i.e., `T` is a subset of `T'`), then `M` is also a model of `T`. In essence, it guarantees that if a structure satisfies a larger theory, it also satisfies any smaller theory contained within the larger one.

If `M` is a model of a theory `T'` and `T` is a subset of `T'`, then `M` is a model of `T`.


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

This theorem states that for any type `α` with a preorder, and for any three elements `a`, `b₁`, and `b₂` of type `α`, if `b₁` is less than `b₂`, then the left-closed right-closed interval from `a` to `b₁` is a subset of the left-closed right-open interval from `a` to `b₂`. In terms of intervals, if one interval ends at `b₁` and another ends beyond `b₁` (i.e., at `b₂`), the entire first interval is contained within the second.

For any preorder type `α` and elements `a`, `b₁`, `b₂` with `b₁` less than `b₂`, the left-closed right-closed interval from `a` to `b₁` is a subset of the left-closed right-open interval from `a` to `b₂`.


theorem Finset.mem_sigmaLift :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
      (f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : Sigma α) (b : Sigma β) (x : Sigma γ),
      x ∈ Finset.sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd) :=
  by sorry

The theorem `Finset.mem_sigmaLift` asserts that for any types `ι`, `α i`, `β i` and `γ i` where `i` ranges over `ι` and there is a decidable equality on `ι`, and for any function `f` that maps pairs of elements from `α i` and `β i` to a finite set of `γ i`, an element `x` from `Sigma γ` (a dependent pair type where the first component is from `ι` and the second component is from `γ i`) belongs to the finite set produced by `Finset.sigmaLift f` applied to a pair of elements from `Sigma α` and `Sigma β`, if and only if there exist proofs `ha` and `hb` that the first component of `a` and `b` respectively (which are both from `ι`) equal the first component of `x`, and the second component of `x` belongs to the finite set produced by the function `f` applied to the second components of `a` and `b` (which are from `α i` and `β i` respectively) under the equality assumptions `ha` and `hb`.

For any decidably equipped types `ι`, `α i`, `β i`, and `γ i`, and decidable equality `=_`, if `f : Π i, α i × β i → Finset γ i`, then `x ∈ Finset.sigmaLift f (a, b)` if and only if there exist `ha : a = a'_i`, `hb : b = b'_i`, and `y ∈ f (a'_i, b'_i)` such that `x = (i, y)`.


theorem Asymptotics.IsEquivalent.isBigO_symm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l u v → v =O[l] u :=
  by sorry

The theorem `Asymptotics.IsEquivalent.isBigO_symm` states that for any types `α` and `β`, with `β` being a normed addition commutative group, and for any functions `u` and `v` from `α` to `β` and a filter `l` on `α`, if `u` and `v` are asymptotically equivalent along `l`, then `v` is a big O of `u` along `l`. In mathematical terms, if `u(x) - v(x) = o(v(x))` as `x` approaches `l`, then `v(x) = O(u(x))` as `x` approaches `l`.

If functions `u` and `v` from type `α` to a normed additive commutative group `β` are asymptotically equivalent along filter `l` on `α`, then `v` is a big O of `u` along `l`.


theorem mem_circle_iff_abs : ∀ {z : ℂ}, z ∈ circle ↔ Complex.abs z = 1 := by sorry

The theorem `mem_circle_iff_abs` states that for every complex number `z`, `z` is a member of the unit circle in the complex plane if and only if the absolute value (or modulus) of `z` is equal to 1. This is essentially a formal statement in Lean 4 that reflects the geometric interpretation that points on the unit circle in the complex plane are precisely those complex numbers with an absolute value (or modulus) of 1.

A complex number `z` lies on the unit circle if and only if the absolute value of `z` equals 1.


theorem Iio_mem_nhdsSet_Ico :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderClosedTopology α] {a b c : α},
      b ≤ c → Set.Iio c ∈ nhdsSet (Set.Ico a b) :=
  by sorry

This theorem states that for any given type `α` which has a linear order, a topological space structure, and an order closed topology, and for any three elements `a`, `b`, and `c` of this type where `b` is less than or equal to `c`, the left-infinite right-open interval ending at `c` is an element of the filter of neighborhoods of the left-closed right-open interval from `a` to `b`. In other words, the set of all elements less than `c` is a neighborhood of the interval `[a, b)` in the given topological space.

For any type `α` with a linear order, topology, and order-closed topology, if `a < b <= c` are elements of `α`, then the set of elements strictly less than `c` is a neighborhood of the interval `[a, b)` in the given topology.


theorem ShrinkingLemma.PartialRefinement.mem_find_carrier_iff :
    ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {u : ι → Set X} {s : Set X}
      {c : Set (ShrinkingLemma.PartialRefinement u s)} {i : ι} (ne : Set.Nonempty c),
      i ∈ (ShrinkingLemma.PartialRefinement.find c ne i).carrier ↔
        i ∈ ShrinkingLemma.PartialRefinement.chainSupCarrier c :=
  by sorry

This theorem, `ShrinkingLemma.PartialRefinement.mem_find_carrier_iff`, states that for a given nonempty set of partial refinements `c` of some topology `X` indexed by type `ι`, and a given `ι` index `i`, the index `i` is in the carrier of the partial refinement selected by the `find` function if and only if `i` is in the carrier of the least upper bound of the chain of these partial refinements. In simpler terms, it says that the `find` function will locate a partial refinement in the chain that contains the index `i`, if and only if `i` is included in the union of all the carriers in the chain.

For a nonempty chain of partial refinements of a topology, an index is in the carrier of the partial refinement selected by `find` if and only if it is in the carrier of their least upper bound.


theorem lt_sSup_iff :
    ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, b < sSup s ↔ ∃ a ∈ s, b < a := by sorry

The theorem `lt_sSup_iff` states that for any type `α` with a `CompleteLinearOrder` instance, any set `s` of type `α`, and any element `b` of type `α`, `b` is less than the supremum (`sSup`) of `s` if and only if there exists an element `a` in `s` such that `b` is less than `a`. This is a property of upper bounds in order theory, expressing that being less than the least upper bound of a set implies being less than some element of the set.

For any type `α` with a complete linear order and any set `s` and element `b` in `α`, `b` is strictly less than the supremum of `s` if and only if there exists an element `a` in `s` such that `b` is strictly less than `a`.


theorem Continuous.uniformContinuous_of_tendsto_cocompact :
    ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} {x : β},
      Continuous f → Filter.Tendsto f (Filter.cocompact α) (nhds x) → UniformContinuous f :=
  by sorry

The theorem `Continuous.uniformContinuous_of_tendsto_cocompact` states that for any two types `α` and `β` with uniform spaces, and for any function `f` from `α` to `β` and any point `x` in `β`, if the function `f` is continuous and it converges to `x` with respect to the filter generated by the complements of compact sets in `α` (i.e., `f` tends to `x` when all points in `α` are getting closer to the edges of compact sets), then the function `f` is uniformly continuous. Uniform continuity means that the rate of change of `f` is bounded across its entire domain, or equivalently, that `f` preserves closeness: points that are close together in `α` get mapped to points that are close together in `β`.

If a continuous function from a uniform space to another uniform space tends to a point with respect to the filter generated by the complements of compact sets, then it is uniformly continuous.


theorem CategoryTheory.Limits.kernelSubobjectMap_arrow :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [inst_2 : CategoryTheory.Limits.HasKernel f]
      {X' Y' : C} {f' : X' ⟶ Y'} [inst_3 : CategoryTheory.Limits.HasKernel f']
      (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelSubobjectMap sq)
          (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.kernelSubobject f')) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.kernelSubobject f))
          sq.left :=
  by sorry

This theorem is about the composition of morphisms in the context of category theory. Specifically, for any category `C`, objects `X`, `Y`, `X'`, and `Y'` in `C`, and morphisms `f : X ⟶ Y`, `f' : X' ⟶ Y'`, where `f` and `f'` have kernels, then for any morphism `sq` from the arrow object made from `f` to the arrow object made from `f'`, the composition of the kernel subobject map of `sq` and the arrow from the kernel subobject of `f'` is equal to the composition of the arrow from the kernel subobject of `f` and the left part of `sq`. In mathematical terms, this theorem states that `(kernelSubobjectMap sq) ∘ (arrow (kernelSubobject f')) = (arrow (kernelSubobject f)) ∘ sq.left`, where `∘` denotes the composition of morphisms.

Given any categories `C`, objects `X`, `Y`, `X'`, `Y'`, morphisms `f : X ⟶ Y`, `f' : X' ⟶ Y'` with kernels, and arrow object morphism `sq : (f ⟶ f')`, the composition of the kernel subobject maps factors through `sq` as `(kernelSubobjectMap sq) ∘ (arrow (kernelSubobject f')) = (arrow (kernelSubobject f)) ∘ sq.left`.


theorem Matrix.cramer_apply :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α)
      (b : n → α) (i : n), (Matrix.cramer A) b i = Matrix.det (Matrix.updateColumn A i b) :=
  by sorry

This theorem states that for any square matrix `A` of type `Matrix n n α` with entries in a commutative ring `α`, and any vector `b` of type `n → α`, the `i`-th component of the vector obtained by applying Cramer's rule to `A` and `b`, `(Matrix.cramer A) b i`, is equal to the determinant of the matrix obtained by replacing the `i`-th column of `A` with `b`, `Matrix.det (Matrix.updateColumn A i b)`. This is a formal statement of a standard result in linear algebra regarding the computation of solutions to a system of linear equations using Cramer's rule.

For any square matrix `A` and vector `b`, the `i`-th component of the vector obtained by applying Cramer's rule to `A` and `b` equals the determinant of the matrix obtained by replacing the `i`-th column of `A` with `b`.


theorem Associated.mul_mul :
    ∀ {α : Type u_1} [inst : CommMonoid α] {a₁ a₂ b₁ b₂ : α},
      Associated a₁ b₁ → Associated a₂ b₂ → Associated (a₁ * a₂) (b₁ * b₂) :=
  by sorry

This theorem states that in a commutative monoid, if two elements `a₁` and `b₁` are associated, and another two elements `a₂` and `b₂` are also associated, then the products `a₁ * a₂` and `b₁ * b₂` are associated as well.

In general, two elements in a monoid are said to be associated if one can be obtained from the other by multiplying by a unit on the right. In this context, "associated" does not mean just "related" in some way, but has a specific mathematical meaning.

In a commutative monoid, if elements `a₁` and `b₁`, and `a₂` and `b₂` are right-associated with some units `r₁` and `r₂` respectively, then `a₁ * a₂` and `b₁ * b₂` are associated, that is, there exists a unit `r` such that `a₁ * a₂ = b₁ * b₂ * r`.


theorem WfDvdMonoid.exists_factors :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : WfDvdMonoid α] (a : α),
      a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ Associated (Multiset.prod f) a :=
  by sorry

The theorem `WfDvdMonoid.exists_factors` states that in any well-founded commutative monoid with zero, given a nonzero element `a`, there exist a multiset `f` of irreducible elements such that every element in `f` is irreducible and the product of all elements in `f` is associated with `a`. In other words, every nonzero element `a` in such a monoid can be expressed as a product of irreducible elements, up to an association. This is akin to the idea of prime factorization in the integers, where every integer can be expressed as a product of prime numbers (which are irreducible).

In a commutative well-founded monoid with zero, every nonzero element can be expressed as the product of irreducible elements, up to association.


theorem Filter.comap_lift'_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {h : Set α → Set β} {m : γ → β},
      Filter.comap m (Filter.lift' f h) = Filter.lift' f (Set.preimage m ∘ h) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, any filter `f` on `α`, any function `h` from a set of `α` to a set of `β`, and any function `m` from `γ` to `β`, the filter obtained by first applying the lift' operation to `f` with `h` and then taking the `comap` with `m` is the same as the filter obtained by first applying `Set.preimage` with `m` to `h` and then applying the lift' operation to `f`. In other words, `Filter.comap m (Filter.lift' f h)` is equal to `Filter.lift' f (Set.preimage m ∘ h)`. This equivalence establishes a key relationship between the operations of lifting a filter and pre-imaging a set under a function.

For any filters `f` on type `α`, functions `h: α → β` and `m: γ → β`, the filters `Filter.comap m (Filter.lift' f h)` and `Filter.lift' f (Set.preimage m ∘ h)` are equal.


theorem FreeAbelianGroup.map_id : ∀ {α : Type u}, FreeAbelianGroup.map id = AddMonoidHom.id (FreeAbelianGroup α) := by
  sorry

The theorem `FreeAbelianGroup.map_id` asserts that for any type `α`, applying the identity function as the map in `FreeAbelianGroup.map` results in the same homomorphism as `AddMonoidHom.id` (the identity map) on the type `FreeAbelianGroup α`. In other words, the homomorphism induced by the identity function in the context of free abelian groups is, indeed, the identity homomorphism.

The identity function induces the identity homomorphism in the context of FreeAbelianGroups.


theorem Asymptotics.SuperpolynomialDecay.param_mul :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {k f : α → β} [inst : TopologicalSpace β] [inst_1 : CommSemiring β],
      Asymptotics.SuperpolynomialDecay l k f → Asymptotics.SuperpolynomialDecay l k (k * f) :=
  by sorry

The theorem `Asymptotics.SuperpolynomialDecay.param_mul` states that for any types `α` and `β` where `β` is a commutative semiring with a topology, any filter `l` on `α`, and any functions `k` and `f` from `α` to `β`, if the function `f` has superpolynomial decay in terms of parameter `k` along filter `l`, then the function `k * f` also has superpolynomial decay in the same terms. In the context of asymptotics, superpolynomial decay means that the magnitude of `f` decreases faster than any polynomial rate of `k`.  So here, even after multiplying `f` by `k`, it still satisfies the property of superpolynomial decay.

If a function `f` from `α` to a commutative semiring `β` with a topology has superpolynomial decay in terms of parameter `k` along filter `l`, then the function `k * f` also has superpolynomial decay in the same terms.


/-- The conditional cdf tends to 0 at -∞ for all `a : α`.  -/
theorem ProbabilityTheory.tendsto_condCDF_atBot :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α),
      Filter.Tendsto (↑(ProbabilityTheory.condCDF ρ a)) Filter.atBot (nhds 0) :=
  by sorry

The theorem `ProbabilityTheory.tendto_condCDF_atBot` states that for every datum `a` of any type `α`, within a `MeasurableSpace α`, and for a given measure `ρ` on the product space of `α` and `ℝ` (the real numbers), the conditional cumulative distribution function (CDF) of `ρ` with respect to `a` tends to 0 as it approaches negative infinity. In more mathematical terms, this theorem asserts that $\lim_{x\to -\infty} \text{condCDF } \rho a = 0$ for all `a : α`.

For every measurable space `(α, Σ)` and measure `ρ` on its product with `ℝ`, the conditional cumulative distribution function of `ρ` with respect to any datum `a : α` tends to 0 as `x` approaches negative infinity. In symbols: $\lim\_{x \to -\infty} \text{condCDF}\_\rho(a)(x) = 0$.


theorem ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ} (hf : ProbabilityTheory.IsMeasurableRatCDF f) (x : ℝ),
      Measurable fun a => ↑(ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction hf a) x :=
  by sorry

The theorem `ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction` states that for any measurable space `α`, and any rational function `f : α → ℚ → ℝ` that satisfies the `IsMeasurableRatCDF` property, for any real number `x`, the function that maps each `α` to the `x`-th value of the Stieltjes function associated with `f` (obtained through `ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction`) is measurable. This means the preimage of every measurable set under this function is a measurable set. The `IsMeasurableRatCDF` property ensures that `f` is a measurable function from the rational numbers to the real numbers.

For any measurable space `α` and measurable function `f : α → ℚ → ℝ` satisfying the `IsMeasurableRatCDF` property, the function that maps each `x ∈ ℝ` to the `x`-th value of the Stieltjes function associated with `f` is measurable.


theorem Matrix.conjTranspose_one :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Semiring α] [inst_2 : StarRing α],
      Matrix.conjTranspose 1 = 1 :=
  by sorry

This theorem states that for any type `n` and any type `α` which has decidable equality, is a semiring and a star-ring, the conjugate transpose of the identity matrix is equal to the identity matrix. This can be interpreted in mathematical terms as, given a complex matrix `A`, if `A` is an identity matrix, then the conjugate transpose of `A` (also known as Hermitian transpose or adjoint), denoted as `A*`, is also an identity matrix. This property holds for all square matrices of any size `n`.

For any square matrix `A` of type `n` over a type `α` with decidable equality, is a semiring and a star-ring, the conjugate transpose `A*` equals the identity matrix `Id`.


/-- The main feature of the Besicovitch Vitali family is that its filter at a point `x` corresponds
to convergence along closed balls. We record one of the two implications here, which will enable us
to deduce specific statements on differentiation of measures in this context from the general
versions.  -/
theorem Besicovitch.tendsto_filterAt :
    ∀ {α : Type u_1} [inst : MetricSpace α] [inst_1 : SecondCountableTopology α] [inst_2 : MeasurableSpace α]
      [inst_3 : OpensMeasurableSpace α] [inst_4 : HasBesicovitchCovering α] (μ : MeasureTheory.Measure α)
      [inst_5 : MeasureTheory.SigmaFinite μ] (x : α),
      Filter.Tendsto (fun r => Metric.closedBall x r) (nhdsWithin 0 (Set.Ioi 0))
        (VitaliFamily.filterAt (Besicovitch.vitaliFamily μ) x) :=
  by sorry

This theorem, named `Besicovitch.tendsto_filterAt`, states that for any point `x` in a metric space `α`, which also has a second countable topology, a measurable space, an open measurable space and a Besicovitch covering, along with a sigma finite measure `μ`, the filter of the function mapping each real number `r` to the closed ball of radius `r` around `x` within the range of real numbers greater than zero tends to the filter at `x` of the Vitali family associated with the measure `μ`. Essentially, this means that as the radii of the closed balls decrease and approach zero, the corresponding elements in the Vitali family also approach to `x`. This theorem is part of the underlying theory supporting the differentiation of measures in metric spaces.

For any point `x` in a second countable metric space with a measurable structure, a sigma-finite measure `μ`, and a Besicovitch covering, the filter of closed balls around `x` with decreasing radii converges to the filter at `x` of the Vitali family associated with `μ`.


theorem Filter.tendsto_prod_iff' :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {g' : Filter γ} {s : α → β × γ},
      Filter.Tendsto s f (g ×ˢ g') ↔ Filter.Tendsto (fun n => (s n).1) f g ∧ Filter.Tendsto (fun n => (s n).2) f g' :=
  by sorry

The theorem `Filter.tendsto_prod_iff'` states that for all filters `f` over a type `α`, `g` over a type `β`, and `g'` over a type `γ`, and for all functions `s` from `α` to the cartesian product of `β` and `γ`, the function `s` tends to the product filter `g ×ˢ g'` if and only if the first component of `s` tends to `g` and the second component of `s` tends to `g'`. In other words, this theorem characterizes the limit of a function towards a product of filters in terms of the limits of the individual components of the function.

For any filters $f$ over type $\alpha$, $g$ over type $\beta$, and $g'$ over type $\gamma$, and any function $s$ from $\alpha$ to the cartesian product $β × γ$, $s$ tends to the product filter $g ×ˢ g'$ if and only if the first component of $s$ tends to $g$ and the second component of $s$ tends to $g'$.


theorem Set.eqOn_union :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f₁ f₂ : α → β},
      Set.EqOn f₁ f₂ (s₁ ∪ s₂) ↔ Set.EqOn f₁ f₂ s₁ ∧ Set.EqOn f₁ f₂ s₂ :=
  by sorry

The theorem `Set.eqOn_union` states that for any two types `α` and `β`, any two sets `s₁` and `s₂` of type `α`, and any two functions `f₁` and `f₂` from `α` to `β`, the functions `f₁` and `f₂` are equal on the union of `s₁` and `s₂` if and only if `f₁` and `f₂` are equal on `s₁` and `f₁` and `f₂` are equal on `s₂`. In other words, two functions are equal over the union of two sets if they are equal over each of the sets individually.

For sets `s₁` and `s₂` of type `α` and functions `f₁` and `f₂` from `α` to `β`, `f₁ = f₂` on `s₁ ∪ s₂` if and only if `f₁ = f₂` on `s₁` and `f₁ = f₂` on `s₂`.


theorem MvPFunctor.wDest'_wMk :
    ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} (a : P.A)
      (f' : TypeVec.Arrow ((MvPFunctor.drop P).B a) α) (f : (MvPFunctor.last P).B a → MvPFunctor.W P α),
      MvPFunctor.wDest' P (MvPFunctor.wMk P a f' f) = { fst := a, snd := TypeVec.splitFun f' f } :=
  by sorry

The theorem `MvPFunctor.wDest'_wMk` states that for any natural number `n`, any multivariable polynomial functor `P` of arity `n + 1`, any type vector `α` of length `n`, any value `a` in the set of objects of `P`, any arrow `f'` from the type vector obtained by dropping the last type from the B operation of `P` on `a` to `α`, and any function `f` from the last type in the B operation of `P` on `a` to the W-type of `P` on `α`, applying the destructor `MvPFunctor.wDest'` to the W-type constructed by `MvPFunctor.wMk` with `P`, `a`, `f'`, and `f` results in a pair whose first element is `a` and second element is the function obtained by appending `f'` and `f` using `TypeVec.splitFun`. In other words, it validates the consistency of the constructed W-type with its inputs and demonstrates that the destructor essentially reverses the construction operation.

For any multivariable polynomial functor `P` of arity `n+1`, the destructor `MvPFunctor.wDest'` applied to the W-type constructed by `MvPFunctor.wMk` from `P`, an object `a` in `P`, the B operation projections `f'` and `f`, returns a pair `(a, g)` where `g` is the composite function of `f'` and `f`.


/-- The other direction does not hold because of the `s`-`s` cross terms on the RHS.  -/
theorem Finset.image₂_distrib_subset_left :
    ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ' : Type u_6} {δ : Type u_7} {ε : Type u_9}
      [inst : DecidableEq β'] [inst_1 : DecidableEq γ'] [inst_2 : DecidableEq δ] [inst_3 : DecidableEq ε] {s : Finset α}
      {t : Finset β} {γ : Type u_14} {u : Finset γ} {f : α → δ → ε} {g : β → γ → δ} {f₁ : α → β → β'} {f₂ : α → γ → γ'}
      {g' : β' → γ' → ε},
      (∀ (a : α) (b : β) (c : γ), f a (g b c) = g' (f₁ a b) (f₂ a c)) →
        Finset.image₂ f s (Finset.image₂ g t u) ⊆ Finset.image₂ g' (Finset.image₂ f₁ s t) (Finset.image₂ f₂ s u) :=
  by sorry

This theorem states that for any types `α`, `β`, `β'`, `γ'`, `δ`, `ε`, and `γ`, and given finsets `s`, `t`, and `u` of these types, along with functions `f : α → δ → ε`, `g : β → γ → δ`, `f₁ : α → β → β'`, `f₂ : α → γ → γ'`, and `g' : β' → γ' → ε`, if for all elements `a` of `α`, `b` of `β`, and `c` of `γ`, `f a (g b c)` equals to `g' (f₁ a b) (f₂ a c)`, then the image of the binary function `f` over the set `s` and the image of the binary function `g` over the sets `t` and `u` is a subset of the image of the binary function `g'` over the image of the binary function `f₁` over the sets `s` and `t` and the image of the binary function `f₂` over the sets `s` and `u`. The theorem is establishing a specific kind of relationship between these binary functions and the subsets of their ranges.

If for all `a` in `α`, `b` in `β`, and `c` in `γ`, `f a (g b c) = g' (f₁ a b) (f₂ a c)` implies the image of `f` over sets `s` and `t` and image of `g` over sets `u`, `t`, and `v` is a subset of the image of `g'` over the images of `f₁` and `f₂` on sets `s`, `t`, and `s`, `u`, respectively.


ringChar.dvd

theorem ringChar.dvd : ∀ {R : Type u_1} [inst : NonAssocSemiring R] {x : ℕ}, ↑x = 0 → ringChar R ∣ x := by sorry

The theorem `ringChar.dvd` states that for any type `R` which is a `NonAssocSemiring` and any natural number `x`, if the natural number `x` cast to `R` is zero, then the characteristic of the semiring `R`, denoted as `ringChar R`, divides `x`. In other words, if `x` becomes zero when considered as an element of `R`, then `x` is a multiple of the unique characteristic of the semiring `R`.

If a natural number `x` maps to zero in a non-associative semiring `R`, then the characteristic of `R` divides `x`.


theorem WittVector.v2_coeff :
    ∀ {p' : ℕ} {R' : Type u_2} (x y : WittVector p' R') (i : Fin 2), (![x, y] i).coeff = ![x.coeff, y.coeff] i := by
  sorry

This theorem states that for any natural number `p'` and any type `R'`, and for any two Witt vectors `x` and `y` over these, the `.coeff` method applied to the `i`'th element (where `i` is a value in the finite set of size 2) of the vector containing `x` and `y` equals the `i`'th element of the vector formed by the `.coeff` methods of `x` and `y`. In other words, the theorem asserts that taking the `i`'th element and then the coefficient is the same as first taking the coefficient and then the `i`'th element.

For any natural number `p` and type `R`, and for any Witt vectors `x` and `y` over `R` of length 2, the `i`-th coefficient of the vector containing `x.coeff i` and `y.coeff i` is equal to `x.coeff i.coeff p` and `y.coeff i.coeff p`.


theorem AffineSubspace.map_span :
    ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂) (s : Set P₁),
      AffineSubspace.map f (affineSpan k s) = affineSpan k (⇑f '' s) :=
  by sorry

The theorem `AffineSubspace.map_span` states that for any ring `k`, additive commutative groups `V₁` and `V₂`, torsors `P₁` and `P₂` under these groups respectively, and an affine map `f` from `P₁` to `P₂`, the affine image of the affine span of a set `s` in `P₁` under the map `f` is the same as the affine span of the image of `s` under `f`. In other words, mapping the smallest affine subspace containing `s` (the affine span of `s`) under `f` results in the smallest affine subspace containing the image of `s`.

For any ring `k`, additive commutative groups `V₁` and `V₂`, torsors `P₁` and `P₂` under `V₁` and `V₂` respectively, and an affine map `f : P₁ → P₂`, the affine image of the affine span of a set `s` in `P₁` under `f` equals the affine span of the image of `s` in `P₂`.


theorem UniqueMul.of_mulOpposite :
    ∀ {G : Type u_1} [inst : Mul G] {A B : Finset G} {a0 b0 : G},
      UniqueMul (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } B)
          (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } A) (MulOpposite.op b0) (MulOpposite.op a0) →
        UniqueMul A B a0 b0 :=
  by sorry

The theorem `UniqueMul.of_mulOpposite` states the following:

For any type `G` equipped with a multiplication operation, two finite subsets `A` and `B` of `G`, and two elements `a0` and `b0` of `G`, if the product `MulOpposite.op b0 * MulOpposite.op a0` can be written in at most one way as a product of an element from the image set of `B` under the operation `MulOpposite.op` and an element from the image set of `A` under the same operation, then the product `a0 * b0` can be written in at most one way as a product of an element from `A` and an element from `B`. In other words, uniqueness of multiplication in the opposite multiplicative structure implies uniqueness of multiplication in the original structure.

If the product of the opposites of two elements has at most one representation as a product of elements from two sets under multiplication, then the product of the original elements has at most one representation as a product of an element from each set.


/-- In a topological space with second countable topology, if `f` is a function that sends each
point `x` to a neighborhood of `x`, then for some countable set `s`, the neighborhoods `f x`,
`x ∈ s`, cover the whole space.  -/
theorem TopologicalSpace.countable_cover_nhds :
    ∀ {α : Type u} [t : TopologicalSpace α] [inst : SecondCountableTopology α] {f : α → Set α},
      (∀ (x : α), f x ∈ nhds x) → ∃ s, Set.Countable s ∧ ⋃ x ∈ s, f x = Set.univ :=
  by sorry

This theorem states that in a topological space with a second-countable topology, given a function `f` that maps each point `x` to a neighborhood of `x`, there exists a countable set `s` such that the union of the neighborhoods `f x` for each `x` in `s` covers the entire space. This means that every point in the space is in the neighborhood `f x` for some `x` in `s`.

In a second-countable topological space, given a function mapping each point to a neighborhood of it, there exists a countable set of points whose neighborhoods cover the entire space.


theorem le_mul_iff_one_le_left :
    ∀ {α : Type u_1} {a b : α} [inst : MulOneClass α] [inst_1 : Zero α] [inst_2 : Preorder α] [inst_3 : MulPosMono α]
      [inst_4 : MulPosReflectLE α], 0 < a → (a ≤ b * a ↔ 1 ≤ b) :=
  by sorry

The theorem `le_mul_iff_one_le_left` states that for any type `α` equipped with multiplication, zero, and a preorder, and where multiplication is both monotonically increasing when multiplying by nonnegative elements on the right (`MulPosMono`) and has reverse monotonicity when multiplying by positive elements on the right (`MulPosReflectLE`), if `a` is a positive element, then `a` is less than or equal to `b * a` if and only if `1` is less than or equal to `b`.

For any type equipped with multiplication, zero, and a preorder such that multiplication by nonnegative elements on the right is monotonically increasing and has reverse monotonicity with positive elements, if `a` is positive, then `a ≤ b * a` if and only if `1 ≤ b`.


theorem Set.preimage_smul_inv :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] (a : α) (t : Set β),
      (fun x => a⁻¹ • x) ⁻¹' t = a • t :=
  by sorry

This theorem, `Set.preimage_smul_inv`, states that for any types `α` and `β` where `α` is a group and `β` has a multiplication action by `α`, and for any element `a` of `α` and a set `t` of `β`, the preimage of the set `t` under the function `(fun x => a⁻¹ • x)` (which maps each element `x` of `β` to the product of the inverse of `a` and `x`) is equal to the set obtained by scaling all elements of `t` by `a`. In terms of group actions, this theorem describes how the preimage under the action of an inverse element corresponds to the original set scaled by the element itself.

For any group `α` acting on a set `β` and any `a in α` and set `t in β`, the preimage of `t` under the function `x => a⁻¹ • x` is equal to the set obtained by scaling `t` by `a`.


ringExpChar.eq

theorem ringExpChar.eq : ∀ (R : Type u) [inst : Semiring R] (q : ℕ) [h : ExpChar R q], ringExpChar R = q := by sorry

This theorem states that for any type `R` that has a `Semiring` structure, and for any natural number `q` that has an `ExpChar` (exponential characteristic) structure with `R`, the function `ringExpChar` applied to `R` is equal to `q`. In other words, the unique exponential characteristic of a semiring `R`, as produced by the function `ringExpChar`, is exactly `q`.

For any semiring `R` and its associated natural number `q` with an `ExpChar` structure, `ringExpChar R = q`.


theorem Polynomial.leadingCoeff_X_add_C :
    ∀ {S : Type v} [inst : Semiring S] (r : S), Polynomial.leadingCoeff (Polynomial.X + Polynomial.C r) = 1 := by sorry

The theorem `Polynomial.leadingCoeff_X_add_C` states that for any type `S` that forms a semiring and for any element `r` belonging to `S`, the leading coefficient of the polynomial which is the sum of the polynomial variable `X` and the constant polynomial `r` is always 1. This means that the highest degree term in the polynomial `X + r` (where `r` is a constant) always has the coefficient 1.

The leading coefficient of the polynomial `X + r` in a semiring is always 1, where `X` is a polynomial variable and `r` is a constant.


theorem LaurentPolynomial.T_add :
    ∀ {R : Type u_1} [inst : Semiring R] (m n : ℤ),
      LaurentPolynomial.T (m + n) = LaurentPolynomial.T m * LaurentPolynomial.T n :=
  by sorry

This theorem states that for any semiring `R` and any two integers `m` and `n`, the function `LaurentPolynomial.T`, which maps an integer to a Laurent polynomial (a kind of polynomial that allows for negative exponents), satisfies the property that `T(m + n)` equals `T(m) * T(n)`. In other words, the function `LaurentPolynomial.T` is multiplicative with respect to integer addition, similar to properties of exponents in regular mathematics where `a^(m+n) = a^m * a^n`.

For any semiring `R` and integers `m` and `n`, the function `LaurentPolynomial.T` satisfies `T(m + n) = T(m) * T(n)`.


theorem Filter.Tendsto.mul_const :
    ∀ {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [inst_2 : ContinuousMul M] (b : M)
      {c : M} {f : α → M} {l : Filter α},
      Filter.Tendsto (fun k => f k) l (nhds c) → Filter.Tendsto (fun k => f k * b) l (nhds (c * b)) :=
  by sorry

The theorem `Filter.Tendsto.mul_const` states that for any topological space `M` with multiplication operation that is continuous, given any element `b` of `M`, and a filter `l` over some type `α`, if a function `f` from `α` to `M` tends towards a limit `c` as per the neighborhood filter at `c` when applied on `l`, then the function that maps `k` to `f(k) * b` also tends towards the limit `c * b` with respect to the neighborhood filter at `c * b` when applied on `l`. In short, it states that if a function tends towards a limit, then the function multiplied by a constant also tends towards the limit multiplied by the same constant, provided multiplication is continuous in the topological space.

If a function from a filter to a topological space with continuous multiplication tends towards a limit, then the function multiplied by a constant tends towards the limit multiplied by that constant.


theorem Subgroup.card_eq_card_quotient_mul_card_subgroup :
    ∀ {α : Type u_1} [inst : Group α] [inst_1 : Fintype α] (s : Subgroup α) [inst_2 : Fintype ↥s]
      [inst_3 : DecidablePred fun a => a ∈ s], Fintype.card α = Fintype.card (α ⧸ s) * Fintype.card ↥s :=
  by sorry

The theorem `Subgroup.card_eq_card_quotient_mul_card_subgroup` states that for any given type `α` that has a group structure and is finite (`Fintype`), and a subgroup `s` of `α` that is also finite, the cardinality (i.e., the number of elements) of `α` is equal to the product of the cardinality of the quotient group `α ⧸ s` and the cardinality of the subgroup `s` itself. This is under the condition that the predicate "a is an element of `s`" is decidable for all `a` in `α`, i.e., for any element of the group, we can determine whether or not it belongs to the subgroup `s`. This theorem is a version of the Lagrange's theorem in group theory, which states that the order of any finite group is the product of the order of a subgroup and the order of the quotient group formed by dividing the group by that subgroup.

For any finite group `α` with a decidable subgroup `s`, the cardinality of `α` equals the product of the cardinalities of `α/s` and `s`.


/-- Hölder's inequality, as an inequality on the `ℒp` seminorm of a scalar product `φ • f`.  -/
theorem MeasureTheory.snorm_smul_le_mul_snorm :
    ∀ {𝕜 : Type u_1} {α : Type u_2} {E : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : MulActionWithZero 𝕜 E] [inst_3 : BoundedSMul 𝕜 E]
      {p q r : ENNReal} {f : α → E},
      MeasureTheory.AEStronglyMeasurable f μ →
        ∀ {φ : α → 𝕜},
          MeasureTheory.AEStronglyMeasurable φ μ →
            1 / p = 1 / q + 1 / r →
              MeasureTheory.snorm (φ • f) p μ ≤ MeasureTheory.snorm φ q μ * MeasureTheory.snorm f r μ :=
  by sorry

This theorem is a formalization of Hölder's inequality in the context of Lebesgue spaces (`ℒp` spaces). It states that for any measure space `α`, any measure `μ` on `α`, any scalar field `𝕜`, any normed additively commutative group `E`, any `𝕜`-scalar multiplication on `E`, and any exponents `p`, `q`, and `r` in the extended nonnegative real numbers, if `f` is a function from `α` to `E` that is almost everywhere strongly measurable with respect to `μ`, and `φ` is a function from `α` to `𝕜` that is also almost everywhere strongly measurable with respect to `μ`, and if `1/p = 1/q + 1/r`, then the `ℒp` seminorm of the scalar product `φ • f` is less than or equal to the product of `ℒq` seminorm of `φ` and the `ℒr` seminorm of `f`. Note that the `ℒp` seminorm is defined as `0` for `p=0`, as `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, and as the essential supremum of `‖f‖` with respect to measure `μ` for `p = ∞`.

For any measure space, measure, scalar field, normed additively commutative group, scalar multiplication, and measurable functions `f: α → E` and `φ: α → ℝ`, if `1/p = 1/q + 1/r`, `p, q, r > 0`, and `μ` is a measure on `α`, then the scalar product `φ • f` belongs to the `ℒp` space and satisfies `∥φ • f∥\_p ≤ ∥φ∥\_q * ∥f∥\_r`.


theorem Sublattice.coe_inj : ∀ {α : Type u_2} [inst : Lattice α] {L M : Sublattice α}, ↑L = ↑M ↔ L = M := by sorry

This theorem, `Sublattice.coe_inj`, states that for any given type `α` that's a lattice, and for any two sublattices `L` and `M` of this lattice, the coercion of `L` to `α` being equal to the coercion of `M` to `α` is equivalent to `L` and `M` being equal. Coercion, denoted by `↑`, is a way to convert one type into another in Lean. Here, it's used to convert sublattices into their containing lattice. The theorem essentially says that if two sublattices are equal when viewed as sets in the larger lattice, then they are indeed equal as sublattices.

For any lattice type `α` and sublattices `L` and `M` of `α`, `↑L = ↑M` if and only if `L = M`.


theorem DiscreteQuotient.fiber_eq :
    ∀ {X : Type u_2} [inst : TopologicalSpace X] (S : DiscreteQuotient X) (x : X),
      DiscreteQuotient.proj S ⁻¹' {DiscreteQuotient.proj S x} = setOf (Setoid.Rel S.toSetoid x) :=
  by sorry

The theorem `DiscreteQuotient.fiber_eq` states that for any type `X` equipped with a topological space instance, any `DiscreteQuotient S` of `X`, and any element `x` of `X`, the preimage of the set `{DiscreteQuotient.proj S x}` under the projection `DiscreteQuotient.proj S` equals the set of all elements which are related to `x` under the equivalence relation `S.toSetoid`. In other words, this theorem says that the preimage of the equivalence class of `x` under the quotient map is exactly the set of all elements equivalent to `x`.

For any topological space `X` and equivalence relation `S` on `X`, the preimage of the equivalence class of an element `x` in `X` under the quotient map is equal to the set of all elements related to `x` by `S`.


/-- Any homeomorphism from a `TietzeExtension` space is one itself. -/
theorem TietzeExtension.of_homeo :
    ∀ {Y : Type v} {Z : Type w} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z] [inst_2 : TietzeExtension Z],
      Y ≃ₜ Z → TietzeExtension Y :=
  by sorry

This theorem states that if there exists a homeomorphism (a bijective, continuous function whose inverse is also continuous) from a space Y to a space Z, and if Z is a Tietze Extension space (a topological property that guarantees the ability to extend a continuous real-valued function defined on a closed subset to a continuous real-valued function on the whole space), then Y is also a Tietze Extension space.

If Y is a Hausdorff space homeomorphic to a Tietze Extension space Z, then Y is also a Tietze Extension space.


theorem IsIntegralClosure.of_isIntegrallyClosed :
    ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [iic : IsIntegrallyClosed R]
      (K : Type u_3) [inst_2 : CommRing K] [inst_3 : Algebra R K] [ifr : IsFractionRing R K] [inst_4 : Algebra S R]
      [inst_5 : Algebra S K] [inst_6 : IsScalarTower S R K], Algebra.IsIntegral S R → IsIntegralClosure R S K :=
  by sorry

The theorem `IsIntegralClosure.of_isIntegrallyClosed` states that for any three types `R`, `S`, and `K` along with the relevant algebraic structures (where `R` is a commutative ring, `S` is another commutative ring, `K` is a commutative ring that is also an algebra over `R` and `S`, and `R` is the field of fractions of `K`), if `R` is integrally closed, `S` is an integral extension of `R`, and there is a scalar tower `S` `R` `K`, then `S` is the integral closure of `R` in `K`.

In other words, if every element of `S` is integral over `R` and `R` satisfies the property of being integrally closed, then `S` is considered the 'integral closure' of `R` in `K`, meaning it is the smallest algebraic extension of `R` in `K` in which every element is integral over `R`.

If `R` is a commutative ring, `S` is an integral extension of `R` with a scalar tower `S` `R` `K`, and `R` is integrally closed, then `S` is the integral closure of `R` in `K`.


theorem compare_lt_iff_lt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, compare a b = Ordering.lt ↔ a < b := by
  sorry

This theorem, named `compare_lt_iff_lt`, states that for all types `α` that have a `LinearOrder` instance, and for all `a` and `b` of type `α`, the function `compare` returns `Ordering.lt` if and only if `a` is less than `b`. In other words, it establishes the exact condition under which the `compare` function would return `Ordering.lt` in a linear order.

For any type `α` with a `LinearOrder` instance, `compare a b` equals `Ordering.lt` if and only if `a` is strictly less than `b`.


theorem Mathlib.Order.Filter.Germ._auxAddLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f g : α → β}, (↑f = ↑g) = (f =ᶠ[l] g) := by sorry

This theorem, named `Mathlib.Order.Filter.Germ._auxAddLemma.2`, is from the `Mathlib.Order.Filter.Germ` namespace of the Lean 4 Mathlib library. It states that for any two functions `f` and `g` from a type `α` to a type `β` and any filter `l` on `α`, the functions `f` and `g` being equal as germs (indicated by `↑f = ↑g`) is equivalent to the statement that `f` and `g` are eventually equal (`f =ᶠ[l] g`) with respect to the filter `l`. In other words, `f` and `g` being equal almost everywhere in terms of `l` is the same as them having the same germ at `l`.

For any functions `f` and `g` from type `α` to type `β` and filter `l` on `α`, `↑f = ↑g` implies `f =ᶠ[l] g`. (Here, `↑f` denotes the germ of `f` at any point in `α`.)


theorem MvPolynomial.ACounit_X :
    ∀ (A : Type u_1) {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B] (b : B),
      (MvPolynomial.ACounit A B) (MvPolynomial.X b) = b :=
  by sorry

The theorem `MvPolynomial.ACounit_X` states that for all types `A` and `B`, where `A` is a commutative semiring and `B` is a commutative semiring that is also an `A`-algebra, and for any element `b` of `B`, when the algebra homomorphism `MvPolynomial.ACounit A B` is applied to the degree `1` monomial `MvPolynomial.X b`, the result is `b`. Intuitively, this means that `MvPolynomial.ACounit A B` maps the monomial `X_b` to the element `b` in `B`.

For any commutative semirings `A` and `B` with `B` an `A`-algebra, the algebra homomorphism `MvPolynomial.ACounit A B` maps the degree `1` monomial `MvPolynomial.X b` to the element `b` in `B`.


theorem Monoid.exponent_pos_of_exists :
    ∀ {G : Type u} [inst : Monoid G] (n : ℕ), 0 < n → (∀ (g : G), g ^ n = 1) → 0 < Monoid.exponent G := by sorry

The theorem 'Monoid.exponent_pos_of_exists' asserts that for any type 'G' equipped with a monoid structure, given a positive integer 'n' such that every element 'g' of 'G' raised to the power 'n' equals the identity element (i.e., 'g ^ n = 1'), the exponent of the monoid 'G' is always positive. In simpler terms, if there exists a positive integer power that makes all elements of a monoid equal to the identity element, then the smallest such power (which is the exponent of the monoid) must be a positive number.

For any monoid G and positive integer n such that g^n = 1 for all g in G, the exponent of G is positive.


/-- The definition of `0 ⧏ x` on pre-games, in terms of `0 ≤`.  -/
theorem SetTheory.PGame.zero_lf_le :
    ∀ {x : SetTheory.PGame}, SetTheory.PGame.LF 0 x ↔ ∃ i, 0 ≤ SetTheory.PGame.moveLeft x i := by sorry

This theorem explains the definition of the "less or fuzzy" relation (`0 ⧏ x`) on pre-games in the context of the "less or equal" (`0 ≤`) relationship. It states the following: for any pre-game `x`, the relation `0 ⧏ x` holds if and only if there exists some left move `i` such that after Left makes that move, the game `x` is in a state where it is "less or equal" to `0`. In other words, it implies that Left can make a winning move by placing the game in a state where they have at least as good of a position as having no moves to make.

The "less or fuzzy" relation `0 ⧏ x` holds for a pre-game `x` if and only if there exists a Left move leading to a game state where `0 ≤ x`.


theorem Mathlib.Data.Set.Card._auxLemma.8 : ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) := by sorry

This theorem in Lean 4 states that for any type `α` and any elements `a` and `b` of type `α`, the condition "`a` is an element of the singleton set containing `b`" is equivalent to "`a` is equal to `b`". Essentially, it asserts that a value is an element of a singleton set if and only if it is equal to the single element of that set.

For any type `α` and any elements `a`, `b` of type `α`, `a` is an element of the singleton set `{b}` if and only if `a` is equal to `b`.


Asymptotics.IsBigO.congr

theorem Asymptotics.IsBigO.congr :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
      {g₁ g₂ : α → F}, f₁ =O[l] g₁ → (∀ (x : α), f₁ x = f₂ x) → (∀ (x : α), g₁ x = g₂ x) → f₂ =O[l] g₂ :=
  by sorry

This theorem states that for any types `α`, `E`, and `F` with norms defined for `E` and `F`, and any function `f₁`, `f₂`, `g₁`, `g₂` mapping `α` to `E` or `F`, if `f₁` is big-O of `g₁` under some arbitrary filter `l`, and `f₁` is identical to `f₂` for all `x : α`, and `g₁` is identical to `g₂` for all `x : α`, then `f₂` is also big-O of `g₂` under the same filter `l`. In simpler terms, this means that if two function pairs are identical and the first pair adheres to big-O notation, then the second pair also adheres to big-O notation.

If functions `f₁` and `f₂` are identical and `f₁` is big-O of `g₁`, where `g₁` is identical to `g₂`, then `f₂` is big-O of `g₂`.


theorem finSuccEquiv_symm_some : ∀ {n : ℕ} (m : Fin n), (finSuccEquiv n).symm (some m) = Fin.succ m := by sorry

The theorem `finSuccEquiv_symm_some` states that for all natural numbers `n` and for all `m` in `Fin n`, the inverse of the equivalence `finSuccEquiv n`, when applied to `m` wrapped in `some`, is equal to the successor of `m` in `Fin (Nat.succ n)`. In simpler terms, using the inverse equivalence `finSuccEquiv n` to convert an optional finite number back to a finite number increments the value by one.

For all natural numbers `n` and `m` in `Fin n`, the inverse of `finSuccEquiv n` applied to `some m` equals `some (m.succ)` in `Fin (Nat.succ n)`.


theorem Mathlib.Order.Filter.Bases._auxLemma.22 : ∀ {α : Type u} (a : α), pure a = Filter.principal {a} := by sorry

This theorem asserts that for any type `α` and any element `a` of this type, the pure filter of `a` is equivalent to the principal filter of the singleton set containing only `a`. In other words, the collection of all supersets of a singleton set `{a}` is effectively the same as the pure filter of `a`, which, intuitively, is a filter that captures only `a` and nothing else.

For any type `α` and element `a` of type `α`, the filter of sets containing `a` (i.e., the principal filter of `{a}`) is equal to the pure filter of `a`.


theorem LieHom.surjective_rangeRestrict :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {L₂ : Type w}
      [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L →ₗ⁅R⁆ L₂),
      Function.Surjective ⇑(LieHom.rangeRestrict f) :=
  by sorry

The theorem `LieHom.surjective_rangeRestrict` states that for any commutative ring `R`, Lie rings `L` and `L₂`, and a Lie algebra structure over `L` and `L₂` with coefficients in `R`, every Lie morphism `f` from `L` to `L₂` is surjective when restricted to its range. In other words, for every element in the range of `f`, there exists an element in `L` such that applying the restricted Lie homomorph `f` to this element yields the original element from the range.

Given a commutative ring R, Lie rings L and L₂, and a Lie algebra homomorphism f from L to L₂ over R, the image of f is all of L₂.