theorem tsub_pos_of_lt :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b : α},
      a < b → 0 < b - a :=
  by sorry

This theorem, `tsub_pos_of_lt`, states that for any type `α` that is a canonically ordered additive commutative monoid and also supports subtraction and ordered subtraction, if `a` and `b` are elements of `α` and `a` is less than `b`, then the result of `b - a` is greater than zero. Essentially, in a context where subtraction is well-behaved and the elements are ordered in a sensible way, subtracting a smaller number from a larger one produces a positive result.

If `α` is a canonically ordered additive commutative monoid with subtraction and ordered subtraction, then for all `a` and `b` in `α` with `a` less than `b`, `b - a` is positive.


/-- **Alias** of `div_mul_cancel`. -/
theorem div_mul_cancel' : ∀ {G : Type u_3} [inst : Group G] (a b : G), a / b * b = a := by sorry

This theorem, known as an alias of `div_mul_cancel`, states that for any group `G` of a certain type and for any elements `a` and `b` in this group, the operation of dividing `a` by `b`, and then multiplying the result by `b`, will always equal `a`. This is a generalization of the principle from arithmetic that dividing a number by a certain factor and then multiplying the result by the same factor will restore the original number.

For any group `G` and elements `a, b` in `G` such that `b ≠ 0`, we have `a / b * b = a`.


LinearIsometryEquiv.ext

theorem LinearIsometryEquiv.ext :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] {e e' : E ≃ₛₗᵢ[σ₁₂] E₂}, (∀ (x : E), e x = e' x) → e = e' :=
  by sorry

The theorem `LinearIsometryEquiv.ext` states that for any two types `R` and `R₂` with semiring structures, types `E` and `E₂` with seminormed add commutative group structures and module structures over `R` and `R₂` respectively, and given ring homomorphisms `σ₁₂` and `σ₂₁` that form an inverse pair, if we have two linear isometric equivalences `e` and `e'` between `E` and `E₂` that are compatible with `σ₁₂`, and if these two equivalences map each element of `E` to the same element in `E₂`, then `e` and `e'` must be the same linear isometric equivalence.

Given types `E` and `E₂` with seminormed add commutative group structures and module structures over semiring `R` and `R₂`, respectively, and given ring homomorphisms `σ₁₂` and `σ₂₁` with inverse pair, if there exist linear isometric equivalences `e` and `e'` between `E` and `E₂`, compatible with `σ₁₂`, mapping every element in `E` to the same image in `E₂`, then `e` and `e'` are equal.


theorem Filter.tendsto_pure :
    ∀ {α : Type u} {β : Type v} {f : α → β} {a : Filter α} {b : β},
      Filter.Tendsto f a (pure b) ↔ ∀ᶠ (x : α) in a, f x = b :=
  by sorry

The theorem `Filter.tendsto_pure` states that for any given types `α` and `β`, a function `f` from `α` to `β`, a filter `a` on `α`, and a value `b` of type `β`, the function `f` tends towards `b` (in the sense of the `Filter.Tendsto` predicate) with respect to filter `a` if and only if it is eventually true in `a` that the function `f` applied to any element `x` of `α` equals `b`. In other words, for every element that eventually comes from `a`, the function `f` maps it to `b`.

For any types `α` and `β`, a function `f:` `α` → `β`, a filter `a` on `α`, and a value `b` in `β`, `Filter.tendsto f a b` if and only if for every `x` in `α` that belongs to `a` infinitely often, `f x = b`.


theorem Matrix.tail_cons : ∀ {α : Type u} {m : ℕ} (x : α) (u : Fin m → α), Matrix.vecTail (Matrix.vecCons x u) = u := by
  sorry

The theorem `Matrix.tail_cons` states that for any type `α`, any natural number `m`, any element `x` of type `α`, and any vector `u` of size `m` with elements of type `α`, if we prepend `x` to `u` using `Matrix.vecCons` and then remove the first element of the resulting vector using `Matrix.vecTail`, we get back the original vector `u`. This essentially proves the property that `Matrix.vecTail` and `Matrix.vecCons` are inverse of each other in the sense that prepending an element on a vector and then removing the first element of the resulting vector gives back the original vector.

For any type `α` and natural number `m`, the operations `Matrix.vecCons` and `Matrix.vecTail` on vectors of size `m+1` satisfy `Matrix.vecTail (Matrix.vecCons x u) = u`, where `x` is an element of type `α` and `u` is a vector of size `m` with elements of type `α`.


theorem CategoryTheory.Functor.epi_of_epi_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.Functor.ReflectsEpimorphisms F] {X Y : C} {f : X ⟶ Y},
      CategoryTheory.Epi (F.map f) → CategoryTheory.Epi f :=
  by sorry

This theorem from category theory states that for any two objects `X` and `Y` in a category `C`, and a functor `F` from `C` to another category `D` that reflects epimorphisms, if the image of a morphism `f : X ⟶ Y` under `F` is an epimorphism in `D`, then `f` is an epimorphism in `C`. An epimorphism is a morphism whose cancellation property holds for all pairs of morphisms. This theorem, in essence, asserts that the property of being an epimorphism is preserved under the functor `F`.

If `F` is a functor from category `C` to category `D` that reflects epimorphisms, then for any objects `X` and `Y` in `C` and morphism `f : X ⟶ Y` in `C`, if `F(f)` is an epimorphism in `D`, then `f` is an epimorphism in `C`.


theorem disjoint_sdiff_self_left : ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], Disjoint (y \ x) x :=
  by sorry

This theorem, `disjoint_sdiff_self_left`, states that for all types `α` and for all elements `x` and `y` of type `α` in a generalized boolean algebra, the 'difference' of `y` and `x` (denoted as `y \ x`) and `x` itself are disjoint. In the context of lattice theory, two elements are considered disjoint if their greatest lower bound (or infimum) is the bottom element of the lattice. In other words, for every other element `z` in the lattice, if `z` is less than or equal to both `y \ x` and `x`, then `z` must be less than or equal to the bottom element. This is a way of expressing the notion that `y \ x` and `x` have no elements in common (hence, they are 'disjoint').

In a generalized boolean algebra, for all types `α` and elements `x` and `y` of type `α`, the sets `{z | z ≤ x ∧ z ≤ y \ x}` and `{x}` have no common elements.


theorem Array.push_data : ∀ {α : Type u_1} (arr : Array α) (a : α), (Array.push arr a).data = arr.data ++ [a] := by
  sorry

This theorem, named `Array.push_data`, states that for all types `α`, given an array `arr` of type `α` and an element `a` of type `α`, when the element `a` is pushed onto the end of the array `arr` using the `Array.push` function, the underlying data of the resulting array is equivalent to appending the element `a` to the end of the underlying data of the original array `arr`. In other words, it states that the `push` operation for arrays in Lean 4 corresponds to the `append` operation for lists.

For all types `α`, the operation of pushing an element `a` to the end of an array `arr` in Lean 4 results in an array with the same underlying data as appending `a` to the original array `arr`.


theorem Nat.lt_trans : ∀ {n m k : ℕ}, n < m → m < k → n < k := by sorry

This theorem, `Nat.lt_trans`, is a statement about the transitivity of the 'less than' relation on natural numbers. Specifically, it asserts that for any three natural numbers `n`, `m`, and `k`, if `n` is less than `m` and `m` is less than `k`, then `n` is less than `k`. In mathematical notation, this would be expressed as: ∀ {n m k : ℕ}, n < m → m < k → n < k. This is a fundamental property of ordered sets.

For all natural numbers `n, m, k`, if `n` is less than `m` and `m` is less than `k`, then `n` is less than `k` (i.e., `n < m` and `m < k` imply `n < k`).


theorem Metric.mem_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, y ∈ Metric.closedBall x ε ↔ dist y x ≤ ε := by sorry

This theorem states that for any pseudo-metric space, a point `y` is in the closed ball centered at `x` with radius `ε` if and only if the distance from `y` to `x` is less than or equal to `ε`. In other words, it characterizes the membership of a point in a closed ball in terms of the distance between points in the metric space.

A point `y` lies in the closed ball with center `x` and radius `ε` in a pseudo-metric space if and only if the distance from `x` to `y` is less than or equal to `ε`.


theorem Irreducible.ne_zero : ∀ {α : Type u_1} [inst : MonoidWithZero α] {p : α}, Irreducible p → p ≠ 0 := by sorry

This theorem states that for any type `α` (with the condition that `α` is a monoid with zero), an element `p` of type `α` that is irreducible cannot be equal to zero. In mathematical terms, if `p` is an irreducible element of a monoid with zero, then `p` must be a non-zero element.

If `α` is a monoid with zero, then any irreducible element `p` in `α` is non-zero.


theorem Real.rpow_neg : ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), x ^ (-y) = (x ^ y)⁻¹ := by sorry

This theorem states that for any real number `x` that is non-negative, and for any real number `y`, the power of `x` to the negation of `y` (i.e., `x` raised to the power `-y`) is equal to the reciprocal of `x` raised to the power `y`. This is a standard rule of exponents that is also valid in the realm of real numbers.

For any non-negative real number `x` and real number `y`, `x^(-y) = 1/x^y`.


theorem Ideal.IsPrime.ne_top : ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, Ideal.IsPrime I → I ≠ ⊤ := by sorry

The theorem `Ideal.IsPrime.ne_top` states that for any type `α` with a semiring structure, if `I` is a prime ideal in `α`, then `I` cannot be the top ideal. In other words, a prime ideal in a semiring cannot be the whole semiring itself.

A prime ideal in a semiring is Proper (i.e., strict subset of the semiring).


theorem mul_div_assoc' : ∀ {G : Type u_3} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c := by sorry

This theorem states that for any type `G` that has a division and inverse operation (making it a `DivInvMonoid`), for all elements `a`, `b`, and `c` of `G`, the multiplication of `a` by the division of `b` by `c` is equal to the division of the multiplication of `a` and `b` by `c`. In mathematical notation, it says that $a \cdot \frac{b}{c} = \frac{a \cdot b}{c}$.

For any `DivInvMonoid` type `G` and its elements `a`, `b`, and `c`, $a \cdot (b \div c) = (a \cdot b) \div c$.


theorem Finset.card_insert_of_not_mem :
    ∀ {α : Type u_1} {s : Finset α} {a : α} [inst : DecidableEq α], a ∉ s → (insert a s).card = s.card + 1 := by sorry

This theorem states that for any type `α` with decidable equality and for any finite set `s` of type `α`, if an element `a` of type `α` is not a member of `s`, then the cardinality (or size) of the result of inserting `a` into `s` is the cardinality of `s` plus one. In mathematical terms, if $a \notin s$ then $|s \cup \{a\}| = |s| + 1$ where $s$ is a finite set and $a$ is an element not in $s$.

For any finite type `α` with decidable equality, the cardinality of a finite set `s` of type `α` is strictly increased by one when an element not in `s` is added to it.


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

This theorem, `Polynomial.eval₂_add`, states that for any two polynomials `p` and `q` over a semiring `R`, a ring homomorphism `f` from `R` to another semiring `S`, and an element `x` in `S`, the evaluation of the sum `p + q` at `x` via `f` (denoted as `Polynomial.eval₂ f x (p + q)`) is equal to the sum of the evaluations of `p` and `q` at `x` via `f` (denoted as `Polynomial.eval₂ f x p + Polynomial.eval₂ f x q`). In other words, it states that the evaluation function for polynomials respects addition.

For any semirings R and S, ring homomorphism f from R to S, and polynomials p and q over R, the evaluation of p + q at x via f is equal to the sum of the evaluations of p and q at x via f.


theorem of_decide_eq_false : ∀ {p : Prop} [inst : Decidable p], decide p = false → ¬p := by sorry

This theorem states that for any proposition `p` that has a decidable truth value, if the decision procedure `decide p` for `p` returns false, then the proposition `p` is not true. In other words, it confirms that the `decide` function correctly identifies propositions that are false within the context of classical logic.

If `decide p` returns false for a proposition `p` in classical logic, then `p` is false.


theorem Nat.factorization_eq_zero_of_non_prime : ∀ (n : ℕ) {p : ℕ}, ¬Nat.Prime p → (Nat.factorization n) p = 0 := by
  sorry

The theorem `Nat.factorization_eq_zero_of_non_prime` states that for any natural number `n` and any other natural number `p`, if `p` is not prime, then the factorization of `n` at `p` is equal to zero. In other words, non-prime numbers do not contribute to the prime factorization of a number.

For any natural number `n` and non-prime natural number `p`, `n.have_factor p` implies `n = 0`.


theorem Nat.succ_sub_succ : ∀ (n m : ℕ), Nat.succ n - Nat.succ m = n - m := by sorry

This theorem states that for any two natural numbers `n` and `m`, the successor of `n` minus the successor of `m` is equal to `n` minus `m`. In other words, if you increment both `n` and `m` by 1, the difference between them remains the same. This is essentially a formalization of the basic arithmetic property that the difference between two numbers is invariant under the same increment to both numbers.

For all natural numbers `n` and `m`, `(n.succ - m.succ) = (n - m)`.


theorem Set.image_union : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s t : Set α), f '' (s ∪ t) = f '' s ∪ f '' t :=
  by sorry

The theorem `Set.image_union` states that for any two sets `s` and `t` of elements of some type `α`, and any function `f` from `α` to another type `β`, the image of the union of sets `s` and `t` under function `f` is equivalent to the union of the individual images of sets `s` and `t` under the same function. In mathematical notation, this is the property that $f(S \cup T) = f(S) \cup f(T)$ where $S$ and $T$ are sets and $f$ is a function.

The theorem asserts that for sets $S, T \subseteq \alpha$ and function $f : \alpha \to \beta$, $f(S \cup T) = f(S) \cup f(T)$.


theorem CategoryTheory.Limits.Cofork.IsColimit.π_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      {s t : CategoryTheory.Limits.Cofork f g} (hs : CategoryTheory.Limits.IsColimit s),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π s) (hs.desc t) =
        CategoryTheory.Limits.Cofork.π t :=
  by sorry

This theorem, `CategoryTheory.Limits.Cofork.IsColimit.π_desc`, states that for any category `C` with objects `X` and `Y`, and for any pair of morphisms `f` and `g` from `X` to `Y`, if we have two coforks `s` and `t` over the pair `(f, g)`, and if `s` is a colimit, then composing the projection from `s` to `Y` with the unique morphism from `s` to `t` that makes the triangle commute (given by `hs.desc t`), gives us the projection from `t` to `Y`. This essentially states a property of the universal property of colimits in the context of coforks.

Given a category `C` with objects `X` and `Y`, and morphisms `f`, `g` from `X` to `Y`, if `s` is a colimit cofork over `(f, g)` and there is a morphism `h` from `s` to `t` making the triangle commute, then the composite of the projection from `s` to `Y` and `h` equals the projection from `t` to `Y`.


theorem Nat.factorial_succ : ∀ (n : ℕ), Nat.factorial (n + 1) = (n + 1) * Nat.factorial n := by sorry

The theorem `Nat.factorial_succ` states that for all natural numbers `n`, the factorial of `n + 1` is equal to `(n + 1) times the factorial of `n`. This corresponds to the recursive definition of the factorial function in mathematics, where the factorial of a number `n` (denoted as `n!`) is `n` multiplied by the factorial of `n - 1`.

The theorem `Nat.factorial_succ` asserts that for all natural numbers `n`, `(n + 1)! = (n + 1) * n!`.


theorem mul_lt_mul_left' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {b c : α},
      b < c → ∀ (a : α), a * b < a * c :=
  by sorry

This theorem, `mul_lt_mul_left'`, states that for any type `α` that has a multiplication operation, a less-than relation, and satisfies the covariant class property with respect to multiplication and the less-than relation, given two elements `b` and `c` of `α` where `b` is less than `c`, for any element `a` in `α`, the result of `a` multiplied by `b` is less than `a` multiplied by `c`. In other words, when multiplying by a common factor on the left, an inequality is preserved. This is a statement about the preservation of order under left multiplication in a certain class of ordered semigroups.

For any covariant ordered semigroup `α` with respect to multiplication and the less-than relation, if `b` < `c` in `α`, then for all `a` in `α`, `a` * `b` < `a` * `c`.


theorem zero_zsmul : ∀ {G : Type u_1} [inst : SubNegMonoid G] (a : G), 0 • a = 0 := by sorry

This theorem states that, for any type `G` that is a `SubNegMonoid` (a structure with subtraction and negation operations), the scalar multiplication of zero (`0`) and any element `a` from `G` will always yield zero (`0`). This is a generalization of the standard algebraic property that multiplying anything by zero gives zero, but in the context of any object that behaves like numbers with respect to subtraction and negation.

For any type `G` with subtraction and negation operations, scalar multiplication of any element `a` in `G` by zero results in zero.


theorem Finset.union_comm : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ ∪ s₂ = s₂ ∪ s₁ := by sorry

The theorem `Finset.union_comm` states that for any type `α` with decidable equality (`DecidableEq α`) and for any two finite sets (`Finset α`) `s₁` and `s₂`, the union of `s₁` and `s₂` is the same as the union of `s₂` and `s₁`. In other words, the operation of taking the union of two finite sets is commutative.

For any type `α` with decidable equality and any two finite sets `s₁` and `s₂` of type `Finset α`, `s₁ ∎ s₂` equals `s₂ ∎ s₁`, where `∎` denotes the finite set union operation.


theorem Finset.card_sdiff :
    ∀ {α : Type u_1} {s t : Finset α} [inst : DecidableEq α], s ⊆ t → (t \ s).card = t.card - s.card := by sorry

The theorem `Finset.card_sdiff` states that for all types `α`, for all sets `s` and `t` of type `α` where `α` has decidable equality, if `s` is a subset of `t`, then the cardinality (or the number of elements) of the difference of `t` and `s` is equal to the difference of the cardinalities of `t` and `s`. This theorem essentially gives a way to calculate the number of elements in the set difference `t \ s` in terms of the cardinalities of `t` and `s`.

If `α` has decidable equality and `s` is a subset of `t` in type `α`, then the cardinality of `t \ s` equals the difference of the cardinalities of `t` and `s`.


theorem UpperHalfPlane.im_pos : ∀ (z : UpperHalfPlane), 0 < UpperHalfPlane.im z := by sorry

This theorem states that for any point `z` in the open upper half plane, the imaginary part of `z`, as given by the function `UpperHalfPlane.im`, is always greater than zero. In other words, the imaginary part of any point in the upper half plane is always positive.

For any point in the open upper half plane, its imaginary part is positive.


theorem add_right_eq_self : ∀ {M : Type u} [inst : AddLeftCancelMonoid M] {a b : M}, a + b = a ↔ b = 0 := by sorry

This theorem, `add_right_eq_self`, states that for any type `M` which is an instance of `AddLeftCancelMonoid`, and any elements `a` and `b` of `M`, the equation `a + b = a` holds true if and only if `b` equals zero. In mathematical terms, for a left-cancelable monoid, adding an element `b` to `a` results in `a` only when `b` is the identity element of the monoid (which is zero in the case of addition).

For any `M` an instance of `AddLeftCancelMonoid` and `a` an element of `M`, `a + b = a` if and only if `b` is the additive identity of `M`.


theorem CategoryTheory.Limits.biprod.lift_snd :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f : W ⟶ X) (g : W ⟶ Y),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift f g) CategoryTheory.Limits.biprod.snd = g :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.lift_snd` states that in any category `C` with zero morphisms, given three objects `W`, `X`, and `Y` such that `X` and `Y` have a binary biproduct, and given any two morphisms `f` from `W` to `X` and `g` from `W` to `Y`, the composition of the morphism constructed by the lift operation on `f` and `g` and the projection onto the second summand of the binary biproduct equals `g`. In more mathematical terms, this means that if we form a morphism from `W` to the biproduct `X ⊞ Y` using `f` and `g`, and then project onto `Y`, we get back the original morphism `g`.

Given a category with zero morphisms `C` where `X` and `Y` have a binary biproduct, for any morphisms `f: W → X` and `g: W → Y`, we have `(π₂ ∘ lift₂ X Y f g) = g`, where `lift₂` is the lift operation on morphisms, `π₂` is the projection onto the second summand of the biproduct, and the domain of all morphisms is the object `W`.


theorem ENNReal.ofReal_le_ofReal : ∀ {p q : ℝ}, p ≤ q → ENNReal.ofReal p ≤ ENNReal.ofReal q := by sorry

The theorem `ENNReal.ofReal_le_ofReal` states that for any two real numbers `p` and `q`, if `p` is less than or equal to `q`, then the nonnegative real number corresponding to `p` (obtained using the `ENNReal.ofReal` function) is also less than or equal to the nonnegative real number corresponding to `q`. In other words, the function `ENNReal.ofReal` preserves the order of real numbers when they are mapped to their nonnegative counterparts.

For all real numbers `p` and `q`, if `p ≤ q`, then `ENNReal.ofReal p ≤ ENNReal.ofReal q`.


theorem lt_min : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a < b → a < c → a < min b c := by sorry

This theorem, `lt_min`, asserts that for any type `α` that has a linear order, and for any three elements `a`, `b`, and `c` of that type, if `a` is less than `b` and `a` is less than `c`, then `a` is less than the minimum of `b` and `c`. Essentially, it's saying that if `a` is less than two other elements, it's also less than the smallest of those two elements.

For all types `α` with a linear order and all `a`, `b`, `c` in `α`, if `a` is less than `b` and `a` is less than `c`, then `a` is less than the minimum of `b` and `c`. In mathematical notation: `a < b ∧ a < c → a < min b c`.


theorem Nat.factorial_ne_zero : ∀ (n : ℕ), Nat.factorial n ≠ 0 := by sorry

The theorem `Nat.factorial_ne_zero` states that for every natural number `n`, the factorial of `n` is not equal to zero. In mathematical terminology, this can be written as: for all natural numbers `n`, `n! ≠ 0`. This corresponds to the well-known fact that the factorial of any natural number is always positive, since it is a product of positive integers.

For every natural number `n`, the factorial `n!` is non-zero.


theorem Filter.HasBasis.le_basis_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
      {s' : ι' → Set α},
      Filter.HasBasis l p s → Filter.HasBasis l' p' s' → (l ≤ l' ↔ ∀ (i' : ι'), p' i' → ∃ i, p i ∧ s i ⊆ s' i') :=
  by sorry

This theorem states that for any two types `α` and `ι` along with their variants `ι'`, and given two filters `l` and `l'` on the type `α`, along with two properties `p : ι → Prop` and `p' : ι' → Prop` and two functions `s : ι → Set α` and `s' : ι' → Set α` that map each index to a set of elements of type `α`, if `l` and `l'` have the bases defined by `p`, `s` and `p'`, `s'` respectively, then `l` is less than or equal to `l'` (in the sense of filter inclusion) if and only if for every index `i'` where `p' i'` holds, there exists an index `i` such that `p i` holds and the set `s i` is a subset of `s' i'`.

For filters `l` and `l'` on types `α` with index types `ι` and `ι'`, and functions `s` and `s'` mapping indices to sets of elements in `α`, if `l` is defined by properties `p : ι → Prop` and `s : ι → Set α`, and `l'` is defined by `p' : ι' → Prop` and `s' : ι' → Set α`, then `l` is a subset of `l'` if and only if for all `i'` such that `p' i'` holds, there exists an `i` with `p i` holding and `s i` a subset of `s' i'`.


StieltjesFunction.mono

theorem StieltjesFunction.mono : ∀ (f : StieltjesFunction), Monotone ↑f := by sorry

The theorem `StieltjesFunction.mono` states that for every Stieltjes function `f`, the function `f` is monotone. In other words, if `a ≤ b` for any real numbers `a` and `b`, then `f(a) ≤ f(b)`. This property is essential in many mathematical contexts, for instance in probability theory where Stieltjes functions often represent distribution functions of random variables, which must be non-decreasing.

For every Stieltjes function `f`, if `a ≤ b` are real numbers then `f(a) ≤ f(b)`.


theorem Real.Angle.cos_coe : ∀ (x : ℝ), Real.Angle.cos ↑x = Real.cos x := by sorry

This theorem states that for every real number `x`, the cosine of the `Real.Angle` corresponding to `x` (obtained by considering `x` as an angle in radians) is equal to the value of the real cosine function at `x`. Formally, if `↑x` denotes the conversion of `x` from a real number to a `Real.Angle`, then `Real.Angle.cos ↑x = Real.cos x` for all real numbers `x`.

For every real number `x`, the cosine of the angle `x` in radians is equal to the cosine of `x` as a real number, i.e., `Real.Angle.cos (Real.pi * x / 180) = Real.cos x`.


theorem Nat.eq_zero_of_le_zero : ∀ {n : ℕ}, n ≤ 0 → n = 0 := by sorry

This theorem states that for any natural number `n`, if `n` is less than or equal to zero, then `n` must be equal to zero. In other words, there is no natural number less than zero, so if a natural number is not greater than zero, it must be zero itself.

For all natural numbers n, if n ≤ 0 then n = 0.


theorem pow_dvd_pow : ∀ {α : Type u_1} [inst : Monoid α] {m n : ℕ} (a : α), m ≤ n → a ^ m ∣ a ^ n := by sorry

This theorem, `pow_dvd_pow`, states that for any type `α` that is a monoid, for any natural numbers `m` and `n`, and for any element `a` of type `α`, if `m` is less than or equal to `n`, then `a` to the power `m` divides `a` to the power `n`. In other words, in a monoid, the power of an element to a smaller or equal exponent always divides the power of that element to a greater or equal exponent.

For all monoids type `α`, natural numbers `m ≤ n`, and elements `a` of `α`, `a^m` divides `a^n`.


theorem isClosed_Ici :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIciTopology α] {a : α},
      IsClosed (Set.Ici a) :=
  by sorry

The theorem `isClosed_Ici` states that for any type `α`, given a topology `TopologicalSpace α`, a total order `Preorder α`, and a topology `ClosedIciTopology α` where left-closed right-infinite intervals are closed, if `a` is an element of type `α`, then the left-closed right-infinite interval starting at `a`, denoted `Set.Ici a`, is a closed set in the topological space `α`. In other terms, this theorem asserts that under these conditions, the set of all elements `x` in `α` such that `a ≤ x` forms a closed set.

Given a topological space `α` with a total order and a ClosedIciTopology where left-closed right-infinite intervals are closed, the left-closed right-infinite interval `Set.Ici a` is a closed set for any element `a` in `α`.


/-- The `AddSubgroup` generated by a set includes the set. -/
theorem AddSubgroup.subset_closure : ∀ {G : Type u_1} [inst : AddGroup G] {k : Set G}, k ⊆ ↑(AddSubgroup.closure k) :=
  by sorry

This theorem states that, for any additive group `G` and any set `k` of elements of `G`, the set `k` is a subset of the additive subgroup generated by `k`. In simpler terms, this means that every element of the set `k` is also an element of the subgroup created by taking all possible sums (with repetition) of elements from `k`.

For any additive group G and subset k of its elements, k is contained in the additive subgroup generated by k.


theorem Set.Finite.cast_ncard_eq : ∀ {α : Type u_1} {s : Set α}, Set.Finite s → ↑(Set.ncard s) = Set.encard s := by
  sorry

This theorem states that, for any type `α` and any set `s` of type `α`, if `s` is finite, then the cardinality of `s` (as a natural number and converted to an extended natural number) is equal to the cardinality of `s` as an extended natural number. In simpler terms, it states that the conversion of the number of elements in a finite set `s` to an extended natural number is equivalent to the direct computation of the number of elements in `s` as an extended natural number.

For any finite set `s` of type `α`, the cardinality of `s` as a natural number equals its cardinality as an extended natural number.


MeasureTheory.Integrable.sub

theorem MeasureTheory.Integrable.sub :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f g : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → MeasureTheory.Integrable (f - g) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.sub` states that for any measure space `α`, normed addition-commutative group `β`, measurable function `f` and `g` from `α` to `β`, and measure `μ` on `α`, if `f` and `g` are both integrable with respect to `μ`, then the function `f - g` is also integrable with respect to `μ`. In other words, the difference between two integrable functions is also integrable.

If `f` and `g` are integrable functions from a measure space to a normed addition-commutative group with respect to a given measure, then their difference `f - g` is also an integrable function.


theorem Bool.not_false : (!false) = true := by sorry

This theorem states that the logical negation of "false" (`!false`), in Boolean logic, is "true". It mirrors the standard truth table for logical NOT, where NOT false equals true. In simpler terms, it's a formal expression of the fact that if something is not false, then it must be true.

The logical negation of false is true. (`!false = true`)


theorem Polynomial.map_zero :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S), Polynomial.map f 0 = 0 := by
  sorry

This theorem, `Polynomial.map_zero`, states that for any given ring homomorphism `f` from a semiring `R` to another semiring `S`, the map of the zero polynomial, under `f`, is still the zero polynomial. In mathematical terms, given a ring homomorphism `f : R → S`, we have that `f` maps the zero polynomial to the zero polynomial, i.e., `f(0) = 0`. Here, `Polynomial.map` is a function that applies a ring homomorphism to the coefficients of a polynomial.

Given a ring homomorphism `f : R -> S`, the map of the zero polynomial under `f` is the zero polynomial, i.e., `f(0) = 0`.


theorem Pi.smul_apply :
    ∀ {I : Type u} {β : Type u_2} {f : I → Type v₁} [inst : (i : I) → SMul β (f i)] (b : β) (x : (i : I) → f i) (i : I),
      (b • x) i = b • x i :=
  by sorry

This theorem states that for any index set `I`, any type `β`, and any function `f` from `I` to some type `v₁`, given a scalar multiplication instance on `(f i)` for each `i` in `I`, a scalar `b` of type `β`, and a function `x` from `I` to `f i`, the result of scalar multiplication applied to `x` at a particular index `i` is the same as scalar multiplying the result of `x` evaluated at `i`. Essentially, it is the formalization of the rule of distribution of scalar multiplication over a function in a product space.

For any index set `I`, type `β`, function `f` from `I` to some type `v₁`, scalar multiplication instance on `(f i)` for each `i` in `I`, scalar `b` of type `β`, and function `x` from `I` to `f i`, we have `b * (x i) = x i * b`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.2 :
    ∀ {α : 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 : α}, (-a ≤ 0) = (0 ≤ a) :=
  by sorry

This theorem, from the Mathlib library in Lean 4, states a property of additive groups with a total order. Specifically, it says that for any element 'a' of such a group, the inequality 'negative a is less than or equal to 0' is equivalent to '0 is less than or equal to a'. This theorem is essentially stating that negating 'a' and comparing it to zero gives the same result as comparing zero to 'a' in the given order structure.

For any additive group with a total order, the element 'a' is less than or equal to zero if and only if the negative of 'a' is less than or equal to zero.


Filter.EventuallyLE.trans

theorem Filter.EventuallyLE.trans :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f g h : α → β}, f ≤ᶠ[l] g → g ≤ᶠ[l] h → f ≤ᶠ[l] h :=
  by sorry

This theorem, named `Filter.EventuallyLE.trans`, establishes the transitivity of the "eventually less than or equal to" (`≤ᶠ[l]`) relation over functions `f`, `g`, and `h` from a type `α` to a type `β`, given a preorder on `β` and a filter `l` on `α`. In simpler terms, it states that if `f` is eventually less than or equal to `g` under filter `l`, and `g` is eventually less than or equal to `h` under the same filter, then `f` is eventually less than or equal to `h` under filter `l`. This aligns with the concept of transitivity in mathematics.

If `f ≤ᶠ[l] g` and `g ≤ᶠ[l] h` for functions `f, g, h : α → β` and filter `l` on `α`, then `f ≤ᶠ[l] h`.


theorem BoxIntegral.Prepartition.le_of_mem :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I), J ∈ π → J ≤ I := by sorry

This theorem states that for any type `ι`, and any `I` and `J` that are boxes in `ι` (i.e., multidimensional intervals), if `π` is a prepartition of box `I` and box `J` is a member of this prepartition, then `J` is a subbox of `I`. In other words, every box in a prepartition of a given box is contained within that given box.

For any type `ι`, and for any prepartition `π` of boxes in `ι`, if box `J` is an element of `π` and `I` is the box containing `J`, then `J` is a subbox of `I`.


theorem inner_smul_left :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y : E) (r : 𝕜), ⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜 :=
  by sorry

This theorem, `inner_smul_left`, establishes a property of the inner product operation in the context of an inner product space `E` over a field `𝕜` with a `RCLike` (Regularity and Completeness Like) structure. Specifically, it states that for any two vectors `x` and `y` in `E` and any scalar `r` in `𝕜`, the inner product of the scaled vector `r • x` and `y` is equal to the product of the conjugate of the scalar `r` (represented by `(starRingEnd 𝕜) r`) and the inner product of the original vectors `x` and `y`. This theorem thus encapsulates a form of homogeneity property of the inner product with respect to scalar multiplication.

For any inner product space E over a field 𝕜 with a RCLike structure, the inner product of a scalar r times a vector x with a vector y is equal to the product of the conjugate of r and the inner product of x and y. In Lean notation, `(∥x, y∥ = (starRingEnd 𝕜) r * ∥x, y∥)`.


theorem extChartAt_source :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (I : ModelWithCorners 𝕜 E H) [inst_5 : ChartedSpace H M] (x : M),
      (extChartAt I x).source = (chartAt H x).source :=
  by sorry

The theorem `extChartAt_source` states that for any nontrivially normed field '𝕜', normed additive commutative group 'E', topological spaces 'H' and 'M', model with corners 'I', and charted space with model 'H' on 'M', and any point 'x' in 'M', the source set of the extended chart at 'x' is equal to the source set of the preferred chart at 'x'. Here, a chart gives a local homeomorphism between the manifold 'M' and the model space 'H', and an extended chart is a chart that has been extended to the boundary of the model space.

For any nontrivially normed field '𝕜', normed additive commutative group 'E', topological spaces 'H' and 'M', model with corners 'I', charted space with model 'H' on 'M', and point 'x' in 'M' with chart and extended chart, the source sets of the chart and extended chart at 'x' are equal.


theorem List.map_cons :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (a : α) (l : List α), List.map f (a :: l) = f a :: List.map f l := by
  sorry

The theorem `List.map_cons` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, any element `a` of type `α`, and any list `l` of type `List α`, the operation of mapping the function `f` over the list that results from appending `a` to the start of `l`, is the same as appending the function `f` applied to `a` to the start of the list that results from mapping `f` over `l`. In other words, the function `f` can be applied before or after appending an element to a list, and the result will be the same.

For all types `α` and `β`, and for any function `f` from `α` to `β`, the operation of appending `f(a)` to the front of `List.map f l` is equal to applying `f` to `a` and then appending the result to the front of `l`.


theorem WithTop.coe_lt_top : ∀ {α : Type u_1} [inst : LT α] (a : α), ↑a < ⊤ := by sorry

This theorem states that for any type `α` that has a less than (`LT`) relation and given any element `a` of type `α`, the coersion of `a` (`↑a`) is always less than positive infinity (`⊤`). In other words, for all possible types with a less than operation, any value from that type is less than infinity when considered in the extended number system (which includes positive infinity).

For any type `α` with a `LT` relation, and for all `a : α`, `↑a < ⊤`.


theorem Complex.ofReal_sub : ∀ (r s : ℝ), ↑(r - s) = ↑r - ↑s := by sorry

This theorem states that for all real numbers `r` and `s`, the complex representation of the difference between `r` and `s` is equal to the difference of the complex representations of `r` and `s`. In other words, the operation of subtraction is preserved under the function that maps real numbers to their complex counterparts.

For all real numbers r and s, (r : ℝ) → ℂ) (s : ℝ) := ⇑(-) r s = ((-): ℝ → ℝ → ℝ) r s : ℂ, where (-) is real number subtraction and (-) is complex number subtraction.


theorem Finite.of_injective :
    ∀ {α : Sort u_4} {β : Sort u_5} [inst : Finite β] (f : α → β), Function.Injective f → Finite α := by sorry

The theorem `Finite.of_injective` states that for any types `α` and `β`, if `β` is finite and there exists an injective function `f` from `α` to `β`, then `α` is also finite. In other words, if we have a function `f` such that for all elements `x` and `y` in `α`, if `f(x) = f(y)`, then `x = y`, and if the codomain `β` of this function is finite, then the domain `α` is also finite. This theorem connects the concept of injective functions with the finiteness property of sets in the context of mathematical logic and type theory.

If `β` is a finite type and there exists an injective function from `α` to `β`, then `α` is also finite.


theorem Subalgebra.algebraMap_mem :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (S : Subalgebra R A) (r : R), (algebraMap R A) r ∈ S :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `A`, and algebra structure of `R` on `A`, if we have a subalgebra `S` of `A` over `R` and any element `r` of `R`, then the algebra map (which is a ring homomorphism) of `r` from `R` to `A` is in `S`. Essentially, this means that the image of any element from the base ring `R` under the algebra map is always in the subalgebra `S`. This is a fundamental property of subalgebras.

For any commutative semiring `R`, semiring `A`, algebra structure of `R` on `A`, subalgebra `S` of `A` over `R`, and element `r` in `R`, the algebra map of `r` from `R` to `A` belongs to `S`.


theorem Filter.mem_principal_self : ∀ {α : Type u} (s : Set α), s ∈ Filter.principal s := by sorry

The theorem `Filter.mem_principal_self` states that for any type `α` and any set `s` of type `α`, the set `s` is a member of its own principal filter. In other words, considering the principal filter as a collection of all supersets of `s`, `s` is always a superset of itself, and therefore belongs to its own principal filter.

For any set `s` of type `α`, `s` is a subset of its principal filter.


WittVector.ext

theorem WittVector.ext : ∀ {p : ℕ} {R : Type u_1} {x y : WittVector p R}, (∀ (n : ℕ), x.coeff n = y.coeff n) → x = y :=
  by sorry

The theorem `WittVector.ext` states that for any prime number `p`, any type `R`, and any two Witt vectors `x` and `y` over `R` with coefficients in the natural numbers, if the coefficients of `x` and `y` are equal for all natural numbers, then `x` and `y` are the same Witt vector. In more mathematical terms, this theorem asserts the uniqueness of Witt vectors: two Witt vectors are equal if and only if their coefficients are equal for all indices in the set of natural numbers.

Given any prime number `p` and types `R` and `W` for Witt vectors over `R` with coefficients in the natural numbers, two Witt vectors `x` and `y` over `R` are equal if and only if their corresponding coefficient sequences are equal.


theorem Filter.tendsto_comap :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x : Filter β}, Filter.Tendsto f (Filter.comap f x) x := by sorry

The theorem `Filter.tendsto_comap` states that for all types `α` and `β`, for all functions from `α` to `β` denoted as `f`, and for all filters on `β` denoted as `x`, the function `f` tends to the filter `x` when composed with the preimage under `f` of filter `x`. In simple terms, applying `f` to the preimages of the elements of `x` under `f` will map us back into the neighborhood of `x`. This confirms that the function `f` respects the filter structure and it's a fundamental property in filter theory.

For any type `α` and function `f` from `α` to `β`, and filter `x` on `β`, if `f` tends to `x`, then the preimage `f⁁⁻¹(x)` under `f` also tends to `x`.


theorem Ideal.gc_map_comap :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F), GaloisConnection (Ideal.map f) (Ideal.comap f) :=
  by sorry

This theorem states that for any given types `R`, `S` and `F` with `R` and `S` being semirings and `F` behaving like a function from `R` to `S` (i.e., a `FunLike` from `R` to `S`), and given a `RingHomClass` instance from `R` to `S`, there is a Galois connection between the `Ideal.map` with regard to a function `f` and the `Ideal.comap` with regard to the same function `f`. In simpler terms, it asserts that the mapping of ideals from `R` to `S` and the preimage of ideals from `S` to `R` form a Galois connection, a specific relationship characterized by the property `l a ≤ b ↔ a ≤ u b` where `l` and `u` are the two functions forming the Galois connection.

Given semirings `R`, `S`, a `FunLike` `F` from `R` to `S`, and a ring homomorphism `h : R → S`, there exists a Galois connection between `Ideal.map` and `Ideal.comap` with respect to `F` and `h`.


theorem continuous_of_discreteTopology :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : DiscreteTopology α] {β : Type u_2}
      [inst_2 : TopologicalSpace β] {f : α → β}, Continuous f :=
  by sorry

This theorem states that for any two types `α` and `β` where `α` is equipped with a topological space structure and a discrete topology, and `β` is equipped with a topological space structure, any function `f` from `α` to `β` is continuous. Essentially, this means if we have a space with a discrete topology, any function mapping from this space to another topological space is guaranteed to be continuous.

For any types `α` and `β` with discrete topologies, and any function `f : α → β`, `f` is continuous.


theorem Mathlib.Data.DFinsupp.Basic._auxLemma.16 :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (f : Π₀ (i : ι), β i) (i : ι),
      (i ∈ DFinsupp.support f) = (f i ≠ 0) :=
  by sorry

The given theorem states that for any types `ι` and `β` mapping `ι` to `β`, given that `ι` has decidable equality, and that every `i` in `ι` maps to a zero of `β` and for each `i` in `ι` and `x` in `β i`, `x ≠ 0` is decidable, then for any function `f` of type `(Π₀ (i : ι), β i)` and any `i` in `ι`, `i` is in the support of `f` if and only if `f i` is not equal to zero. In other words, the support of `f` is exactly the set of `i` in `ι` such that `f i` is not zero.

The support of a function `f` from a type `ι` to a type `β`, where `β` maps `ι` to itself and every element of `ι` maps to a non-zero element of `β`, is equal to the subset of `ι` consisting of elements mapping to non-zero values.


Setoid.trans

theorem Setoid.trans : ∀ {α : Sort u} [inst : Setoid α] {a b c : α}, a ≈ b → b ≈ c → a ≈ c := by sorry

This theorem states the transitivity property of a Setoid. In the context of any type `α` with a Setoid structure, for any three values `a`, `b`, and `c` of type `α`, if `a` is equivalent to `b` and `b` is equivalent to `c`, then `a` is equivalent to `c`. This is essentially a formalization of the transitivity of equivalence relations in the context of Setoids.

If `α` is a type with a Setoid structure and `a`, `b`, and `c` are elements of `α`, then `a ≈ b` and `b ≈ c` imply `a ≈ c`.


theorem uniformContinuous_sub :
    ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : UniformAddGroup α],
      UniformContinuous fun p => p.1 - p.2 :=
  by sorry

The theorem `uniformContinuous_sub` states that for all types `α` that have a uniform space structure, an additive group structure, and a uniform additive group structure, the function that takes a pair of elements of `α` and subtracts the second element from the first is uniformly continuous. In other words, if `x` and `y` are sufficiently close in the uniform space `α`, then the difference `x - y` also approaches zero, regardless of the specific location of `x` and `y` in `α`.

For any uniform space `α` equipped with an additive group and a uniform additive group structure, the function subtracting the second element from the first is a uniformly continuous additive homomorphism.


theorem sup_le_sup_left : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a ≤ b → ∀ (c : α), c ⊔ a ≤ c ⊔ b := by
  sorry

This theorem, `sup_le_sup_left`, states that for any type `α` that is a semilattice with an operation `sup` (supremum), and for any elements `a`, `b`, and `c` of this type, if `a` is less than or equal to `b`, then the supremum of `c` and `a` is less than or equal to the supremum of `c` and `b`. In simpler terms, if `a` is less than or equal to `b`, replacing `a` with `b` in the supremum with `c` will not decrease the overall value. This is a property of the supremum operation in semilattices.

For any semilattice `α` with supremum operation `sup`, and for all `a`, `b`, `c` in `α` with `a ≤ b`, we have `sup c a ≤ sup c b`.


theorem Polynomial.eq_C_of_degree_le_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.degree p ≤ 0 → p = Polynomial.C (Polynomial.coeff p 0) :=
  by sorry

This theorem states that for any polynomial `p` over a semiring `R`, if the degree of `p` is less than or equal to 0, then `p` is equal to the constant polynomial `C` with the coefficient of `p` at 0. In other words, if a polynomial has no terms of degree higher than zero, then it is a constant polynomial, and its value is equal to its coefficient at 0.

For any polynomial `p` over a semiring `R` of degree zero or less, `p` equals the constant polynomial with coefficient `p.0`.


theorem continuousAt_const :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x : X} {y : Y},
      ContinuousAt (fun x => y) x :=
  by sorry

This theorem, named `continuousAt_const`, states that for any two types `X` and `Y` both equipped with a topological space structure, a function that maps any element `x` from `X` to a fixed element `y` from `Y` is continuous at `x`. In mathematical terms, it asserts that a constant function is always continuous at any point in its domain.

For any topological spaces X and Y and any fixed y : Y, the constant function from X to y is continuous.


theorem Set.compl_inter : ∀ {α : Type u} (s t : Set α), (s ∩ t)ᶜ = sᶜ ∪ tᶜ := by sorry

This theorem states that for any two sets `s` and `t` of some type `α`, the complement of the intersection of `s` and `t` (denoted as `(s ∩ t)ᶜ`) is equal to the union of the complements of `s` and `t` (denoted as `sᶜ ∪ tᶜ`). This theorem is a formalization of one of the De Morgan's laws from set theory in Lean 4.

The complement of the intersection of sets `s` and `t` equals the union of their complements: `(s ∩ t)ᶜ = sᶜ ∪ tᶜ`.


theorem ENNReal.toReal_mul : ∀ {a b : ENNReal}, (a * b).toReal = a.toReal * b.toReal := by sorry

This theorem states that for all extended nonnegative real numbers `a` and `b`, the real part of the product of `a` and `b` is equal to the product of the real parts of `a` and `b`. In other words, when we multiply two extended nonnegative real numbers (which could possibly be infinite) and then take the real part, it's the same as if we had first taken the real part of each number and then multiplied them. This theorem is crucial when working with measures, as it ensures that the multiplication operation is compatible with real numbers and extended nonnegative real numbers.

For all extended nonnegative real numbers `a` and `b`, the real part of their product equals the product of their real parts.


theorem Nat.pow_zero : ∀ (n : ℕ), n ^ 0 = 1 := by sorry

This theorem states that any natural number raised to the power of zero is equal to one. That is, for any natural number 'n', 'n' to the power of 0 is 1. This is consistent with the mathematical law that any non-zero number raised to the power of zero equals one.


theorem div_lt_iff : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < c → (b / c < a ↔ b < a * c) :=
  by sorry

This theorem, `div_lt_iff`, applies to any type `α` that is a "linear ordered semifield", i.e., a field defined on a totally ordered set. The theorem states that for any three elements `a`, `b`, and `c` of this field where `c` is greater than zero, the inequality `b / c < a` is equivalent to `b < a * c`. In other words, dividing `b` by `c` and comparing the result to `a` is the same as comparing `b` to the product of `a` and `c`.

For any linear ordered semifield type `α` and elements `a`, `b`, and `c` of `α` where `c` is positive, `b / c < a` if and only if `b < a * c`.


theorem not_nontrivial_iff_subsingleton : ∀ {α : Type u_1}, ¬Nontrivial α ↔ Subsingleton α := by sorry

This theorem states that for any type `α`, `α` is not nontrivial if and only if `α` is a subsingleton. In other words, for a given type, there is no pair of distinct elements (i.e., it is not nontrivial) if and only if every pair of elements in the type are identical (i.e., it is a subsingleton). This theorem bridges the concept of nontriviality and subsingularity in type theory.

A type `α` is not nontrivial if and only if it is a subsingleton.


theorem and_true_iff : ∀ (p : Prop), p ∧ True ↔ p := by sorry

The theorem `and_true_iff` states that for any proposition `p`, the conjunction of `p` and `True` is logically equivalent to `p` itself. This is based on the logical trait of True, which doesn't affect the truth value when conjoined with any other proposition. Essentially, it says that if you have a statement and true, it's just the same as the statement by itself.

For all propositions p, p ∧ True is logically equivalent to p.


theorem Set.inter_subset_inter_right : ∀ {α : Type u} {s t : Set α} (u : Set α), s ⊆ t → u ∩ s ⊆ u ∩ t := by sorry

The theorem `Set.inter_subset_inter_right` states that for all types `α`, and for any sets `s`, `t`, and `u` of type `α`, if set `s` is a subset of set `t`, then the intersection of set `u` and set `s` is a subset of the intersection of set `u` and set `t`. In terms of set theory, this means that if we have a set that intersects both `s` and `t`, and `s` is entirely contained within `t`, then the intersection with `s` is also entirely contained within the intersection with `t`.

If `s` is a subset of `t`, then `s ∩ u` is a subset of `t ∩ u`.


theorem Array.size_set :
    ∀ {α : Type u} (a : Array α) (i : Fin (Array.size a)) (v : α), Array.size (Array.set a i v) = Array.size a := by
  sorry

The theorem `Array.size_set` states that for all types `α`, given an array `a` of type `α`, an element `v` of type `α`, and an index `i` which is a valid index for `a` (i.e., it is a member of the finite set `Fin (Array.size a)`), the size of the array that results from setting the element at index `i` of `a` to `v` is equal to the size of the original array `a`. In other words, updating the value of an element in an array does not change the size of the array.

For all types `α` and arrays `a` of length `n` over `α`, setting the `i`-th element of `a` to a new value does not change the length `n` of `a`.


/-- Embedding `i : Fin n` into `Fin (n + 1)` with a hole around `p : Fin (n + 1)`
embeds `i` by `castSucc` when the resulting `i.castSucc < p`.  -/
theorem Fin.succAbove_of_castSucc_lt :
    ∀ {n : ℕ} (p : Fin (n + 1)) (i : Fin n), Fin.castSucc i < p → Fin.succAbove p i = Fin.castSucc i := by sorry

This theorem states that for any natural number `n` and any two elements `p` from `Fin (n + 1)` and `i` from `Fin n`, if embedding `i` into `Fin (n + 1)` using the function `castSucc` results in a value that is less than `p`, then embedding `i` into `Fin (n + 1)` with a hole around `p` using the function `succAbove` is equivalent to the original embedding using `castSucc`. In other words, when the embedded value of `i` by `castSucc` is less than `p`, `succAbove` uses `castSucc` for embedding.

If `i < p` in `Fin (n + 1)`, then `succAbove i p = castSucc i`.


theorem Nat.dvd_one : ∀ {n : ℕ}, n ∣ 1 ↔ n = 1 := by sorry

This theorem states that for any natural number `n`, `n` divides 1 if and only if `n` is equal to 1. In terms of number theory, this means that 1 can only be divided evenly (i.e., without remainder) by the number 1 itself.

For any natural number n, n divides 1 if and only if n = 1.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.2 :
    ∀ {α : Type u_3} [inst : OrderedSemiring α] (n : ℕ), (0 ≤ ↑n) = True := by sorry

This theorem states that for any natural number `n` and any type `α` that forms an ordered semiring, the cast of `n` to `α` is always greater than or equal to zero. In mathematical terms, if we cast a natural number to a member of an ordered semiring, the result will always be non-negative.

For any natural number `n` and ordered semiring `α`, the coercion of `n` to `α` is non-negative.


theorem tsum_fintype :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Fintype β]
      (f : β → α), ∑' (b : β), f b = Finset.sum Finset.univ fun b => f b :=
  by sorry

The theorem `tsum_fintype` states that for any types `α` and `β`, where `α` is a commutative monoid with a topology and `β` is a finite type, and for any function `f` from `β` to `α`, the infinite sum (notated as `∑' (b : β), f b`) equals the sum of `f b` as `b` ranges over the universal finite set of type `β`. In other words, for finite types, the infinite series sum is equivalent to the sum taken over all elements of the type.

For any commutative monoid with a topology `α`, finite type `β`, and function `f` from `β` to `α`, the infinite sum `∑' (b : β), f b` equals the sum of `f b` over all elements in `β`.


theorem Nat.mul_div_cancel' : ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` divides `m` (denoted by `n ∣ m`), then the product of `n` and the quotient of `m` divided by `n` (expressed as `n * (m / n)`) equals `m`. Simply put, we multiply the divisor `n` with the result of integer division of `m` by `n`, and it equals the original dividend `m`. This matches with the concept in mathematics that when we divide a number by another and then multiply the result by the divisor, we should get back our initial number.

For all natural numbers `n` and `m`, `n * (m / n) = m` when `n` divides `m`.


List.Sublist.refl

theorem List.Sublist.refl : ∀ {α : Type u_1} (l : List α), List.Sublist l l := by sorry

This theorem states that, for any type `α` and any list `l` of values of that type, the list `l` is a sublist of itself. In other words, every list is considered a sublist of itself in Lean 4.

For any type `α` and any list `l` of length `n` over `α`, `l` is a sublist of itself.


theorem mul_lt_mul_iff_right :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] (a : α) {b c : α},
      b * a < c * a ↔ b < c :=
  by sorry

The theorem `mul_lt_mul_iff_right` states that for any type `α` equipped with a multiplication operation and a less-than relation, and which satisfies the properties of being a covariant and a contravariant class under multiplication (i.e., multiplication preserves the order), if you have three elements `a`, `b`, and `c` of this type, then `b` times `a` is less than `c` times `a` if and only if `b` is less than `c`. This essentially states that multiplication by a fixed element on the right-hand side preserves the order of elements.

For any type equipped with a multiplication and a total order such that multiplication is covariant and contravariant, the relation a \* b < a \* c holds if and only if b < c.


theorem Bool.not_true : (!true) = false := by sorry

This theorem states that the logical negation of true, denoted as '!true' in Lean 4, is equal to false. In other words, if we negate or reverse the boolean value 'true', we obtain 'false'.

The logical negation of true is equal to false. (or) !true = false in Lean 4.


theorem IsScalarTower.algebraMap_eq :
    ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
      [inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R S A],
      algebraMap R A = RingHom.comp (algebraMap S A) (algebraMap R S) :=
  by sorry

The theorem `IsScalarTower.algebraMap_eq` states that, for any three types `R`, `S`, and `A` where `R` and `S` are commutative semirings, `A` is a semiring, `R` and `S` are algebras over `A`, and `R`,`S` and `A` form a scalar tower, the algebra map from `R` to `A` is equal to the composition of the algebra map from `S` to `A` and the algebra map from `R` to `S`. In other words, if we have a scalar tower, then mapping a scalar from the base of the tower to the top of the tower directly or going through an intermediate level yields the same result.

For any commutative semirings R, S, and semiring A with R, S algebra extensions, if R, S, and A form a scalar tower, then the algebra map from R to A equals the composition of the algebra maps from S to A and R to S.


theorem Mathlib.Order.Lattice._auxLemma.13 :
    ∀ {α : Type u} [inst : SemilatticeInf α] {a b c : α}, (a ≤ b ⊓ c) = (a ≤ b ∧ a ≤ c) := by sorry

This theorem, titled `Mathlib.Order.Lattice._auxLemma.13`, states that for any type `α` which has a structure of a semilattice with respect to an infimum operation (denoted as `⊓`), for any three elements `a`, `b`, and `c` of this type, `a` is less than or equal to the infimum of `b` and `c` if and only if `a` is less than or equal to `b` and `a` is less than or equal to `c`. This encapsulates the fundamental property of the infimum in a semilattice, which is the greatest lower bound of a set.

For any semilattice `α` with infimum operation `⊓`, for all `a, b, c ∈ α`, `a ≤ b ∧ a ≤ c` if and only if `a ≤ b⊓c`.


theorem MeasureTheory.IntegrableOn.mono_set :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s t : Set α}
      {μ : MeasureTheory.Measure α}, MeasureTheory.IntegrableOn f t μ → s ⊆ t → MeasureTheory.IntegrableOn f s μ :=
  by sorry

The theorem `MeasureTheory.IntegrableOn.mono_set` states that for any two sets `s` and `t` of a certain type `α`, given that we have a measurable space over `α` and a normed additive commutative group over another type `E`, if a function `f` from `α` to `E` is integrable on the set `t` with respect to a measure `μ`, and the set `s` is a subset of `t`, then the function `f` is also integrable on the set `s` with respect to the same measure `μ`. In other words, if a function is integrable over a larger set, it is also integrable over any of its subsets.

If `f` is integrable over the set `t` with respect to measure `μ` and `s` is a subset of `t`, then `f` is integrable over the set `s` with respect to `μ`.


theorem Finset.subset_union_right : ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₂ ⊆ s₁ ∪ s₂ := by sorry

The theorem `Finset.subset_union_right` states that for any given type `α` that has decidable equality, and any two finite sets (`Finset`) `s₁` and `s₂` of type `α`, the set `s₂` is a subset of the union of `s₁` and `s₂`. This is a basic property of sets, which essentially says that if you take a set and union it with another set, the resulting set will always contain the second set.

For any type `α` with decidable equality and finite sets `s₁` and `s₂` of type `Finset α`, `s₂` is a subset of `s₁ ∪ s₂`.


theorem div_pow : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α) (n : ℕ), (a / b) ^ n = a ^ n / b ^ n := by
  sorry

This theorem, `div_pow`, states that for any type `α` that forms a division commutative monoid, for any elements `a` and `b` of type `α` and any natural number `n`, the nth power of the division of `a` by `b` is equal to the division of the nth power of `a` by the nth power of `b`. In mathematical notation, this would be expressed as $(a / b)^n = a^n / b^n$.

For any divisive commutative monoid type `α` and elements `a` and `b` of type `α`, the division of `a` by `b` raised to the power of a natural number `n` equals the power of `a` raised to `n` divided by the power of `b` raised to `n`.


CategoryTheory.Limits.colimit.w

theorem CategoryTheory.Limits.colimit.w :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      (F : CategoryTheory.Functor J C) [inst_2 : CategoryTheory.Limits.HasColimit F] {j j' : J} (f : j ⟶ j'),
      CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.Limits.colimit.ι F j') =
        CategoryTheory.Limits.colimit.ι F j :=
  by sorry

This theorem, named `CategoryTheory.Limits.colimit.w`, is a fundamental property of colimits in category theory. It states that for any category `J`, any category `C`, any functor `F` from `J` to `C` that has a colimit, and any morphism `f` from an object `j` to an object `j'` in `J`, the composition of the image of `f` under `F` and the co-projection from the image of `j'` under `F` to the colimit of `F` is equal to the co-projection from the image of `j` under `F` to the colimit of `F`. In other words, the following diagram commutes in the category `C`:
```
F.obj j --(F.map f)--> F.obj j' --(colimit.ι F j')--> colimit F
  |                                               |
  |------------------(colimit.ι F j)--------------|
```

Given a category `C`, a functor `F` from a small category `J` to `C` with a colimit, and morphisms `f : j -> j'` in `J`, the diagram of `F` commutes at the colimit, i.e., `F.map f ∘ colimit.ι F j = colimit.ι F j'`.


theorem Set.toFinset_congr :
    ∀ {α : Type u_1} {s t : Set α} [inst : Fintype ↑s] [inst_1 : Fintype ↑t], s = t → Set.toFinset s = Set.toFinset t :=
  by sorry

The theorem `Set.toFinset_congr` states that for any two sets `s` and `t` of the same type `α`, if these two sets are equal (denoted as `s = t`), and both have `Fintype` instances, then their corresponding finite sets (or `Finset`) obtained using the `Set.toFinset` function are also equal. In other words, the `Set.toFinset` function preserves set equality.

If two sets `s` and `t` of type `α` are equal (`s = t`) and have `Fintype` instances, then their corresponding finite sets obtained using `Set.toFinset` are also equal (`Set.toFinset s = Set.toFinset t`).


theorem CategoryTheory.Limits.Cofork.IsColimit.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      {s : CategoryTheory.Limits.Cofork f g},
      CategoryTheory.Limits.IsColimit s →
        ∀ {W : C} {k l : s.pt ⟶ W},
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π s) k =
              CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.π s) l →
            k = l :=
  by sorry

This theorem is stating that in any category `C`, given two morphisms `f` and `g` from `X` to `Y`, and a cofork `s` on `f` and `g`, if `s` is a colimit, then for any object `W` in the category, and any two morphisms `k` and `l` from the point of `s` to `W`, if the composition of the projection of `s` and `k` is equal to the composition of the projection of `s` and `l`, then `k` and `l` must be the same morphism. In other words, this is a uniqueness condition on morphisms from the tip of a cofork that is a colimit.

Given any category `C`, if morphisms `f` and `g` from object `X` to object `Y` have a cofork `s` that is a colimit, then any two morphisms `k` and `l` from the object at the tip of `s` to any object `W` with `proj(s) ∘ k = proj(s) ∘ l` imply `k = l`.


theorem lt_imp_lt_of_le_imp_le :
    ∀ {α : Type u} {β : Type u_3} [inst : LinearOrder α] [inst_1 : Preorder β] {a b : α} {c d : β},
      (a ≤ b → c ≤ d) → d < c → b < a :=
  by sorry

This theorem states that for any types `α` and `β` with a linear order and a preorder respectively, given two elements `a` and `b` of type `α`, and two elements `c` and `d` of type `β`, if it is the case that whenever `a` is less than or equal to `b` then `c` is less than or equal to `d`, then if `d` is less than `c`, it must be that `b` is less than `a`. Essentially, this theorem shows that a certain relationship between `a` and `b` implies a corresponding relationship between `c` and `d`, and vice versa.

If `α` is a type with a linear order, and `β` is a type with a preorder, if `a ≤ b` in `α` implies `c ≤ d` in `β`, then `d < c` implies `b < a`.


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

The theorem `OrderIso.symm_symm` states that for any two types `α` and `β`, both equipped with an order relation (`LE`), given an order isomorphism `e` from `α` to `β`, the double application of the operation `OrderIso.symm` (which takes the inverse of an order isomorphism) to `e` gives back `e`. Essentially, this theorem ensures that taking the inverse twice gives you the original order isomorphism.

For any order isomorphism `e` between types `α` and `β` equipped with order relations `LEα` and `LEβ` respectively, we have `OrderIso.symm (OrderIso.symm e) = e`.


theorem smul_le_smul_of_nonneg_right :
    ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
      [inst_3 : Zero β] [inst_4 : SMulPosMono α β], a₁ ≤ a₂ → 0 ≤ b → a₁ • b ≤ a₂ • b :=
  by sorry

This theorem states that for any types `α` and `β`, along with any two elements `a₁` and `a₂` of type `α` and an element `b` of type `β`, given that there is a scalar multiplication operation defined on `α` and `β`, and assuming `α` and `β` are both preordered (i.e., they have a less than or equal to relation defined that is reflexive and transitive), and `β` has a zero element, and the scalar multiplication is positive monotonic (meaning that if `a₁` is less than or equal to `a₂`, then `a₁` multiplied by any positive `b` is less than or equal to `a₂` multiplied by `b`), then if `a₁` is less than or equal to `a₂` and `b` is non-negative, `a₁ • b` is less than or equal to `a₂ • b`.

If `α` and `β` are preordered types with zero elements and scalar multiplication is positive monotonic, then for any `a₁ ≤ a₂` in `α` and non-negative `b` in `β`, `a₁ • b ≤ a₂ • b`.


theorem Int.le_trans : ∀ {a b c : ℤ}, a ≤ b → b ≤ c → a ≤ c := by sorry

This theorem, `Int.le_trans`, states the transitive property of less than or equal to relation for integers. Specifically, for any three integers `a`, `b`, and `c`, if `a` is less than or equal to `b` and `b` is less than or equal to `c`, then it follows that `a` is less than or equal to `c`.

If `a ≤ b` and `b ≤ c`, then `a ≤ c`. (In other words, the transitive property holds for the integer less-than-or-equal-to relation.)


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

The theorem `gt_mem_nhds` states that for any two elements `a` and `b` of a certain type `α`, where `α` is equipped with a topological space structure, a preorder structure, and an order topology, if `a` is strictly less than `b`, then all elements `x` that are sufficiently close to `a` (i.e., within a neighborhood of `a`) are strictly less than `b`. Here, "sufficiently close" is defined in terms of the neighborhood filter `nhds`.

For any topological preorder space `(α, ≤, top)` with order topology `top`, if `a ≤ b` does not hold and `x ∈ nhds a`, then `x < b`.


theorem IsOfFinOrder.orderOf_pos : ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinOrder x → 0 < orderOf x := by
  sorry

The theorem `IsOfFinOrder.orderOf_pos` states that for any monoid `G` and an element `x` of that monoid, if `x` is of finite order, then the order of `x` is a positive integer. In other words, if there exists a non-zero natural number `n` such that `x^n = 1` in the monoid `G`, then the smallest such `n` (the order of `x`) is greater than zero.

In a monoid, if an element has finite order then its order is a positive integer.


theorem Mathlib.Data.Real.NNReal._auxLemma.18 : ∀ {r₁ r₂ : NNReal}, (↑r₁ ≤ ↑r₂) = (r₁ ≤ r₂) := by sorry

The theorem `Mathlib.Data.Real.NNReal._auxLemma.18` states that for any two nonnegative real numbers `r₁` and `r₂`, the inequality `r₁ ≤ r₂` holds if and only if the same inequality holds when `r₁` and `r₂` are coerced to real numbers. In other words, comparing two nonnegative real numbers using the `≤` operator on the original type `NNReal` is equivalent to comparing them using the `≤` operator on the type `Real`.

For any nonnegative real numbers `r₁` and `r₂`, `r₁ ≤ r₂` in `NNReal` if and only if `r₁.to Real ≤ r₂.to Real` in `Real`.


theorem ComplexShape.next_eq' :
    ∀ {ι : Type u_1} (c : ComplexShape ι) {i j : ι}, c.Rel i j → ComplexShape.next c i = j := by sorry

The theorem `ComplexShape.next_eq'` states that for any type `ι`, given a `ComplexShape` `c` of type `ι` and any two elements `i` and `j` of type `ι`, if the relation `Rel` defined on the `ComplexShape` `c` holds between `i` and `j`, then the `next` function on the `ComplexShape` `c` applied to `i` will return `j`. In simpler terms, if `j` is a "successor" of `i` according to the relationship defined by the `ComplexShape`, then the `next` function will return `j` when applied to `i`.

For any `ComplexShape` `c` and elements `i` and `j` of type `ι` in it, if `Rel` holds between `i` and `j` on `c`, then `next c i = j`.


/-- If one controls the norm of every `A x`, then one controls the norm of `A`.  -/
theorem ContinuousLinearMap.opNorm_le_bound :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} (f : E →SL[σ₁₂] F) {M : ℝ},
      0 ≤ M → (∀ (x : E), ‖f x‖ ≤ M * ‖x‖) → ‖f‖ ≤ M :=
  by sorry

This theorem states that for a continuous linear map `f` from a normed vector space `E` over a nontrivially normed field `𝕜` to a normed vector space `F` over another nontrivially normed field `𝕜₂`, if there exists a non-negative real number `M` such that the norm of `f(x)` is always less than or equal to `M` times the norm of `x` for all `x` in `E`, then the operator norm of `f` is less than or equal to `M`. In other words, if you can bound the norm of the image of any vector `x` by a constant times the norm of `x`, then you can bound the operator norm of the linear map by the same constant.

If a continuous linear map between two normed vector spaces satisfies the condition that the norm of its image is less than or equal to a constant times the norm of the input for all inputs, then the operator norm of the map is less than or equal to that constant.


theorem min_comm : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), min a b = min b a := by sorry

This theorem, named `min_comm`, states that for any type `α` that has a `LinearOrder` instance (meaning the type has a linear, or total, order), the minimum of two elements `a` and `b` of type `α` is the same regardless of the order in which `a` and `b` are considered. In other words, the operation of taking the minimum is commutative.

For any type `α` with a linear order and any elements `a` and `b` of type `α`, `min a b` is equal to `min b a`.


theorem Finsupp.support_single_ne_zero :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {b : M} (a : α), b ≠ 0 → (fun₀ | a => b).support = {a} := by sorry

This theorem, `Finsupp.support_single_ne_zero`, states that for any types `α` and `M` with `M` having a zero element, given a non-zero element `b` of type `M` and an element `a` of type `α`, the support (set of indices with non-zero values) of the function from `α` to `M` that maps `a` to `b` and all other elements to zero, is the singleton set containing only `a`. In other words, only the index `a` has a non-zero value (`b`) in this function.

Given a function from type `α` to type `M` with domain size one and image `{a ↔ b}`, where `M` has a zero element and `b ≠ 0`, the support of this function is the singleton set `{a}`.


theorem MeasureTheory.StronglyMeasurable.comp_measurable :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace β] {x : MeasurableSpace α}
      {x_1 : MeasurableSpace γ} {f : α → β} {g : γ → α},
      MeasureTheory.StronglyMeasurable f → Measurable g → MeasureTheory.StronglyMeasurable (f ∘ g) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.comp_measurable` states that for all types `α`, `β`, and `γ`, given a topological space over `β`, a measurable space over `α`, and another measurable space over `γ`, if we have a function `f` from `α` to `β` that is strongly measurable (i.e., it can be approximated by a sequence of simple functions) and a function `g` from `γ` to `α` that is measurable (i.e., the preimage of every measurable set under `g` is also measurable), then the composition of `f` and `g` (denoted by `f ∘ g`) is also strongly measurable. This implies that the property of being strongly measurable is preserved under composition with a measurable function.

If `f: α → β` is strongly measurable and `g: γ → α` is measurable, then the composition `f ∘ g: γ → β` is also strongly measurable.


theorem Filter.nonempty_of_mem :
    ∀ {α : Type u} {f : Filter α} [hf : Filter.NeBot f] {s : Set α}, s ∈ f → Set.Nonempty s := by sorry

The theorem `Filter.nonempty_of_mem` states that for any type `α`, any filter `f` of type `α` such that `f` is not the bottom filter (expressed via the `Filter.NeBot f` assumption), and any set `s` of type `α`, if `s` belongs to the filter `f` (expressed as `s ∈ f`), then the set `s` is not empty (expressed as `Set.Nonempty s`). In other words, if a set is in a non-bottom filter, it must contain at least one element.

If `α` is a type, `f` is a non-bottom filter on `α`, and `s ∈ f`, then `Set.Nonempty s`.


Function.Involutive.injective

theorem Function.Involutive.injective : ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.Injective f := by
  sorry

The theorem states that for any type `α` and any function `f` from `α` to `α`, if `f` is involutive (meaning applying `f` twice to any element yields the original element), then `f` is also injective (meaning that no two different elements of `α` are mapped to the same element by `f`). In mathematical terms, if for a function `f : α → α`, we have `f(f(x)) = x` for all `x` in `α`, this theorem guarantees that if `f(x) = f(y)` for some `x` and `y` in `α`, then necessarily `x = y`.

If a function from a type to itself is involutive (i.e., applying it twice to any element equals the original element), then it is injective (i.e., no two distinct elements are mapped to the same image).


theorem Finset.univ_eq_empty : ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : IsEmpty α], Finset.univ = ∅ := by sorry

The theorem `Finset.univ_eq_empty` states that for any arbitrary type `α`, given that `α` has a finite number of elements (as denoted by `Fintype α`) and `α` is empty (as denoted by `IsEmpty α`), the universal finite set of type `Finset α`, represented by `Finset.univ`, is identical to the empty set, denoted by `∅`. Essentially, if a type is empty, its corresponding universal finite set is also empty.

For any type `α` that is both finite and empty, `Finset.univ (Fintype α) = ∅`.


/-- To prove something about polynomials,
it suffices to show the condition is closed under taking sums,
and it holds for monomials.
 -/
theorem Polynomial.induction_on' :
    ∀ {R : Type u} [inst : Semiring R] {M : Polynomial R → Prop} (p : Polynomial R),
      (∀ (p q : Polynomial R), M p → M q → M (p + q)) → (∀ (n : ℕ) (a : R), M ((Polynomial.monomial n) a)) → M p :=
  by sorry

This theorem, `Polynomial.induction_on'`, states that for any type `R` equipped with a semiring structure, and any property `M` on polynomials with coefficients in `R`, to prove that a property `M` holds for all polynomials `p`, it is enough to show two things:

1. The property `M` is closed under addition, that is, if `M` holds for two polynomials `p` and `q`, then it also holds for the sum of `p` and `q`.
2. The property `M` holds for all monomials, i.e., for all polynomials of the form `a * X^n` for a coefficient `a` in `R` and a natural number `n`.

In other words, we can prove any property about polynomials by showing it's true for all monomials and also preserved under addition.

Given a semiring `R` and a property `M` on polynomials over `R`, if `M` holds for all monomials and is closed under polynomial addition, then `M` holds for all polynomials.


theorem CategoryTheory.Limits.PushoutCocone.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      (t : CategoryTheory.Limits.PushoutCocone f g),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.PushoutCocone.inl t) =
        CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.PushoutCocone.inr t) :=
  by sorry

The theorem `CategoryTheory.Limits.PushoutCocone.condition` states that for any category `C` and given three objects `X`, `Y`, `Z` within this category, and two morphisms `f : X ⟶ Y` and `g : X ⟶ Z`, for any pushout cocone `t` of `f` and `g`, the composition of `f` with the first inclusion of `t` (denoted as `CategoryTheory.Limits.PushoutCocone.inl t`) is equal to the composition of `g` with the second inclusion of `t` (denoted as `CategoryTheory.Limits.PushoutCocone.inr t`). This is a fundamental condition for the pushout cocone in category theory, ensuring that the diagram commutes.

For any category C and morphisms f : X ⟶ Y and g : X ⟶ Z in C, if t is a pushout cocone of f and g, then f ∘ CategoryTheory.Limits.PushoutCocone.inl t = g ∘ CategoryTheory.Limits.PushoutCocone.inr t.


CategoryTheory.Sieve.ext

theorem CategoryTheory.Sieve.ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
      (∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f) → R = S :=
  by sorry

This theorem is stating that in any category `C`, for any object `X` in `C` and any two sieves `R` and `S` on `X`, if for all objects `Y` in `C` and all morphisms `f` from `Y` to `X`, `f` is an arrow of sieve `R` if and only if `f` is an arrow of sieve `S`, then sieve `R` must be equal to sieve `S`. In other words, two sieves on the same object are equal if they have the same set of morphisms.

In any category, two sieves on an object are equal if and only if they have the same set of morphisms to that object.


IsAlgebraic.isIntegral

/-- **Alias** of the forward direction of `isAlgebraic_iff_isIntegral`.

---

An element of an algebra over a field is algebraic if and only if it is integral. -/
theorem IsAlgebraic.isIntegral :
    ∀ {K : Type u} {A : Type v} [inst : Field K] [inst_1 : Ring A] [inst_2 : Algebra K A] {x : A},
      IsAlgebraic K x → IsIntegral K x :=
  by sorry

This theorem, known as an alias of the forward direction of `isAlgebraic_iff_isIntegral`, states that for any element `x` in an algebra `A` over a field `K`, if `x` is algebraic over `K` then `x` is also integral over `K`. Here, an element being algebraic means that it is a root of a nonzero polynomial with coefficients in `K`, and being integral means that it is root of some monic polynomial with coefficients in `K`. In other words, if an element of an algebra satisfies a polynomial equation with coefficients in the field, it also satisfies a monic polynomial equation with coefficients in the field.

If an element in an algebra over a field is algebraic, then it is integral.


theorem Set.image_prod :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) {s : Set α} {t : Set β},
      (fun x => f x.1 x.2) '' s ×ˢ t = Set.image2 f s t :=
  by sorry

The theorem `Set.image_prod` states that for all types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, the image of the function `f` when applied to the Cartesian product of two sets `s` and `t` (where `s` is a set of elements of type `α` and `t` is a set of elements of type `β`), is equal to the image of the function `f` when it's applied separately to each element of the sets `s` and `t`. In mathematical terms, for a function `f : α × β → γ`, the image of `f` over the Cartesian product of `s` and `t` is the same as the set of all `f(a, b)` where `a` is in `s` and `b` is in `t`.

For any function `f : α × β → γ`, the image of `f` on the Cartesian product `s × t` is equal to the set of all `f(a, b)` where `a` is in `s` and `b` is in `t`.


theorem Subtype.ext_iff_val : ∀ {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}, a1 = a2 ↔ ↑a1 = ↑a2 := by sorry

This theorem, `Subtype.ext_iff_val`, states that for any type `α` and a predicate `p` that applies to `α`, two elements `a1` and `a2` of the subtype `{ x // p x }` (i.e., the subset of `α` for which `p` holds) are equal if and only if their underlying values (`↑a1` and `↑a2`) in `α` are equal. In other words, two elements of a subtype are equal if and only if their corresponding elements in the original type are equal.

For any type $\alpha$ and predicate $p$, elements $a\_1$ and $a\_2$ of the subtype ${x // p(x)}$ are equal if and only if their underlying values in $\alpha$ are equal.


Filter.EventuallyLE.antisymm

theorem Filter.EventuallyLE.antisymm :
    ∀ {α : Type u} {β : Type v} [inst : PartialOrder β] {l : Filter α} {f g : α → β},
      f ≤ᶠ[l] g → g ≤ᶠ[l] f → f =ᶠ[l] g :=
  by sorry

This theorem is stating that for any types `α` and `β`, where `β` is a partially ordered set, and any filter `l` on `α`, and any two functions `f` and `g` from `α` to `β`, if `f` is less than or equal to `g` almost everywhere with respect to the filter `l`, and `g` is also less than or equal to `f` almost everywhere with respect to the same filter, then `f` and `g` are equal almost everywhere with respect to that filter. In more mathematical terms, this theorem states that if $f \leq g$ and $g \leq f$ almost everywhere on a set `α` with respect to a filter `l`, then $f = g$ almost everywhere on that set with respect to the same filter.

If functions $f$ and $g$ from a set $\alpha$ to a partially ordered set $\beta$ satisfy $f \leq g$ and $g \leq f$ almost everywhere with respect to a filter $l$ on $\alpha$, then $f = g$ almost everywhere with respect to $l$.


theorem Fin.ext_iff : ∀ {n : ℕ} {a b : Fin n}, a = b ↔ ↑a = ↑b := by sorry

This theorem states that for any natural number `n` and any two elements `a` and `b` of the type `Fin n` (which represents a finite set of size `n`), `a` and `b` are equal if and only if their corresponding natural number representations (obtained by the coercion function `↑`) are also equal. In mathematical terms, it's saying that two elements of a finite set are equal if their corresponding indices in the set (from 0 to n-1) are the same.

For any natural number `n` and elements `a` and `b` of `Fin n`, `a = b` if and only if `↑a = ↑b`.


theorem HasStrictDerivAt.comp_hasStrictFDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type w} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {𝕜' : Type u_1} [inst_3 : NontriviallyNormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜']
      {h₂ : 𝕜' → 𝕜'} {h₂' : 𝕜'} {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} (x : E),
      HasStrictDerivAt h₂ h₂' (f x) → HasStrictFDerivAt f f' x → HasStrictFDerivAt (h₂ ∘ f) (h₂' • f') x :=
  by sorry

The theorem `HasStrictDerivAt.comp_hasStrictFDerivAt` states that if a function `h₂` has a strict derivative `h₂'` at the point `f(x)` (in the sense of strict differentiability), and another function `f` has strict Frechet derivative `f'` at point `x`, then the composed function `(h₂ ∘ f)` has a strict Frechet derivative of `(h₂' • f')` at the point `x`. In simpler terms, this theorem is about the chain rule in differential calculus, which describes the derivative of a composition of functions.

If `f` is strictly Frechet differentiable at `x` and `h₂` is strictly differentiable at `f(x)`, then the composed function `h₂ ∘ f` is strictly Frechet differentiable at `x` with derivative `(h₂' • f')`.


theorem Filter.tendsto_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {m : α → β} {f : Filter α},
      Filter.Tendsto m f Filter.atTop ↔ ∀ (b : β), ∀ᶠ (a : α) in f, b ≤ m a :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` is an ordered set, and for any function `m` from `α` to `β` and any filter `f` on `α`, the function `m` tends to infinity along `f` (i.e., `Filter.Tendsto m f Filter.atTop`) if and only if, for any element `b` in `β`, eventually (for all elements `a` in the filter `f`) the value of `b` is less than or equal to `m a`. In mathematical terms, this can be written as:
\\[\forall b \in \beta, \, \exists a \in \alpha \, \text{in the filter} \, f \, \text{such that} \, b \leq m(a).\\]
The symbol "∀ᶠ" refers to the "eventually" quantifier, used in the context of filters: a statement is said to hold "eventually" if it holds in the filter outside of a finite subset.

For any function from a type to an ordered set and any filter on the domain, the function tends to infinity along the filter if and only if every element in the range is eventually less than or equal to the function value for some element in the filter.


theorem Set.left_mem_Ici : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ Set.Ici a := by sorry

The theorem `Set.left_mem_Ici` states that for all types `α` that have a `Preorder` structure, any element `a` of type `α` belongs to the set that represents the interval from `a` to infinity, inclusive. In other words, it asserts that `a` is always included in the interval `[a, ∞)` in any preordered set.

For any preordered type `α` and element `a` in `α`, `a` belongs to the interval `[a, ∞)`.


theorem Option.some_get : ∀ {α : Type u_1} {x : Option α} (h : Option.isSome x = true), some (Option.get x h) = x := by
  sorry

The theorem `Option.some_get` states that for any type `α` and any option value `x` of type `Option α`, if we can confirm that `x` is not `none` (i.e., `Option.isSome x = true`), then when we extract the value from `x` using the `Option.get` function and wrap it back into an `Option` using `some`, we get back the original option `x`.

For any type `α` and `Option α` value `x`, if `Option.isSome x` holds, then `Option.get (Option.some x) = x`.


theorem MeasureTheory.Measure.AbsolutelyContinuous.mk :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      (∀ ⦃s : Set α⦄, MeasurableSet s → ↑↑ν s = 0 → ↑↑μ s = 0) → MeasureTheory.Measure.AbsolutelyContinuous μ ν :=
  by sorry

This theorem states that for any type `α` equipped with a `MeasurableSpace` structure, and any two measures `μ` and `ν` on `α`, if for every measurable set `s`, it holds that whenever `ν` assigns `0` to `s`, `μ` also assigns `0` to `s`, then `μ` is absolutely continuous with respect to `ν`. In other words, it provides a condition under which one measure is absolutely continuous with respect to another, which is that the first measure must assign measure zero to any set to which the second measure assigns measure zero.

If for all measurable sets `s` in a measurable space `α`, `ν(s) = 0` implies `μ(s) = 0`, then measure `μ` is absolutely continuous with respect to measure `ν`.


theorem ENNReal.coe_mul : ∀ (x y : NNReal), ↑(x * y) = ↑x * ↑y := by sorry

This theorem states that for any two nonnegative real numbers `x` and `y`, the operation of taking their product in the nonnegative real numbers (`x * y`) and then taking its real part (denoted by `↑(x * y)`) is the same as first taking their real parts (`↑x` and `↑y`) and then multiplying these real numbers. In other words, multiplication in the nonnegative real numbers commutes with the operation of taking the real part.

For all non-negative real numbers x and y, ↑(x * y) = ↑x * ↑y.


theorem isCompact_iff_compactSpace :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s ↔ CompactSpace ↑s := by sorry

The theorem `isCompact_iff_compactSpace` states that for any type `X` endowed with a topological space structure and any set `s` of type `X`, the set `s` is compact if and only if the set `s` considered as a type has a structure of compact space. Here, compactness of a set is defined such that for every nontrivial filter `f` that contains the set, there exists an element in the set such that every set of the filter intersects every neighborhood of this element. A compact space is a space where every open cover has a finite subcover.

A set in a topological space is compact if and only if it has the structure of a compact space, where a compact space is a space such that every open cover has a finite subcover.


theorem List.mem_append : ∀ {α : Type u_1} {a : α} {s t : List α}, a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t := by sorry

This theorem, `List.mem_append`, states that for any type `α`, any element `a` of type `α`, and any two lists `s` and `t` of type `α`, `a` is a member of the list formed by appending `s` and `t` if and only if `a` is a member of `s` or `a` is a member of `t`. In other words, an element is in the concatenated list if it is in either of the original lists.

For any type `α`, list `s` and list `t` of type `α`, and element `a` of type `α`, `a ∈ s ++ t` if and only if `a ∈ s` or `a ∈ t`.


/-- Given two elements `b`, `c` of a `CancelMonoidWithZero` and a nonzero element `a`,
`a*b` divides `a*c` iff `b` divides `c`.  -/
theorem mul_dvd_mul_iff_left :
    ∀ {α : Type u_1} [inst : CancelMonoidWithZero α] {a b c : α}, a ≠ 0 → (a * b ∣ a * c ↔ b ∣ c) := by sorry

This theorem states that for any given type `α` that forms a `CancelMonoidWithZero`, and for any three elements `a`, `b`, and `c` of this type, where `a` is not zero, the product of `a` and `b` divides the product of `a` and `c` if and only if `b` divides `c`. In mathematical terms, if α is a cancellative monoid with zero and a ≠ 0, then a*b divides a*c exactly when b divides c.

For any cancellative monoid with zero `α` and non-zero elements `a, b, c` in `α`, `a*b` divides `a*c` if and only if `b` divides `c`.


theorem mul_dvd_mul : ∀ {α : Type u_1} [inst : CommSemigroup α] {a b c d : α}, a ∣ b → c ∣ d → a * c ∣ b * d := by sorry

This theorem states that for any type `α` that forms a commutative semigroup, given any elements `a`, `b`, `c`, and `d` of `α`, if `a` divides `b` and `c` divides `d`, then the product `a * c` divides the product `b * d`. Here, "divides" is a relation expressing that one element can be multiplied by some other to yield a third.

If `α` is a commutative semigroup, then for all `a, b, c, d ∈ α`, if `a` divides `b` and `c` divides `d`, then `a * c` divides `b * d`.


theorem ProbabilityTheory.iIndepFun.isProbabilityMeasure :
    ∀ {Ω : Type u_1} {ι : Type u_2} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : ι → Type u_10}
      {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i},
      ProbabilityTheory.iIndepFun m f μ → MeasureTheory.IsProbabilityMeasure μ :=
  by sorry

This theorem states that for any type `Ω`, index type `ι`, measurable space `mΩ` over `Ω`, measure `μ` over `Ω`, and a function `f` from the index type to functions from `Ω` to an indexed type `β`, if the function `f` is independent under the measure `μ`, then `μ` is a probability measure. In terms of probability theory, this means that if we have a collection of random variables that are independent, then the measure used to model the probability is indeed a probability measure, which is a measure with total mass equal to 1.

If a function from an index type to measurable functions on a measurable space preserves the independence of indices under a measure, then the measure is a probability measure.


Antitone.antitoneOn

theorem Antitone.antitoneOn :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Antitone f → ∀ (s : Set α), AntitoneOn f s :=
  by sorry

This theorem states that for any two types `α` and `β` with preordered structures and a function `f` from `α` to `β`, if `f` is antitone (i.e., for all `a` and `b` in `α`, if `a` is less than or equal to `b` then `f(b)` is less than or equal to `f(a)`), then `f` is also antitone on any set `s` of type `α`. In other words, for any `a` and `b` in set `s`, if `a` is less than or equal to `b`, then `f(b)` is less than or equal to `f(a)`.

If `f` is an antitone function from preordered types `α` to `β`, then `f` is antitone on any subset `s` of `α`.


Asymptotics.IsBigO.isBigOWith

theorem Asymptotics.IsBigO.isBigOWith :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =O[l] g → ∃ c, Asymptotics.IsBigOWith c l f g :=
  by sorry

The theorem `Asymptotics.IsBigO.isBigOWith` states that for any two functions `f` and `g` on a type `α` with norms (`Norm E` and `Norm F` respectively) and a filter `l` on `α`, if `f` is Big O of `g` at the filter `l` (notated as `f =O[l] g`), then there exists a real number `c` such that `f` is eventually bounded by `c * ‖g‖` at the filter `l`. In other words, the ratio `‖f‖ / ‖g‖` is eventually bounded by `c`, ignoring division by zero issues. This establishes a connection between `IsBigO` and `IsBigOWith` relations in the context of asymptotic notation.

If `f =O[l] g` for functions `f` and `g` on type `α` with norms and filter `l`, then there exists a constant `c` such that `|f(x)| ≤ c * |g(x)|` for all `x` in the filter `l`.


IsLeast.isGLB

theorem IsLeast.isGLB : ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, IsLeast s a → IsGLB s a := by sorry

This theorem states that for any set `s` of a type `α` with a preorder (a binary relation that is reflexive and transitive), if an element `a` from `α` is the least element of `s`, then `a` is also the greatest lower bound of `s`. In other words, if `a` is in `s` and no element in `s` is less than `a`, then `a` is the highest possible value that is less than or equal to every element in `s`.

If a preorder `≤` on a set `α` has a least element `a` in `s ≤ α`, then `a` is the greatest lower bound of `s`.


theorem Finset.mem_sdiff :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, a ∈ s \ t ↔ a ∈ s ∧ a ∉ t := by sorry

The theorem `Finset.mem_sdiff` states that for any type `α` equipped with a decision procedure for equality (`DecidableEq α`), and any two finite sets (`s` and `t`) of that type, for all `a` of type `α`, `a` belongs to the difference of `s` and `t` (notated `s \ t`) if and only if `a` belongs to `s` and `a` does not belong to `t`. This theorem thus characterizes membership in the difference of two finite sets in Lean 4.

For any type `α` with Decidable Equality, and finite sets `s` and `t` of type `Finset α`, an element `a` belongs to `s \ t` if and only if `a` is in `s` but not in `t`.


theorem Real.coe_toNNReal : ∀ (r : ℝ), 0 ≤ r → ↑(Real.toNNReal r) = r := by sorry

The theorem `Real.coe_toNNReal` states that for every real number `r`, if `r` is non-negative (i.e., `r` is greater than or equal to 0), then the coercion of the non-negative real number returned by the function `Real.toNNReal` when applied to `r` is equal to `r` itself. This theorem guarantees that the `Real.toNNReal` function is an identity on non-negative real numbers, when we consider the output as a real number again by applying the coercion function.

For all real numbers `r` with `r ≥ 0`, the coercion of `Real.toNNReal r` back to a real number equals `r` itself.