theorem MvPolynomial.is_id :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (f : MvPolynomial σ R →+* MvPolynomial σ R),
      RingHom.comp f MvPolynomial.C = MvPolynomial.C →
        (∀ (n : σ), f (MvPolynomial.X n) = MvPolynomial.X n) → ∀ (p : MvPolynomial σ R), f p = p :=
  by sorry

The theorem `MvPolynomial.is_id` states that for any type `R` and index set `σ`, given a commutative semiring structure on `R`, and a ring homomorphism `f` from multivariate polynomials over `σ` and `R` to themselves, if the composition of `f` and the constant polynomial function is the constant polynomial function itself, and if for every index `n` in `σ`, `f` applied to the degree `1` monomial $X_n$ is still $X_n$, then `f` is the identity function on all multivariate polynomials over `σ` and `R`. In other words, under these conditions, for any polynomial `p`, `f(p)` equals `p`.

Given a commutative semiring `R`, a ring homomorphism `f` from multivariate polynomials over `σ` and `R` to themselves preserving constant polynomials and monomials `X_n`, then `f` is the identity function on multivariate polynomials over `σ` and `R`.


theorem PowerBasis.equivOfMinpoly.proof_2 :
    ∀ {S : Type u_3} [inst : Ring S] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_1}
      [inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S) (pb' : PowerBasis A S'),
      minpoly A pb.gen = minpoly A pb'.gen → (Polynomial.aeval pb'.gen) (minpoly A pb.gen) = 0 :=
  by sorry

This theorem states that for any two power bases `pb` and `pb'` over the same commutative ring `A` and rings `S` and `S'` respectively, if the minimal polynomial of the generator of `pb` is equal to the minimal polynomial of the generator of `pb'`, then the polynomial obtained by evaluating the minimal polynomial of `pb.gen` at `pb'.gen` equals zero. In other words, if two power bases have the same minimal polynomial for their generators, then one generator is a root of the other's minimal polynomial.

If power bases `pb` and `pb'` over commutative ring `A` have generators with equal minimal polynomials, then evaluating the minimal polynomial of `pb.gen` at `pb'.gen` yields zero.


theorem PowerBasis.equivOfMinpoly.proof_1 :
    ∀ {S : Type u_1} [inst : Ring S] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_3}
      [inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S) (pb' : PowerBasis A S'),
      minpoly A pb.gen = minpoly A pb'.gen → (Polynomial.aeval pb.gen) (minpoly A pb'.gen) = 0 :=
  by sorry

The theorem `PowerBasis.equivOfMinpoly.proof_1` states that for any given rings `S` and `S'` with `A` as a common commutative ring and algebra over them, and given two power bases `pb` and `pb'` over `A` on `S` and `S'` respectively, if the minimal polynomial of the generator of `pb` is equal to the minimal polynomial of the generator of `pb'`, then applying the algebra homomorphism that maps a polynomial to an element of the algebra induced by the generator of the power basis `pb` to the minimal polynomial of the generator of `pb'` results in the zero element of the algebra. In other words, the minimal polynomial of the generator of `pb'` is annihilated by the algebra homomorphism induced by the generator of `pb` when these minimal polynomials coincide.

If two power bases over a commutative ring have generators with equal minimal polynomials, then the algebra homomorphism induced by one generator annihilates the minimal polynomial of the other generator.


theorem ack_mono_right : ∀ (m : ℕ), Monotone (ack m) := by sorry

The theorem `ack_mono_right` asserts that for every natural number `m`, the Ackermann function `ack m` is monotone. In other words, if `n₁ ≤ n₂` for any natural numbers `n₁` and `n₂`, then `ack m n₁ ≤ ack m n₂`. This signifies that the Ackermann function, when fixed with a particular value of `m`, never decreases as its second argument increases. The Ackermann function is well-known in computer science as an example of a function that grows very rapidly and is not primitive recursive.

For all natural numbers m and n₁, n₂, if n₁ ≤ n₂ then Ackermann function ack m with argument n₁ is less than or equal to the Ackermann function ack m with argument n₂.


theorem FractionalIdeal.ne_zero_of_mul_eq_one :
    ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
      (I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → I ≠ 0 :=
  by sorry

The theorem `FractionalIdeal.ne_zero_of_mul_eq_one` states that for any commutative ring `R₁` and any field `K` with `K` being a `R₁`-algebra, if `I` and `J` are fractional ideals of `R₁` in `K` with respect to the submonoid of non-zero divisors of `R₁`, and the product of `I` and `J` equals the multiplicative identity `1`, then `I` cannot be the zero ideal. This essentially means that if the multiplication of two fractional ideals results in the multiplicative identity, neither of the fractional ideals can be zero, ensuring the invertibility of non-zero fractional ideals in the ring of fractional ideals.

If `I` and `J` are fractional ideals of a commutative ring `R₁` in a field `K` with respect to the submonoid of non-zero divisors, and `I ∘ J = 1`, then `I` is not the zero ideal.


theorem Ideal.IsRadical.radical_le_iff :
    ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, Ideal.IsRadical J → (Ideal.radical I ≤ J ↔ I ≤ J) := by
  sorry

The theorem states that for any commutative semiring `R` and any two ideals `I` and `J` of `R`, if `J` is a radical ideal, then the radical of `I` is a subset of `J` if and only if `I` is a subset of `J`. Here, an ideal `J` is said to be radical if it contains all elements `r` such that `r^n` is in `J` for some `n`, and the radical of an ideal `I` is the set of all such elements `r`.

For any commutative semiring R and ideals I and J with J radical, I is a subset of J if and only if the radical of I is a subset of J.


theorem Set.SurjOn.cancel_right :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {t : Set β} {f : α → β} {g₁ g₂ : β → γ},
      Set.SurjOn f s t → Set.MapsTo f s t → (Set.EqOn (g₁ ∘ f) (g₂ ∘ f) s ↔ Set.EqOn g₁ g₂ t) :=
  by sorry

This theorem, `Set.SurjOn.cancel_right`, states that for any three types `α`, `β`, and `γ`, any sets `s` of `α` and `t` of `β`, and any functions `f : α → β` and `g₁, g₂ : β → γ`, if `f` is surjective from `s` to `t`, and the image of `s` under `f` is contained in `t`, then the functions `g₁` and `g₂` are equal on the image of `s` under `f` if and only if they are equal on `t`. In simpler terms, if `f` maps `s` onto `t` and two functions `g₁` and `g₂` agree on the image of `s` under `f`, then `g₁` and `g₂` also agree on `t`.

If `f : α → β` is surjective from `s ⊆ α` to `t ⊆ β` and `s = f⁻¹[t]`, then `g₁ = g₂` on `t` implies `g₁ = g₂` on `s`.


theorem List.Perm.eq_nil : ∀ {α : Type u_1} {l : List α}, List.Perm l [] → l = [] := by sorry

This theorem states that for any list `l` of a certain type `α`, if `l` is a permutation of an empty list, then `l` must be an empty list itself. This makes sense because the only permutation of an empty list is the empty list itself, thus any list that can be rearranged to match an empty list must also be an empty list.

If `α` is a type and `l` is a list of type `α`, then `l` is a permutation of the empty list `[]` if and only if `l` is empty.


ContT.ext

theorem ContT.ext :
    ∀ {r : Type u} {m : Type u → Type v} {α : Type w} {x y : ContT r m α},
      (∀ (f : α → m r), ContT.run x f = ContT.run y f) → x = y :=
  by sorry

The theorem `ContT.ext` is a statement about equality in the context of continuation-passing style transformations. Specifically, it says that for any types `r`, `m`, and `α`, and any two values `x` and `y` of type `ContT r m α`, if for all functions `f` from `α` to `m r`, applying `f` to `x` and `y` via the `ContT.run` function yields the same result, then `x` and `y` must be equal. In other words, two continuation-passing style transformations are equal if they produce the same result when run with any continuation.

If for all functions `f` from `α` to `m r`, the application of `f` to two values `x` and `y` in `ContT r m α` via `ContT.run` yields the same result, then `x` and `y` are equal.


theorem Algebra.span_le_adjoin :
    ∀ (R : Type uR) {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A),
      Submodule.span R s ≤ Subalgebra.toSubmodule (Algebra.adjoin R s) :=
  by sorry

The theorem `Algebra.span_le_adjoin` states that for any commutative semiring `R` and any semiring `A` with a given algebra structure over `R`, for any set `s` of elements from `A`, the span of `s` as a submodule of `A` over `R` is a subset of (or equal to) the submodule associated with the smallest subalgebra that includes `s`. Here, the span of a set `s` is the smallest submodule of `A` that contains `s`, and the smallest subalgebra that includes `s` is obtained by adjoining `s` to the algebra of `R`. The theorem formalizes the intuition that the process of adjoining elements to an algebra 'enlarges' the algebra more (or at least not less) than merely forming the span of those elements as a submodule.

For any commutative semiring `R`, semiring `A` with an algebra structure over `R`, and set `s` of elements from `A`, the span of `s` in `A` is contained in the submodule generated by `s` in the algebra of `R`.


theorem Mathlib.RingTheory.RootsOfUnity.Basic._auxLemma.13 :
    ∀ {M : Type u_1} [inst : CommMonoid M] (ζ : M) (k : ℕ),
      IsPrimitiveRoot ζ k = (ζ ^ k = 1 ∧ ∀ (l : ℕ), ζ ^ l = 1 → k ∣ l) :=
  by sorry

This theorem states that for any commutative monoid `M` and any element `ζ` of `M`, `ζ` is a primitive root of order `k` if and only if `ζ` raised to the `k`th power equals one and for any natural number `l`, if `ζ` raised to the `l`th power equals one, then `k` divides `l`. In simpler terms, a number is a primitive root of a certain order if it cycles back to 1 after that many steps and any other power that brings it to 1 must be a multiple of that order.

A commutative monoid element `ζ` is a primitive root of order `k` if and only if `ζ^k = 1` and `k` divides `l` for all `l` such that `ζ^l = 1`.


/-- If a function `f` vanishes outside of a finite set `s`, then it `HasSum`
`∑ b in s, f b`. -/
theorem hasSum_sum_of_ne_finset_zero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {s : Finset β},
      (∀ b ∉ s, f b = 0) → HasSum f (Finset.sum s fun b => f b) :=
  by sorry

The theorem `hasSum_sum_of_ne_finset_zero` states that for any types `α` and `β`, given `α` is an additive commutative monoid and also a topological space, for any function `f` from `β` to `α` and any finite set `s` of type `β`, if the function `f` yields zero for all elements not in the set `s`, then the function `f` has a sum which is equivalent to the sum of `f b` for each element `b` in the set `s`.

In mathematical terms, if a function `f` is zero outside of a finite set `s`, then the series represented by `f` converges to the sum of `f(x)` for each `x` in `s`.

Given a function `f` from a finite set `s` to an additive commutative monoid and topological space `α`, if `f` is zero outside of `s`, then the sum of `f` equals the sum of `f(x)` for all `x` in `s`.


theorem AddGroupFilterBasis.mem_nhds_zero :
    ∀ {G : Type u} [inst : AddGroup G] (B : AddGroupFilterBasis G) {U : Set G}, U ∈ B → U ∈ nhds 0 := by sorry

This theorem states that for any type `G` that has an `AddGroup` structure and any `AddGroupFilterBasis` `B` of `G`, if a set `U` is an element of `B`, then `U` is a neighborhood of the additive identity element `0`. In simpler terms, if a set `U` belongs to a certain filter basis for the additive group `G`, then `U` must also belong to the neighborhood filter of zero in `G`.

For any AddGroup `G` and AddGroupFilterBasis `B` of `G`, any element `U` in `B` is a neighborhood of the additive identity `0` in `G`.


theorem bernoulli_eq_bernoulli'_of_ne_one : ∀ {n : ℕ}, n ≠ 1 → bernoulli n = bernoulli' n := by sorry

This theorem states that for any natural number 'n', if 'n' is not equal to 1, then the value of the Bernoulli number (as defined by the `bernoulli` function) for 'n' is equal to the value of the Bernoulli number according to the alternative definition provided by the `bernoulli'` function. The Bernoulli numbers are a sequence of rational numbers which are important in number theory and analysis.

For all natural numbers n exceeding 1, the Bernoulli number `bernoulli n` equals the Bernoulli number according to the alternative definition `bernoulli' n`.


theorem smul_eq_iff_eq_inv_smul :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : MulAction α β] (g : α) {x y : β}, g • x = y ↔ x = g⁻¹ • y :=
  by sorry

This theorem states that for any group `α` and any set `β` with a multiplication action of `α` on `β`, and for any elements `g` in `α` and `x` and `y` in `β`, the statement that `g` multiplied by `x` equals `y` is equivalent to the statement that `x` equals the inverse of `g` multiplied by `y`. Here, `•` denotes the multiplication action of `α` on `β`, and `g⁻¹` denotes the inverse of `g` in the group `α`.

For any group action of `α` on a set `β` and any `g` in `α` and `x, y` in `β`, `g • x = y` is equivalent to `x = g⁻¹ • y`.


theorem exists_seq_strictMono_tendsto :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] [inst_4 : NoMinOrder α] [inst_5 : FirstCountableTopology α] (x : α),
      ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Filter.Tendsto u Filter.atTop (nhds x) :=
  by sorry

The theorem `exists_seq_strictMono_tendsto` states that for any point `x` in a topological space `α`, which is also a linear order where the order topology is assumed, densely ordered with no minimal element and having a first-countable topology, there exists a sequence `u` that is strictly monotonically increasing (meaning each term `u n` is less than `u (n+1)`) and all terms of `u` are less than `x`. Moreover, this sequence `u` converges to `x` as it tends to infinity. In other words, arbitrarily large terms of `u` get arbitrarily close to `x`.

Given a densely ordered, first-countable linear space `α` without a minimal element, there exists a strictly monotonically increasing sequence `u` such that `u(n)` converges to any `x` in `α` as `n` tends to infinity.


Multiset.Subset.refl

theorem Multiset.Subset.refl : ∀ {α : Type u_1} (s : Multiset α), s ⊆ s := by sorry

The theorem `Multiset.Subset.refl` states that for any type `α` and for any multiset `s` of type `α`, `s` is a subset of itself. In other words, the theorem asserts the reflexivity of the subset relation on multisets. This is a basic property of the subset relation in set theory.

For any multiset `s` of type `α`, `s` is a subset of `s`.


theorem Mathlib.Data.Finset.Basic._auxLemma.113 :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑s \ {a} = ↑(Finset.erase s a) := by sorry

The theorem `Mathlib.Data.Finset.Basic._auxLemma.113` states that for any type `α` that has decidable equality, and for any element `a` of type `α` and any finite set `s` of elements of type `α`, removing the element `a` from the set `s` in two different ways leads to the same result. More specifically, it states that the set difference of `s` and the singleton set `{a}` is equal to the set obtained by using the `Finset.erase` function to remove `a` from `s`.

For any type `α` with decidable equality and any finite set `s` of elements from `α` and any `a` in `s`, the set difference `s \ {a}` is equal to the set obtained by erasing `a` from `s` using the `Finset.erase` function.


theorem Mathlib.Data.Finset.Basic._auxLemma.111 : ∀ {a b c : Prop}, (a ∧ (b ∨ c)) = (a ∧ b ∨ a ∧ c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the proposition "a AND (b OR c)" is logically equivalent to the proposition "(a AND b) OR (a AND c)". This is a statement of distributive law of logic, similar to the distributive law in arithmetic where `a * (b + c) = a * b + a * c`.

The propositions `a AND (b OR c)` and `(a AND b) OR (a AND c)` are logically equivalent.


theorem Mathlib.Data.Finset.Basic._auxLemma.101 : ∀ (α : Sort u), (α → True) = True := by sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.101`, states that for any type `α`, the function type from `α` to `True` is itself `True`. In other words, for any type, a function that takes an element of that type and produces `True` is always truthfully described by `True`. This is a reflection of the fact that in Lean 4, a function from any type to `True` is always true.

For any type `α`, the constant function from `α` to `True` is equal to `True`.


theorem MulAction.isPeriodicPt_smul_iff :
    ∀ {α : Type v} {M : Type u} [inst : Monoid M] [inst_1 : MulAction M α] {m : M} {a : α} {n : ℕ},
      Function.IsPeriodicPt (fun x => m • x) n a ↔ m ^ n • a = a :=
  by sorry

This theorem states that for any types `α` and `M`, where `M` has a monoid structure and `α` has an action of `M`, for any element `m` of `M`, an element `a` of `α`, and a natural number `n`, a point `a` is a periodic point of the function `(λx, m • x)` with period `n` if and only if the `n`-th power of `m` acting on `a` results in `a`. In other words, if the `n`-th iteration of the action of `m` on `a` gives `a` back, then `a` is a periodic point of the action of `m` with period `n`, and vice versa.

For any monoid `M` and type `α` with an `M`-action, an element `a` of `α` is periodic under the action of `m` with period `n` if and only if `(m ^ n) . a = a`.


theorem MonoidAlgebra.single_mul_apply :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Group G] (r : k) (x : G) (f : MonoidAlgebra k G)
      (y : G), (MonoidAlgebra.single x r * f) y = r * f (x⁻¹ * y) :=
  by sorry

This theorem states that for any semiring `k`, group `G`, scalar `r` from `k`, group element `x` from `G`, and a formal linear combination `f` in the monoid algebra of `G` with coefficients in `k`, the convolution of the singleton formal linear combination of `x` and `r` with `f`, evaluated at a group element `y`, equals `r` times the evaluation of `f` at the element `x⁻¹ * y`. In simpler terms, this is a distributive property showing how multiplication distributes over the convolution in the monoid algebra.

For any semiring `k`, group `G`, scalar `r` from `k`, group elements `x, y` from `G`, and formal linear combination `f` in the monoid algebra of `G` with coefficients in `k`, we have `(rx : k) * (f ! x) ^-1 * f = r * f ! (x ^-1 * y)`.


theorem Mathlib.Data.Finset.Basic._auxLemma.144 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem states that, for any two propositions `a` and `b`, the existence of a proof of `b` given a proof of `a` is equivalent to the conjunction of `a` and `b`. In other words, there exists a proof of `b` under the assumption that `a` is true if and only if both `a` and `b` are true.

The theorem asserts that for all propositions `a` and `b`, `(∃ (p : proof a), b) ↔ a ∧ b`.


theorem Icc_mem_nhdsWithin_Ioi :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b c : α},
      b ∈ Set.Ico a c → Set.Icc a c ∈ nhdsWithin b (Set.Ioi b) :=
  by sorry

The theorem `Icc_mem_nhdsWithin_Ioi` states that for any given types `α` with a topological space structure, a linear order and a closed left-inclusive right-unbounded (closed-ici) topology, and any elements `a`, `b`, `c` of type `α`, if `b` is in the left-closed right-open interval from `a` to `c` (denoted as `Set.Ico a c`), then the left-closed, right-closed interval from `a` to `c` (denoted as `Set.Icc a c`) is in the neighborhood of `b` within the set of all elements greater than `b` (denoted as `nhdsWithin b (Set.Ioi b)`).

In simpler terms, this theorem ensures that if a number `b` is in an interval that includes its lower limit `a` and excludes its upper limit `c`, then the entire interval from `a` to `c` which includes both ends, is within the neighborhood of `b` considering only the numbers greater than `b`.

If `a < b < c` and `b` belongs to the interval `[a, c)`, then `[a, c]` is contained in the neighborhood of `b` in the upper half-open interval `(b, ∞)`.


theorem Finset.sum_disjiUnion :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} {f : α → β} [inst : AddCommMonoid β] (s : Finset ι)
      (t : ι → Finset α) (h : Set.PairwiseDisjoint (↑s) t),
      (Finset.sum (Finset.disjiUnion s t h) fun x => f x) = Finset.sum s fun i => Finset.sum (t i) fun x => f x :=
  by sorry

This theorem, `Finset.sum_disjiUnion`, states that for any types `ι`, `α`, and `β`, along with a function `f` from `α` to `β` and given an additive commutative monoid structure on `β`, the sum of the function `f` over the disjoint union of a collection of finite sets `t` indexed by elements of another finite set `s` (with the guarantee that these sets `t i` are pairwise disjoint) equals the sum, over each element `i` of `s`, of the sum of `f` over the elements `x` of `t i`. In mathematical notation, this could be written as $\sum_{x \in \bigsqcup_{i \in s} t_i} f(x) = \sum_{i \in s} \sum_{x \in t_i} f(x)$, where $\bigsqcup$ denotes a disjoint union.

The sum of a function over the disjoint union of a collection of finite sets is equal to the sum of the function over each set in the collection.


theorem AbsoluteValue.pos_iff :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S) {x : R},
      0 < abv x ↔ x ≠ 0 :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a semiring and `S` is an ordered semiring, and for any absolute value function `abv` from `R` to `S`, the absolute value of `x` (a member of `R`) is positive if and only if `x` is not zero. In more mathematical terms, this is stating that the absolute value of `x`, denoted as `|x|`, is greater than 0 if and only if `x ≠ 0`.

For any semiring `R`, ordered semiring `S`, and absolute value function `abv` from `R` to `S`, |x| > 0 if and only if x ≠ 0.


theorem Complex.arg_neg_one : Complex.arg (-1) = Real.pi := by sorry

The theorem `Complex.arg_neg_one` states that the argument of the complex number -1 is equal to the mathematical constant pi. This can be interpreted in the complex plane as the angle formed by -1 and the positive real axis being pi radians (or 180 degrees). In other words, using the `Complex.arg` function, which returns the principal value of the argument of a complex number (in the range (-π, π]), if we input -1 (which falls in the left half of the complex plane), we get out pi.

The argument of the complex number -1 is equal to the mathematical constant pi.


theorem AddLECancellable.add_tsub_cancel_left :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b : α}, AddLECancellable a → a + b - a = b :=
  by sorry

This theorem states that for any type `α` that has a partial order, an additive commutative semigroup structure, and an ordered subtraction operation, given any two elements `a` and `b` of type `α` where `a` is 'addition-left-cancellable' (meaning that if `a + b ≤ a + c` then `b ≤ c`), we have that `a + b - a` equals `b`. Essentially, this theorem represents the property that we can add `a` to `b`, subtract `a`, and end up with `b` if and only if `a` is 'addition-left-cancellable'.

If `α` is a type with a partial order, an additive commutative semigroup structure, and an ordered subtraction operation, and `a` is addition-left-cancellable in `α`, then `a + b - a` equals `b` for all `b` in `α`.


theorem List.splitOnP_cons :
    ∀ {α : Type u} (p : α → Bool) (x : α) (xs : List α),
      List.splitOnP p (x :: xs) =
        if p x = true then [] :: List.splitOnP p xs else List.modifyHead (List.cons x) (List.splitOnP p xs) :=
  by sorry

This theorem, `List.splitOnP_cons`, is about splitting a list based on a certain condition in Lean 4. It takes a type variable `α`, a Boolean function `p` applied to elements of type `α`, an element `x` of type `α`, and a list `xs` of elements of type `α`.

The theorem states that if we call the function `List.splitOnP` on a list that starts with the element `x` and then contains the elements of `xs`, the result depends on the evaluation of the function `p` on `x`. If `p x` is true, then the list will be split at `x` (which is excluded from the resulting sublists), and the function is then recursively applied to the rest of the list `xs`. If `p x` is not true, `x` is added to the head of each of the sublists resulting from splitting the rest of the list `xs` based on the condition `p`.

Given a type `α` and a Boolean function `p` on `α`, the list `xs` split at `x` using `List.splitOnP` in Lean 4 results in sublists where `x` is excluded if `p x` is true, and `x` is added to each sublist if `p x` is false.


theorem Int.log_of_right_le_zero :
    ∀ {R : Type u_1} [inst : LinearOrderedSemifield R] [inst_1 : FloorSemiring R] (b : ℕ) {r : R},
      r ≤ 0 → Int.log b r = 0 :=
  by sorry

The theorem `Int.log_of_right_le_zero` states that for any type `R` which is a linear ordered semifield and a floor semiring, and given a natural number `b` and a real number `r`, if `r` is less than or equal to zero, then the result of the function `Int.log` with parameters `b` and `r` is equal to zero. In other words, the greatest power of a natural number `b` such that `b` to the power of logarithm base `b` of `r` is less than or equal to `r`, is zero when `r` is less than or equal to zero.

For any linear ordered semifield and floor semiring type R, and natural number b and real number r, if r ≤ 0 then Int.log b r = 0.


Filter.HasBasis.isBasis

theorem Filter.HasBasis.isBasis :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → Filter.IsBasis p s :=
  by sorry

The theorem `Filter.HasBasis.isBasis` states that for all types `α` and `ι`, a filter `l` of type `α`, and functions `p : ι → Prop` and `s : ι → Set α`, if the filter `l` has a basis characterized by the properties `p` and sets `s`, then `(p, s)` is a basis. This theorem is a part of the framework for working with filters, which are mathematical structures used in various areas of mathematics such as topology and analysis.

If a filter on a type `α` has property functions `p : ι → Prop` and set functions `s : ι → Set α` as its basis, then `(p, s)` is the basis for that filter.


/-- The unbundled orthogonal projection is in the given subspace.
This lemma is only intended for use in setting up the bundled version
and should not be used once that is defined.  -/
theorem orthogonalProjectionFn_mem :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {K : Submodule 𝕜 E} [inst_3 : HasOrthogonalProjection K] (v : E), orthogonalProjectionFn K v ∈ K :=
  by sorry

The theorem `orthogonalProjectionFn_mem` states that for any type `𝕜` endowed with the structure of a ring with conjugation, any type `E` that is a normed additive commutative group and an inner product space over `𝕜`, and any submodule `K` of `E` that has an orthogonal projection, the orthogonal projection of any vector `v` from `E` (as computed by the function `orthogonalProjectionFn`) is an element of the submodule `K`. This theorem is a setup for the bundled version of the orthogonal projection and should not be used once the bundled version is defined.

For any normed additive commutative group and inner product space `E` over a ring with conjugation `𝕜`, and any submodule `K` of `E` with an orthogonal projection, the orthogonal projection of any vector `v` from `E` is an element of `K`.


theorem Commute.commutator_eq : ∀ {G : Type u_1} [inst : Group G] {g₁ g₂ : G}, Commute g₁ g₂ → ⁅g₁, g₂⁆ = 1 := by sorry

The theorem `Commute.commutator_eq` states that for any type `G` that forms a group (denoted by `[inst : Group G]`), for any two elements `g₁` and `g₂` of type `G`, if `g₁` and `g₂` commute (as defined by the `Commute` definition, i.e., `g₁ * g₂ = g₂ * g₁`), then their group commutator (denoted by `⁅g₁, g₂⁆`), is equal to the identity element of the group `1`. In mathematical notation, for all `g₁, g₂` in a group `G`, if `g₁ * g₂ = g₂ * g₁`, then `⁅g₁, g₂⁆ = 1`. Here, `⁅g₁, g₂⁆` represents the group commutator of `g₁` and `g₂`, defined as `g₁ * g₂ * g₁⁻¹ * g₂⁻¹`.

In a group `G`, if `g₁` and `g₂` commute (i.e., `g₁ * g₂ = g₂ * g₁`), then their group commutator `[g₁, g₂] = g₁ * g₂ * g₁⁻¹ * g₂⁻¹` equals the identity element `1`.


theorem Primrec.ofNat_iff :
    ∀ {α : Type u_4} {β : Type u_5} [inst : Denumerable α] [inst_1 : Primcodable β] {f : α → β},
      Primrec f ↔ Primrec fun n => f (Denumerable.ofNat α n) :=
  by sorry

The theorem `Primrec.ofNat_iff` asserts that for any types `α` and `β`, given instances of `Denumerable α` and `Primcodable β`, and a function `f` from `α` to `β`, the function `f` is primitive recursive if and only if the function that maps each natural number `n` to `f` applied to the `n`-th element of `α` is also primitive recursive. In essence, it is stating a correspondence between the primitiveness of a function `f` and the primitiveness of the function obtained by applying `f` after enumerating the input type.

For any types α and β, if α is denumerable, β is primcodable, and the function f from α to β is primitive recursive, then the function that maps each natural number n to f applied to the n-th element of α is also primitive recursive. Conversely, if the composed function is primitive recursive, then so is f.


theorem frontier_univ : ∀ {X : Type u} [inst : TopologicalSpace X], frontier Set.univ = ∅ := by sorry

The theorem `frontier_univ` states that for any type `X` with a topological space structure, the frontier of the universal set is the empty set. In other words, there are no points in `X` that lie between the closure and interior of the universal set, which consists of all elements in `X`. This is consistent with the intuition that the frontier of a space, which represents boundary points, should be empty in the case of the whole space.

The frontier of the universal set in any topological space is the empty set.


theorem ContinuousLinearEquiv.image_symm_eq_preimage :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂),
      ⇑(ContinuousLinearEquiv.symm e) '' s = ⇑e ⁻¹' s :=
  by sorry

The theorem `ContinuousLinearEquiv.image_symm_eq_preimage` states that for any semirings `R₁` and `R₂` with ring homomorphisms `σ₁₂` from `R₁` to `R₂` and `σ₂₁` from `R₂` to `R₁` that form a ring homomorphism inverse pair, and for any topological spaces `M₁` and `M₂` that are also additively commutative monoids and modules over `R₁` and `R₂` respectively, given a continuous linear equivalence `e` from `M₁` to `M₂` and a set `s` in `M₂`, the image under the inverse of `e` of the set `s` is equal to the preimage of the set `s` under `e`. In simpler terms, applying the inverse of the equivalence `e` to a set `s` gives the same result as finding all points in the domain of `e` that `e` would map into `s`.

For any continuous linear equivalence between additively commutative monoids and modules over commutative semirings, the image of a set under the inverse of the equivalence equals the preimage of that set.


/-- To show a category is an `InitialMonoClass` it suffices to give an initial object such that
every morphism out of it is a monomorphism.  -/
theorem CategoryTheory.Limits.InitialMonoClass.of_isInitial :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {I : C} (hI : CategoryTheory.Limits.IsInitial I),
      (∀ (X : C), CategoryTheory.Mono (CategoryTheory.Limits.IsInitial.to hI X)) →
        CategoryTheory.Limits.InitialMonoClass C :=
  by sorry

The theorem `CategoryTheory.Limits.InitialMonoClass.of_isInitial` states that, for a given category `C` and an object `I` in `C`, if `I` is an initial object and every morphism from `I` to any other object in `C` is a monomorphism (a morphism which is left-cancellative), then `C` is an `InitialMonoClass`. In other words, to prove that a category is an `InitialMonoClass`, it's enough to show the existence of an initial object from which every outgoing morphism is a monomorphism.

In a category, if every morphism from an initial object is a monomorphism, then the category has the initial object property in the monic morphism class.


theorem Units.mk0_val : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (u : G₀ˣ) (h : ↑u ≠ 0), Units.mk0 (↑u) h = u := by
  sorry

The theorem `Units.mk0_val` states that for any type `G₀` which is an instance of the `GroupWithZero` class, any non-zero unit `u` in this group, and any proof `h` that the value of `u` is not zero, when we embed `u` into the unit group using the `Units.mk0` function, we get back `u` itself. Basically, this is saying that if we embed a non-zero unit of a group with zero into the unit group, we retrieve the same unit.

For any group with zero `G₀` and non-zero unit `u` in `G₀` with proof `h` of non-zero, `Units.mk0 u h` equals `u`.


ContinuousLinearEquiv.uniformEmbedding

theorem ContinuousLinearEquiv.uniformEmbedding :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {E₁ : Type u_9} {E₂ : Type u_10}
      [inst_4 : UniformSpace E₁] [inst_5 : UniformSpace E₂] [inst_6 : AddCommGroup E₁] [inst_7 : AddCommGroup E₂]
      [inst_8 : Module R₁ E₁] [inst_9 : Module R₂ E₂] [inst_10 : UniformAddGroup E₁] [inst_11 : UniformAddGroup E₂]
      (e : E₁ ≃SL[σ₁₂] E₂), UniformEmbedding ⇑e :=
  by sorry

This Lean theorem, `ContinuousLinearEquiv.uniformEmbedding`, states that for any two types `R₁` and `R₂` equipped with semiring structures, and any two ring homomorphisms `σ₁₂` from `R₁` to `R₂` and `σ₂₁` from `R₂` to `R₁` that form an inverse pair, and any two types `E₁` and `E₂` that have uniform spaces, additive commutative group structures, and are modules over `R₁` and `R₂` respectively, and are also equipped with uniform additive group structures, any continuous linear equivalence `e` from `E₁` to `E₂` (with respect to the ring homomorphism `σ₁₂`) is a uniform embedding. In simpler terms, a continuous linear equivalence between two appropriate mathematical structures is always a uniform embedding.

A continuous linear equivalence between two uniformly equipped, ring-module structures over commutative semirings, with inversely compatible ring homomorphisms, is a uniform embedding.


theorem ball_add :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (s : Set E) (x : E),
      Metric.ball x δ + s = x +ᵥ Metric.thickening δ s :=
  by sorry

This theorem states that for any seminormed additive commutative group `E`, real number `δ`, set `s` of type `E`, and element `x` of type `E`, the addition of the open ball of radius `δ` centered at `x` and the set `s` is equal to the addition of `x` and the `δ`-thickening of the set `s`. In mathematical terms, if `s` is a set in `E`, `x` is an element of `E`, and `δ` is a real number, then the set of all points within distance `δ` from `x` added to `s` is the same as the set of all points `x` plus those points in `E` that are less than `δ` away from any point in `s`.

For any seminormed additive commutative group `E`, real number `δ`, and set `s` in `E`, the set `{x + y : x ∈ E, y ∈ s, ∥y∥ < δ}` is equal to `{z : ∥z - x∥ < δ, z ∈ s}`.


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

This theorem states that for any two integers `a` and `b`, if the negative of `b` is less than or equal to the negative of `a`, then `a` is less than or equal to `b`. This is a property of the order relation on the integers, and captures the idea that reversing the order of the integers also reverses the inequality.

If `a` and `b` are integers, then `a <= b` if and only if `-b <= -a`.


theorem Nat.sSup_def : ∀ {s : Set ℕ} (h : ∃ n, ∀ a ∈ s, a ≤ n), sSup s = Nat.find h := by sorry

This theorem states that for any set `s` of natural numbers, if there exists a natural number `n` such that every element `a` in `s` is less than or equal to `n`, then the supremum (`sSup`) of the set `s` is equal to the smallest natural number satisfying the aforementioned condition. This smallest natural number is found by the function `Nat.find`. Therefore, this theorem connects the notion of a supremum of a set in the natural numbers to the concept of finding the smallest natural number that serves as an upper bound for the set.

For any set `s` of natural numbers, if there exists a natural number `n` such that every element `a` in `s` is less than or equal to `n`, then `sSup = n`, where `sSup` is the supremum of `s`.


theorem EReal.preimage_coe_Iio : ∀ (y : ℝ), Real.toEReal ⁻¹' Set.Iio ↑y = Set.Iio y := by sorry

The theorem `EReal.preimage_coe_Iio` states that for every real number `y`, the preimage of the set of values less than `y` under the mapping from reals to extended reals is equal to the set of real numbers less than `y`. In other words, if you take all the elements less than `y` in the space of extended real numbers, and map them back to the real numbers, you get exactly the set of real numbers less than `y`. This result is crucial in ensuring that our extension from real numbers to extended real numbers behaves as expected when dealing with sets and intervals.

The preimage of the set of real numbers less than a real number `y` under the coercion from extended real numbers to real numbers is equal to the set of real numbers less than `y`.


theorem Real.hasStrictDerivAt_exp : ∀ (x : ℝ), HasStrictDerivAt Real.exp (Real.exp x) x := by sorry

This theorem states that the real exponential function has a strict derivative at any real number `x`. The value of this derivative at any point `x` happens to be the value of the exponential function at `x` itself. In mathematical terms, we can write this as `d/dx exp(x) = exp(x)` for all `x` in ℝ (the set of all real numbers). This means that the rate of change of the function `exp(x)` at any point `x` is equal to the value of the function at that point. This key property is one of the defining characteristics of the exponential function.

The real exponential function has a derivative equal to itself at every real number: `d/dx (exp x) = exp x`.


theorem EReal.preimage_coe_Iic : ∀ (y : ℝ), Real.toEReal ⁻¹' Set.Iic ↑y = Set.Iic y := by sorry

The theorem `EReal.preimage_coe_Iic` states that for any real number `y`, the preimage of the set of all extended real numbers less than or equal to `y` under the function mapping real numbers to extended real numbers, is equal to the set of all real numbers less than or equal to `y`. In other words, if we take a set of all extended real numbers less than or equal to a given real number `y`, convert each of those extended real numbers back to a real number (if possible), we would end up with the set of all real numbers less than or equal to `y`.

The preimage of the set of real numbers less than or equal to a real number `y` under the extension of the real numbers to the extended real numbers is equal to the set of real numbers less than or equal to `y`.


Int.ModEq.dvd

/-- **Alias** of the forward direction of `Int.modEq_iff_dvd`. -/
theorem Int.ModEq.dvd : ∀ {n a b : ℤ}, a ≡ b [ZMOD n] → n ∣ b - a := by sorry

The theorem `Int.ModEq.dvd` is an alias of the forward direction of another theorem `Int.modEq_iff_dvd`. It states that for any integers `n`, `a`, and `b`, if `a` is congruent to `b` modulo `n` (denoted as `a ≡ b [ZMOD n]`), then `n` divides the difference between `b` and `a` (denoted as `n ∣ b - a`). In other words, if the remainder of `a` divided by `n` equals the remainder of `b` divided by `n`, then `n` is a divisor of the difference `b - a`.

If `a` is congruent to `b` modulo `n`, then `n` divides the difference between `a` and `b`.


theorem Continuous.matrix_det :
    ∀ {X : Type u_1} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R]
      [inst_2 : Fintype n] [inst_3 : DecidableEq n] [inst_4 : CommRing R] [inst_5 : TopologicalRing R]
      {A : X → Matrix n n R}, Continuous A → Continuous fun x => Matrix.det (A x) :=
  by sorry

The theorem `Continuous.matrix_det` states that for any type `X` with a topological space structure, type `n` with a finite number of elements and decidable equality, and ring `R` with a commutative ring structure and a topological ring structure, if `A` is a continuous function from `X` to the matrices of dimension `n x n` over `R`, then the function which assigns to each `x` in `X` the determinant of the matrix `A(x)` is also continuous. In other words, the determinant operation preserves continuity when applied on continuous functions from a topological space to the set of matrices over a topological ring.

The determinant function of matrices is continuous when mapped from a continuous function of a topological space to the set of matrices over a topological ring.


theorem Mathlib.Data.Set.Function._auxLemma.1 :
    ∀ {α : Sort u_1} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) := by sorry

This theorem states that for any type `α`, any property `p` on `α`, and any two elements `a1` and `a2` of the subtype of `α` consisting of elements satisfying `p`, the equality of `a1` and `a2` is equivalent to the equality of their underlying elements in `α`. In more mathematical terms, if we have two elements of a subset defined by some property `p` of a set `α`, then the elements are equal in the subset if and only if they are equal in the set `α`.

For any type `α` and property `p` on `α`, two elements `a1` and `a2` of the subtype of elements satisfying `p` are equal if and only if their underlying elements in `α` are equal.


theorem Asymptotics.IsBigOWith.prod_left_same :
    ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} {G' : Type u_8} [inst : SeminormedAddCommGroup E']
      [inst_1 : SeminormedAddCommGroup F'] [inst_2 : SeminormedAddCommGroup G'] {c : ℝ} {f' : α → E'} {g' : α → F'}
      {k' : α → G'} {l : Filter α},
      Asymptotics.IsBigOWith c l f' k' →
        Asymptotics.IsBigOWith c l g' k' → Asymptotics.IsBigOWith c l (fun x => (f' x, g' x)) k' :=
  by sorry

The theorem `Asymptotics.IsBigOWith.prod_left_same` states that for any type `α`, normed additive commutative groups `E'`, `F'`, and `G'`, a real number `c`, functions `f'`, `g'`, and `k'` from `α` to `E'`, `F'`, and `G'` respectively, and a filter `l` on `α`, if `f'` and `g'` are both "big O" of `k'` with constant `c` at filter `l`, then the function that takes `x` in `α` and returns the pair `(f' x, g' x)` is also "big O" of `k'` with the same constant `c` at the same filter `l`. Here, "big O" is a notation for asymptotic upper bounds, meaning that the norms of `f'` and `g'` are eventually at most `c` times the norm of `k'` for `l`.

If functions `f'` and `g'` are both big O of `k'` with constant `c` at filter `l` on type `α`, then the function `x ↦ (f' x, g' x)` is also big O of `k'` with constant `c` at filter `l`.


theorem EReal.preimage_coe_Ici : ∀ (x : ℝ), Real.toEReal ⁻¹' Set.Ici ↑x = Set.Ici x := by sorry

This theorem is stating that for any real number 'x', the preimage of the interval [x, +∞) under the function that coverts real numbers to extended real numbers is equal to the interval [x, +∞) in the real numbers. In other words, when we convert each number in the real interval [x, +∞) to an extended real number, we get the same set as the original interval [x, +∞).

For any real number x, the preimage of the interval [x, +∞) under the extension of the real numbers to the extended real numbers is equal to the interval [x, +∞) in the real numbers.


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

The theorem `uniqueDiffWithinAt_congr` states that for any non-trivially normed field `𝕜` and any normed additive commutative group `E` that is a normed space over `𝕜`, given any element `x` of `E` and any two sets `s` and `t` of `E`, if the "neighborhood within" filter of `x` with respect to `s` equals the "neighborhood within" filter of `x` with respect to `t`, then `x` has unique derivatives within `s` if and only if `x` has unique derivatives within `t`. In other words, the property of having unique derivatives at a point within a set is preserved under equivalence of the "neighborhood within" filters.

If for all non-trivially normed fields `𝕜` and normed additive commutative groups `E` over `𝕜`, the "neighborhood within" filters of an element `x` in `E` with respect to sets `s` and `t` are equal, then `x` has unique derivatives within `s` if and only if `x` has unique derivatives within `t`.


theorem Submodule.set_smul_eq_of_le :
    ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] {S : Type u_4} [inst_1 : Monoid S] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : DistribMulAction S M] (s : Set S) (N p : Submodule R M),
      (∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p) → p ≤ s • N → s • N = p :=
  by sorry

The theorem `Submodule.set_smul_eq_of_le` states that for any types `R`, `M`, and `S`, given a semiring structure on `R`, a monoid structure on `S`, an additive commutative monoid structure on `M`, a module structure of `R` over `M`, a distributive multiplication action of `S` on `M`, a set `s` of type `S`, and two submodules `N` and `p` of `M`, if for every element `r` of `s` and every element `n` of `N`, the scalar multiplication `r • n` belongs to `p`, and if `p` is a subset of the scalar multiplication set `s • N`, then `s • N` is equal to `p`.

In simpler terms, this theorem is about the relationship between three mathematical structures - a set and two submodules - under certain operations. If all elements from the set and one submodule, when multiplied, result in an element of the other submodule, and this other submodule is a subset of the set scaled by the first submodule, then the set scaled by the first submodule is the other submodule.

If a set `s` of a semiring `R`, acting distributively on an additive commutative monoid `M` with a module structure over `R`, maps every element of a submodule `N` to another submodule `p`, and `p` is contained in the submodule generated by `s` and `N`, then `s • N = p`.


MeasurableSet.sInter

theorem MeasurableSet.sInter :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {s : Set (Set α)},
      Set.Countable s → (∀ t ∈ s, MeasurableSet t) → MeasurableSet (⋂₀ s) :=
  by sorry

This theorem states that for any type `α` and any measurable space `m` over `α`, if we have a countable collection `s` of sets of `α`, and each of these sets is measurable, then the intersection of all the sets in `s` is also a measurable set. In other words, the intersection of a countable collection of measurable sets is itself a measurable set. This theorem holds in the context of measure theory, which deals with concepts such as measurable spaces and sets.

In measure theory, the intersection of any countable collection of measurable sets is a measurable set.


/-- The function `exp(x)/x^n` tends to `+∞` at `+∞`, for any natural number `n`  -/
theorem Real.tendsto_exp_div_pow_atTop :
    ∀ (n : ℕ), Filter.Tendsto (fun x => Real.exp x / x ^ n) Filter.atTop Filter.atTop := by sorry

The theorem `Real.tendsto_exp_div_pow_atTop` states that for any natural number `n`, the function `exp(x)/x^n` tends to positive infinity as `x` tends to positive infinity. In other words, as `x` gets larger and larger, the value of `exp(x)/x^n` also gets larger without bound, regardless of the value of `n`. This is a statement about the rate of growth of the exponential function relative to polynomial functions: the exponential function grows faster than any power of `x`.

For any natural number `n`, the function `exp(x) / x^n` approaches positive infinity as `x` approaches positive infinity.


Complex.areaForm

theorem Complex.areaForm : ∀ (w z : ℂ), ((Orientation.areaForm Complex.orientation) w) z = ((starRingEnd ℂ) w * z).im :=
  by sorry

This theorem states that for any two complex numbers `w` and `z`, the oriented area of the parallelogram they span (calculated by applying the `Orientation.areaForm` on `Complex.orientation` to `w` and `z`) is equivalent to the imaginary part of the result of multiplying the conjugate of `w` with `z`. The conjugate of `w` is calculated using `starRingEnd ℂ`, which denotes the operation of complex conjugation in the field of complex numbers.

The oriented area of the parallelogram spanned by complex numbers `w` and `z` is equal to the imaginary part of the product of the complex conjugate of `w` and `z`.


theorem disjoin_manyOneReducible :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop}, p ≤₀ r → q ≤₀ r → Sum.elim p q ≤₀ r :=
  by sorry

The theorem `disjoin_manyOneReducible` states that for any types `α`, `β`, and `γ` where `α`, `β`, and `γ` are primcodable, and any predicates `p` on `α`, `q` on `β`, and `r` on `γ`, if `p` is many-one reducible to `r` and `q` is many-one reducible to `r`, then the function `Sum.elim p q`, which defines a function on the disjoint union of `α` and `β` (i.e., `α ⊕ β`) by giving separate definitions on `α` and `β`, is also many-one reducible to `r`. Here, "many-one reducible" is denoted by `≤₀`.

If `p` is many-one reducible to `r` and `q` is many-one reducible to `r`, then the function `Sum.elim p q` on the disjoint union of `α` and `β` is many-one reducible to `r`.


theorem Nat.mul_self_le_mul_self : ∀ {m n : ℕ}, m ≤ n → m * m ≤ n * n := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `m` is less than or equal to `n`, then `m` squared (i.e., `m` multiplied by itself) is also less than or equal to `n` squared (i.e., `n` multiplied by itself). In mathematical notation, this states that ∀ m, n ∈ ℕ (m ≤ n → m² ≤ n²).

For all natural numbers m and n, if m <= n then m^2 <= n^2.


theorem supClosed_univ : ∀ {α : Type u_2} [inst : SemilatticeSup α], SupClosed Set.univ := by sorry

The theorem `supClosed_univ` states that for any type `α` that forms a semilattice with a supremum operation (`SemilatticeSup α`), the universal set (`Set.univ`) is supremum-closed (`SupClosed`). In other words, for any two elements `a` and `b` in the set, the supremum of `a` and `b`, denoted by `a ⊔ b`, is also in the set. This holds true universally for all types that have a supremum operation.

For any semilattice type `α` with supremum operation, the universal set is supremum-closed, i.e., the supremum of any two elements in the set belongs to the set.


theorem Mathlib.Data.PFun._auxLemma.11 : ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) ∧ b) = ∃ x, p x ∧ b :=
  by sorry

This theorem states that for any type `α`, any predicate `p` on `α`, and any proposition `b`, the proposition `((∃ x, p x) ∧ b)` is equivalent to `∃ x, p x ∧ b`. In simpler terms, it says that the existence of an element satisfying a certain property and another independent proposition being true, is the same as there existing an element which satisfies the property and the independent proposition is true.

For any type `α`, predicate `p` on `α`, and proposition `b`, `∃x, p x ∧ b` is equivalent to `(∃x, p x) ∧ b`.


theorem Mathlib.Data.PFun._auxLemma.10 :
    ∀ {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} {b : β}, (b ∈ Part.bind f g) = ∃ a ∈ f, b ∈ g a := by
  sorry

The theorem `Mathlib.Data.PFun._auxLemma.10` states that for all types `α` and `β`, a partial function `f` from `α`, a function `g` from `α` to `Part β`, and a value `b` of type `β`, `b` belongs to the bind operation of `f` and `g` if and only if there exists a value `a` belonging to `f` such that `b` belongs to `g a`. In other words, `b` is in the result of binding `f` and `g` if there is an element in `f` which when passed through `g` produces `b`.

For all types `α` and `β`, and partial functions `f : α → Option β` and `g : α → Part β`, the value `b` belongs to `bind f g` if and only if there exists an `a` in the domain of `f` such that `b` is an element of `g a`.


theorem MeasureTheory.aedisjoint_compl_right :
    ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.AEDisjoint μ s sᶜ :=
  by sorry

This theorem states that for any given type `α`, any measurable space `m` defined over this type, any measure `μ` defined on this measurable space, and any set `s` of type `α`, the set `s` and its complement `sᶜ` are almost everywhere (a.e.) disjoint with respect to the measure `μ`. In other words, the intersection of set `s` and its complement `sᶜ` has measure zero under the measure `μ`. This is a common property in measure theory as a set and its complement should not have any common elements almost everywhere.

For any measurable space `(α, m)`, measure `μ`, and sets `s` and `sᶜ` of type `α` with `μ(s ∩ sᶜ) = 0`, the sets `s` and `sᶜ` are almost everywhere disjoint.


theorem EReal.preimage_coe_Ioi : ∀ (x : ℝ), Real.toEReal ⁻¹' Set.Ioi ↑x = Set.Ioi x := by sorry

This theorem states that for every real number `x`, the preimage of the interval `(x, +∞)` under the canonical inclusion from real numbers to extended real numbers is exactly the interval `(x, +∞)`. In other words, the canonical inclusion maps the interval `(x, +∞)` of real numbers onto the interval `(x, +∞)` of extended real numbers.

The canonical inclusion map from real numbers to extended real numbers maps the open interval (x, +∞) to the same open interval in the extended real numbers.


theorem AddMonoidHom.map_range :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} {P : Type u_6} [inst_1 : AddGroup N] [inst_2 : AddGroup P]
      (g : N →+ P) (f : G →+ N),
      AddSubgroup.map g (AddMonoidHom.range f) = AddMonoidHom.range (AddMonoidHom.comp g f) :=
  by sorry

The theorem `AddMonoidHom.map_range` states that for any two additive group homomorphisms `f` and `g`, where `f` is from an additive group `G` to an additive group `N` and `g` is from `N` to another additive group `P`, the range of the composition of `f` and `g` (denoted as `AddMonoidHom.range (AddMonoidHom.comp g f)`) is equal to the image of the range of `f` under the map `g` (denoted as `AddSubgroup.map g (AddMonoidHom.range f)`). In other words, this theorem guarantees the commutativity of taking the range of a homomorphism and taking the image of a subgroup in the context of additive group theory.

The range of the composition of two additive group homomorphisms is equal to the image of the range of the first homomorphism under the second homomorphism.


theorem Submodule.comap_smul :
    ∀ {K : Type u_9} {V : Type u_10} {V₂ : Type u_11} [inst : Semifield K] [inst_1 : AddCommMonoid V]
      [inst_2 : Module K V] [inst_3 : AddCommMonoid V₂] [inst_4 : Module K V₂] (f : V →ₗ[K] V₂) (p : Submodule K V₂)
      (a : K), a ≠ 0 → Submodule.comap (a • f) p = Submodule.comap f p :=
  by sorry

This theorem states that for any non-zero scalar `a`, the preimage of a submodule `p` under the scalar multiplication map `a • f` is the same as the preimage of the submodule `p` under the original linear map `f`. Here, `K` is a semifield, `V` and `V₂` are additive commutative monoids, and both `V` and `V₂` are modules over `K`. The linear map `f` is from `V` to `V₂`. The scalar multiplication `a • f` means each element of `V` is first multiplied by `a` and then mapped to `V₂` by `f`.

For any non-zero scalar `a` in a semifield `K`, the preimage of a submodule `p` under the scalar multiplication map `a • f` equals the preimage of `p` under the linear map `f`.


/-- **Alias** of the reverse direction of `Order.pred_eq_iff_isMin`. -/
theorem IsMin.pred_eq :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] {a : α}, IsMin a → Order.pred a = a := by sorry

This theorem states that for any type `α` that has a partial order and a predecessor order, and for any element `a` of type `α`, if `a` is a minimal element (meaning no element is strictly less than it), then the predecessor of `a` is `a` itself. This essentially means that for minimal elements, the predecessor operation leaves the element unchanged.

For any type `α` with a partial order and a predecessor function, if `a` is a minimal element, then `pred a = a`.


theorem SetTheory.PGame.not_fuzzy_of_le : ∀ {x y : SetTheory.PGame}, x ≤ y → ¬SetTheory.PGame.Fuzzy x y := by sorry

This theorem states that for any two pre-games `x` and `y` in set theory, if `x` is less than or equal to `y`, then we can say that `x` and `y` are not in a fuzzy relationship. In other words, if the first player has a strategy to either win or draw playing `x` against `y`, then it is not the case that the first player has a strategy to win regardless of whether they are playing `x` or `y`.

If `x` is less than or equal to `y` in set theory, then there does not exist a strategy for the first player to win consistently against both `x` and `y`.


theorem AddMonoidAlgebra.divOf.proof_1 :
    ∀ {G : Type u_1} [inst : AddCancelCommMonoid G] (g : G), Function.Injective fun x => g + x := by sorry

The theorem `AddMonoidAlgebra.divOf.proof_1` states that for any type `G` that forms an additive cancellative commutative monoid (i.e., a structure where addition operation is associative, commutative, and has an identity, and moreover, every element has an additive inverse), every element `g` of `G` gives rise to a function that adds `g` to its input. This function is injective. In mathematical terms, this means for all `g`, the function `f(x) = g + x` is such that if `f(x) = f(y)`, then `x = y`.

For every additive cancellative commutative monoid `G`, the function `x => g + x` is an injection from `G` to itself for any `g` in `G`.


theorem Icc_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderClosedTopology α] {a b x : α},
      a < x → x < b → Set.Icc a b ∈ nhds x :=
  by sorry

This theorem states that for any types `α` with a topology, a linear order, and an order-closed topology, and for any elements `a`, `b`, and `x` of type `α`, if `x` is strictly between `a` and `b`, then the closed interval from `a` to `b` (`Set.Icc a b`) is a neighborhood of `x`. In other words, the interval `[a, b]` contains an open set around `x` and as such is part of the filter of neighborhoods of `x` (`nhds x`).

For any type `α` with a topology, a linear order, and an order-closed topology, if `x` strictly lies between `a` and `b` in `α`, then the closed interval `[a, b]` is a neighborhood of `x`.


theorem IsUnit.div_eq_iff : ∀ {α : Type u} [inst : DivisionMonoid α] {a b c : α}, IsUnit b → (a / b = c ↔ a = c * b) :=
  by sorry

This theorem states that for any type `α` that is a division monoid, and any elements `a`, `b`, and `c` in `α`, if `b` is a unit (i.e., it has a two-sided inverse), then the condition of `a` divided by `b` being equal to `c` is equivalent to the condition of `a` being equal to `c` multiplied by `b`. In other words, it provides a way to rewrite division as multiplication in the presence of a unit element.

For any division monoid `α` and units `b` in `α`, the condition `a / b = c` is equivalent to `a = c * b`.


theorem rank_submodule_le :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (s : Submodule R M),
      Module.rank R ↥s ≤ Module.rank R M :=
  by sorry

This theorem states that for any Ring `R` and an additive commutative group `M` that also has a structure of `R`-Module, the rank of any submodule `s` of `M` is less than or equal to the rank of `M` itself. In mathematical terms, this means that the dimension of a subspace is always less than or equal to the dimension of the space that it is contained in.

For any submodule `s` of an `R`-Module `M` over a ring `R`, the rank of `s` is less than or equal to the rank of `M`.


theorem LieSubmodule.wellFounded_of_noetherian :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : IsNoetherian R M],
      WellFounded fun x x_1 => x > x_1 :=
  by sorry

This theorem states that for any types `R`, `L`, and `M`, given a commutative ring structure on `R`, a Lie ring structure on `L`, an additively commutative group structure on `M`, a module structure of `R` on `M`, a Lie ring module structure of `L` on `M`, and assuming that `M` is a Noetherian module over `R`, the relation "greater than" (`>`) on the elements of `M` is well-founded. In simpler terms, this theorem is about the order structure of modules in the context of Lie algebras, and it says that if a module is Noetherian, then there are no infinitely descending chains, which is a property known as well-foundedness.

Given a commutative ring `R`, a Lie ring `L`, an `R`-module `M` with Lie ring module structure and Noetherian condition, the "greater than" relation on `M` is well-founded.


theorem Set.Ioi_union_left : ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, Set.Ioi a ∪ {a} = Set.Ici a := by sorry

This theorem, named `Set.Ioi_union_left`, states that for any given type `α` with a partial order and any element `a` of this type, the union of the set of all elements strictly greater than `a` (denoted as `Set.Ioi a`) and the singleton set containing `a` is equal to the set of all elements greater than or equal to `a` (denoted as `Set.Ici a`). This essentially tells us that the "open" set of elements greater than `a`, when combined with `a`, forms the "closed" set of elements greater than or equal to `a`.

For any type with a partial order, the union of the upward-closed set containing a single element `a` and the set of elements strictly greater than `a` equals the set of elements greater than or equal to `a`.


theorem Matrix.linfty_opNNNorm_mul :
    ∀ {l : Type u_2} {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype l] [inst_1 : Fintype m]
      [inst_2 : Fintype n] [inst_3 : NonUnitalSeminormedRing α] (A : Matrix l m α) (B : Matrix m n α),
      ‖A * B‖₊ ≤ ‖A‖₊ * ‖B‖₊ :=
  by sorry

The theorem `Matrix.linfty_opNNNorm_mul` states that for any two matrices `A` and `B` with entries in a non-unital semi-normed ring `α`, the `ℓ∞` (also known as the infinity or Chebyshev) norm of the product of `A` and `B` is less than or equal to the product of the `ℓ∞` norms of `A` and `B` individually. This theorem holds for matrices of any dimension, as indexed by arbitrary types `l`, `m`, `n`, where `l`, `m` index the rows and `n` indexes the columns of the matrices, respectively.

For any matrices A and B with entries in a non-unital semi-normed ring, the ℓ∞ norm of their product is less than or equal to the product of their individual ℓ∞ norms.


theorem Set.Nonempty.bddBelow_upperBounds :
    ∀ {α : Type u} [inst : Preorder α] {s : Set α}, Set.Nonempty s → BddBelow (upperBounds s) := by sorry

The theorem `Set.Nonempty.bddBelow_upperBounds` states that for any type `α` with a preorder structure and for any nonempty set `s` of type `α`, the set of upper bounds of `s` has a lower bound. In simple terms, this theorem asserts that if we have a nonempty set, the collection of all elements which are greater than or equal to every element in the set, has at least one element that is smaller than or equal to all others in this collection.

If `α` is a type with a preorder structure and `s ≠∅` is a set of `α`, then the set of upper bounds of `s` has a least element.


theorem CategoryTheory.Limits.biprod.inl_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl CategoryTheory.Limits.biprod.fst =
        CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem states that for any category `C` which has zero morphisms and a binary biproduct of `X` and `Y`, the composition of the morphism that includes `X` into the binary biproduct of `X` and `Y` (`CategoryTheory.Limits.biprod.inl`) and the morphism that projects the first summand of the binary biproduct onto `X` (`CategoryTheory.Limits.biprod.fst`) is the identity morphism on `X` (`CategoryTheory.CategoryStruct.id X`). In other words, if you include `X` into a binary biproduct and then project back to `X`, you get back where you started. This is a formal expression of one of the basic properties of biproducts in category theory.

In any category with zero morphisms and binary biproducts, the inclusion morphism of one summand into the biproduct followed by the projection morphism of the biproduct onto that summand is the identity morphism on that summand.


theorem Int.mul_fdiv_cancel : ∀ (a : ℤ) {b : ℤ}, b ≠ 0 → Int.fdiv (a * b) b = a := by sorry

This theorem states that for any integer `a` and any non-zero integer `b`, when you perform floor division (`Int.fdiv`) of the product of `a` and `b` by `b`, the result is `a`. Essentially, it's stating that if you multiply an integer by another integer and then do floor division by the second integer, you get the first integer back.

For any integers `a` and `b` (`b` non-zero), `a * Int.div b = a * Quot.↑ (b : Int)`. (Here, `Int.div` denotes integer division and `Quot.↑` denotes the up-conversion of rational quotients to integers.)


theorem ProbabilityTheory.kernel.measure_eq_zero_or_one_of_indepSet_self :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μα : MeasureTheory.Measure α}
      [inst : ∀ (a : α), MeasureTheory.IsFiniteMeasure (κ a)] {t : Set Ω},
      ProbabilityTheory.kernel.IndepSet t t κ μα → ∀ᵐ (a : α) ∂μα, ↑↑(κ a) t = 0 ∨ ↑↑(κ a) t = 1 :=
  by sorry

This theorem, `measure_eq_zero_or_one_of_indepSet_self` in `ProbabilityTheory.kernel`, asserts that for any given type `α` and `Ω` with their respective measurable spaces `_mα` and `m0`, any kernel `κ` which maps from `α` to `Ω`, any measure `μα` on `α` such that for every element `a` in `α` the measure `(κ a)` is finite, and any set `t` in `Ω`, if `t` is independent with itself under the kernel `κ` and the measure `μα`, then almost every `a` in `α` under measure `μα` has the property that the measure of `t` under `(κ a)` is either `0` or `1`. In other words, if a set is independent with itself in a probability space, then the probability of the event corresponding to that set must be either 0 or 1 for almost all outcomes.

Given a measurable space `(α,_mα)`, a kernel `κ : α → Ω`, a finite measure `μα` on `α`, and a κ-independent and μα-measurable set `t` in `Ω`, almost every `a` in `α` has `μα` measure 0 or 1 for the measure of `t` under `κ(a)`.


theorem MeasureTheory.StronglyMeasurable.measurableSet_eq_fun :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {E : Type u_5} [inst : TopologicalSpace E]
      [inst_1 : TopologicalSpace.MetrizableSpace E] {f g : α → E},
      MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable g → MeasurableSet {x | f x = g x} :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.measurableSet_eq_fun` states that for any two functions `f` and `g` from a measurable space `α` to a topological and metrizable space `E`, if both `f` and `g` are strongly measurable (i.e., each one is the limit of a sequence of simple functions), then the set of points in `α` where `f` and `g` agree is a measurable set. In other words, the set of all `x` in `α` such that `f(x)` equals `g(x)` is measurable.

If `f` and `g` are two strongly measurable functions from a measurable space `α` to a topological and metrizable space `E`, then the set `{x ∈ α | f(x) = g(x)}` is measurable.


theorem Multiset.lcm_dedup :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] [inst_2 : DecidableEq α]
      (s : Multiset α), Multiset.lcm (Multiset.dedup s) = Multiset.lcm s :=
  by sorry

The `Multiset.lcm_dedup` theorem asserts that for any type `α` that is a cancel commutative monoid with zero, a normalized GCD monoid, and has decidable equality, and for any multiset `s` of the type `α`, the least common multiple (LCM) of the multiset obtained by removing duplicates from `s` is exactly the same as the LCM of `s` itself. In essence, this theorem states that duplicate elements in a multiset do not affect the calculation of the LCM.

For any cancel commutative monoid with zero, a normalized GCD monoid, and decidable equality `α`, the LCM of the multiset obtained by removing duplicates from a multiset `s` of type `α` equals the LCM of `s` itself.


theorem AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_snd_snd :
    ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.OpenCover X) (x y z : 𝒰.J),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.OpenCover.gluedCoverT' 𝒰 x y z)
          (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.snd CategoryTheory.Limits.pullback.snd) =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst CategoryTheory.Limits.pullback.fst :=
  by sorry

The theorem `AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_snd_snd` states that for any algebraic scheme `X`, given an open cover `𝒰` of `X` and three elements `x`, `y`, `z` from the indexing set of the open cover, the composition of morphisms `gluedCoverT' 𝒰 x y z` and the composition of two `pullback.snd` is equal to the composition of two `pullback.fst`. In the language of category theory, this theorem relates to the commutativity of a certain diagram involving pullbacks in the category of algebraic schemes.

 For any algebraic scheme X, open cover 𝒰, and indices i, j, k from its indexing set, the diagram commutes: (gluedCoverT' 𝒰 i j k).pullback.snd ∘ (pullback.fst i).pullback.snd = pullback.fst i ∘ pullback.fst j.

In other words, the composition of the second projections through the pullbacks along the open cover elements i, j, and k is equal to the composition of the first projections.


theorem Fin.last_add_one : ∀ (n : ℕ), Fin.last n + 1 = 0 := by sorry

This theorem states that for any natural number `n`, if we add `1` to the greatest value of `Fin (n+1)`, we get `0`. In other words, the greatest element of the finite ordered set with `n+1` elements (represented as `Fin (n+1)`), when incremented by `1`, loops back to the smallest element, `0`. This behavior is akin to that of modular arithmetic or circular arrays.

The greatest element in `Fin (n+1)` wraps around to `0` when incremented.


List.Pairwise.pmap

theorem List.Pairwise.pmap :
    ∀ {α : Type u_1} {β : Type u_2} {R : α → α → Prop} {l : List α},
      List.Pairwise R l →
        ∀ {p : α → Prop} {f : (a : α) → p a → β} (h : ∀ x ∈ l, p x) {S : β → β → Prop},
          (∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)) → List.Pairwise S (List.pmap f l h) :=
  by sorry

This theorem states that for any two types `α` and `β`, a relation `R` on elements of type `α`, and a list of elements of type `α`, if the elements of the list are pairwise related by `R`, then for any predicate `p` on elements of type `α`, and a function `f` from elements of `α` satisfying `p` to `β`, if every element in the list satisfies `p`, and there's a relation `S` on elements of type `β` such that for any two elements `x` and `y` of `α` satisfying `p`, if `x` and `y` are related by `R` then the images of `x` and `y` under `f` are related by `S`, then the elements of the list obtained by mapping `f` over the original list are pairwise related by `S`.

Given types `α`, `β`, a relation `R` on `α`, a list `ls : list α`, a predicate `p` on `α`, a function `f : {x : α | p x} -> β`, and a relation `S` on `β`, if every pair of related elements in `ls` satisfy `p` and the image of every pair of `p`-related elements under `f` are related by `S`, then the images of the list under `f` are pairwise related by `S`.


theorem CategoryTheory.Endofunctor.Coalgebra.Hom.ext :
    ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {F : CategoryTheory.Functor C C}
      {V₀ V₁ : CategoryTheory.Endofunctor.Coalgebra F} (x y : CategoryTheory.Endofunctor.Coalgebra.Hom V₀ V₁),
      x.f = y.f → x = y :=
  by sorry

This theorem states that in a given category `C` with an endofunctor `F`, for any two coalgebras `V₀` and `V₁` of this functor, any two morphisms `x` and `y` from `V₀` to `V₁` are identical if their underlying functions `x.f` and `y.f` are identical. In other words, in the context of endofunctor coalgebras, the morphism between two coalgebras is entirely determined by its underlying function.

In the category of endofunctor coalgebras, morphisms are determined by their underlying functions.


theorem Filter.hasBasis_cofinite : ∀ {α : Type u_2}, Filter.HasBasis Filter.cofinite (fun s => Set.Finite s) compl := by
  sorry

The theorem `Filter.hasBasis_cofinite` states that for all types `α`, the cofinite filter (which is the filter of subsets of `α` whose complements are finite) has a basis given by the function `Set.Finite s` applied to the complement of `s`. In other words, the cofinite filter is generated by the sets whose complements are finite.

The cofinite filter on a type `α` is generated by the sets whose complements are finite.


Algebra.FinitePresentation.mvPolynomial

/-- The ring of polynomials in finitely many variables is finitely presented.  -/
theorem Algebra.FinitePresentation.mvPolynomial :
    ∀ (R : Type w₁) [inst : CommRing R] (ι : Type u_2) [inst_1 : Finite ι],
      Algebra.FinitePresentation R (MvPolynomial ι R) :=
  by sorry

This theorem states that the ring of multivariate polynomials is finitely presented. More specifically, for any commutative ring `R` and any set `ι` of variables which is finite, the algebra of the multivariate polynomial with coefficients in `R` and variables from `ι` is a finitely presented algebra. In other words, it is the quotient of a polynomial ring in `n` variables by a finitely generated ideal.

For any finite set of variables `ι` and commutative ring `R`, the algebra of multivariate polynomials over `R` in variables `ι` is a finitely presented algebra.


theorem deriv_sub :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {x : 𝕜},
      DifferentiableAt 𝕜 f x → DifferentiableAt 𝕜 g x → deriv (fun y => f y - g y) x = deriv f x - deriv g x :=
  by sorry

The theorem `deriv_sub` states that for any two functions `f` and `g` that are differentiable at a point `x`, in a normed space over a nontrivially normed field `𝕜`, the derivative at `x` of the difference of `f` and `g` is equal to the difference of the derivatives at `x` of `f` and `g` respectively. In mathematical terms, this can be written as: if `f` and `g` are differentiable at `x`, then `(f - g)'(x) = f'(x) - g'(x)`.

The derivative of the difference of two differentiable functions is equal to the difference of their derivatives.


Memℓp.bddAbove

theorem Memℓp.bddAbove :
    ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      Memℓp f ⊤ → BddAbove (Set.range fun i => ‖f i‖) :=
  by sorry

The theorem `Memℓp.bddAbove` states that for all types `α` and for all types `E` which depend on `α`, given a normed add commutative group structure on `E i` for every `i` in `α`, and a function `f` from `α` to `E i`, if `f` belongs to the space `ℓ∞` (denoted as `Memℓp f ⊤`), then the set formed by the range of the norm of `f`, i.e., the set of all `‖f i‖`, is bounded above. In simpler terms, if a function belongs to the space of bounded sequences, then the norms of its values form a set which has an upper bound.

Given a normed add commutative group `E` indexed by a type `α`, and a function `f` from `α` to `E` belonging to `ℓ∞`, the set of norms `{||f i|| | i ∈ α}` is bounded above.


theorem HahnSeries.single_zero_mul_eq_smul :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : OrderedCancelAddCommMonoid Γ] [inst_1 : Semiring R] {r : R}
      {x : HahnSeries Γ R}, (HahnSeries.single 0) r * x = r • x :=
  by sorry

This theorem states that for any given type `Γ` with an ordered cancel addition commutative monoid structure, and another type `R` with a semiring structure, along with any element `r` of type `R` and a Hahn series `x` of type `HahnSeries Γ R`, the product of `r` (interpreted as a Hahn series where `r` is the coefficient at `0` and `0` is the coefficient everywhere else) and `x` equals `r` scaled by `x`. In other words, this theorem asserts that multiplication by a scalar in Hahn series corresponds to scalar multiplication.

For any ordered commutative monoid type `Γ`, semiring type `R`, element `r` in `R`, and Hahn series `x` of type `HahnSeries Γ R`, the product of `r` as a Hahn series and `x` equals `r` scaled by `x`, i.e., `r * x = (r * 1) * x`.


theorem norm_div_rev : ∀ {E : Type u_6} [inst : SeminormedGroup E] (a b : E), ‖a / b‖ = ‖b / a‖ := by sorry

This theorem, `norm_div_rev`, states that for any type `E` that forms a Semi-normed group, the norm of the result of dividing `a` by `b` is equal to the norm of the result of dividing `b` by `a`. In more mathematical terms, this is equivalent to stating that for any elements `a` and `b` in `E`, the norm of `a / b` (denoted as ‖a / b‖) is equal to the norm of `b / a` (denoted as ‖b / a‖).

For any type `E` forming a Semi-normed group and elements `a`, `b` in `E` with `b ≠ 0`, the norms of `a / b` and `b / a` are equal: ‖`a / b`‖ = ‖`b / a`‖.


theorem LinearEquiv.map_smulₛₗ :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (c : R)
      (x : M), e (c • x) = σ c • e x :=
  by sorry

This theorem states that for any semirings `R` and `S`, additive commutative monoids `M` and `M₂`, a module `M` over `R`, a module `M₂` over `S`, ring homomorphisms `σ : R →+* S` and `σ' : S →+* R` that form a ring homomorphism inverse pair, and a linear equivalence `e : M ≃ₛₗ[σ] M₂`, if we scale `x` in `M` by `c` in `R` and then apply the linear equivalence `e`, it's the same as applying the ring homomorphism `σ` to `c` and scaling `e(x)` by the result. In mathematical terms, it asserts that `e (c • x) = σ c • e x` for any `c` in `R` and `x` in `M`.

For any semirings R and S, additive commutative monoids M and M₂, a module M over R, a module M₂ over S, ring homomorphisms σ : R →+* S and σ' : S →+* R forming a ring homomorphism inverse pair, and a linear equivalence e : M ≃ₛₗ[σ] M₂, we have e (cx) = σ(c) * e(x) for all c in R and x in M.


theorem Option.getD_some : ∀ {α : Type u_1} {a b : α}, Option.getD (some a) b = a := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of type `α`, when the `getD` function is applied to the `Option` type `some a` and a default option `b`, it always returns `a`. This is because the `getD` function is defined such that it returns the value encapsulated in the `some` type if it exists, ignoring the default option.

For all types `α` and elements `a, b` of type `α`, `getD (some a) b = a`.


theorem Multiset.lcm_singleton :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {a : α},
      Multiset.lcm {a} = normalize a :=
  by sorry

The theorem `Multiset.lcm_singleton` states that for any type `α` that is a cancel commutative monoid with zero and a normalized GCD monoid, and for any element `a` of type `α`, the least common multiple (LCM) of a multiset containing only `a` is equal to the normalized form of `a`. Here, "normalize" means choosing an element of each associate class by multiplying by `normUnit`, and "lcm" represents the concept of least common multiple in the context of multisets.

For any cancel commutative monoid with zero and a normalized GCD monoid `α`, the LCM of a multiset containing only `a` is equal to the normalized form of `a`.


theorem MeasureTheory.IsSetSemiring.diff_sUnion_eq_sUnion_diffFinset₀ :
    ∀ {α : Type u_1} {C : Set (Set α)} {s : Set α} {I : Finset (Set α)} (hC : MeasureTheory.IsSetSemiring C)
      (hs : s ∈ C) (hI : ↑I ⊆ C), s \ ⋃₀ ↑I = ⋃₀ ↑(MeasureTheory.IsSetSemiring.diffFinset₀ hC hs hI) :=
  by sorry

The theorem `MeasureTheory.IsSetSemiring.diff_sUnion_eq_sUnion_diffFinset₀` states that for any type `α`, any semiring of sets `C`, any set `s` in `C`, and any finite set of sets `I` that is a subset of `C`, if `C` is a semiring of sets, then the difference between `s` and the union of `I` (i.e., `s \ ⋃₀ ↑I`) is equal to the union of the finite set of sets calculated by `MeasureTheory.IsSetSemiring.diffFinset₀` applied with `C`, `s` and `I` (i.e., `⋃₀ ↑(MeasureTheory.IsSetSemiring.diffFinset₀ hC hs hI)`). In simpler terms, it's stating that the difference between a set and a union of sets can be found by taking the union of the differences between that set and each set in the union.

For any semiring of sets `C`, set `s` in `C`, and finite subset `I` of `C`, `s \ (⋃ I) = ⋃ (MeasureTheory.IsSetSemiring.diffFinset₀ C s I)`.


theorem Complex.continuousAt_ofReal_cpow_const :
    ∀ (x : ℝ) (y : ℂ), 0 < y.re ∨ x ≠ 0 → ContinuousAt (fun a => ↑a ^ y) x := by sorry

The theorem `Complex.continuousAt_ofReal_cpow_const` states that for any real number `x` and any complex number `y`, if the real part of `y` is greater than zero or `x` is not equal to zero, then the function that maps a real number `a` to its complex power `y`, denoted as `a ^ y`, is continuous at `x`. In mathematical terms, this means the limit as `a` approaches `x` of `a ^ y` equals `x ^ y`.

For real numbers `x` neither zero nor equal to the real part of complex number `y`, the complex power function `a => a ^ y` is continuous at `x`.


theorem IsIntegralClosure.algebraMap_lift :
    ∀ {R : Type u_1} (A : Type u_2) (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
      [inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] {S : Type u_4}
      [inst_6 : CommRing S] [inst_7 : Algebra R S] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R S B]
      [inst_10 : Algebra R A] [inst_11 : IsScalarTower R A B] (h : Algebra.IsIntegral R S) (x : S),
      (algebraMap A B) ((IsIntegralClosure.lift A B h) x) = (algebraMap S B) x :=
  by sorry

The theorem, `IsIntegralClosure.algebraMap_lift`, states that for all types `R`, `A`, `B`, and `S` with certain properties and relations (specifically, `R`, `A`, `B`, and `S` being types of commutative rings having algebra structures, and `B` being an integral closure of `A` in `R`, with `R`, `A`, and `S` being scalar towers over `B`), if all elements of `S` are integral over `R`, then for any element `x` of `S`, the algebraic mapping of the lift of `x` from `A` to `B` is equal to the algebraic mapping of `x` from `S` to `B`.

In other words, lifting `x` to the integral closure and then applying the algebraic mapping results in the same value as directly applying the algebraic mapping to `x`.

For any commutative rings `R`, `A`, `B`, and `S` with algebra structures, if `B` is the integral closure of `A` in `R`, `R`, `A`, and `S` are scalar towers over `B`, and all elements of `S` are integral over `R`, then for any `x` in `S`, the algebraic mapping of the lift of `x` from `A` to `B` equals the algebraic mapping of `x` from `S` to `B`.


/-- The `Fin.castSucc_zero` in `Std` only applies in `Fin (n+1)`.
This one instead uses a `NeZero n` typeclass hypothesis.
 -/
theorem Fin.castSucc_zero' : ∀ {n : ℕ} [inst : NeZero n], Fin.castSucc 0 = 0 := by sorry

The theorem `Fin.castSucc_zero'` states that for any non-zero natural number `n`, the function `Fin.castSucc`, when applied to `0`, results in `0`. This is different from the `Fin.castSucc_zero` in the standard library, which only applies when `n` is incremented by `1`. This version of the theorem instead utilizes a typeclass hypothesis `NeZero n`, which ensures that `n` is non-zero.

For any non-zero natural number `n`, `Fin.castSucc 0 = 0`.


theorem Set.sInter_eq_iInter : ∀ {α : Type u_1} {s : Set (Set α)}, ⋂₀ s = ⋂ i, ↑i := by sorry

This theorem states that, for any type `α` and any set `s` of sets of `α`, the intersection over all elements of `s` (represented as `⋂₀ s` in Lean 4) is equal to the intersection over all elements `i` in `s` (represented as `⋂ i, ↑i`). In other words, this theorem equates two different formulations of the intersection of a collection of sets: one that directly takes the intersection of all sets in the collection, and one that iterates over the collection to compute the intersection.

For any type `α` and set `s` of sets of `α`, the intersection of all sets in `s` (⋂ s) is equal to the iterated intersection over each set `i` in `s` (⋂ i, i).


theorem CategoryTheory.OplaxNatTrans.Modification.ext :
    ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
      {F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (x y : CategoryTheory.OplaxNatTrans.Modification η θ),
      x.app = y.app → x = y :=
  by sorry

This theorem states that, given two types `B` and `C` each equipped with a structure of bicategory, two oplax functors `F` and `G` from `B` to `C`, and two oplax natural transformations `η` and `θ` from `F` to `G`; if we have two modifications `x` and `y` between `η` and `θ`, and the application of these modifications `x.app` and `y.app` are the same, then the modifications `x` and `y` are themselves the same. This theorem holds in the context of category theory and oplax natural transformations.

If two modifications between two oplax natural transformations between bicategory structures with the same domain and codomain have equal application, then they are equal.


theorem ZMod.int_cast_eq_int_cast_iff' : ∀ (a b : ℤ) (c : ℕ), ↑a = ↑b ↔ a % ↑c = b % ↑c := by sorry

This theorem states that for any two integers `a` and `b`, and a natural number `c`, the integer casts of `a` and `b` are equal if and only if the remainders of `a` and `b` when divided by `c` are equal. In mathematical terms, this theorem is saying if `a` is equivalent to `b` modulo `c`, then `a mod c` is equal to `b mod c`, and vice versa.

For integers `a`, `b`, and natural number `c`, `a % c = b % c` if and only if `⁇a = ⁇b`, where `⁇` denotes integer casting.


theorem Real.arctan_tan : ∀ {x : ℝ}, -(Real.pi / 2) < x → x < Real.pi / 2 → Real.arctan (Real.tan x) = x := by sorry

This theorem, `Real.arctan_tan`, states that for all real numbers `x`, if `x` is strictly greater than negative half of pi and strictly less than half of pi, then the arctangent of the tangent of `x` is equal to `x`. In other words, for any `x` in the open interval (-π/2, π/2), the inverse tangent (or arctangent) function is the inverse of the tangent function.

For all real numbers `x` in the open interval `(-π/2, π/2)`, `arctan(tan(x)) = x`.


theorem Rat.cast_injective :
    ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α], Function.Injective Rat.cast := by sorry

The theorem `Rat.cast_injective` states that for any type `α` that is a DivisionRing and has a "characteristic zero" property (expressed by the typeclass `CharZero`), the canonical homomorphism from rational numbers to `α` (denoted by the function `Rat.cast`) is injective. In other words, if `Rat.cast` maps two rational numbers to the same element of `α`, then these two rational numbers were the same to begin with. This property is fundamental in the field of number theory and algebra.

The canonical homomorphism from rational numbers to a DivisionRing of characteristic zero preserves equalities.


theorem CategoryTheory.Sieve.generate_sieve :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} (S : CategoryTheory.Sieve X),
      CategoryTheory.Sieve.generate S.arrows = S :=
  by sorry

The theorem `CategoryTheory.Sieve.generate_sieve` states that for any category `C` and any object `X` in this category, if `S` is a Sieve on `X`, then generating a Sieve from the arrows of `S` yields `S` itself. In other words, the generation process does not alter an existing Sieve. This highlights that the `generate` function is idempotent on sieves in the context of category theory.

For any category C and object X, generating a sieve from the arrows of a sieve S on X results in S itself.


theorem nhdsWithin_basis_open :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (t : Set α),
      Filter.HasBasis (nhdsWithin a t) (fun u => a ∈ u ∧ IsOpen u) fun u => u ∩ t :=
  by sorry

This theorem, `nhdsWithin_basis_open`, states that for any type `α` that has a topological space structure, any element `a` of type `α`, and any set `t` of type `α`, the "neighborhood within" filter (`nhdsWithin`) has a basis. This basis is characterized by the sets `u` that contain the point `a` and are open in the topological space. The elements of this basis are the intersections of `u` and `t`. In mathematical terms, this theorem is saying that for any point in a topological space and any subset of that space, we can find a fundamental system of neighborhoods (basis of the filter) for the point, consisting of open sets containing the point, whose intersections with the given subset form the neighborhoods within the subset.

For any point `a` in a topological space `α` and any subset `t` of `α`, the filter of neighborhoods of `a` within `t` has a basis consisting of open sets containing `a` whose intersections with `t` are the neighborhoods within `t`.


theorem Hyperreal.Infinite.not_infinitesimal : ∀ {x : ℝ*}, Hyperreal.Infinite x → ¬Hyperreal.Infinitesimal x := by sorry

The theorem `Hyperreal.Infinite.not_infinitesimal` states that for any hyperreal number `x`, if `x` is infinite (either infinitely positive or infinitely negative), then `x` cannot be infinitesimal. In other words, a hyperreal number cannot be both infinite and have a standard part of 0.

A hyperreal number is not infinitesimal if it is infinite.


theorem isUpperSet_iInter₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : LE α] {f : (i : ι) → κ i → Set α},
      (∀ (i : ι) (j : κ i), IsUpperSet (f i j)) → IsUpperSet (⋂ i, ⋂ j, f i j) :=
  by sorry

The `isUpperSet_iInter₂` theorem states that for any type `α` that has a less than or equal to (`≤`) relation, and for any two indexed families `{ι : Sort u_4}` and `{κ : ι → Sort u_5}`, if for every index `i` from `ι` and `j` from `κ i`, the set `f i j` is an upper set, then the intersection of all these sets (expressed as `(⋂ i, ⋂ j, f i j)`) is also an upper set. In other words, the intersection of any collection of upper sets is itself an upper set.

If for every index `i` and `j`, `f i j` is an upper set, then their intersection `(⋂ i, ⋂ j, f i j)` is also an upper set.


theorem MeasureTheory.OuterMeasure.le_trim_iff :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {m₁ m₂ : MeasureTheory.OuterMeasure α},
      m₁ ≤ MeasureTheory.OuterMeasure.trim m₂ ↔ ∀ (s : Set α), MeasurableSet s → ↑m₁ s ≤ ↑m₂ s :=
  by sorry

This theorem states that for any type `α` with a given `MeasurableSpace` structure and any two outer measures `m₁` and `m₂` on `α`, the measure `m₁` is less than or equal to the trimmed measure of `m₂` if and only if for every set `s` of `α` that is measurable, the measure of `s` under `m₁` is less than or equal to its measure under `m₂`. In mathematical terms, this could be written as: \(m_1 \leq \text{{trim}}(m_2) \iff \forall s: \text{{MeasurableSet }} s \rightarrow m_1(s) \leq m_2(s)\).

For any measurable spaces `(α, Σ)` and measurable sets `s` in `α`, and for any outer measures `m₁` and `m₂` on `α`, the inequality `m₁ ≤ trim(m₂)` holds if and only if `m₁(s) ≤ m₂(s)` for all measurable sets `s`.


theorem Matrix.UnitaryGroup.toLin'_mul :
    ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
      (A B : ↥(Matrix.unitaryGroup n α)),
      Matrix.UnitaryGroup.toLin' (A * B) = Matrix.UnitaryGroup.toLin' A ∘ₗ Matrix.UnitaryGroup.toLin' B :=
  by sorry

The theorem `Matrix.UnitaryGroup.toLin'_mul` states that for any type `n` with decidable equality and finiteness, and any type `α` with a commutative ring and star ring structure, given two elements `A` and `B` of the unitary group of `n x n` matrices with entries from `α`, the linear map corresponding to the product of `A` and `B` is equal to the composition of the linear maps corresponding to `A` and `B`. In other words, this theorem shows that matrix multiplication corresponds to composition of linear maps in the context of unitary group.

For any commutative ring and star ring `α` with decidable equality and finiteness, and for any `n x n` unitary matrices `A` and `B` over `α`, the product of `A` and `B` as matrices equals the composition of the linear transformations represented by `A` and `B`.


theorem ENNReal.tsum_eq_iSup_nat :
    ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = ⨆ i, Finset.sum (Finset.range i) fun a => f a := by sorry

This theorem states that for any given function `f` which maps natural numbers to the extended nonnegative real numbers (`ENNReal`), the infinite sum (or series) of `f(i)` over all natural numbers `i` is equal to the least upper bound (or supremum, denoted by `⨆`) of the finite sums of `f(a)` over the range set `{0, 1, 2, ..., i-1}` for each `i`.

In other words, the value of an infinite sum in the extended nonnegative reals can be found by considering the supremum of the values of the finite sums over all natural number ranges.

For any function `f` mapping natural numbers to extended nonnegative reals, the infinite series $\sum\_{i=0}^{\infty} f(i)$ equals the supremum of the finite sums $\sum\_{j=0}^{i-1} f(j)$ over all natural numbers `i`.


Set.Intersecting.insert

theorem Set.Intersecting.insert :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {s : Set α} {a : α},
      Set.Intersecting s → a ≠ ⊥ → (∀ b ∈ s, ¬Disjoint a b) → Set.Intersecting (insert a s) :=
  by sorry

The theorem `Set.Intersecting.insert` states that for any type `α` with a `SemilatticeInf` and `OrderBot` structure, a set `s` of type `α`, and an element `a` of type `α`, if `s` is an intersecting set (that is, every pair of elements in `s` is non-disjoint), `a` is not the bottom element, and `a` is not disjoint with any element in `s`, then the insertion of `a` into `s` results in a set that is still intersecting. In other words, adding an element that intersects with all the existing elements in an intersecting set maintains the intersecting property of the set.

If `α` is a type with `SemilatticeInf` and `OrderBot` structures, `s` is an intersecting set of `α`, and `a` is not the bottom element nor disjoint with any element in `s`, then `a ∉ ∅ ∧ s ⊆ t ∧ ∀ x ∈ s, a ≤ x → a ∈ t` implies `a ∈ s ⊆ t`, where `t = s ∪ {a}`.


theorem CategoryTheory.ShortComplex.SnakeInput.L₀_exact :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
      (S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.Exact S.L₀ :=
  by sorry

This theorem states that for any given category `C` of type `u_1`, where `C` is assumed to be a category in the sense of category theory and furthermore an Abelian category, and for a given short complex `S` defined on `C`, the zeroth term `L₀` of the short complex `S` is exact. In category theory, a complex is said to be exact at a term if the image of the morphism from the previous term equals the kernel of the morphism to the next term.

In an Abelian category `C` of type `u_1`, the zeroth term of a given short complex `S` is exact, meaning the image of the morphism from the preceding term equals the kernel of the morphism to the next term.


theorem PiLp.nnnorm_equiv_symm_single :
    ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fintype ι]
      [inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] [hp : Fact (1 ≤ p)] (i : ι) (b : β i),
      ‖(WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b)‖₊ = ‖b‖₊ :=
  by sorry

This theorem states that for any extended nonnegative real number `p`, given a type `ι`, a function `β` mapping elements of `ι` to some other type, and assuming that `ι` has finite number of elements, elements of `β i` form a seminormed additively commutative group, there exists a decidable equality on `ι`, and `p` is greater than or equal to 1. For any element `i` of type `ι` and any element `b` of type `β i`, the nonnegative norm of the inverse of the canonical equivalence between the space of functions `WithLp p ((i : ι) → β i)` and `((i : ι) → β i)`, applied to the function supported at `i`, with value `b` there, and `0` elsewhere, is equal to the nonnegative norm of `b`. Essentially, the norm of a function that is non-zero at a single point `i` and zero elsewhere, under this equivalence, is just the norm of the value at `i`.

For any finite type `ι`, function `β : ι →* X`, and extended nonnegative real number `p ≥ 1`, the inverse of the canonical equivalence between the `Lp[0]` space of functions `ι → β` and `β` under pointwise operations preserves the `Lp[0]` norm, i.e., for all `i ∈ ι` and `b ∈ β i`, the `Lp[0]` norm of the function supported at `i` with value `b` and zero elsewhere equals the `Lp[0]` norm of `b`.