theorem Opposite.unop_injective : ∀ {α : Sort u}, Function.Injective Opposite.unop := by sorry

The theorem `Opposite.unop_injective` asserts that, for any type `α` (which can be a type or a sort in Lean), the canonical map `unop` from the opposite type `αᵒᵖ` to `α` is injective. In other words, if two elements from the opposite type `αᵒᵖ` have the same image under the `unop` function, then these two elements must be the same. This ensures the uniqueness of the `unop` function's preimage.

The `unop` function from the opposite type `αᵒᵖ` to `α` in Lean is an injection.


theorem Fin.castSucc_lt_castSucc_iff : ∀ {n : ℕ} {a b : Fin n}, Fin.castSucc a < Fin.castSucc b ↔ a < b := by sorry

The theorem `Fin.castSucc_lt_castSucc_iff` states that for any natural number `n` and any two elements `a` and `b` of the finite set `Fin n`, the embedding of `a` into `Fin (n+1)` is less than the embedding of `b` into `Fin (n+1)` if and only if `a` is less than `b`. In other words, the order of elements is preserved when they are embedded from `Fin n` to `Fin (n+1)` via the `castSucc` function.

For all natural numbers n and Fin n elements a and b, a < b if and only if castSucc a < castSucc b in Fin (n+1).


theorem Mathlib.Data.Set.Prod._auxLemma.13 :
    ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) := by sorry

This theorem, named `Mathlib.Data.Set.Prod._auxLemma.13`, states that for any two sets `s` of type `α` and `t` of type `β`, and any ordered pair `p` of type `α × β`, the pair `p` is a member of the Cartesian product of `s` and `t` if and only if the first element of `p` is a member of `s` and the second element of `p` is a member of `t`. In mathematical terms, it asserts that $(p \in s \times t) \iff (p_1 \in s \land p_2 \in t)$.

The theorem asserts that for any sets `s` and `t`, and any pair `p` in their Cartesian product `s × t`, the first component `p.1` is in `s` and the second component `p.2` is in `t`. In symbols: for all `s : Type _, t : Type _, p : s × t, p = (x, y) ↔ x ∈ s ∧ y ∈ t`.


theorem Ordinal.one_ne_zero : 1 ≠ 0 := by sorry

This theorem states that the ordinal number one is not equal to zero. In other words, it asserts that one and zero are distinct values in the context of ordinal numbers, which are a type of number system used to represent order or position.

One is not equal to zero in the ordinal number system.


DenseInducing.prod

/-- The product of two dense inducings is a dense inducing  -/
theorem DenseInducing.prod :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : TopologicalSpace α]
      [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] [inst_3 : TopologicalSpace δ] {e₁ : α → β}
      {e₂ : γ → δ}, DenseInducing e₁ → DenseInducing e₂ → DenseInducing fun p => (e₁ p.1, e₂ p.2) :=
  by sorry

This theorem states that the Cartesian product of two dense inducing functions results in another dense inducing function. In the context of topology, given two topological spaces `α` and `γ` mapped onto `β` and `δ` respectively by dense inducing functions `e₁` and `e₂`, the function that maps a pair `(a,c)` from `α × γ` to `(e₁ a, e₂ c)` in `β × δ` is also dense inducing.

If `e₁:` `α` → `β` and `e₂:` `γ` → `δ` are dense functions, then the function `(e₁, e₂): α × γ` → `β × δ` given by `(a, c)` ↦ `(e₁ a, e₂ c)` is also a dense function.


theorem Nat.Coprime.dvd_of_dvd_mul_right : ∀ {k n m : ℕ}, Nat.Coprime k n → k ∣ m * n → k ∣ m := by sorry

This theorem states that for any natural numbers `k`, `n`, and `m`, if `k` and `n` are coprime (i.e., their greatest common divisor is 1), and `k` divides the product of `m` and `n`, then `k` also divides `m`. In other words, if a number `k` shares no common factors with `n` other than 1, and `k` is a divisor of `m*n`, then `k` is necessarily a divisor of `m`.

If `k` is coprime to `n` and `k` divides the product `m * n`, then `k` divides `m`.


theorem PiNat.apply_eq_of_lt_firstDiff :
    ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, n < PiNat.firstDiff x y → x n = y n := by sorry

This theorem states that for any two functions `x` and `y` from natural numbers to a type `E` indexed by natural numbers, and for any natural number `n`, if `n` is less than the first index where `x` and `y` differ (denoted as `PiNat.firstDiff x y`), then the values of `x` and `y` at index `n` are equal. Essentially, for any index before the first differing index, the two functions `x` and `y` have the same values.

For any functions `x` and `y` from natural numbers to type `E`, if `n` is less than the first index where they differ, then `x n = y n`.


theorem LipschitzWith.prod_snd :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β],
      LipschitzWith 1 Prod.snd :=
  by sorry

The theorem `LipschitzWith.prod_snd` states that for any types `α` and `β` which are equipped with a pseudo emetric space structure, the second projection function `Prod.snd`, which takes a pair and returns its second component, is Lipschitz continuous with constant `1`. In mathematical terms, this means that for any pair of points `x` and `y` in the product space `α × β`, the distance between the second components of `x` and `y` (using the metric of `β`) is less than or equal to the distance between `x` and `y` (using the product metric).

Given two pseudo metric spaces `(α, dα)` and `(β, dβ)`, the second projection function of their product space `(α × β, dₓ)` is 1-Lipschitz with respect to the second component metric `dβ`.


theorem ENNReal.Tendsto.mul_const :
    ∀ {α : Type u_1} {f : Filter α} {m : α → ENNReal} {a b : ENNReal},
      Filter.Tendsto m f (nhds a) → a ≠ 0 ∨ b ≠ ⊤ → Filter.Tendsto (fun x => m x * b) f (nhds (a * b)) :=
  by sorry

This theorem is about the limit of a function with extended nonnegative real numbers as output. It states that for any type `α`, any filter `f` on `α`, any function `m` from `α` to the extended nonnegative real numbers, and any two extended nonnegative real numbers `a` and `b`, if the function `m` tends to `a` under the filter `f` (i.e., for every neighborhood of `a`, the preimage under `m` is a neighborhood under `f`), and if either `a` is not zero or `b` is not infinite, then the function that maps every `x` in `α` to the product of `m(x)` and `b` also tends to the product of `a` and `b` under the filter `f`. In simpler terms, under certain conditions, the limit of the product of a function and a constant is the product of the limit of the function and the constant.

If a function from a type `α` to extended nonnegative real numbers tends to limit `a` under filter `f`, and either `a` is nonzero or the limit of the function is finite (i.e., not infinite), then the function that maps every `x` in `α` to the product of `m(x)` and a constant `b` tends to the product of `a` and `b` under filter `f`.


QuadraticModuleCat.Hom.ext

theorem QuadraticModuleCat.Hom.ext :
    ∀ {R : Type u} {inst : CommRing R} {V W : QuadraticModuleCat R} (x y : QuadraticModuleCat.Hom V W),
      x.toIsometry = y.toIsometry → x = y :=
  by sorry

This theorem states that for any commutative ring `R` and any two quadratic modules `V` and `W` over `R`, if we have two homomorphisms `x` and `y` from `V` to `W`, and the isometric part of `x` equals to the isometric part of `y`, then `x` is equal to `y`. Essentially, it means that a homomorphism in the category of quadratic modules is uniquely determined by its isometry part.

Given any commutative ring `R` and quadratic modules `V` and `W` over `R`, if two homomorphisms `x` and `y` from `V` to `W` have equal isometric parts, then `x = y`.


theorem subsingleton_of_bot_eq_top :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : BoundedOrder α], ⊥ = ⊤ → Subsingleton α := by sorry

This theorem states that for any type `α` that has a partial order and a bounded order, if the bottom element `⊥` is equal to the top element `⊤`, then `α` is a subsingleton. In other words, if the least and greatest elements in the ordered set are the same, then the set consists of at most one element.

If a type `α` equipped with a partial order and a bottom element `⊥` has `⊥ = ⊤`, then `α` is a subsingleton. (In other words, an ordered set `(α, ≤, ⊥)` with a bottom element and a greatest element identical is a set with at most one element.)


theorem Matrix.mul_diagonal :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n]
      [inst_2 : DecidableEq n] (d : n → α) (M : Matrix m n α) (i : m) (j : n),
      (M * Matrix.diagonal d) i j = M i j * d j :=
  by sorry

The theorem `Matrix.mul_diagonal` states that for any types `m`, `n`, and `α` where `α` is a non-unital, non-associative semiring, and where `n` has a finite number of elements and decidable equality, given a function `d : n → α` that determines the elements on the diagonal of a matrix, a matrix `M : Matrix m n α`, and indices `i : m` and `j : n`, the result of matrix multiplication of `M` with the diagonal matrix determined by `d` at the indices `i, j` is equal to the product of the element at `i, j` in `M` and the `j`-th element of `d`. In other words, it states that multiplying a matrix by a diagonal matrix on the right corresponds to element-wise multiplication of the matrix by the diagonal entries.

For any non-unital, non-associative semiring `α`, finite type `n` with decidable equality, function `d : n → α`, matrix `M : Matrix m n α`, and indices `i : m` and `j : n`, `M * (diagonalMatrix d)! j = M! i, j * d! j`, where `*` denotes matrix multiplication and `!` denotes matrix-vector multiplication.


Set.Finite.insert

theorem Set.Finite.insert : ∀ {α : Type u} (a : α) {s : Set α}, Set.Finite s → Set.Finite (insert a s) := by sorry

This theorem states that for any type `α`, any element `a` of that type, and any set `s` of elements of that type, if the set `s` is finite, then the set resulting from inserting the element `a` into `s` is also finite. In other words, inserting an element into a finite set results in another finite set.

If `α` is a type, `a : α`, and `s : set α` is finite, then `insert a s` is also finite.


theorem CategoryTheory.Limits.Cofan.IsColimit.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type u_1} {F : I → C}
      {c : CategoryTheory.Limits.Cofan F},
      CategoryTheory.Limits.IsColimit c →
        ∀ {A : C} (f g : c.pt ⟶ A),
          (∀ (i : I),
              CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj c i) f =
                CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj c i) g) →
            f = g :=
  by sorry

The theorem `CategoryTheory.Limits.Cofan.IsColimit.hom_ext` states that in a category `C`, for any cofan `c` over a diagram `F : I → C` that has the property of being a colimit, if we have two morphisms `f` and `g` from the tip of the cofan to some object `A` in `C` such that the composition of `f` and `g` respectively with each "injection" (or morphism) from the diagram to the tip of the cofan yields the same result, then `f` and `g` must be the same. In other words, the morphism from the colimit of the cofan to any other object is determined uniquely by the way it interacts with the morphisms making up the cocone, embodying a universal property of colimits in category theory.

In a category with colimits, if two morphisms from the tip of a cocone over a diagram to an object have the same image under all injections from the diagram, then they are equal.


theorem ascPochhammer_succ_left :
    ∀ (S : Type u) [inst : Semiring S] (n : ℕ),
      ascPochhammer S (n + 1) = Polynomial.X * Polynomial.comp (ascPochhammer S n) (Polynomial.X + 1) :=
  by sorry

The theorem `ascPochhammer_succ_left` states that for any semiring `S` and natural number `n`, the ascending Pochhammer symbol of `S` at `(n + 1)` is equal to the polynomial `X` multiplied by the composition of the ascending Pochhammer symbol of `S` at `n` and the polynomial `X + 1`. The ascending Pochhammer symbol of `S` at `n` is the polynomial `X * (X + 1) * ... * (X + n - 1)` with coefficients in the semiring `S`.

The ascending Pochhammer symbol of a semiring `S` at `n + 1` equals the product of `X`, the ascending Pochhammer symbol of `S` at `n`, and `(X + 1)` in `S[X]`.


theorem MeasureTheory.SimpleFunc.coe_zero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Zero β], ↑0 = 0 := by sorry

The theorem `MeasureTheory.SimpleFunc.coe_zero` states that for any types `α` and `β`, where `α` has a measurable space structure and `β` has a zero element, the coercion of zero (denoted as `↑0`) equals to zero. Essentially, it establishes that in the context of measure theory, the simple function's representation of zero is the same as the typical notion of zero.

For any measurable space `α` and type `β` with a zero element, the coercion of zero from the simple function space to `β` equals zero.


theorem SetTheory.PGame.Impartial.neg_equiv_self : ∀ (G : SetTheory.PGame) [h : SetTheory.PGame.Impartial G], G ≈ -G :=
  by sorry

This theorem states that for any impartial game `G` in set theory, the game `G` is equivalent to its negation `-G`. Here, an impartial game is defined as a game in which the possible moves for each player are the same, given the same position. The equivalence between `G` and `-G` is a concept in the field of combinatorial game theory where two games are considered equivalent if no matter who starts, the outcome (win, lose or draw) will be the same.

For any impartial game G in set theory, G is equivalent to its negation -G.


theorem ZMod.val_coe_unit_coprime : ∀ {n : ℕ} (u : (ZMod n)ˣ), Nat.Coprime (ZMod.val ↑u) n := by sorry

This theorem states that for any natural number `n` and any unit `u` from the group of units of integers modulo `n` (denoted as `(ZMod n)ˣ`), the value of `u` (obtained using the `ZMod.val` function and then coercing `u` to integer) is coprime with `n`. In other words, the greatest common divisor (gcd) of `ZMod.val ↑u` and `n` is 1, meaning that they share no common factor other than 1.

For any natural number `n` and unit `u` in `(ZMod n)ˣ`, the greatest common divisor of `n` and the integer representation of `u` is 1.


theorem Polynomial.degree_X_pow_sub_C :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] {n : ℕ},
      0 < n → ∀ (a : R), Polynomial.degree (Polynomial.X ^ n - Polynomial.C a) = ↑n :=
  by sorry

The theorem `Polynomial.degree_X_pow_sub_C` states that for any ring `R` which is nontrivial, and for any natural number `n` greater than 0 and any element `a` from the ring `R`, the degree of the polynomial obtained by subtracting the constant polynomial `a` from the `n`th power of the polynomial variable `X` is equal to `n`. The degree of the polynomial is the highest power of `X` that appears in the polynomial.

For any nontrivial ring R and natural number n, the degree of X^n - X^(n-1)*a is n, where a is an element of R.


theorem refl_of : ∀ {α : Sort u} (r : α → α → Prop) [inst : IsRefl α r] (a : α), r a a := by sorry

This theorem states that for any type `α` and a binary relation `r` on `α`, if `r` is reflexive (as indicated by the reflexive instance `IsRefl α r`), then `r` holds for every element `a` of type `α` with itself. In other words, for all `a` in `α`, we have `r a a`, which is the formal definition of reflexivity.

If `r` is a reflexive binary relation on type `α`, then for all `a` in `α`, we have `r a a`.


theorem WithBot.bot_ne_coe : ∀ {α : Type u_1} {a : α}, ⊥ ≠ ↑a := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, the bottom element (denoted by `⊥`) is not equal to the co-element of `a` (denoted by `↑a`). In other words, no element of any type can be equal to the bottom element in the type `WithBot α`, which includes all elements of `α` along with a lowest (or "bottom") element.

For all types `α` and elements `a` of type `α`, `⊥ ≠ ↑a` in `WithBot α`.


theorem Mathlib.Topology.Basic._auxLemma.1 : ∀ {X : Type u} [inst : TopologicalSpace X], IsOpen ∅ = True := by sorry

This theorem states that for any type `X` equipped with a topology (meaning it is an instance of a topological space), the empty set is always an open set in this topological space. This property is universal and does not depend on the specifics of the topological space under consideration.

In any topological space, the empty set is open.


theorem ProbabilityTheory.measurable_preCDF :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} {ρ : MeasureTheory.Measure (α × ℝ)} {r : ℚ},
      Measurable (ProbabilityTheory.preCDF ρ r) :=
  by sorry

The theorem `ProbabilityTheory.measurable_preCDF` states that for any given type `α`, a measurable space `mα` over this type, a measure `ρ` on the product of this type and the real numbers, and a rational number `r`, the pre-cumulative distribution function (`preCDF`) for the given measure `ρ` and rational `r` is measurable. Here, a function is deemed measurable if the preimage of any measurable set under this function is also measurable. This theorem is a fundamental concept in probability theory, ensuring the measurability of the pre-cumulative distribution function, a prerequisite for any further probabilistic analysis.

The pre-cumulative distribution function of a measure over a type and a rational number is measurable.


theorem addOrderOf_dvd_of_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G} {n : ℕ}, n • x = 0 → addOrderOf x ∣ n := by sorry

The theorem `addOrderOf_dvd_of_nsmul_eq_zero` states that for any type `G` that is an additive monoid, for any element `x` of `G`, and for any natural number `n`, if `n` times `x` equals zero, then the additive order of `x` divides `n`. In other words, if the multiple of an element `x` with natural number `n` makes the total sum zero, then `n` must be a multiple of the additive order of `x`.

If `x` is an element of an additive monoid `G` and `n` is a natural number such that `n * x = 0` in `G`, then the additive order of `x` divides `n`.


theorem Mathlib.Algebra.GroupWithZero.Units.Basic._auxLemma.10 :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a = (a ≠ 0) := by sorry

This theorem states that for any type `G₀` that is a `GroupWithZero`, an element `a` of `G₀` is a unit (i.e., it has a two-sided inverse) if and only if `a` is not equal to zero. This is expressed in the context of algebraic structures, where a `GroupWithZero` is a group that has an element identified as zero.

In the context of groups with zero, an element is a unit if and only if it is not the additive identity.


theorem MeasureTheory.Measure.singularPart_def :
    ∀ {α : Type u_3} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α),
      μ.singularPart ν =
        if h : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν then (Classical.choose ⋯).1 else 0 :=
  by sorry

This theorem, `MeasureTheory.Measure.singularPart_def`, in the Measure Theory context, states that for any given measurable space `α` and any two measures `μ` and `ν` on this space, the singular part of `μ` with respect to `ν` is defined as follows: If `μ` and `ν` have a Lebesgue decomposition, then the singular part is the first component of a pair chosen from an indefinite description (existence proof), otherwise, if there's no such decomposition, the singular part is simply zero.

The singular part of measure `μ` with respect to `ν` in the measurable space `α` is the first component of their Lebesgue decomposition if it exists, or zero otherwise.


theorem norm_sub_rev : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), ‖a - b‖ = ‖b - a‖ := by sorry

This theorem states that for any type `E` that forms a semi-normed add group (which is a mathematical structure that combines the properties of a group and a semi-norm), the norm of the difference between any two elements `a` and `b` (`‖a - b‖`) is equal to the norm of the difference between `b` and `a` (`‖b - a‖`). This is essentially saying that the order in which you subtract the two elements does not affect the result of the norm, aligning with the idea that distance is direction-independent.

For any type `E` forming a semi-normed add group, the norm of the difference between two elements `a` and `b` is equal to the norm of `b` minus `a`, i.e., `‖a - b‖ = ‖b - a‖`.


/-- Given a Localization map `f : M →* N` for a Submonoid `S ⊆ M` and a map of `CommMonoid`s
`g : M →* P` such that `g(S) ⊆ Units P`, `f x = f y → g x = g y` for all `x y : M`.  -/
theorem Submonoid.LocalizationMap.eq_of_eq :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
      [inst_2 : CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P},
      (∀ (y : ↥S), IsUnit (g ↑y)) →
        ∀ {x y : M}, (Submonoid.LocalizationMap.toMap f) x = (Submonoid.LocalizationMap.toMap f) y → g x = g y :=
  by sorry

This theorem states that, given a localization map `f` from a commutative monoid `M` to another commutative monoid `N`, associated with a submonoid `S` of `M`, and another map `g` from `M` to a third commutative monoid `P` such that the image of `S` under `g` lies within the group of units of `P`, if two elements `x` and `y` of `M` are mapped to the same element under `f`, then they must also be mapped to the same element under `g`. This is a property of localization maps in the context of commutative monoids.

Given a localization map `f` from commutative monoid `M` to `N` with respect to submonoid `S`, and a map `g` from `M` to commutative monoid `P` with `g(S)` in the group of units of `P`, if `f(x) = f(y)` for all `x, y` in `M`, then `g(x) = g(y)`.


theorem npow_zero :
    ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [inst_2 : NatPowAssoc M] (x : M), x ^ 0 = 1 := by sorry

This theorem states that for any type `M` that has a multiplication operation and a unity (i.e., there exists a `MulOneClass` instance), and has a power operation with natural numbers (i.e., there exists a `Pow M ℕ` instance), and multiplication and power are associative (i.e., there exists a `NatPowAssoc` instance), then any element `x` of type `M` raised to the power of zero is equal to the unity. In mathematical terms, for any `x` in `M`, `x ^ 0 = 1`.

If `M` is a type with a multiplication, unity, and power operations, and multiplication and power are associative, then for all `x` in `M`, `x ^ 0 = 1`.


theorem Ordinal.log_of_not_one_lt_left : ∀ {b : Ordinal.{u_1}}, ¬1 < b → ∀ (x : Ordinal.{u_1}), Ordinal.log b x = 0 :=
  by sorry

The theorem `Ordinal.log_of_not_one_lt_left` states that for any ordinals `b` and `x`, if `b` is not greater than 1 then the ordinal logarithm of `x` with base `b` is equal to 0. In other words, when the base of the ordinal logarithm is not greater than 1, the ordinal logarithm always returns 0 regardless of the value of `x`. This theorem is a reflection of the mathematical fact that logarithms are undefined for bases less than or equal to 1.

For any ordinal `b` less than or equal to 1 and any ordinal `x`, the ordinal logarithm of `x` with base `b` equals 0.


theorem HasSum.add_compl :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a b : α}
      [inst_2 : ContinuousAdd α] {s : Set β},
      HasSum (f ∘ Subtype.val) a → HasSum (f ∘ Subtype.val) b → HasSum f (a + b) :=
  by sorry

This theorem states that for any types `α` and `β`, given an addition commutative monoid structure and a topological space structure on `α`, and a continuous addition on `α`, if we have a function `f` from `β` to `α` and two elements `a` and `b` of `α`, and a set `s` of `β`, then if the sum of applying `f` to each element of the subtype defined by `s` equals `a` and the sum of applying `f` to each element of the complement of `s` equals `b`, then the sum of applying `f` to each element in `β` equals `a + b`. In other words, the total sum of `f` over the whole space is the sum of the sum over a subset and the sum over its complement.

Given a commutative monoid `α` with topological space and continuous addition structures, and a function `f` from a topological space `β` to `α`, if the sum of `f` over every subset `s` of `β` equals `a` and the sum over `β \ s` equals `b`, then the sum of `f` over all of `β` equals `a + b`.


theorem MonoidAlgebra.sum_single_index :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] {N : Type u_3} [inst_1 : AddCommMonoid N] {a : G} {b : k}
      {h : G → k → N}, h a 0 = 0 → Finsupp.sum (MonoidAlgebra.single a b) h = h a b :=
  by sorry

The theorem `MonoidAlgebra.sum_single_index` states that for any types `k` and `G` with an instance of semiring `k`, and for any type `N` with an instance of additive commutative monoid, given a function `h` from `G` and `k` to `N` such that `h a 0 = 0` for any `a` in `G`, and any `a` of type `G` and `b` of type `k`, the sum of `h a (f a)` over the support of `f` (where `f` is the monoid algebra of a single element `a` with coefficient `b`) is equal to `h a b`. This means that when you apply the sum operation on the single element monoid algebra, the result is the same as directly applying `h` to `a` and `b`.

For any semiring `k`, additive commutative monoid `N`, type `G` with semiring instance, function `h` from `G x k` to `N` with `h a 0 = 0`, and element `a` of type `G`, the sum of `h` applied to `a` and the monoid algebra of `a` with coefficient `b` equals `h a b`.


/-- Determinant of 2x2 matrix  -/
theorem Matrix.det_fin_two :
    ∀ {R : Type v} [inst : CommRing R] (A : Matrix (Fin 2) (Fin 2) R), Matrix.det A = A 0 0 * A 1 1 - A 0 1 * A 1 0 :=
  by sorry

This theorem, named `Matrix.det_fin_two`, states that for any 2x2 matrix `A` with elements in a commutative ring `R`, the determinant of `A` is calculated as the product of the elements at the first row and the second column (i.e., `A 0 0` and `A 1 1`) minus the product of the elements at the first column and the second row (i.e., `A 0 1` and `A 1 0`). In other words, this is the standard formula for the determinant of a 2x2 matrix.

The determinant of a 2x2 matrix over a commutative ring is equal to the product of its first row's first and second elements, minus the product of its first column's first and second elements.


theorem Mathlib.Order.Filter.Basic._auxLemma.18 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem states that, for any two propositions 'a' and 'b', the existence of 'b' given 'a' is equivalent to the conjunction (logical "and") of 'a' and 'b'. In simple words, it means that 'b' exists if and only if both 'a' and 'b' are true.

The theorem asserts that for all propositions 'a' and 'b', the existence of 'b' given 'a' is equivalent to 'a' and 'b' being true simultaneously.


theorem Function.IsPeriodicPt.mul_const :
    ∀ {α : Type u_1} {f : α → α} {x : α} {m : ℕ},
      Function.IsPeriodicPt f m x → ∀ (n : ℕ), Function.IsPeriodicPt f (m * n) x :=
  by sorry

The theorem `Function.IsPeriodicPt.mul_const` states that if a point `x` in the domain of a function `f` is a periodic point of `f` with period `m`, then `x` is also a periodic point of `f` with any period that is a multiple of `m`. In mathematical terms, if the `n`-th iterate of a function `f` satisfies `f^[m](x) = x`, then for any natural number `n`, `f^[m*n](x) = x`.

If a function `f` has a periodic point `x` with period `m`, then `x` is also a periodic point of `f` with any period that is a multiple of `m`. In other words, if `f^[m](x) = x`, then `f^[n](x) = x` for all natural numbers `n` such that `m` divides `n`.


theorem nhdsWithin_inter_of_mem' :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s t : Set α},
      t ∈ nhdsWithin a s → nhdsWithin a (s ∩ t) = nhdsWithin a s :=
  by sorry

This theorem states that for any type `α` equipped with a topology, and any point `a` and sets `s` and `t` in `α`, if `t` is in the neighborhood within `s` of `a`, then the neighborhood within `s` intersected with `t` of `a` is equal to the neighborhood within `s` of `a`. In simpler terms, if `t` is in the "localized neighborhood" of `a` within `s`, then localizing further by `t` doesn't change the neighborhood within `s` of `a`.

For any topological space `(α, τ)`, point `a ∈ α`, and sets `s, t ∈ τ` with `t ∈ Nbd(a, s)`, we have `Nbd(a, s ∩ t) = Nbd(a, s)`.


theorem Valuation.map_neg :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
      (x : R), v (-x) = v x :=
  by sorry

The theorem `Valuation.map_neg` asserts that for any ring `R` and any linearly ordered commutative group with zero `Γ₀`, the valuation `v` of the negation of an element `x` from the ring `R` is equal to the valuation of `x` itself. In simpler terms, this means that the valuation of a number and its negative are the same in the context of this particular structure.

For any ring R and commutative ordered group Γ₀, the valuation function v satisfies v(−x) = v(x) for all x ∈ R.


theorem Equiv.Perm.cycle_induction_on :
    ∀ {β : Type u_3} [inst : Finite β] (P : Equiv.Perm β → Prop) (σ : Equiv.Perm β),
      P 1 →
        (∀ (σ : Equiv.Perm β), Equiv.Perm.IsCycle σ → P σ) →
          (∀ (σ τ : Equiv.Perm β), Equiv.Perm.Disjoint σ τ → Equiv.Perm.IsCycle σ → P σ → P τ → P (σ * τ)) → P σ :=
  by sorry

The theorem `Equiv.Perm.cycle_induction_on` is a principle of mathematical induction for permutations over a finite type `β`. It states that for every property `P` and every permutation `σ` on `β`, if the property holds for the identity permutation, and if whenever the property holds for a cycle `σ` and any other permutation `τ` that is disjoint from `σ`, then it also holds for the product of `σ` and `τ`, then the property holds for all permutations. In other words, any property of permutations that holds for the identity, for cycles, and is preserved under taking disjoint products, holds for all permutations.

If a property holds for the identity permutation and is closed under cyclic shifts and disjoint composition for permutations on a finite type, then it holds for all permutations.


theorem PrimeSpectrum.mem_zeroLocus :
    ∀ {R : Type u} [inst : CommSemiring R] (x : PrimeSpectrum R) (s : Set R),
      x ∈ PrimeSpectrum.zeroLocus s ↔ s ⊆ ↑x.asIdeal :=
  by sorry

This theorem states that for a given type `R` that is a commutative semiring, a point `x` in the prime spectrum of `R`, and a set `s` of `R`, `x` is in the zero locus of `s` if and only if `s` is a subset of the elements of `x` interpreted as an ideal. In the context of algebraic geometry, this is saying that a point on a scheme is in the zero locus of a set of functions if and only if those functions vanish on the corresponding prime ideal.

A point in the prime spectrum of a commutative semiring is in the zero locus of a subset if and only if the subset is contained in the ideal generated by that point.


theorem DFinsupp.zipWith_apply :
    ∀ {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [inst : (i : ι) → Zero (β i)]
      [inst_1 : (i : ι) → Zero (β₁ i)] [inst_2 : (i : ι) → Zero (β₂ i)] (f : (i : ι) → β₁ i → β₂ i → β i)
      (hf : ∀ (i : ι), f i 0 0 = 0) (g₁ : Π₀ (i : ι), β₁ i) (g₂ : Π₀ (i : ι), β₂ i) (i : ι),
      (DFinsupp.zipWith f hf g₁ g₂) i = f i (g₁ i) (g₂ i) :=
  by sorry

This theorem states that for any types `ι`, `β`, `β₁`, and `β₂`, and for any functions `f : (i : ι) → β₁ i → β₂ i → β i` such that `f` maps all `0`s to `0`, and any two Direct Sum Indexed Families with zero `g₁` and `g₂` (denoted as `Π₀ (i : ι), β₁ i` and `Π₀ (i : ι), β₂ i` respectively), the value at `i` of applying `zipWith` operation on `g₁` and `g₂` with function `f` is equal to applying `f` on the values of `g₁` and `g₂` at `i`. In other words, it verifies that `zipWith` operation in the context of Direct Sum Indexed Families behaves as expected, by applying the function `f` to corresponding elements from `g₁` and `g₂`.

For any types `ι`, `β₁`, `β₂`, and functions `f : (i : ι) → β₁ i → β₂ i → β i` preserving the zero element, the `zipWith` operation on `Π₀ (i : ι), β₁ i` and `Π₀ (i : ι), β₂ i` with `f` is equal to applying `f` to the corresponding elements.


theorem OrderIso.map_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β),
      Filter.map (⇑e) Filter.atTop = Filter.atTop :=
  by sorry

This theorem states that for any two preordered types `α` and `β`, and any order isomorphism `e` between `α` and `β`, the application of the forward map `Filter.map` of the order isomorphism `e` to the filter `Filter.atTop` of `α` results in the filter `Filter.atTop` of `β`. In other words, mapping the filter representing the limit towards infinity (`Filter.atTop`) in the preordered type `α` using the order isomorphism `e` gives us the filter representing the limit towards infinity in the preordered type `β`. This essentially means that the concept of 'going towards infinity' remains invariant under an order isomorphism.

Given any order isomorphism between preordered types `α` and `β`, the image of the filter `Filter.atTop` of `α` under the forward map of the order isomorphism is equal to the filter `Filter.atTop` of `β`.


theorem LinearMap.id_comp :
    ∀ {R₂ : Type u_3} {R₃ : Type u_4} {M₂ : Type u_11} {M₃ : Type u_12} [inst : Semiring R₂] [inst_1 : Semiring R₃]
      [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
      {σ₂₃ : R₂ →+* R₃} (f : M₂ →ₛₗ[σ₂₃] M₃), LinearMap.comp LinearMap.id f = f :=
  by sorry

The theorem `LinearMap.id_comp` states that for any semirings `R₂` and `R₃`, any additive commutative monoids `M₂` and `M₃`, any modules `M₂` and `M₃` over `R₂` and `R₃` respectively, and any ring homomorphism from `R₂` to `R₃` denoted by `σ₂₃`, if we have a linear map `f` from `M₂` to `M₃`, then the composition of the linear identity map and `f` (i.e., `LinearMap.comp LinearMap.id f`) is equal to `f` itself. In essence, this theorem asserts that the identity map composed with any linear map leaves the linear map unchanged, which is a fundamental property of identity maps in the context of linear algebra.

For any ring homomorphism σ₂₃ between semirings R₂ and R₃, and any linear map f from an additive commutative monoid/module M₂ to M₃ over R₂/R₃, the composition of the identity linear map and f equals f itself.


theorem SlashInvariantForm.slash_action_eqn :
    ∀ {F : Type u_1} {Γ : Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)} {k : ℤ} [inst : FunLike F UpperHalfPlane ℂ]
      [inst_1 : SlashInvariantFormClass F Γ k] (f : F) (γ : ↥Γ), SlashAction.map ℂ k γ ⇑f = ⇑f :=
  by sorry

The theorem `SlashInvariantForm.slash_action_eqn` states that for all function-like objects `F` mapping from the upper half-plane to complex numbers, subgroup `Γ` of 2 by 2 special linear group over integers and integer `k`, if `F` has a class of slash invariant forms over `Γ` and `k`, then for any function `f` from `F` and any element `γ` from `Γ`, the slash action of `γ` on the function `f` is equal to the function `f` itself. This means the function `f` is invariant under the slash action.

For function-like objects F mapping from the upper half-plane to complex numbers with a class of slash invariant forms over subgroup Γ of 2 by 2 special linear group over integers and integer k, the function f from F is invariant under the slash action of any element γ from Γ.


theorem UniformSpace.comap_iInf :
    ∀ {ι : Sort u_2} {α : Type u_3} {γ : Type u_4} {u : ι → UniformSpace γ} {f : α → γ},
      UniformSpace.comap f (⨅ i, u i) = ⨅ i, UniformSpace.comap f (u i) :=
  by sorry

This theorem states that for any indexing type `ι`, any types `α` and `γ`, any function `f` from `α` to `γ`, and any family `u` of uniform spaces on `γ` indexed by `ι`, the uniform space on `α` obtained by taking the comap of `f` with the infimum (over `ι`) of the uniform spaces `u i` equals the infimum (over `ι`) of the uniform spaces obtained by taking the comap of `f` with each `u i`. In other words, the process of taking the comap of a function with a uniform space commutes with taking the infimum of a family of uniform spaces.

For any indexing type `ι`, type `α`, type `γ`, function `f` from `α` to `γ`, and family `u` of uniform spaces on `γ` indexed by `ι`, the uniform space on `α` obtained by composing `f` with the infimum of `u` equals the infimum of the uniform spaces obtained by composing `f` with each `u i`.


theorem StrictMono.tendsto_atTop : ∀ {φ : ℕ → ℕ}, StrictMono φ → Filter.Tendsto φ Filter.atTop Filter.atTop := by sorry

The theorem `StrictMono.tendsto_atTop` states that for any strictly monotone function `φ` from natural numbers to natural numbers, the function `φ` tends to infinity as its argument tends to infinity. In other words, if for every pair of natural numbers `a` and `b`, where `a < b`, it holds that `φ(a) < φ(b)`, then for every neighborhood of infinity in the codomain, the preimage under `φ` is a neighborhood of infinity in the domain.

For any strictly monotonic function φ from natural numbers to natural numbers, if for all a < b, φ(a) < φ(b), then φ is unbounded.


theorem Group.closure_subset :
    ∀ {G : Type u_1} [inst : Group G] {s t : Set G}, IsSubgroup t → s ⊆ t → Group.closure s ⊆ t := by sorry

The theorem `Group.closure_subset` states that for any type `G` that forms a group, and for any subsets `s` and `t` of `G`, if `t` is a subgroup of `G` and `s` is a subset of `t`, then the closure of `s` (i.e., the smallest subgroup of `G` containing `s`) is also a subset of `t`. In other words, if a set `s` is contained in a subgroup, then the smallest subgroup generated by `s` is also contained within that same subgroup.

For any group `G`, if `s` is a subset of subgroup `t` of `G`, then the closure of `s` in `G` is contained in `t`.


theorem CategoryTheory.NonPreadditiveAbelian.neg_def :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (a : X ⟶ Y), -a = 0 - a :=
  by sorry

This theorem states that for any category `C` that is NonPreadditiveAbelian and for any objects `X` and `Y` in this category, the negation of a morphism `a` from `X` to `Y` is equivalent to subtracting `a` from zero. In other words, `-a` is equal to `0 - a` in the context of this particular category theory.

In a NonPreadditiveAbelian category, the negation of a morphism is equivalent to subtracting the morphism from the identity morphism of the zero object.


theorem NormedSpace.expSeries_apply_eq :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸]
      [inst_3 : TopologicalSpace 𝔸] [inst_4 : TopologicalRing 𝔸] (x : 𝔸) (n : ℕ),
      ((NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) = (↑(Nat.factorial n))⁻¹ • x ^ n :=
  by sorry

The theorem `NormedSpace.expSeries_apply_eq` states that for any field `𝕂`, ring `𝔸` with `𝔸` being an algebra over `𝕂`, a topological space and a topological ring, then for any element `x` of `𝔸` and natural number `n`, the `n`-th term of the exponential series at `x` equals to the reciprocal of the factorial of `n` times `x` raised to the power `n`.

For any field 𝕂, topological space, and topological ring 𝔸 being an algebra over 𝕂, the `n`-th term of the exponential series of an element `x` in 𝔸 equals to `(1/n!) * x^n`.


theorem norm_one' : ∀ {E : Type u_6} [inst : SeminormedGroup E], ‖1‖ = 0 := by sorry

This theorem, named `norm_one'`, states that for any given type `E` that forms a seminormed group, the norm of `1` is equal to `0`. In mathematical terms, it could be written as ‖1‖ = 0 for all seminormed groups `E`. This theorem is important in the field of functional analysis, where norms and seminorms are used to measure the size or length of elements in a vector space.

For any seminormed group `E`, the norm of the identity element 1 is zero.


theorem SetTheory.PGame.birthday_def :
    ∀ (x : SetTheory.PGame),
      SetTheory.PGame.birthday x =
        max (Ordinal.lsub fun i => SetTheory.PGame.birthday (SetTheory.PGame.moveLeft x i))
          (Ordinal.lsub fun i => SetTheory.PGame.birthday (SetTheory.PGame.moveRight x i)) :=
  by sorry

The theorem `SetTheory.PGame.birthday_def` states that for any pre-game `x`, the birthday of `x` is defined as the maximum of two values: the least strict upper bound of the birthdays of the games resulting from all possible left moves from `x`, and the least strict upper bound of the birthdays of the games resulting from all possible right moves from `x`. In other words, the birthday of a game is determined by the highest birthday of any subsequent game that can be reached by making a legal move, either by the Left or the Right player.

The birthday of a pre-game is the maximum of the least upper bounds of the birthdays of its possible left and right successor games.


theorem ENNReal.coe_mono : Monotone ENNReal.ofNNReal := by sorry

The theorem `ENNReal.coe_mono` states that the function `ENNReal.ofNNReal`, which is a coercion from nonnegative real numbers (`ℝ≥0` or `NNReal` in Lean 4) to extended nonnegative real numbers (`ℝ≥0∞` or `ENNReal` in Lean 4), is a monotone function. In mathematical terms, if `a` and `b` are nonnegative real numbers and `a ≤ b`, then `ENNReal.ofNNReal a ≤ ENNReal.ofNNReal b`. This means that the extended nonnegative real number corresponding to `a` is less than or equal to the extended nonnegative real number corresponding to `b`.

The coercion `ENNReal.ofNNReal` from nonnegative real numbers to extended nonnegative real numbers is a monotone function.


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

This theorem, `le_of_smul_le_smul_left`, states that for any types `α` and `β`, given an instance of the `SMul α β` type class (indicating that elements of type `α` can scale elements of type `β`), instances of `Preorder α` and `Preorder β` (implying that both `α` and `β` have a "less than or equal to" relation), an instance of `Zero α` (indicating that `α` has a notion of zero), and an instance of `PosSMulReflectLE α β` (indicating that positive scaling reflects order in `β`), if `a • b₁` is less than or equal to `a • b₂` and `a` is greater than zero, then `b₁` is less than or equal to `b₂`. In other words, if one quantity scaled by a positive scalar is smaller or equal to another quantity scaled by the same scalar, then the original quantity is also smaller or equal to the other quantity.

Given `α` and `β` types with `Preorder`, `SMul`, `Zero`, and `PosSMulReflectLE` instances, if `a > 0`, `a * b₁ ≤ a * b₂` implies `b₁ ≤ b₂`.


Dilation.antilipschitz

theorem Dilation.antilipschitz :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F), AntilipschitzWith (Dilation.ratio f)⁻¹ ⇑f :=
  by sorry

The theorem `Dilation.antilipschitz` states that for any types `α`, `β`, `F` and for any term `f` of type `F`, if `α` and `β` are pseudo emetric spaces, `F` is a function-like type from `α` to `β`, and `F` satisfies the dilation conditions, then the function `f` is antilipschitz with a constant equal to the inverse of the dilation ratio of `f`. In other words, the extended distance between any two points in the domain is bounded above by the inverse of the dilation ratio of `f` times the extended distance between the images of these two points under `f`.

Given functions `f : α → β` between pseudo-metric spaces `(α, dα)` and `(β, dβ)`, if `f` is a dilation map with dilation ratio `r`, then `f` is an antilipschitz function with constant `1/r`.


sSupHom.ext

theorem sSupHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SupSet α] [inst_1 : SupSet β] {f g : sSupHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, `sSupHom.ext`, states that for any two sup-semilattice homomorphisms `f` and `g` from one type `α` to another type `β` (where both `α` and `β` are sup-semilattices), if `f` and `g` agree on every element of `α` (in other words, for all `a` in `α`, `f(a)` equals `g(a)`), then `f` and `g` are proven to be equal. This demonstrates the principle of function extensionality for sup-semilattice homomorphisms.

If two sup-semilattice homomorphisms from one sup-semilattice to another agree on every element, then they are equal.


theorem StrictAnti.le_iff_le :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      StrictAnti f → ∀ {a b : α}, f a ≤ f b ↔ b ≤ a :=
  by sorry

The theorem, `StrictAnti.le_iff_le`, states that for any types `α` and `β`, which have the structure of a linear order and a preorder respectively, and for any function `f` from `α` to `β` that is strictly antitone (meaning if `a < b` then `f(b) < f(a)`), the statement `f(a) ≤ f(b)` is equivalent to `b ≤ a`. This simply expresses that if we have a strictly decreasing function between two ordered sets, then the order of the function values reverses the order of their arguments.

For any strictly antitone function between linearly ordered types, the order of their images reverses the order of their arguments.


theorem Set.ordConnected_Iio : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.OrdConnected (Set.Iio a) := by sorry

This theorem states that for any type `α` with a preorder (`Preorder α`), and for any element `a` of type `α`, the left-infinite right-open interval up to 'a' (denoted as `Set.Iio a`) is ordered-connected. Ordered-connectedness means that for any two elements in the set, all elements between them (in the order) are also contained within the set. In other words, for any set of numbers, if we take two numbers from the set, all the numbers in between them also belong to the set.

For any type `α` with a preorder and any element `a` in `α`, the left-infinite right-open interval `Set.Iio a` is ordered-connected, meaning any two elements in the interval have every element between them also in the interval.


theorem Set.ordConnected_Iic : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.OrdConnected (Set.Iic a) := by sorry

This theorem states that for any type `α` that has a preorder relation, and any element `a` of type `α`, the left-infinite right-closed interval up to `a` (denoted as `Set.Iic a`) is order-connected. In mathematical terms, an interval is order-connected if, given any two elements in the interval, any element that is between these two elements is also in the interval. Here, the interval is defined as the set of all elements `x` of type `α` such that `x` is less than or equal to `a`.

For any type `α` with a preorder relation and any element `a` in `α`, the left-infinite right-closed interval `{x : α | x ≤ a}` is order-connected.


theorem Filter.HasBasis.disjoint_iff_left :
    ∀ {α : Type u_1} {ι : Sort u_4} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → (Disjoint l l' ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l') :=
  by sorry

This theorem states that for any types `α` and `ι`, along with two filters `l` and `l'` on `α`, a predicate `p : ι → Prop` and a function `s : ι → Set α` that gives a set for each `ι`, if `l` has a basis defined by `p` and `s`, then `l` and `l'` are disjoint if and only if there exists some `i` such that `p i` is true and the complement of `s i` is in `l'`. In other words, the filters `l` and `l'` are disjoint if there exists an `i` satisfying `p` such that all elements not in the set `s i` are in `l'`. This theorem allows us to characterize the disjointness of two filters in terms of the basis of one of them.

For filters $l$ and $l'$ on type $\alpha$, if $l$ has basis given by predicate $p$ and function $s$, then $l$ and $l'$ are disjoint if and only if there exists an $i$ such that $p(i)$ holds and the complement of $s(i)$ is contained in $l'$.


theorem Real.Angle.pi_div_two_ne_zero : ↑(Real.pi / 2) ≠ 0 := by sorry

This theorem states that the value of π divided by 2, when mapped from the real numbers to the complex numbers, is not equal to zero. In other words, half of π does not map to the complex zero.

The theorem asserts that π/2 ≠ 0 in the complex numbers.


theorem Fintype.card_sigma :
    ∀ {α : Type u_4} (β : α → Type u_5) [inst : Fintype α] [inst_1 : (a : α) → Fintype (β a)],
      Fintype.card (Sigma β) = Finset.sum Finset.univ fun a => Fintype.card (β a) :=
  by sorry

The theorem `Fintype.card_sigma` states that for any type `α` and a function `β : α → Type u_5`, given that `α` and `β a` for all `a : α` are finite types (`Fintype`), the total number of elements in the dependent pair type `(Sigma β)` is equal to the sum of the number of elements in each `β a`, as `a` ranges over the universal finite set of type `α`. In other words, it expresses the cardinality of a disjoint union of finite sets in terms of the sum of the cardinalities of each individual set.

The theorem `Fintype.card_sigma` asserts that the cardinality of the dependent sum of a family of finite types indexed by a finite type equals the sum of the cardinalities of each individual type.


/-- An induction principle for closure membership. If `p` holds for all elements of `s`, and
is preserved under multiplication, then `p` holds for all elements of the closure of `s`.  -/
theorem Subsemigroup.closure_induction :
    ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {p : M → Prop} {x : M},
      x ∈ Subsemigroup.closure s → (∀ x ∈ s, p x) → (∀ (x y : M), p x → p y → p (x * y)) → p x :=
  by sorry

The theorem `Subsemigroup.closure_induction` is an induction principle for membership in the closure of a set in a semigroup. It states that for any type `M` with a multiplication operation, a set `s` of elements of `M`, a property `p` that elements of `M` might satisfy, and an element `x` of `M`, if `x` is in the closure of `s` under the semigroup operation, and if `p` is true for all elements of `s` and is preserved under the multiplication operation (i.e., whenever `p` is true for two elements `x` and `y`, it is also true for their product `x * y`), then `p` is true for `x`. This essentially allows us to prove properties about elements in the closure of `s` by showing they hold for elements in `s` and are preserved under multiplication.

If `s` is a closed semigroup under multiplication, `x` is in the closure of `s`, and `p(y)` holds for all `y` in `s` with `p(x * y)` following from `p(x)` and `p(y)`, then `p(x)` holds.


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

This theorem states that for any type `M` that is an `AddRightCancelMonoid`, given any two elements `a` and `b` of type `M`, the sum of `a` and `b` equals `b` if and only if `a` is zero. In other words, in the context of a monoid where the right cancellation law holds (i.e., for all `a`, `b`, and `c` in `M`, if `a + b = a + c`, then `b = c`), the only element `a` that when added to another element `b` equals `b`, is the zero element.

For any AddRightCancelMonoid `M`, an element `a` of `M` satisfies `a + b = b` if and only if `a` is the zero element of `M`.


theorem forall₂_imp :
    ∀ {α : Sort u_5} {β : α → Sort u_1} {p q : (a : α) → β a → Prop},
      (∀ (a : α) (b : β a), p a b → q a b) → (∀ (a : α) (b : β a), p a b) → ∀ (a : α) (b : β a), q a b :=
  by sorry

This theorem says that for all types `α` and indexed type `β`, and for any predicates `p` and `q` that take two arguments (an element of `α` and an element of `β` indexed by that `α`), if it is true that `p a b` implies `q a b` for all `a` in `α` and `b` in `β a`, and if it is true that `p a b` holds for all `a` and `b`, then it must also be true that `q a b` holds for all `a` and `b`. Essentially, it's stating a kind of transitivity rule for universally quantified, two-argument predicates.

If `p(a, b)` implies `q(a, b)` for all `a` and `b`, and `∀a, ∃b, p(a, b)`, then `∀a, ∀b, q(a, b)`.


theorem measurable_coe_nnreal_ennreal : Measurable ENNReal.ofNNReal := by sorry

The theorem `measurable_coe_nnreal_ennreal` states that the function `ENNReal.ofNNReal`, which coerces a non-negative real number (`ℝ≥0` or `NNReal` in Lean) to an extended non-negative real number (`ℝ≥0∞` or `ENNReal` in Lean), is a measurable function. In other words, for every measurable set in the space of extended non-negative real numbers, the preimage of the set under the function `ENNReal.ofNNReal` is also a measurable set in the space of non-negative real numbers.

The coerction function `ENNReal.ofNNReal` from non-negative reals to extended non-negative reals is measurable.


theorem List.pwFilter_cons_of_pos :
    ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] {a : α} {l : List α},
      (∀ b ∈ List.pwFilter R l, R a b) → List.pwFilter R (a :: l) = a :: List.pwFilter R l :=
  by sorry

The theorem `List.pwFilter_cons_of_pos` states that for any type `α`, any decidable relation `R` on `α`, any element `a` of `α`, and any list `l` of `α`, if `a` has the relation `R` with all elements in the list obtained by applying the `pwFilter` function with the relation `R` to the list `l`, then applying the `pwFilter` function with the relation `R` to the list obtained by prepending `a` to `l` results in the list obtained by prepending `a` to the list obtained by applying the `pwFilter` function with the relation `R` to `l`. In other words, if all elements in the `pwFilter` of a list satisfy a certain relation with a given element, then this element stays at the head of the list when we apply `pwFilter`.

If `a` is in the `pwFilter` of `l` with respect to relation `R`, then `a` is at the head of the `pwFilter` of the list `a :: l`.


theorem dist_add_left :
    ∀ {M : Type u} [inst : PseudoMetricSpace M] [inst_1 : Add M] [inst_2 : IsometricVAdd M M] (a b c : M),
      dist (a + b) (a + c) = dist b c :=
  by sorry

This theorem, referred to as `dist_add_left`, states that for any type `M` that is a pseudo metric space (a space where distances between points are defined and satisfy certain properties), and supports addition and isometric vector addition (meaning it has a "size" or "length" that is preserved under addition), the distance between the sum of `a` and `b` and the sum of `a` and `c` is equivalent to the distance between `b` and `c`. Simply put, it says that in such a space, adding the same element `a` to two different points `b` and `c` does not change the distance between those points.

In a pseudo metric space with isometric vector addition, the distance between `a + b` and `a + c` is equal to the distance between `b` and `c`.


theorem uniformContinuous_comap : ∀ {α : Type ua} {β : Type ub} {f : α → β} [u : UniformSpace β], UniformContinuous f :=
  by sorry

The theorem `uniformContinuous_comap` states that for any two types `α` and `β`, and for any function `f` mapping from `α` to `β`, if `β` is equipped with a uniform space structure, then the function `f` is uniformly continuous. In the context of mathematics, uniformly continuous means that the closeness of the output values `f(x)` and `f(y)` depends only on the closeness of the input values `x` and `y`, and it does not matter where `x` and `y` are located within the space `α`.

If `α` is a type and `β` is a uniform space, and `f : α → β` is a function, then `f` is uniformly continuous.


/-- The linear map on the result of subtracting two points is the
result of subtracting the result of the affine map on those two
points.  -/
theorem AffineMap.linearMap_vsub :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
      [inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
      [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] (f : P1 →ᵃ[k] P2) (p1 p2 : P1),
      f.linear (p1 -ᵥ p2) = f p1 -ᵥ f p2 :=
  by sorry

This theorem states that for any affine map `f`, which maps points in an affine space `P1` over a ring `k` to another affine space `P2`, and any two points `p1` and `p2` in `P1`, applying the linear map associated with `f` to the vector obtained by subtracting `p2` from `p1` is the same as subtracting the image of `p2` (under `f`) from the image of `p1` (under `f`). In other words, the action of the linear map on the difference of two points in the original space corresponds to the difference of their images in the target space.

For any affine map f from an affine space P1 over a ring k to an affine space P2, the linear map associated with f maps the difference of any two points in P1 to the difference of their images in P2.


/-- The **binomial theorem**  -/
theorem add_pow :
    ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (n : ℕ),
      (x + y) ^ n = Finset.sum (Finset.range (n + 1)) fun m => x ^ m * y ^ (n - m) * ↑(Nat.choose n m) :=
  by sorry

The **binomial theorem** states that for any commutative semiring `R` and any elements `x` and `y` of `R`, the `n`-th power of the sum of `x` and `y` is equal to the sum, as `m` ranges from `0` to `n`, of the product of `x` to the power `m`, `y` to the power `(n - m)`, and the binomial coefficient `n choose m`. This binomial coefficient represents the number of ways to choose `m` elements from a set of `n` elements. The theorem can be represented mathematically as: \((x + y)^n = \sum_{m=0}^{n} x^m y^{n-m} \binom{n}{m}\).

For any commutative semiring `R` and elements `x` and `y` in `R`, the `n`-th power of `x + y` equals the sum, over `m` from 0 to `n`, of `x^m * y^(n-m)` multiplied by the binomial coefficient `n choose m`.


theorem Complex.mul_cpow_ofReal_nonneg : ∀ {a b : ℝ}, 0 ≤ a → 0 ≤ b → ∀ (r : ℂ), (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r := by
  sorry

This theorem states that for all real numbers `a` and `b` that are nonnegative (i.e., `a` and `b` are greater than or equal to zero), and for any complex number `r`, the complex power of the product of `a` and `b` is equal to the product of the complex powers of `a` and `b`. In other words, `(a * b) ^ r = a ^ r * b ^ r` where the operations are performed in the complex field. This theorem generalizes a familiar property of exponents in the field of real numbers to the field of complex numbers.

For all nonnegative real numbers `a` and `b` and any complex number `r`, `(a * b) ^ r = a ^ r * b ^ r`.


theorem Associates.quot_out : ∀ {α : Type u_1} [inst : Monoid α] (a : Associates α), Associates.mk (Quot.out a) = a :=
  by sorry

This theorem, `Associates.quot_out`, states that for any type `α` that has a monoid structure and any element `a` of the `Associates` of `α`, if we first take an element from the equivalence class of `a` using `Quot.out` and then map back to the `Associates` of `α` using `Associates.mk`, we get the original element `a` back. In other words, it verifies that the process of picking a representative from an equivalence class and then finding the equivalence class again will yield the original equivalence class. The theorem encapsulates the idea that the `Associates.mk` and `Quot.out` operations are inverse to each other up to the equivalence relation.

For any type `α` with a monoid structure and any `a` in the associates of `α`, `Associates.mk (Quot.out a) = a` holds up to the associates equivalence relation.


theorem Polynomial.Monic.eq_one_of_isUnit :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.Monic p → IsUnit p → p = 1 := by sorry

The theorem `Polynomial.Monic.eq_one_of_isUnit` states that for all types `R` that have a semiring structure, for any polynomial `p` over `R`, if `p` is a monic polynomial and `p` is a unit (i.e., it has a two-sided inverse), then `p` is equal to the polynomial `1`. In mathematical terms, given a polynomial `p` in a semiring `R`, if the leading coefficient of `p` is `1` and there exists an element `q` in `R` such that `p*q = 1` and `q*p = 1`, then `p` is the polynomial `1`.

If `p` is a monic polynomial over a semiring `R` with a two-sided inverse, then `p = 1`.


theorem continuousOn_inv₀ :
    ∀ {G₀ : Type u_3} [inst : Zero G₀] [inst_1 : Inv G₀] [inst_2 : TopologicalSpace G₀] [inst_3 : HasContinuousInv₀ G₀],
      ContinuousOn Inv.inv {0}ᶜ :=
  by sorry

This theorem states that for any type `G₀`, which is equipped with a zero element, an inversion operation, and a topological space structure, and also assuming that the inversion operation is continuous except at zero (`HasContinuousInv₀ G₀`), then the inversion function (`Inv.inv`) is continuous on the set of all elements of `G₀` excluding zero (`{0}ᶜ`). In simpler terms, if you have a space where you can flip elements around zero, and this flipping operation is continuous except at zero, then this flipping operation is continuous everywhere except at zero.

If `G₀` is a topological space with a zero element, an inversion operation, and `HasContinuousInv₀ G₀`, then the inversion function `Inv.inv` is continuous on `G₀ \ {0}`.


Measurable.pow

theorem Measurable.pow :
    ∀ {β : Type u_2} {γ : Type u_3} {α : Type u_4} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace γ]
      [inst_2 : Pow β γ] [inst_3 : MeasurablePow β γ] {m : MeasurableSpace α} {f : α → β} {g : α → γ},
      Measurable f → Measurable g → Measurable fun x => f x ^ g x :=
  by sorry

The theorem `Measurable.pow` states that for any types `β`, `γ`, and `α`, where `β` and `γ` have `MeasurableSpace` instances and a `Pow` operation, and `β` and `γ` also have a `MeasurablePow` instance, if we have a measurable space `m` of type `α`, and two functions `f : α → β` and `g : α → γ` such that `f` and `g` are measurable, then the function that takes an input `x` of type `α` and maps it to the power of `f x` by `g x` is also measurable. In simpler terms, this theorem asserts that the power of two measurable functions is also measurable.

If `β` and `γ` are measurable spaces with measurable powers, and `f : α → β` and `g : α → γ` are measurable functions, then the function `x ↦ f x^g x` is measurable.


theorem Int.ne_of_lt : ∀ {a b : ℤ}, a < b → a ≠ b := by sorry

This theorem states that for any two integers `a` and `b`, if `a` is less than `b`, then `a` is not equal to `b`. Essentially, it asserts the inconsistency of an integer being simultaneously less than and equal to another specific integer.

For all integers a and b, if a < b then a ≠ b.


theorem Int.emod_two_eq_zero_or_one : ∀ (n : ℤ), n % 2 = 0 ∨ n % 2 = 1 := by sorry

This theorem states that for every integer `n`, the remainder when `n` is divided by 2 is either 0 or 1. In other words, if you take any integer `n` and calculate `n modulo 2`, the result will always be either 0 (if `n` is even) or 1 (if `n` is odd).

For every integer `n`, the remainder of `n` when divided by 2 is either 0 or 1. (Or equivalently, every integer `n` is congruent to 0 or 1 modulo 2.)


theorem CategoryTheory.Adjunction.unit_naturality_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) {X Y : C} (f : X ⟶ Y) {Z : C} (h : G.obj (F.obj Y) ⟶ Z),
      CategoryTheory.CategoryStruct.comp (adj.unit.app X) (CategoryTheory.CategoryStruct.comp (G.map (F.map f)) h) =
        CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (adj.unit.app Y) h) :=
  by sorry

This theorem states that for any two categories `C` and `D` with a pair of functors `F` (from `C` to `D`) and `G` (from `D` to `C`) that form an adjunction, and for any two objects `X` and `Y` in `C` with a morphism `f` from `X` to `Y`, the unit of the adjunction behaves naturally. Specifically, for any object `Z` in `C` and a morphism `h` from `G(F(Y))` to `Z`, the composition of the unit at `X` with the composition of the `G`-image of the `F`-image of `f` and `h`, is the same as the composition of `f` with the composition of the unit at `Y` and `h`.

In other words, this theorem is saying that the following square commutes in category `C`:
```
    F(X) --(unit at X)--> G(F(X)) --(G(F(f)))--> G(F(Y))
     |                                              |
  F(f)                                             (unit at Y)
     |                                              |
    v                                              v
    F(Y) --(unit at Y)--> G(F(Y)) --(h)--> Z
```
Here, the vertical arrows are given by the functor `F` and `h`, and the horizontal arrows are given by the unit of the adjunction. The theorem is stating that going from `F(X)` to `Z` via the top path yields the same result as going via the bottom path.

 For any adjunction between categories `C` and `D` given by functors `F: C -> D` and `G: D -> C`, and for any objects `X, Y in C` and morphisms `f: X -> Y` and `h: G(F(Y)) -> Z` in `C`, the unit of the adjunction at `X` and composition with `h` is equal to composition with `F(f)` and the unit at `Y` and `h`. In other words, the following square commutes:

```
F(X) ---- (unit at X) ---- G(F(X)) ----> G(F(Y))
|         |                         |
|         v                         v
| F(f)                            h
| |                               |
| v                               v
F(Y) ---- (unit at Y) ---- G(F(Y)) ----> Z
```


theorem Filter.limsup_congr :
    ∀ {β : Type u_2} {α : Type u_6} [inst : ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β},
      (∀ᶠ (a : α) in f, u a = v a) → Filter.limsup u f = Filter.limsup v f :=
  by sorry

The theorem `Filter.limsup_congr` states that for any types `β` and `α` with `β` being a conditionally complete lattice, and for any filter `f` on `α` and any two functions `u` and `v` from `α` to `β`, if it is the case that for all `a` eventually in `f`, `u(a)` equals `v(a)`, then the limit superior (limsup) of `u` along `f` is equal to the limit superior of `v` along `f`.

In less technical terms, it says that if two functions are eventually the same for all elements in a certain filter, then the limsup of the two functions over that filter are also the same.

If `β` is a conditionally complete lattice and `f` is a filter on `α`, then for functions `u` and `v` from `α` to `β` with `u(a) = v(a)` for all `a` eventually in `f`, it holds that `limsup(u) = limsup(v)` along `f`.


theorem Finsupp.sum_fintype :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] [inst_2 : Fintype α]
      (f : α →₀ M) (g : α → M → N),
      (∀ (i : α), g i 0 = 0) → Finsupp.sum f g = Finset.sum Finset.univ fun i => g i (f i) :=
  by sorry

The theorem `Finsupp.sum_fintype` states that for any types `α`, `M`, and `N`, given `M` is a type with a zero element and `N` is a type forming an additive commutative monoid, and `α` is a finite type. If we have a function `f` from `α` to `M` and a function `g` from `α` and `M` to `N` such that `g i 0 = 0` for all `i` in `α`, then the sum of `g a (f a)` over the support of `f` is equal to the sum of `g i (f i)` for every element `i` in the universal finite set of type `α`. This sum is defined in terms of `Finset.sum`, which sums a function over elements of a finite set, and `Finsupp.sum`, which sums a function over the support of another function.

For any finite type `α`, functions `f : α → M` and `g : α × M → N` with `M` an additive commutative monoid and `g(i, 0) = 0` for all `i` in `α`, the sum of `g(i, f(i))` over `α` equals the sum of `g(i, f(i))` over the support of `f` according to `Finset.sum` and `Finsupp.sum`.


theorem Mathlib.Combinatorics.SimpleGraph.Connectivity._auxLemma.6 :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      (u ∈ SimpleGraph.Walk.support p) = True :=
  by sorry

This theorem states that for any SimpleGraph `G` with vertices of type `V`, and any two vertices `u` and `v` in `G`, if there exists a walk `p` from `u` to `v`, then `u` is always an element of the support of `p`. The support of a walk is the list of vertices the walk visits in order.

For any SimpleGraph `G` and vertices `u` and `v` in `G`, if there exists a walk from `u` to `v`, then `u` is in the support of that walk.


theorem affineSegment_image :
    ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : OrderedRing R]
      [inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : AddTorsor V P] [inst_4 : AddCommGroup V']
      [inst_5 : Module R V'] [inst_6 : AddTorsor V' P'] (f : P →ᵃ[R] P') (x y : P),
      ⇑f '' affineSegment R x y = affineSegment R (f x) (f y) :=
  by sorry

This theorem states that for any affine transformation `f` from a point `P` to another point `P'`, the image of an affine segment between two points `x` and `y` under `f` is equivalent to the affine segment between the images of `x` and `y` under `f`. In other words, an affine transformation preserves the affine segments. Here, `P` and `P'` can be considered as points in vector spaces `V` and `V'` over the ordered ring `R`, respectively.

Given affine transformations `f` from vector space `V` over ordered ring `R` and points `x, y` in `V`, the image of the affine segment `[x, y]` under `f` is equivalent to the affine segment `[fx, fy]`.


theorem min_le_max : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, min a b ≤ max a b := by sorry

This theorem states that in a linearly ordered type `α`, for any two elements `a` and `b` of that type, the minimum of `a` and `b` is less than or equal to the maximum of `a` and `b`. In mathematical terms, this corresponds to the fact that for any two elements in a set that is linearly ordered (like the real numbers, for example), the smaller one is always less than or equal to the larger one.

In a linearly ordered type, the minimum of any two elements is less than or equal to their maximum.


theorem Multiset.quot_mk_to_coe : ∀ {α : Type u_1} (l : List α), ⟦l⟧ = ↑l := by sorry

This theorem is stating that for any list `l` of an arbitrary type `α`, the multiset that `l` is embedded into (denoted by ⟦l⟧) is equivalent to the coe of `l`, where coe is a coercion function that converts the list into a multiset. Essentially, this theorem is asserting that any list can be viewed as a multiset and vice versa.

For any list `l` of type `α`, the multiset ⟦l⟧ is equivalent to the coerced multiset of `l`.


theorem Filter.cocompact_eq_bot :
    ∀ {X : Type u} [inst : TopologicalSpace X] [inst_1 : CompactSpace X], Filter.cocompact X = ⊥ := by sorry

This theorem states that for any type `X` equipped with a topological space structure and also being a compact space (i.e., any subset of `X` can be covered by a finite number of open sets in `X`), the filter generated by the complements of compact sets in `X`, denoted as `Filter.cocompact X`, is equal to the bottom filter (`⊥`). The bottom filter is the filter containing all subsets of `X`.

For any compact topological space X, the filter of all subsets of X whose complements are compact is equal to the bottom filter.


theorem Set.monotone_powerset : ∀ {α : Type u}, Monotone Set.powerset := by sorry

The theorem `Set.monotone_powerset` states that for all types `α`, the powerset function is monotone. In other words, for any two sets `a` and `b` of type `α`, if `a` is a subset of `b` (`a ≤ b`), then the powerset of `a` is a subset of the powerset of `b` (`Set.powerset a ≤ Set.powerset b`). The powerset of a set is the set of all its subsets.

For any type `α`, the powerset function is monotone, that is, for all sets `a` and `b` of type `α`, if `a` is a subset of `b`, then `Set.powerset a` is a subset of `Set.powerset b`.


theorem Finset.lcm_dvd :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
      {f : β → α} {a : α}, (∀ b ∈ s, f b ∣ a) → Finset.lcm s f ∣ a :=
  by sorry

The theorem `Finset.lcm_dvd` states that for any type `α` that is a cancel commutative monoid with zero and a normalized GCD monoid, and for any finite set `s` of type `β`, if every element `b` in `s`, when mapped to `α` using function `f`, divides `a`, then the least common multiple (lcm) of the set `s` under the function `f` also divides `a`. In mathematical notation, this can be written as: If $f(b) | a$ for all $b \in s$, then $\operatorname{lcm}(s,f) | a$.

If `f : α -> α` maps every element `b` in a finite set `s` of type `β` to a factor of `a` in a cancel commutative monoid with zero and normalized GCD monoid, then the least common multiple of `s` under `f` is a factor of `a`.


BoundedOrderHom.ext

theorem BoundedOrderHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : BoundedOrder α]
      [inst_3 : BoundedOrder β] {f g : BoundedOrderHom α β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that given two types `α` and `β` which are preordered and have a bounded order, and given two bounded order homomorphisms `f` and `g` from `α` to `β`, if for every element `a` of type `α`, `f(a)` equals `g(a)`, then `f` and `g` must be the same bounded order homomorphism. In other words, it asserts the uniqueness of a bounded order homomorphism under the condition that they map each element in the domain to the same element in the codomain.

If two bounded order homomorphisms between preordered types with a bounded order map every element to the same image, then they are equal.


theorem LipschitzWith.prod_fst :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β],
      LipschitzWith 1 Prod.fst :=
  by sorry

This theorem states that for any types `α` and `β` that are both instances of a `PseudoEMetricSpace`, the first projection function `Prod.fst` is Lipschitz continuous with a Lipschitz constant of `1`. In mathematical terms, this means that for any pair of points `(x, y)` and `(w, z)` in the product space `α × β`, the distance between `x` and `w` in the space `α` is less than or equal to the distance between `(x, y)` and `(w, z)` in the product space `α × β`.

The first projection function of a product of two pseudo-metric spaces is Lipschitz continuous with Lipschitz constant 1.


theorem Finset.card_union_le :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∪ t).card ≤ s.card + t.card := by sorry

This theorem, `Finset.card_union_le`, states that for any type `α` that has decidable equality and for any two finite sets `s` and `t` of type `α`, the cardinality (or size) of the union of `s` and `t` is less than or equal to the sum of the cardinalities of `s` and `t`. In other words, the size of the union of two sets is always less than or equal to the sum of the sizes of the two sets. This is analogous to the principle of inclusion-exclusion in set theory.

For any type `α` with decidable equality and any finite sets `s` and `t` of type `α`, `Card s.union t <= Card s + Card t`.


MeasurableSet.pi

theorem MeasurableSet.pi :
    ∀ {δ : Type u_4} {π : δ → Type u_6} [inst : (a : δ) → MeasurableSpace (π a)] {s : Set δ} {t : (i : δ) → Set (π i)},
      Set.Countable s → (∀ i ∈ s, MeasurableSet (t i)) → MeasurableSet (Set.pi s t) :=
  by sorry

The theorem `MeasurableSet.pi` states that for any type `δ`, a function `π` mapping `δ` to some type, and a given measurable space for each `δ`, if we have a countable set `s` of type `δ` and a family of sets `t` where each set `t i` is a set of type `π i`, then if all sets `t i` where `i` belongs to `s` are measurable sets, the set `Set.pi s t` of dependent functions `f : Πa, π a` such that `f a` belongs to `t a` whenever `a ∈ s` is also a measurable set. In simpler terms, it means if we have a collection of measurable sets indexed by a countable set, then the set of all functions that map each index to its corresponding set is also measurable.

If `π : δ →* X` is a function, `s : set δ` is countable, and `t i : set (π i)` is measurable for each `i ∈ s`, then `Set.image (λ a : s, t a) (λ a : δ, π a)` is a measurable subset of `X^s`.


theorem le_sdiff_sup : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a ≤ a \ b ⊔ b := by sorry

This theorem states that for any type `α` that forms a Generalized Coheyting Algebra and any two elements `a` and `b` of this type, `a` is less than or equal to the supremum of `a` subtract `b` and `b`. In other words, in such an algebra, any element `a` is always less than or equal to the join of the difference of `a` and `b` with `b` itself. In the language of set theory, if we think of `\` as set difference and `⊔` as union, this is saying that any set `a` is always a subset of the union of `a` without `b` and `b`.

For any type `α` forming a Generalized Codense lattice and any `a, b` in `α`, `a ≤ a⊕ b`, where `⊕` denotes the join operation and `⊓` the meet operation, hence `a⊕ b` is the supremum of `a` and `b`, such that `a ⊓ (−b) = a − b`.


theorem Multiset.cons_swap : ∀ {α : Type u_1} (a b : α) (s : Multiset α), a ::ₘ b ::ₘ s = b ::ₘ a ::ₘ s := by sorry

The theorem `Multiset.cons_swap` states that for all types α, and for any elements `a` and `b` of that type, and a multiset `s` of that type, prepending the multiset `s` first with `a` and then with `b` results in the same multiset as prepending `s` first with `b` and then with `a`. In other words, the order of elements added to the beginning of a multiset does not affect the resulting multiset. This follows from the fact that a multiset is a type of finite sets with duplicates allowed, and sets do not consider the order of their elements.

For all types α and elements a, b of type α, and any multiset s of type α, the multisets [a] ++ s and b ++ [a] are equal, where [a] and [b] denote the singleton multisets.


theorem Submodule.smul_mono_right :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Ideal R}
      {N P : Submodule R M}, N ≤ P → I • N ≤ I • P :=
  by sorry

The theorem `Submodule.smul_mono_right` states that for any commutative semiring `R`, any additive commutative monoid `M` and any module `M` over `R`, if `N` and `P` are submodules of `M` and `N` is a subset of `P`, then the scaling of `N` by an ideal `I` of `R` is a subset of the scaling of `P` by `I`. In other words, scaling preserves the subset relation between submodules in a module over a commutative semiring.

For any commutative semiring `R`, additive commutative monoid `M`, module `M` over `R`, submodules `N` and `P` of `M`, and ideal `I` of `R`, if `N` is a subset of `P`, then `I • N` (the scaling of `N` by `I`) is a subset of `I • P` (the scaling of `P` by `I`).


theorem Multiset.mem_of_mem_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Multiset α}, a ∈ Multiset.erase s b → a ∈ s := by sorry

This theorem states that for any type `α` that has decidable equality, any given elements `a` and `b` of `α`, and any multiset `s` of `α`, if `a` is an element of the multiset obtained by erasing `b` from `s` (`Multiset.erase s b`), then `a` is also an element of the original multiset `s`. In other words, erasing an element from a multiset doesn't indicate the presence of other elements in the modified multiset.

If `α` has decidable equality, `a` is an element of the multiset `s` implies `a` is an element of `Multiset.erase s b`.


theorem Multiset.card_replicate : ∀ {α : Type u_1} (n : ℕ) (a : α), Multiset.card (Multiset.replicate n a) = n := by
  sorry

The theorem `Multiset.card_replicate` states that for any type `α`, any natural number `n`, and any element `a` of type `α`, the cardinality of a multiset created by replicating the element `a` `n` times (`Multiset.replicate n a`) is equal to `n`. In other words, if you create a multiset by repeating a particular element `n` times, the total count of elements in that multiset will also be `n`.

For any type `α` and natural number `n`, the cardinality of the multiset obtained by replicating an element `a` of type `α` `n` times equals `n`.


theorem WithBot.preimage_coe_Iio :
    ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithBot.some ⁻¹' Set.Iio ↑a = Set.Iio a := by sorry

This theorem states that for any type `α` that has a preorder structure (i.e., a set in which an order relation is defined), and for any element `a` of this type, the preimage of the set of elements less than `a` under the function that maps each element of `α` to the corresponding element in `WithBot α` (i.e., `α` supplemented with a least element) is exactly the set of elements less than `a`. In other words, applying the `WithBot.some` function to the set of elements less than `a` in α doesn't change the set.

For any preordered type `α` and element `a` in `α`, the set of elements less than `a` is equal to the preimage of `{x : WithBot α | x < a}` under the natural inclusion function from `α` to `WithBot α`.


StrictMono.dual

/-- **Alias** of the reverse direction of `strictMono_dual_iff`. -/
theorem StrictMono.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono f → StrictMono (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) :=
  by sorry

The theorem `StrictMono.dual` states that for any two types `α` and `β` with preorder relations, and any function `f` from `α` to `β`, if `f` is strictly monotone, then the function formed by first applying the function `f`, then applying the `OrderDual.toDual` function, and then applying the `OrderDual.ofDual` function is also strictly monotone. In other words, a strictly monotone function remains strictly monotone even when the order of its inputs is reversed.

If `f` is a strictly monotone function between preordered types `α` and `β`, then the composition of `f`, `OrderDual.toDual`, and `OrderDual.ofDual` is also a strictly monotone function.


theorem Pi.mulSingle_eq_of_ne :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → One (f i)] {i i' : I},
      i' ≠ i → ∀ (x : f i), Pi.mulSingle i x i' = 1 :=
  by sorry

The theorem `Pi.mulSingle_eq_of_ne` states that for any types `I` and `f`, where `f` is a function from `I` to some type, and given instances of decidable equality for `I` and of the multiplicative identity for `f i` for all `i` in `I`, if `i'` and `i` are distinct elements of `I`, then the function `Pi.mulSingle` evaluated at `i'` is equal to `1` for any `x` in the range of `f` at `i`. In other words, for different indexes `i` and `i'`, the function `Pi.mulSingle` returns the multiplicative identity when evaluated at `i'`.

For any function `f` from a decidably equal type `I` to some type, if instances of decidable equality for `I` and multiplicative identity for `f i` exist for all `i` in `I`, then `Pi.mulSingle f i'` equals the multiplicative identity for all distinct `i'` and `i` in `I`.


theorem Finset.image₂_union_inter_subset_union :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s s' : Finset α}
      {t t' : Finset β} [inst_1 : DecidableEq α] [inst_2 : DecidableEq β],
      Finset.image₂ f (s ∪ s') (t ∩ t') ⊆ Finset.image₂ f s t ∪ Finset.image₂ f s' t' :=
  by sorry

The theorem `Finset.image₂_union_inter_subset_union` states that for any types `α`, `β`, `γ`, a function `f` from `α` to `β` to `γ`, and four arbitrary finite sets `s`, `s'`, `t`, and `t'` of types `α` and `β` respectively with decidable equality on `α`, `β`, and `γ`, the image under `f` of the union of `s` and `s'` and the intersection of `t` and `t'` is a subset of the union of the images under `f` of `s` with `t` and `s'` with `t'`. In mathematical terms, if we treat `f` as a function `f: α × β → γ`, then this theorem says that

```math
f[(s ∪ s') × (t ∩ t')] ⊆ f[s × t] ∪ f[s' × t']
```

For any functions `f: α -> β -> γ` and finite sets `s, s', t, t'` of types `α` and `β` with decidable equality, `f(s union s' intersect t intersect t')` is a subset of `f(s intersect t) union f(s intersect t') union f(s' intersect t) union f(s' intersect t')`.


theorem RatFunc.num_ne_zero : ∀ {K : Type u} [inst : Field K] {x : RatFunc K}, x ≠ 0 → RatFunc.num x ≠ 0 := by sorry

The theorem `RatFunc.num_ne_zero` states that for any type `K` equipped with a field structure and for any non-zero rational function `x` over this field `K`, the numerator of this rational function, as given by the function `RatFunc.num`, is also non-zero. Essentially, it asserts the non-vanishing property of the numerator for all nonzero rational functions.

For any non-zero rational function `x` over a field `K`, its numerator `RatFunc.num x` is non-zero.


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

This theorem, `Int.neg_pos_of_neg`, states that for any integer `a`, if `a` is less than zero (i.e., `a` is a negative integer), then the negative of `a` is greater than zero. In other words, negating a negative integer results in a positive integer. This is a basic property of integers in number theory.

For any integer `a`, if `a` is negative then -`a` is positive.


theorem MeasureTheory.OuterMeasure.comap_apply :
    ∀ {α : Type u_1} {β : Type u_5} (f : α → β) (m : MeasureTheory.OuterMeasure β) (s : Set α),
      ↑((MeasureTheory.OuterMeasure.comap f) m) s = ↑m (f '' s) :=
  by sorry

This theorem states that for any two types α and β, a function `f` from α to β, a measure `m` on β, and a set `s` of type α, the measure of the preimage of the set `s` under `f` using the pullback of the measure `m` (`(MeasureTheory.OuterMeasure.comap f) m`) is equal to the measure of the image of `s` under `f` using `m`. In other words, pulling back the measure `m` with `f` and then applying it to `s` gives us the same result as applying `m` to the image of `s` under `f`.

For any measure `m` on type β, the pullback measure of `m` through a function `f` from type α to β, and any set `s` of type α, the measure of `s` under the pullback measure equals the measure of the image of `s` under `f` using `m`.


Asymptotics.IsLittleO.def'

theorem Asymptotics.IsLittleO.def' :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E} {g : α → F}
      {l : Filter α}, f =o[l] g → 0 < c → Asymptotics.IsBigOWith c l f g :=
  by sorry

The theorem `Asymptotics.IsLittleO.def'` states that for any positive real number `c`, if a function `f` is little-o of another function `g` at a filter `l` (written as `f =o[l] g`), then `f` is also big-O of `g` at the same filter with constant `c` (expressed as `Asymptotics.IsBigOWith c l f g`). In other words, if `f` grows no faster than `g` at `l` in the limit (ignoring a constant factor), then there exists some positive constant `c` such that `f` is bounded by `c` times `g` at `l` eventually. This theorem provides a connection between the little-o and big-O notations in asymptotic analysis. Note that the types `E` and `F` are normed spaces and `α` is the domain of the functions `f` and `g`.

If `f = o[l] g` (little-o) holds for functions `f` and `g` in the normed spaces `E` and `F` over the domain `α` at filter `l`, then `Asymptotics.IsBigOWith c l f g` (big-O) holds for some constant `c > 0`.


theorem List.get_replicate :
    ∀ {α : Type u_1} (a : α) {n : ℕ} (m : Fin (List.length (List.replicate n a))),
      List.get (List.replicate n a) m = a :=
  by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any natural number `n`, if `m` is a valid index in the list of `n` copies of `a` (obtained using the `List.replicate` function), then the element at index `m` of this list is equal to `a`. In other words, every element in the list that consists of `n` repetitions of `a` is `a`.

For any type `α`, any natural number `n`, and any `α` element `a`, the `n`-th element in the list obtained by repeating `a` using `List.replicate` is equal to `a`.


/-- As `0` is the default value for `Real.sInf` of the empty set, it suffices to show that `S` is
bounded below by `0` to show that `0 ≤ sInf S`.
 -/
theorem Real.sInf_nonneg : ∀ (S : Set ℝ), (∀ x ∈ S, 0 ≤ x) → 0 ≤ sInf S := by sorry

This theorem states that for any set `S` of real numbers, if every element `x` in `S` is greater than or equal to zero, then the greatest lower bound (infimum) of `S` is also greater than or equal to zero. The theorem uses the fact that 0 is the default value for the greatest lower bound of the empty set in its proof.

If every element of a set `S` of real numbers is non-negative, then the infimum of `S` is also non-negative.


Ne.irrefl

theorem Ne.irrefl : ∀ {α : Sort u} {a : α}, a ≠ a → False := by sorry

This theorem, `Ne.irrefl`, states that for all types `α` and for all elements `a` of type `α`, it is not possible for `a` to not be equal to itself. In other words, it asserts the principle of self-identity, that everything is equal to itself, across all types. This is a formalization of the classical logic principle of contradiction, where a proposition cannot be both true and not true. In mathematical notation, this could be written as "for all α and for all a in α, ¬(a ≠ a)".

For all types `α` and elements `a` of type `α`, `a` is equal to `a`.


/-- An additive group homomorphism sends 0 to 0. -/
theorem IsAddGroupHom.map_zero :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup α] [inst_1 : AddGroup β] {f : α → β}, IsAddGroupHom f → f 0 = 0 := by
  sorry

This theorem states that for any additive group homomorphism `f` from one additive group `α` to another additive group `β`, the homomorphism `f` maps the identity element of the first group (which is 0 in additive notation) to the identity element of the second group (also 0 in additive notation). In other words, any group homomorphism preserves the identity elements of the groups involved.

For any additive group homomorphism `f` from group `α` to group `β`, `f(0) = 0`, where `0` denotes the identity element of each group.


theorem Fin.is_le : ∀ {n : ℕ} (i : Fin (n + 1)), ↑i ≤ n := by sorry

This theorem states that for every natural number `n` and for every element `i` of the finite set of size `n + 1`, the value of `i` (when converted to a natural number) is less than or equal to `n`. In mathematical terms, for all natural numbers `n` and all `i` in the finite set of size `n+1`, it holds that `i ≤ n`.

For every natural number `n` and every element `i` in a finite set of size `n+1`, `i` is less than or equal to `n`.


theorem small_of_injective :
    ∀ {α : Type v} {β : Type w} [inst : Small.{u, w} β] {f : α → β}, Function.Injective f → Small.{u, v} α := by sorry

The theorem named `small_of_injective` states that for any types `α` and `β`, if `β` is "small" in some universe `u`, and there exists an injective function `f` from `α` to `β`, then `α` is also "small" in the same universe `u`. Here, a function `f` is said to be injective if for any two elements `a1` and `a2` in `α`, `f(a1) = f(a2)` implies `a1 = a2`. Furthermore, a type is considered "small" in a universe `u` if it can be embedded into a type of universe `u`.

If `β` is a small type in some universe `u` and there exists an injective function from a type `α` to `β`, then `α` is also a small type in universe `u`.


theorem MeasureTheory.inducedOuterMeasure_eq_iInf :
    ∀ {α : Type u_1} {P : Set α → Prop} {m : (s : Set α) → P s → ENNReal} {P0 : P ∅} {m0 : m ∅ P0 = 0}
      (PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)),
      (∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯) →
        (∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂) →
          ∀ (s : Set α), ↑(MeasureTheory.inducedOuterMeasure m P0 m0) s = ⨅ t, ⨅ (ht : P t), ⨅ (_ : s ⊆ t), m t ht :=
  by sorry

This theorem states that, for any type `α`, any property `P` of sets of `α`, any function `m` from sets of `α` satisfying `P` to the extended nonnegative real numbers, any proof `P0` that the empty set satisfies `P`, and any proof `m0` that `m` applied to the empty set is zero, if `P` is closed under countable unions `PU` and `m` is countably subadditive, and `m` is monotonic with respect to set inclusion, then for every set `s` of `α`, the value of the induced outer measure on `s` is equal to the infimum over all sets `t` satisfying `P` that contain `s` of `m(t)`.

In other words, the outer measure induced by `m` under these conditions is the infimum of `m` over all sets containing the given set, among those sets that satisfy `P`.

Given a type `α`, a property `P` of sets of `α`, a function `m` from `P` sets to extended nonnegative real numbers satisfying countable subadditivity, monotonicity, and closure under countable unions, and proofs that the empty set satisfies `P` and `m` applied to the empty set is zero, then for any set `s` of `α`, the outer measure of `s` equals the infimum of `m` over all `P` sets containing `s`.


/-- We state it as a simp lemma, which is regarded as an involved version of
`id_whiskerRight X Y : 𝟙 X ▷ Y = 𝟙 (X ⊗ Y)`.
 -/
theorem CategoryTheory.MonoidalCategory.leftUnitor_whiskerRight :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
      CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.leftUnitor X).hom Y =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).hom
          (CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).hom :=
  by sorry

This theorem, `CategoryTheory.MonoidalCategory.leftUnitor_whiskerRight`, states that for any monoidal category `C` and for any objects `X` and `Y` in `C`, whiskering the left unitor of `X` on the right by `Y` is equal to the composition of the associator of the identity of `C`, `X` and `Y`, with the left unitor of the tensor of `X` and `Y`. Here, whiskering is essentially a way of composing morphisms, the left unitor is a specific morphism that acts like the multiplicative identity in a monoidal category, and the associator is a morphism that expresses the associativity of the tensor product. This theorem is a categorical version of the left identity law.

For any monoidal category `C`, the whiskered composition of the left unitor of object `X` with the identity of `Y` and the associator of `X`, `Y`, and their tensor product is equal to the left unitor of the tensor product of `X` and `Y`.


theorem Mathlib.Data.Set.Pairwise.Basic._auxLemma.1 : ∀ {α : Type u_1} (r : α → α → Prop), Set.Pairwise ∅ r = True := by
  sorry

This theorem states that for any type `α` and a relation `r` between elements of type `α`, the relation `r` holds pairwise on the empty set. In mathematical terms, this means that for all distinct `x` and `y` in the empty set, `r x y` is true. However, since there are no elements in the empty set, this condition is vacuously true.

For any relation `r` on type `α`, `r` holds on the empty set. (Vacuously true)


theorem Matrix.transpose_apply :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (M : Matrix m n α) (i : n) (j : m), Matrix.transpose M i j = M j i :=
  by sorry

This theorem states that for any type `m` and `n` and an arbitrary type `α`, given a matrix `M` with entries of type `α` and indices of types `m` (for rows) and `n` (for columns), and arbitrary indices `i` of type `n` and `j` of type `m`, the entry at index `(i, j)` in the transpose of `M` is equal to the entry at index `(j, i)` in `M`. In other words, it is stating the basic property of matrix transposition: flipping over the entries along the main diagonal.

For any matrices M of type α with indices m for rows and n for columns, the entry at index (i, j) in the transpose of M equals the entry at index (j, i) in M.


theorem List.drop_eq_nil_of_le : ∀ {α : Type u} {as : List α} {i : ℕ}, List.length as ≤ i → List.drop i as = [] := by
  sorry

The theorem `List.drop_eq_nil_of_le` states that for any type `α`, any list `as` of type `α`, and any natural number `i`, if the length of `as` is less than or equal to `i`, then dropping `i` elements from `as` results in an empty list. Essentially, this means if you try to drop more elements from a list than it contains (or exactly as many), you will end up with an empty list.

For any type `α` and any list `as : List α` of length `l`, if `l ≤ i`, then `List.drop i as = ∅` (the empty list).


theorem noncompact_univ :
    ∀ (X : Type u_2) [inst : TopologicalSpace X] [inst_1 : NoncompactSpace X], ¬IsCompact Set.univ := by sorry

This theorem states that for any type `X` equipped with a topological space structure, if `X` is a noncompact space, then the universal set of `X` (that is, the set of all elements of `X`) is not compact. In more mathematical terms, this means that there doesn't exist an element in the universal set such that every set from any nontrivial filter on `X` that contains the universal set intersects every neighborhood of that element.

If `X` is a noncompact topological space, then its universal set has no compact element intersecting every neighborhood in every nontrivial filter on `X`.


theorem sub_le_sub_iff_right :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α} (c : α),
      a - c ≤ b - c ↔ a ≤ b :=
  by sorry

This theorem, `sub_le_sub_iff_right`, states that for any type `α` which forms an additive group and has a partial order `≤`, where the order respects addition (i.e., is a Covariant Class), given any three elements `a`, `b`, and `c` of type `α`, the inequality `a - c ≤ b - c` holds if and only if `a ≤ b`. In layman's terms, it simply means that subtracting the same number `c` from two numbers `a` and `b` does not change the order of the two numbers.

For any additive group type `α` with a covariant partial order `≤`, the subtraction `a - c ≤ b - c` holds if and only if `a ≤ b`.


theorem List.chain_iff_pairwise :
    ∀ {α : Type u} {R : α → α → Prop} [inst : IsTrans α R] {a : α} {l : List α},
      List.Chain R a l ↔ List.Pairwise R (a :: l) :=
  by sorry

This theorem states that for all types `α`, relation `R` that is transitive, an element `a` of type `α`, and a list `l` of elements of type `α`, the condition of the list `l` being chained from the element `a` under the relation `R` is equivalent to the list `l` with `a` prepended being pairwise related under the relation `R`. This means that if each pair of consecutive elements in the list (starting from `a`) satisfies the relation `R`, then every pair of elements in the entire list (including `a` at the start) also satisfies the relation `R`, and vice versa.

For all types `α` and transitive relations `R` on `α`, given `a` in `α` and a list `l` of elements of `α` with `a` as prefix, `l` is chained under `R` if and only if every pair of consecutive elements in `l` is related by `R`.