theorem WithTop.coe_iSup :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : Preorder α] [inst_1 : SupSet α] (f : ι → α),
      BddAbove (Set.range f) → ↑(⨆ i, f i) = ⨆ i, ↑(f i) :=
  by sorry

This theorem states that for any type `α` with a preorder and superset structure, and any function `f` from some arbitrary type `ι` to `α`, if the range of `f` is bounded above, then the supremum (least upper bound) of the co-domain of `f` when mapped to the extended non-negative real line (with the possibility of positive infinity), is equal to the supremum of the image of `f` under the same mapping. In other words, taking the supremum of `f` before or after applying the function does not change the result, provided that the range of `f` is bounded above.

For any function `f` from a type `ι` to a type `α` with a preorder and superset structure, if `f` has a bounded above range, then the supremum of `f`'s image equals the supremum of its range when mapped to the extended non-negative real line.


theorem Finset.coe_offDiag :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), ↑(Finset.offDiag s) = Set.offDiag ↑s := by sorry

The theorem `Finset.coe_offDiag` states that for all finite sets `s` of a type `α` with decidable equality, the off-diagonal of `s` when treated as a finite set and then converted into a set (`↑(Finset.offDiag s)`) is equal to the off-diagonal of `s` directly considered as a set (`Set.offDiag ↑s`). In other words, the off-diagonal operation is consistent whether we consider `s` as a finite set or as a set in general.

Here, the off-diagonal of a set `s` is defined as the set of all pairs `(a, b)` such that `a` and `b` are in `s` and `a ≠ b`. The operation `↑` is used to convert a finite set to a general set in Lean 4.

For any finite set `s` of type `α` with decidable equality, `Finset.offDiag s = Set.offDiag (↑s)`.


theorem Ultrafilter.eq_of_le : ∀ {α : Type u} {f g : Ultrafilter α}, ↑f ≤ ↑g → f = g := by sorry

This theorem states that for any two ultrafilters `f` and `g` of an arbitrary type `α`, if `f` is less than or equal to `g` (denoted by `↑f ≤ ↑g`), then `f` is equal to `g`. This essentially means that if one ultrafilter's set of elements is a subset of or equal to another's, the two ultrafilters are the same. This is specific to the structure of ultrafilters in set theory.

If `f` and `g` are ultrafilters on a set `α`, then `↑f = ↑g` if and only if `f ≤ g`.


padicNorm.neg

/-- `padicNorm p` is symmetric.  -/
theorem padicNorm.neg : ∀ {p : ℕ} (q : ℚ), padicNorm p (-q) = padicNorm p q := by sorry

The theorem `padicNorm.neg` states that the p-adic norm function `padicNorm p` is symmetric with respect to the origin. In other words, for any natural number `p` and any rational number `q`, the p-adic norm of `-q` (the negation of `q`) is equal to the p-adic norm of `q`. This implies that the p-adic norm doesn't change if you take the negative of a rational number `q`.

For any prime number p and rational number q, the p-adic norm of the negation of q equals the p-adic norm of q.


/-- The mean value theorem on a convex set: if the derivative of a function is bounded by `C`, then
the function is `C`-Lipschitz. Version with `HasFDerivWithinAt`.  -/
theorem Convex.norm_image_sub_le_of_norm_hasFDerivWithin_le :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {𝕜 : Type u_3} {G : Type u_4}
      [inst_2 : RCLike 𝕜] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace 𝕜 G]
      {f : E → G} {C : ℝ} {s : Set E} {x y : E} {f' : E → E →L[𝕜] G},
      (∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) →
        (∀ x ∈ s, ‖f' x‖ ≤ C) → Convex ℝ s → x ∈ s → y ∈ s → ‖f y - f x‖ ≤ C * ‖y - x‖ :=
  by sorry

This theorem is a version of the Mean Value Theorem for a convex set. It states that if we have a function `f` from a normed additively commutative group `E` to another normed additively commutative group `G`, where `E` and `G` are normed spaces over some types `𝕜` and `ℝ` respectively, then given a real number `C`, a set `s` of type `E`, and two elements `x` and `y` of type `E`, if the function `f` has a derivative `f'` at every point in the set `s` and the norm of the derivative `f'` at every point in the set `s` is less than or equal to `C`, and if the set `s` is convex over real numbers, then the norm of the difference of the function `f` values at `y` and `x` is less than or equal to `C` times the norm of the difference between `y` and `x`. In simpler terms, if the derivative of a function is bounded by `C` on a convex set, then the function is `C`-Lipschitz.

Given a convex set `s` in a normed additive commutative group `E` over `ℝ`, and a function `f` from `E` to another normed additive commutative group `G` over `𝕜`, if `f` has a Lipschitz continuous derivative `f'` of norm at most `C` on `s`, then `f` is `C`-Lipschitz on `s`.


theorem Finset.max_eq_sup_coe :
    ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α}, Finset.max s = Finset.sup s WithBot.some := by sorry

This theorem states that for any given type `α` which has a linear order and any finite set `s` of `α`, the maximum value of `s` is equal to the supremum of `s` when each element of `s` is mapped into `WithBot α` using the canonical map. In other words, the max function on a finite set equals to applying the supremum function to the same set after each of its elements has been lifted into the `WithBot α` type.

For any finite set `s` of a linearly ordered type `α`, the maximum element of `s` is equal to the supremum of the images of `s` under the canonical map to `WithBot α`.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.23 :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {n : ℕ} [inst_5 : Nat.AtLeastTwo n], (1 ≤ OfNat.ofNat n) = True :=
  by sorry

This theorem, named `Mathlib.Data.Nat.Cast.Order._auxLemma.23`, states that for any type `α` that has the structures of an additive monoid with one, a partial order, a covariant class under addition and order, a Zero to One class, and has characteristic zero, and given any natural number `n` that is at least two, the 'ofNat' cast of `n` to `α` is always greater than or equal to one. In other words, when we map a natural number `n` (where `n` is at least two) to any such structure `α`, the result is always greater than or equal to one.

For any type `α` with the structures of an additive monoid with one, a partial order, covariance under addition and order, Zero to One class, and characteristic zero, the `ofNat` cast of any natural number `n` (where `n` is at least two) is greater than or equal to one.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.24 :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {n : ℕ} [inst_5 : Nat.AtLeastTwo n], (OfNat.ofNat n ≤ 1) = False :=
  by sorry

The theorem `Mathlib.Data.Nat.Cast.Order._auxLemma.24` states that for any type `α` that is an additive monoid with a distinguished one, has a partial order, is covariant, has a zero that is less than or equal to one, has characteristic zero, and a natural number `n` that is at least two, the proposition that `n` (cast to type `α` using the `OfNat.ofNat` function) is less than or equal to `1` is always false.

For any additive monoid α with one, partial order, covariant, zero <= 1, characteristic zero, and n >= 2, it is false that n (as an element of α) is less than or equal to 1.


theorem MeasureTheory.Measure.restrict_toMeasurable :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      ↑↑μ s ≠ ⊤ → μ.restrict (MeasureTheory.toMeasurable μ s) = μ.restrict s :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` of type `α`, any measure `μ` of that measurable space, and any set `s` of type `α`, if `μ s` is not equal to infinity, then the restriction of `μ` to the measurable set derived from `s` is equal to the restriction of `μ` to `s` itself. In other words, if a set does not have infinite measure, the measure restricted to it remains the same even if we replace the set with the corresponding measurable set.

For any measurable space `(α, m0)`, measure `μ`, and set `s` of finite measure `μ(s)`, the restriction of `μ` to the measurable set `{x : α | x ∈ s}∘m0` is equal to `μ` restricted to `s`.


/-- If a function `f` with a densely ordered codomain is strictly monotone on a right neighborhood
of `a` and the closure of the image of this neighborhood under `f` is a right neighborhood of `f a`,
then `f` is continuous at `a` from the right.  -/
theorem StrictMonoOn.continuousWithinAt_right_of_closure_image_mem_nhdsWithin :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : LinearOrder β] [inst_4 : TopologicalSpace β] [inst_5 : OrderTopology β] [inst_6 : DenselyOrdered β]
      {f : α → β} {s : Set α} {a : α},
      StrictMonoOn f s →
        s ∈ nhdsWithin a (Set.Ici a) →
          closure (f '' s) ∈ nhdsWithin (f a) (Set.Ici (f a)) → ContinuousWithinAt f (Set.Ici a) a :=
  by sorry

This theorem states that if a function `f`, from a linearly ordered type `α` to a densely ordered type `β`, is strictly increasing within a set `s` that lies in the right neighborhood of a point `a` in `α` and the closure of the image of `s` under `f` is in the right neighborhood of the image of `a` under `f`, then `f` is right-continuous at `a`.

Here, the term 'right-continuous at `a`' means that as we approach `a` from values greater than `a` (i.e., from the right side of `a`), the values of the function `f` tend to `f(a)`.

Moreover, the closure of a set is the smallest closed set containing the set, and a 'right neighborhood of a point `a`' refers to an interval of the form `[a, ∞)`. The term 'strictly increasing' means that for any two distinct points in the domain, the value at the larger point is greater than the value at the smaller point.

If a strictly increasing function `f` from a linearly ordered type `α` to a densely ordered type `β` is such that the closure of `f`'s image of a right neighborhood of `a` in `α` lies in the right neighborhood of `f(a)` in `β`, then `f` is right-continuous at `a`.


theorem Primrec.subtype_val_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : β → Prop}
      [inst_2 : DecidablePred p] {hp : PrimrecPred p} {f : α → Subtype p}, (Primrec fun a => ↑(f a)) ↔ Primrec f :=
  by sorry

The theorem `Primrec.subtype_val_iff` states that for any two types `α` and `β` which are primcodable (i.e., they can be encoded as natural numbers), a decidable predicate `p` on `β`, a primitive recursive predicate `hp` which tests `p`, and a function `f : α → Subtype p` (that is, a function from `α` to the subtype of `β` determined by `p`), the function `f` is primitive recursive if and only if the function that gets the original element in `β` from the result of `f` is primitive recursive. Essentially, this theorem says that working with subtypes does not affect the property of being primitive recursive.

For types `α` and `β` that are primcodable, a function `f : α → Subtype (p : β → Prop)` is primitive recursive if and only if the function `λ x, p x <| f x` is primitive recursive, where `<|` is the extraction operator for subtypes.


/-- See `rank_zero_iff` for a stronger version with `NoZeroSMulDivisor R M`.  -/
theorem rank_eq_zero_iff :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      Module.rank R M = 0 ↔ ∀ (x : M), ∃ a, a ≠ 0 ∧ a • x = 0 :=
  by sorry

This theorem, `rank_eq_zero_iff`, states that for any ring `R` and additive commutative group `M` that forms a module `M` over `R`, the rank of this module `M` is zero if and only if for every element `x` in `M`, there is a nonzero scalar `a` from `R` such that the scalar multiplication of `a` and `x` equals zero. The theorem provides a characterization for a module having zero rank in terms of its elements being annihilated by a nonzero scalar from the ring.

A module over a ring has rank zero if and only if every element in the module is annihilated by some nonzero scalar in the ring.


theorem ContinuousLinearMap.le_of_opNorm_le_of_le :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
      (f : E →SL[σ₁₂] F) {x : E} {a b : ℝ}, ‖f‖ ≤ a → ‖x‖ ≤ b → ‖f x‖ ≤ a * b :=
  by sorry

This theorem states that for every seminormed additive commutative group `E` and `F`, nontrivially normed fields `𝕜` and `𝕜₂`, and normed spaces over `E` and `F` with respect to `𝕜` and `𝕜₂` respectively, if a continuous linear map `f` from `E` to `F` exists under a ring homomorphism `σ₁₂` from `𝕜` to `𝕜₂`, then for every element `x` in `E` and real numbers `a` and `b`, if the operator norm of `f` is less than or equal to `a` and the norm of `x` is less than or equal to `b`, then the norm of the result of applying `f` to `x` is less than or equal to the product of `a` and `b`.

Given a seminormed additive commutative group `E`, nontrivially normed fields `𝕜` and `𝕜₂`, normed spaces `X` over `E` with respect to `𝕜` and `Y` over `F` with respect to `𝕜₂`, a continuous linear map `f : E → F` under a ring homomorphism `σ₁₂ : 𝕜 → 𝕜₂`, if the operator norm of `f` is less than or equal to a and the norm of every x in E is less than or equal to b, then the norm of `f(x)` in Y is less than or equal to `a * b`.


theorem Nat.gcd_dvd_gcd_of_dvd_left : ∀ {m k : ℕ} (n : ℕ), m ∣ k → Nat.gcd m n ∣ Nat.gcd k n := by sorry

The theorem `Nat.gcd_dvd_gcd_of_dvd_left` states that for all natural numbers `m`, `k`, and `n`, if `m` divides `k`, then the greatest common divisor (gcd) of `m` and `n` divides the gcd of `k` and `n`. In mathematical notation, this is saying that for all m, k, n ∈ ℕ, if m | k, then gcd(m, n) | gcd(k, n).

If `m` divides `k`, then the greatest common divisor of `m` and `n` (gcd(m, n)) is a divisor of the greatest common divisor of `k` and `n` (gcd(k, n)).


theorem Nat.floor_add_nat :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α},
      0 ≤ a → ∀ (n : ℕ), ⌊a + ↑n⌋₊ = ⌊a⌋₊ + n :=
  by sorry

This theorem states that for any non-negative element 'a' of a linear ordered semiring, when you add a natural number 'n' to 'a', the floor of the result is equal to the floor of 'a' added to 'n'. Here, the floor operation is defined on a semiring equipped with a floor operation. It's important to note that the floor function returns the greatest integer less than or equal to a given number, so this theorem is dealing with the interaction of floor operations and addition.

For any non-negative element $a$ in a linear ordered semiring with a floor operation, $\lfloor a + n \rfloor = \lfloor a \rfloor + n$.


theorem Set.OrdConnected.preimage_mono :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {f : β → α},
      Set.OrdConnected s → Monotone f → Set.OrdConnected (f ⁻¹' s) :=
  by sorry

The theorem `Set.OrdConnected.preimage_mono` states that for all types `α` and `β` with preordering, if a set `s` of type `α` is order-connected and a function `f` from `β` to `α` is monotone, then the preimage of `s` under `f` (i.e., the set of all elements in `β` that `f` maps into `s`) is also order-connected.

In other words, if `s` is a set where for any two elements in it, all elements between them (in terms of the order) also belong to `s`, and if `f` is a function that preserves the order, then the set of elements that `f` maps into `s` also has this property of containing all elements between any two of its elements.

If `s` is an order-connected subset of type `α` and `f` is a monotone function from type `β` to `α`, then `f⁻¹[s]` (the preimage of `s` under `f`) is also an order-connected subset of `β`.


theorem Nat.one_mem_properDivisors_iff_one_lt : ∀ {n : ℕ}, 1 ∈ Nat.properDivisors n ↔ 1 < n := by sorry

The theorem `Nat.one_mem_properDivisors_iff_one_lt` states that for all natural numbers `n`, the number 1 is a proper divisor of `n` if and only if `n` is greater than 1. Here, a "proper divisor" of a number is defined as a divisor of the number that is not equal to the number itself. In the special case where `n` is 0, the set of proper divisors is empty, as defined by the function `Nat.properDivisors`.

For all natural numbers $n$, $1$ is a proper divisor of $n$ if and only if $n$ is a positive integer.


theorem segment_eq_image' :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] (x y : E),
      segment 𝕜 x y = (fun θ => x + θ • (y - x)) '' Set.Icc 0 1 :=
  by sorry

The theorem `segment_eq_image'` states that for any type `𝕜` which is an ordered ring, and any type `E` which is an additive commutative group and a `𝕜`-module, for any two elements `x` and `y` of `E`, the segment between `x` and `y` is equivalent to the image of the function that maps `θ` to `x + θ • (y - x)`, where `θ` ranges over the closed interval from 0 to 1. This theorem is essentially stating that a segment in a vector space between two points can be parameterized by a scalar `θ` in the closed interval [0, 1], where `θ = 0` corresponds to the point `x` and `θ = 1` corresponds to the point `y`.

For any ordered ring `𝕜`, additive commutative group and `𝕜`-module `E`, the segment between two elements `x` and `y` in `E` is equal to the image of the function that maps `θ` to `x + θ • (y - x)` for `θ` in the closed interval [0, 1].


theorem Real.Angle.toReal_neg_iff_sign_neg : ∀ {θ : Real.Angle}, Real.Angle.toReal θ < 0 ↔ Real.Angle.sign θ = -1 := by
  sorry

This theorem states that for any real angle 'θ', the real number representation of 'θ' will be less than zero if and only if the sign of 'θ' is -1. The sign of a real angle is defined as the sign of the sine of the angle: it's 0 if the angle is 0 or π, 1 if the angle is strictly between 0 and π, and -1 if the angle is strictly between -π and 0. Therefore, according to this theorem, a negative real representation of a real angle implies that its sine is negative, i.e., the angle is strictly between -π and 0.

The real representation of a real angle is negative if and only if the angle's sine is negative, i.e., the angle is strictly between -π and 0.


theorem Module.card_fintype :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Fintype ι],
      Basis ι R M → ∀ [inst : Fintype R] [inst_4 : Fintype M], Fintype.card M = Fintype.card R ^ Fintype.card ι :=
  by sorry

The theorem `Module.card_fintype` states that for any types `ι`, `R`, and `M`, given a semiring structure on `R`, an additive commutative monoid structure on `M`, and a module structure on `M` over `R`, and assuming that `ι`, `R`, and `M` are finite types (i.e., they have finitely many distinct values), if `ι` serves as a basis for the module `M` over the ring `R`, then the number of elements in `M` (denoted `Fintype.card M`) is equal to the number of elements in `R` (denoted `Fintype.card R`) raised to the power of the number of elements in `ι` (denoted `Fintype.card ι`). In mathematical notation, this would be written as |M| = |R|^|ι|.

If `ι` is a finite basis for a module `M` over a finite ring `R`, then |M| = |R|^|ι|.


theorem Complex.cosh_two_mul : ∀ (x : ℂ), Complex.cosh (2 * x) = Complex.cosh x ^ 2 + Complex.sinh x ^ 2 := by sorry

The theorem named `Complex.cosh_two_mul` states that for all complex numbers `x`, the complex hyperbolic cosine of `2 * x` is equal to the sum of the squares of the complex hyperbolic cosine and the complex hyperbolic sine of `x`. In mathematical terms, it states that for every complex number `x`, $\cosh(2x) = \cosh^2(x) + \sinh^2(x)$. This is a complex number version of the double-angle formula in hyperbolic trigonometry.

The complex hyperbolic cosine of twice a complex number equals the sum of the squares of its hyperbolic cosine and hyperbolic sine. In mathematical notation, $\cosh(2x) = \cosh^2(x) + \sinh^2(x)$.


theorem Complex.ofReal_tsum : ∀ {α : Type u_1} (f : α → ℝ), ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a) := by sorry

This theorem states that for any function `f` from a generic type `α` to the real numbers `ℝ`, the sum of the real part of the complex number representations of the function's outputs over all `α` is equal to the complex number representation of the sum of the function's outputs over all `α`. In other words, when we compute the sum (using tsum) of the real part of the complex numbers obtained from `f`, it's the same as first summing up the real numbers obtained from `f` and then converting to a complex number.

For any function `f` from type `α` to `ℝ`, the complex number sum of the real parts of `f α` for all `α` equals the complex number representation of the real sum of `f α` for all `α`.


theorem ProbabilityTheory.kernel.IndepSets.iUnion :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
      {_mΩ : MeasurableSpace Ω} {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      (∀ (n : ι), ProbabilityTheory.kernel.IndepSets (s n) s' κ μ) →
        ProbabilityTheory.kernel.IndepSets (⋃ n, s n) s' κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.IndepSets.iUnion` states that for any types `α`, `Ω`, and `ι`, given a measurable space `α`, a family of sets `s : ι → Set (Set Ω)`, a set `s' : Set (Set Ω)`, a measurable space `Ω`, a kernel `κ : ↥(ProbabilityTheory.kernel α Ω)` and a measure `μ : MeasureTheory.Measure α`, if every set `s n` in the family is independent with respect to the kernel `κ` and the measure `μ` for all `n` in `ι`, then the union of all these sets `⋃ n, s n` is also independent with respect to the kernel `κ` and the measure `μ`.

In other words, the independence of each set in a family of sets implies the independence of their union. Here, two sets of sets `s₁, s₂` are said to be independent with respect to a kernel `κ` and a measure `μ` if for any sets `t₁ ∈ s₁, t₂ ∈ s₂`, almost everywhere `a`, the kernel `κ` applied to the intersection of `t₁` and `t₂` equals the product of `κ` applied to `t₁` and `κ` applied to `t₂`.

If each set in a measurable family is independent with respect to a kernel and measure, then their union is also independent under the same kernel and measure.


theorem Function.IsFixedPt.perm_zpow :
    ∀ {α : Type u} {x : α} {e : Equiv.Perm α}, Function.IsFixedPt (⇑e) x → ∀ (n : ℤ), Function.IsFixedPt (⇑(e ^ n)) x :=
  by sorry

The theorem `Function.IsFixedPt.perm_zpow` states that for any type `α`, any point `x` of type `α`, and any permutation `e` of type `α`, if `x` is a fixed point of the function represented by the permutation `e` (meaning applying `e` to `x` gives back `x`), then `x` is also a fixed point of the function represented by the `n`-th power of `e` for any integer `n`. In other words, applying the `n`-th power of `e` to `x` also gives back `x`.

If `x` is a fixed point of a permutation `e` on type `α`, then `x` is also a fixed point of `e` raised to the power of any integer `n`.


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

This theorem states that in a category with zero morphisms and binary biproducts, for any four objects W, X, Y, Z, and given morphisms f from W to Y and g from X to Z, the composition of the morphism that includes W into the binary biproduct of W and X with the morphism that maps the binary biproduct of W and X to the binary biproduct of Y and Z using f and g, is equal to the composition of f with the morphism that includes Y into the binary biproduct of Y and Z. In other words, the diagram commutes when mapping from the binary biproducts.

In a category with zero morphisms and binary biproducts, the diagram commutes when forming the binary biproduct of any three objects and composing with given morphisms between them.


Ring.closure.isSubring

theorem Ring.closure.isSubring : ∀ {R : Type u} [inst : Ring R] {s : Set R}, IsSubring (Ring.closure s) := by sorry

The theorem `Ring.closure.isSubring` states that for any type `R` with a ring structure, and any set `s` of elements of `R`, the smallest subring of `R` that contains `s` (denoted by `Ring.closure s`) is indeed a subring of `R`. In mathematical terms, given a ring $(R, +, \cdot)$ and a subset $s$ of $R$, the closure of $s$ under the ring operations (addition and multiplication), denoted by `Ring.closure s`, forms a subring of $R$.

Let $(R, +, \cdot)$ be a ring and $s$ be a subset of $R$. The set `Ring.closure s` is a subring of $R$.


theorem DirectSum.decompose_symm_of :
    ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M]
      [inst_2 : SetLike σ M] [inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ] {i : ι}
      (x : ↥(ℳ i)), (DirectSum.decompose ℳ).symm ((DirectSum.of (fun i => ↥(ℳ i)) i) x) = ↑x :=
  by sorry

The theorem `DirectSum.decompose_symm_of` expresses the property that for any type `ι`, with `M` being an additive commutative monoid and `σ` behaving like a set of `M` with additive submonoid structure, and for any function `ℳ : ι → σ` that decomposes the direct sum, and for any index `ι` with `x` being an element of `ℳ(i)`, the inverse of the function `DirectSum.decompose ℳ` applied to the direct sum of `x` over the index `i` gives back the original element `x`. In other words, it states that the decomposition of the direct sum followed by its inverse transformation leads back to the original element, thus showing that these transformations are inverses of each other for the given structures and conditions.

Given a commutative additive monoid `M` and a set `σ` with additive submonoid structure and a function `ℳ : ι → σ` decomposing the direct sum, the inverse of `DirectSum.decompose ℳ` applied to the direct sum of an element `x` in `ℳ(i)` yields back the original element `x`.


theorem HasCompactMulSupport.mulTSupport_extend_one_subset :
    ∀ {α : Type u_2} {α' : Type u_3} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace α']
      [inst_2 : One β] {f : α → β} [inst_3 : T2Space α'],
      HasCompactMulSupport f →
        ∀ {g : α → α'}, Continuous g → mulTSupport (Function.extend g f 1) ⊆ g '' mulTSupport f :=
  by sorry

This theorem states that for any types `α`, `α'`, and `β`, if `α` and `α'` are topological spaces, `β` has a one element, and `α'` is a T2 space (also known as a Hausdorff space), then for any function `f` from `α` to `β` that has compact multiplicative support, and any continuous function `g` from `α` to `α'`, the topological multiplicative support of the function that extends `g` and `f` by `1` is a subset of the image of the function `g` applied to the topological multiplicative support of the function `f`. Here, the topological multiplicative support of a function is the closure of the set of all elements where the function is not equal to `1`, and a function having compact multiplicative support means that the closure of its multiplicative support is compact.

If `f: α → β` is a continuous function from a compactly supported, compact topological space `α` to a Hausdorff space `β` with a one-point topology, and `g: α → α'` is a continuous function, then the topological support of `f ⊤ g` (the extension of `g` and `f` by 1) is contained in the image of `g` applied to the topological support of `f`.


theorem Mathlib.Data.Set.Countable._auxLemma.2 : ∀ {α : Type u}, Set.Countable ∅ = True := by sorry

This theorem states that for any type `α`, the empty set of type `α` is countable. In other words, there exists an injective mapping from the empty set to the set of natural numbers. This is true by definition, as there are no elements in the empty set that need to be mapped to the set of natural numbers.

The empty set is countable, that is, there exists an injective function from the empty set to the natural numbers.


theorem PowerBasis.lift_aeval :
    ∀ {S : Type u_2} [inst : Ring S] {A : Type u_4} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_7}
      [inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S) (y : S')
      (hy : (Polynomial.aeval y) (minpoly A pb.gen) = 0) (f : Polynomial A),
      (PowerBasis.lift pb y hy) ((Polynomial.aeval pb.gen) f) = (Polynomial.aeval y) f :=
  by sorry

The theorem `PowerBasis.lift_aeval` states that for any given type `S` with a ring structure, type `A` with a commutative ring structure and an algebra structure over `A` and `S`, and any other type `S'` with a ring structure and an algebra structure over `A` and `S'`, given a power basis `pb` of `A` over `S`, and any element `y` of `S'` such that the minimal polynomial of the generator of the power basis `pb` evaluated at `y` is zero, then for any polynomial `f` with coefficients in `A`, the lifting of the power basis `pb` to `S'` evaluated at the polynomial `f` evaluated at the generator of the power basis is equal to the evaluation of the polynomial `f` at `y`.

In other words, the lifting of the power basis `pb` to `S'` respects the evaluation of polynomials in the sense that evaluating a polynomial first and then lifting is the same as lifting first and then evaluating the polynomial.

Given a power basis `pb` of a commutative `A` over a ring `S`, and `y` in a ring `S'` with minimal polynomial of `pb`'s generator evaluating to zero at `y`, for all polynomials `f` in `A[X]`, the lifted evaluation of `pb` at `f(pb.gen)` equals the evaluation of `f` at `y`.


theorem Mathlib.Data.List.Dedup._auxLemma.1 : ∀ {α : Type u} {a : α} {l : List α}, (∀ a' ∈ l, ¬a = a') = (a ∉ l) := by
  sorry

This theorem, named `Mathlib.Data.List.Dedup._auxLemma.1`, states that for any type `α`, any element `a` of type `α`, and any list `l` of type `α`, the statement "for all elements `a'` in the list `l`, `a` is not equal to `a'`" is equivalent to the statement "`a` is not an element of the list `l`". In other words, `a` not being equal to any element in `l` is the same as `a` not being in `l`.

For any type `α` and element `a` of type `α`, `a` is not in list `l` of type `α` if and only if `a` is not equal to any element in `l`.


theorem Polynomial.coe_inj : ∀ {R : Type u_2} [inst : CommSemiring R] {φ ψ : Polynomial R}, ↑φ = ↑ψ ↔ φ = ψ := by sorry

This theorem states that for any commutative semiring R, and any two polynomials φ and ψ over R, the coercion of φ to an expression is equal to the coercion of ψ to an expression if and only if φ is equal to ψ. In other words, the process of coercion preserves the equality of polynomials in the semiring.

For any commutative semiring R, if two polynomials over R have the same coerced expressions, then they are equal.


theorem WithBot.preimage_coe_Ioi_bot : ∀ {α : Type u_1} [inst : Preorder α], WithBot.some ⁻¹' Set.Ioi ⊥ = Set.univ := by
  sorry

The theorem `WithBot.preimage_coe_Ioi_bot` states that for any type `α` with a preorder structure, the preimage of the set of elements strictly greater than the bottom element (⊥) under the canonical map from `α` to `WithBot α` is the universal set. In other words, for every element in `α`, there is an element in `WithBot α` that is strictly greater than ⊥ and maps to it. This is because `WithBot.some` function (canonical map) always lifts an element from `α` to an element in `WithBot α` that is greater than ⊥. Hence, all elements of `α` are included in this preimage, making it equal to the universal set.

For any preordered type `α`, the preimage of the set of elements strictly greater than its bottom element under the canonical map from `α` to `WithBot α` equals the universal set.


theorem Submodule.span_smul_span :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (S : Set R)
      (T : Set M), Ideal.span S • Submodule.span R T = Submodule.span R (⋃ s ∈ S, ⋃ t ∈ T, {s • t}) :=
  by sorry

This theorem states that for any given set `S` of elements of a commutative semiring `R` and any set `T` of elements of an additive commutative monoid `M` which is also a `R`-module, the submodule generated by the ideal span of `S` multiplied by the submodule span of `T` is equal to the submodule generated by the set of all scalar multiplications `s • t`, where `s` is an element of `S` and `t` is an element of `T`. In simpler terms, this means that the submodule generated by scaling all elements of `T` by all elements of `S` is exactly the same as multiplying the whole submodule span of `T` by the ideal span of `S`.

For any commutative semiring `R`, commutative monoid `M` making it an `R`-module, and sets `S` of `R` and `T` of `M`, the submodule generated by the scalar multiplications `s • t` for all `s ∈ S` and `t ∈ T` equals the submodule generated by the ideal span of `S` and the submodule span of `T`.


theorem Int.bodd_neg : ∀ (n : ℤ), Int.bodd (-n) = Int.bodd n := by sorry

The theorem `Int.bodd_neg` states that for all integers `n`, the function `Int.bodd` applied to the negation of `n` is equal to `Int.bodd` applied to `n` itself. In other words, the parity (oddness or evenness) of an integer remains the same when its sign is flipped.

For all integers n, Int.bodd (-\_) n = Int.bodd n.


theorem Real.IsConjExponent.inv_nonneg : ∀ {p q : ℝ}, Real.IsConjExponent p q → 0 ≤ p⁻¹ := by sorry

This theorem states that for any real numbers `p` and `q`, if `p` and `q` are conjugate exponents, then the inverse of `p` is nonnegative. In mathematical terms, this means that if `p` and `q` satisfy the condition $1/p + 1/q = 1$, then $0 \leq 1/p$.

If real numbers `p` and `q` are conjugate exponents, then the inverse of `p` is nonnegative (i.e., 1/p ≥ 0).


theorem Metric.mem_cocompact_of_closedBall_compl_subset :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} [inst_1 : ProperSpace α] (c : α),
      (∃ r, (Metric.closedBall c r)ᶜ ⊆ s) → s ∈ Filter.cocompact α :=
  by sorry

This theorem states that for any type `α` which is a pseudometric space and a proper space, and for any set `s` of type `α`, if there exists some real number `r` such that the complement of the set of all points within a distance `r` from a point `c` (represented as `Metric.closedBall c r`) is a subset of `s`, then `s` belongs to the collection of filters generated by complements of compact sets (represented as `Filter.cocompact α`). In other words, if `s` contains the outside of some closed ball in the pseudometric space, then `s` is in the filter of complements of compact sets.

If `α` is a pseudometric and proper space, and for some `c` in `α` and real `r`, the complement of the closed ball `Metric.closedBall c r` is a subset of a set `s` in `α`, then `s` belongs to the filter of complements of compact sets `Filter.cocompact α`.


theorem Real.arccos_zero : Real.arccos 0 = Real.pi / 2 := by sorry

The theorem `Real.arccos_zero` states that the arccosine of zero equals to half of the mathematical constant pi. In other words, it denotes that the inverse of the cosine function, when applied to zero, results in π/2. The arccosine function is defined in the set of real numbers, and π is defined as twice the zero of the cosine function in the interval [1,2].


theorem isAddUnit_of_add_eq_zero : ∀ {M : Type u_1} [inst : AddCommMonoid M] (a b : M), a + b = 0 → IsAddUnit a := by
  sorry

This theorem states that for any type `M` that is an additive commutative monoid, if the addition of two elements `a` and `b` of `M` equals zero, then `a` is an `AddUnit`. In other words, if the sum of two elements in an additive commutative monoid is zero, then the first element has a two-sided additive inverse, which means it is an additive unit.

In an additive commutative monoid `M`, if `a` and `b` are elements with `a + b = 0`, then `a` is an additive unit of `M`.


theorem Associates.le_of_count_ne_zero :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [dec_irr : (p : Associates α) → Decidable (Irreducible p)]
      [inst_1 : UniqueFactorizationMonoid α] [inst_2 : DecidableEq (Associates α)] {m p : Associates α},
      m ≠ 0 → Irreducible p → Associates.count p (Associates.factors m) ≠ 0 → p ≤ m :=
  by sorry

This theorem, `Associates.le_of_count_ne_zero`, states that for all monoids `α` with a zero element and for all elements `m` and `p` in the set of associates of `α` (`Associates α`), if `m` is not equal to zero, `p` is irreducible, and the count of `p` in the factor set of `m` is not zero, then `p` is less than or equal to `m`. The factor set of `m` is a multiset of irreducible associates.

In other words, in the context of an integral domain (a commutative ring with cancellation and without zero divisors) with unique factorization, an irreducible element `p` that factors into a nonzero element `m` (i.e., `p` is a part of the prime factorization of `m`) is always less than or equal to `m`.

In an integral domain with unique factorization, if an irreducible element `p` is a factor of a nonzero element `m`, then `p` is less than or equal to `m`.


theorem CategoryTheory.braiding_leftUnitor :
    ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      [inst_2 : CategoryTheory.BraidedCategory C] (X : C),
      CategoryTheory.CategoryStruct.comp (β_ X (𝟙_ C)).hom (CategoryTheory.MonoidalCategory.leftUnitor X).hom =
        (CategoryTheory.MonoidalCategory.rightUnitor X).hom :=
  by sorry

This theorem states that for any category `C` that has both a monoidal and braided structure, for any object `X` in `C`, the composition of the morphism associated with the braiding of `X` and the unit object of `C`, and the morphism associated with the left unitor of `X`, is equal to the morphism associated with the right unitor of `X`. In simpler terms, it says that a certain diagram commutes in a braided monoidal category: following one path (first braiding, then applying the left unitor) gets you to the same result as if you took the other path (applying the right unitor directly).

In a braided monoidal category, for any object X, the composition of the morphism associated with the braiding of X and the unit object's left unitor morphism is equal to the morphism associated with X's right unitor.


theorem AlgebraicGeometry.StructureSheaf.const.proof_4 :
    ∀ (R : Type u_1) [inst : CommRing R] (g : R) (U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)),
      (∀ x ∈ U, g ∈ Ideal.primeCompl x.asIdeal) → ∀ (x : ↥(Opposite.op U).unop), g ∈ Ideal.primeCompl (↑x).asIdeal :=
  by sorry

This theorem states that for any commutative ring `R` and any element `g` of `R`, if a topological space `U` is an open subset of the prime spectrum of `R` and `g` is in the complement of the prime ideal of every point of `U`, then for any point `x` in the opposite of `U`, `g` is in the complement of the prime ideal of `x`. In other words, if `g` is not in any of the prime ideals of the points of `U`, then `g` is not in the prime ideal of any point in `U` even when considering `U` in the opposite direction.

If `g` is not in any prime ideal of points in an open subset `U` of the prime spectrum of a commutative ring `R`, then `g` is not in the prime ideal of any point in the opposite of `U`.


theorem List.filter_congr' :
    ∀ {α : Type u_1} {p q : α → Bool} {l : List α},
      (∀ x ∈ l, p x = true ↔ q x = true) → List.filter p l = List.filter q l :=
  by sorry

The theorem `List.filter_congr'` states that for any list `l` of elements of an arbitrary type `α`, and any two predicates `p` and `q` from `α` to `Bool`, if for all elements `x` in `l`, `p` returns `true` if and only if `q` returns `true`, then the result of filtering `l` with `p` equals the result of filtering `l` with `q`. In other words, if two predicates agree on every element of a list, then filtering the list based on these predicates will produce the same results.

If for all elements x in a list l, the predicates p and q agree (i.e., p(x) <-> q(x) holds), then List.filter p l = List.filter q l.


theorem CategoryTheory.Limits.limit.post_π :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      (F : CategoryTheory.Functor J C) {D : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} D]
      [inst_3 : CategoryTheory.Limits.HasLimit F] (G : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Limits.HasLimit (CategoryTheory.Functor.comp F G)] (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.post F G)
          (CategoryTheory.Limits.limit.π (CategoryTheory.Functor.comp F G) j) =
        G.map (CategoryTheory.Limits.limit.π F j) :=
  by sorry

This theorem, `CategoryTheory.Limits.limit.post_π`, is stating a property regarding the composition of morphisms within the context of category theory and more specifically, limit objects. For any types `J`, `C`, and `D` that form categories and any functors `F` from `J` to `C` and `G` from `C` to `D`, given that `F` has a limit and the composition of `F` and `G` also has a limit, for any object `j` in `J`, the composition of the morphism from the limit object of `F` postcomposed with `G` to the limit object of the composition of `F` and `G`, and the projection from the limit object of the composition of `F` and `G` to the image of `j` under the composition of `F` and `G`, is equal to the morphism induced by `G` on the projection from the limit object of `F` to the image of `j` under `F`. In simpler terms, this theorem is about how limits are preserved under functorial action.

Given functors `F: J → C` and `G: C → D` with limit objects, if both `F` and the composition `G ∘ F` have limits, then for any object `j` in `J`, the morphism from the limit of `F` to the image of `j` under `G ∘ F` is equal to the composition of the morphism from the limit of `F` to the image of `j` under `F`, and the morphism from the limit of `G ∘ F` to its image under `G`.


theorem List.lookup_ext :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {l₀ l₁ : List (Sigma β)},
      List.NodupKeys l₀ →
        List.NodupKeys l₁ → (∀ (x : α) (y : β x), y ∈ List.dlookup x l₀ ↔ y ∈ List.dlookup x l₁) → List.Perm l₀ l₁ :=
  by sorry

This theorem, `List.lookup_ext`, states that for any two lists of sigma types, `l₀` and `l₁`, with keys from a type `α` and values from a type dependent on `α`, given that `α` has decidable equality, if both lists have no duplicate keys (`List.NodupKeys l₀` and `List.NodupKeys l₁`), and for all keys `x` from `α` and their corresponding values `y`, `y` is in the lookup of `x` in `l₀` if and only if `y` is in the lookup of `x` in `l₁`, then `l₀` and `l₁` are permutations of each other (`List.Perm l₀ l₁`). In simpler terms, if two key-value lists have unique keys and equivalent lookups for every key-value pair, then they must be rearrangements of each other.

If two lists of sigma types with decidable key equality and no duplicate keys have equivalent lookups for all keys, then they are permutations of each other.


theorem MeasureTheory.le_measure_liminf_of_limsup_measure_compl_le :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_2} {L : Filter ι} {μ : MeasureTheory.Measure Ω}
      {μs : ι → MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsProbabilityMeasure μ]
      [inst_2 : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)] {E : Set Ω},
      MeasurableSet E →
        Filter.limsup (fun i => ↑↑(μs i) Eᶜ) L ≤ ↑↑μ Eᶜ → ↑↑μ E ≤ Filter.liminf (fun i => ↑↑(μs i) E) L :=
  by sorry

The theorem `MeasureTheory.le_measure_liminf_of_limsup_measure_compl_le` states that for any type `Ω` with a measurable space structure, a type `ι`, a filter `L` on `ι`, a probability measure `μ` on `Ω`, a sequence of probability measures `μs` indexed by `ι`, and a measurable set `E` of `Ω`, if the limit superior (limsup) of the measures of the complement of `E` under the sequence of measures `μs` is less than or equal to the measure of the complement of `E` under the measure `μ`, then the measure of `E` under `μ` is less than or equal to the limit inferior (liminf) of the measures of `E` under the sequence of measures `μs`. This theorem provides a relationship between the measure of a set and the liminf and limsup measures of its complement under a sequence of probability measures.

If the limit superior of the complement measures of a measurable set under a sequence of probability measures is less than or equal to the complement measure under the base measure, then the measure of the set is less than or equal to the limit inferior of its measures under the sequence.


theorem dist_vsub_cancel_right :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] (x y z : P), dist (x -ᵥ z) (y -ᵥ z) = dist x y :=
  by sorry

This theorem, `dist_vsub_cancel_right`, states that for any three points `x, y, z` in a pseudometric space `P`, which is a normed add torsor over a seminormed add commutative group `V`, the distance between `(x - z)` and `(y - z)` is the same as the distance between `x` and `y`. Here, the `-ᵥ` operation represents the difference of the vectors pointing to `x` and `z`, and `y` and `z`, respectively. In other words, subtracting the same point `z` from two other points `x` and `y` does not change the distance between `x` and `y`.

In a pseudometric space over a seminormed add commutative group, the distance between `(x - z)` and `(y - z)` equals the distance between `x` and `y`, for any points `x`, `y`, and `z`.


theorem Stream'.Seq.get?_nil : ∀ {α : Type u} (n : ℕ), Stream'.Seq.get? Stream'.Seq.nil n = none := by sorry

The theorem `Stream'.Seq.get?_nil` states that for all types `α` and for any natural number `n`, when you try to get the `n`th element of an empty sequence, you get `None`. This essentially means that retrieving an element from an empty sequence always results in `None` regardless of the index `n`, signifying that the element does not exist.

For all types `α` and for every empty sequence `x : Stream α`, `get? (n: nat) x = None`.


theorem CategoryTheory.GlueData.glue_condition :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
      [inst_1 : CategoryTheory.Limits.HasMulticoequalizer (CategoryTheory.GlueData.diagram D)] (i j : D.J),
      CategoryTheory.CategoryStruct.comp (D.t i j)
          (CategoryTheory.CategoryStruct.comp (D.f j i) (CategoryTheory.GlueData.ι D j)) =
        CategoryTheory.CategoryStruct.comp (D.f i j) (CategoryTheory.GlueData.ι D i) :=
  by sorry

The theorem `CategoryTheory.GlueData.glue_condition` in category theory states that for any category `C` and a glue data `D` over that category, if the associated multispan index of the glue data has a multicoequalizer, then for any two objects `i` and `j` in the indexing set of the glue data, the composition of the morphism `D.t i j` with the composition of the morphism `D.f j i` and the map from `D.U j` to the glued object is equal to the composition of the morphism `D.f i j` and the map from `D.U i` to the glued object. In mathematical notation, this is saying that `(D.t i j) ≫ (D.f j i) ≫ (D.ι j) = (D.f i j) ≫ (D.ι i)`.

For any category `C` and glue data `D` over `C`, if the multispan index of `D` has a multicoequalizer, then for all objects `i` and `j` in the indexing set of `D`, we have `(D.t i j) ∘ (D.f j i) ∘ (D.ι j) = (D.f i j) ∘ (D.ι i)` in `C`.


theorem CategoryTheory.MonoidalClosed.pre_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A : C)
      [inst_2 : CategoryTheory.Closed A],
      CategoryTheory.MonoidalClosed.pre (CategoryTheory.CategoryStruct.id A) =
        CategoryTheory.CategoryStruct.id (CategoryTheory.ihom A) :=
  by sorry

This theorem, `CategoryTheory.MonoidalClosed.pre_id`, states that for any object `A` in a monoidal category `C` that is also a closed category, applying the `pre` functor to the identity morphism on `A` is the same as the identity morphism on the internal hom functor (`ihom`) applied to `A`. In other words, in the context of category theory, it asserts the identity law for the `pre` functor with respect to the identity morphism, which is important in studying how functors behave with identity morphisms.

In a monoidal and closed category, the `pre` functor applied to the identity morphism of an object is equal to the identity morphism of the internal hom functor applied to that object.


theorem NormedField.exists_one_lt_norm : ∀ (α : Type u_1) [inst : NontriviallyNormedField α], ∃ x, 1 < ‖x‖ := by sorry

This theorem states that for every non-trivial normed field `α`, there exists an element `x` in `α` whose norm is greater than 1. In other words, in any non-trivial normed field, we can always find an element whose length or magnitude (as determined by the field's norm function) is more than one.

In every non-trivial normed field, there exists an element with norm greater than 1.


theorem BoxIntegral.Box.le_TFAE :
    ∀ {ι : Type u_1} (I J : BoxIntegral.Box ι),
      List.TFAE
        [I ≤ J, ↑I ⊆ ↑J, Set.Icc I.lower I.upper ⊆ Set.Icc J.lower J.upper, J.lower ≤ I.lower ∧ I.upper ≤ J.upper] :=
  by sorry

This theorem states that for any two boxes `I` and `J` of any type `ι`, the following propositions are equivalent: (1) `I` is less than or equal to `J`, (2) the set denoted by `I` is a subset of the set denoted by `J`, (3) the closed interval from the lower value of `I` to the upper value of `I` is a subset of the closed interval from the lower value of `J` to the upper value of `J`, and (4) the lower value of `J` is less than or equal to the lower value of `I` and the upper value of `I` is less than or equal to the upper value of `J`. In other words, all these conditions are equivalent ways of expressing that `I` is less than or equal to `J`.

For any boxes I and J of type ι, I ≤ J if and only if (i) I is a subset of J, (ii) the interval [lower I, upper I] is a subset of the interval [lower J, upper J], and (iii) lower I ≤ lower J and upper I ≤ upper J.


theorem Real.arcsin_le_iff_le_sin' :
    ∀ {x y : ℝ}, y ∈ Set.Ico (-(Real.pi / 2)) (Real.pi / 2) → (Real.arcsin x ≤ y ↔ x ≤ Real.sin y) := by sorry

This theorem states that for all real numbers `x` and `y`, if `y` is in the left-closed right-open interval from negative half pi to half pi (i.e., `-π / 2 ≤ y < π / 2`), then the arcsine of `x` is less than or equal to `y` if and only if `x` is less than or equal to the sine of `y`. In other words, it is establishing a relation between the arcsine and sine functions within the specified interval for `y` in terms of inequality.

For all real numbers x and y with -π/2 ≤ y < π/2, arcsin(x) ≤ y if and only if x ≤ sin(y).


/-- The composition `l ∘ f` where `l : F → E` and `f : 𝕜 → F`, has a derivative equal to the
Fréchet derivative of `l` applied to the derivative of `f`.  -/
theorem HasFDerivAt.comp_hasDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f : 𝕜 → F}
      {f' : F} (x : 𝕜) {l : F → E} {l' : F →L[𝕜] E},
      HasFDerivAt l l' (f x) → HasDerivAt f f' x → HasDerivAt (l ∘ f) (l' f') x :=
  by sorry

The theorem `HasFDerivAt.comp_hasDerivAt` states that for any two functions `l : F → E` and `f : 𝕜 → F` over a nontrivially normed field `𝕜`, if `l` has a Fréchet derivative `l'` at the point `f(x)`, and `f` has a derivative `f'` at `x`, then the composition function `l ∘ f` has a derivative at `x` equal to the application of the Fréchet derivative `l'` to the derivative `f'`. This encapsulates the chain rule in calculus.

If functions `l : F → E` over a nontrivially normed field `𝕜`, `l` has Fréchet derivative `l'` at `f(x)`, and `f : 𝕜 → F` has derivative `f'` at `x`, then `l ∘ f` has a derivative at `x` equal to `l' (f' (x))`.


theorem mul_le_of_le_one_left' :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α},
      b ≤ 1 → b * a ≤ a :=
  by sorry

The theorem `mul_le_of_le_one_left'` states that for all types `α` that have a multiplication operation, a multiplicative identity (one), and a less than or equal to relation, and for which the multiplication operation is covariant with respect to the less than or equal to relation, if a given value `b` is less than or equal to 1, then the product of `b` and any other value `a` is less than or equal to `a`. In other words, if you multiply any number by a number that is less than or equal to one, the result will be less than or equal to the original number. This is written in mathematical notation as: for all `a` and `b` in `α`, if `b ≤ 1` then `b * a ≤ a`.

For all types `α` with multiplication, identity one, and a covariant multiplication with respect to the <= relation, if `b <= 1` then `b * a <= a` for all `a` in `α`.


theorem Mathlib.Logic.IsEmpty._auxLemma.19 : ∀ {α : Sort u_1} (p : α → Prop), IsEmpty (Subtype p) = ∀ (x : α), ¬p x :=
  by sorry

This theorem, `Mathlib.Logic.IsEmpty._auxLemma.19`, states that for any type `α` and any predicate `p` on `α`, the subtype of `α` for which `p` holds is empty if and only if for every element `x` of `α`, `p x` is not true. Basically, it links the emptiness of a subtype defined by a certain property to the absence of that property in the entire type.

For any type `α` and predicate `p` on `α`, the subtype of `α` where `p` holds is empty if and only if `p` does not hold for any element in `α`.


theorem Mathlib.Logic.IsEmpty._auxLemma.14 : ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x := by sorry

This theorem states that for any type `α` and any property `p` of the elements of `α`, the statement "there does not exist an element `x` in `α` such that `p(x)` holds" is equivalent to the statement "for all elements `x` in `α`, `p(x)` does not hold". In mathematical notation, this can be expressed as "¬∃x, p(x) = ∀x, ¬p(x)".

The negation of the existence of an element in a type with a given property is equivalent to the universally quantified negation of that property holding for all elements. (i.e., ¬∃x. P(x) ≤f=≄> ∀x. ¬P(x))


theorem List.iota_eq_reverse_range' : ∀ (n : ℕ), List.iota n = List.reverse (List.range' 1 n) := by sorry

This theorem states that for any natural number `n`, the list `iota n` - which is a list of numbers from `1` to `n` in decreasing order - is equal to the reverse of the list `range' 1 n` - which is a list of numbers from `1` to `n` in increasing order. In other words, if you generate a list of numbers from `1` to `n` in ascending order and then reverse it, you will get the same list as if you generated a list of numbers from `1` to `n` in descending order.

For any natural number `n`, the list of decreasing integers from `1` to `n` (`iota n`) is equal to the reverse of the list of increasing integers from `1` to `n` (`range' 1 n`).


theorem AlgEquiv.comp_symm :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂),
      AlgHom.comp ↑e ↑(AlgEquiv.symm e) = AlgHom.id R A₂ :=
  by sorry

The theorem `AlgEquiv.comp_symm` states that for all commutative semirings `R` and semirings `A₁` and `A₂` that are also `R`-algebras, if there is an algebraic equivalence `e` between `A₁` and `A₂`, then the composition of `e` and its inverse (or symmetric) is equal to the identity function on `A₂`. In other words, applying an algebraic equivalence and its inverse in succession results in the original element in the algebra `A₂`, just as we would expect with any function and its inverse.

Given a commutative semiring `R`, `R-algebras` `A₁` and `A₂`, and an algebraic equivalence `e` between them, `e` and `e⁻¹` are mutually inverse. Hence, `e ∘ e⁻¹ = id A₂`.


theorem Mathlib.Logic.IsEmpty._auxLemma.34 : ∀ (α : Sort u_1) [h : Nonempty α], IsEmpty α = False := by sorry

This theorem states that for any type `α` that is not empty (i.e., there exists at least one instance of `α`), the proposition that `α` is empty is false. In other words, if we have at least one instance of a type, we can't say that the type is empty. This might seem intuitive, but it's an important foundational concept in formal logic and type theory.

For any non-empty type `α`, the proposition `α = ∅` is false.


theorem circleIntegral.integral_radius_zero :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (f : ℂ → E) (c : ℂ),
      (∮ (z : ℂ) in C(c, 0), f z) = 0 :=
  by sorry

This theorem states that for any complex-valued function `f` and any complex number `c`, the contour (or line) integral of `f` around the circle centered at `c` with radius 0 is always 0. More formally, `∮ (z : ℂ) in C(c, 0), f z = 0`, where `C(c, 0)` is the circle centered at `c` with radius 0, `ℂ` denotes the set of complex numbers, and `E` is any normed add-commutative group that is also a normed space over the complex numbers.

The contour integral of any complex-valued function `f` over the circle centered at `c` with radius 0 is equal to 0.


theorem PartialHomeomorph.contDiffOn_extend_coord_change :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] {f f' : PartialHomeomorph M H} (I : ModelWithCorners 𝕜 E H)
      [inst_5 : ChartedSpace H M],
      f ∈ SmoothManifoldWithCorners.maximalAtlas I M →
        f' ∈ SmoothManifoldWithCorners.maximalAtlas I M →
          ContDiffOn 𝕜 ⊤ (↑(PartialHomeomorph.extend f I) ∘ ↑(PartialEquiv.symm (PartialHomeomorph.extend f' I)))
            (PartialEquiv.trans (PartialEquiv.symm (PartialHomeomorph.extend f' I))
                (PartialHomeomorph.extend f I)).source :=
  by sorry

This theorem, `PartialHomeomorph.contDiffOn_extend_coord_change`, states that for any types 𝕜, E, M, H, where 𝕜 is a nontrivially normed field, E is a normed add-commutative group, E is also a normed space over 𝕜, H and M are topological spaces, and any pair of partial homeomorphisms `f` and `f'` from M to H that are in the maximal atlas of the smooth manifold with corners defined by the model with corners `I`, the composition of the extensions of these homeomorphisms is a continuously differentiable function (of any order) on the source of the transitive closure of the inverses of these extensions. In other words, the composition of the extensions of the partial homeomorphisms behaves smoothly when restricted to the appropriate domain.

Given nontrivially normed field 𝕜, normed add-commutative groups E with the structure of a normed space over 𝕜, topological spaces H and M, and partial homeomorphisms `f` and `f'` from M to H in the maximal atlas of the smooth manifold with corners defined by `I`, the extension of their composition is continuously differentiable on the source of the transitive closure of the inverses of these extensions.


theorem le_floorDiv_iff_smul_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : FloorDiv α β] {a : α} {b c : β}, 0 < a → (c ≤ b ⌊/⌋ a ↔ a • c ≤ b) :=
  by sorry

This theorem asserts that for any types `α` and `β` with ordered additive commutative monoid structures, an action of `α` on `β` that respects zero, and a floor division operation from `α` to `β`, given non-zero elements `a` of `α` and `b` and `c` of `β`, the condition that `c` is less than or equal to the floor division of `b` by `a` is equivalent to the condition that the scalar multiplication of `a` and `c` is less than or equal to `b`.

For types `α` and `β` with ordered additive commutative monoid structures, an action of `α` on `β` preserving zero, and a floor division operation from `α` to `β`, the floor division `b / a ≤ c` is equivalent to `a * c ≤ b`.


theorem Cardinal.aleph'_isNormal : Ordinal.IsNormal (Cardinal.ord ∘ Cardinal.aleph') := by sorry

This theorem states that the composition of the `Cardinal.ord` and `Cardinal.aleph'` functions forms a normal ordinal function. A normal ordinal function is a strictly increasing function that is also order-continuous. In this context, order-continuity means that the image of a limit ordinal under this function is the supremum of the images of all smaller ordinals. Essentially, the theorem tells us that as we move up in the ordinal index with `Cardinal.aleph'` and then map to the least ordinal of the same cardinality with `Cardinal.ord`, the resulting function preserves the order and continuity properties of normal ordinal functions.

The composition of `Cardinal.aleph'` and `Cardinal.ord` is a normal ordinal function in Lean 4.


theorem Int.negSucc_coe : ∀ (n : ℕ), Int.negSucc n = -↑(n + 1) := by sorry

This theorem states that for every natural number `n`, the negative successor function on integers (`Int.negSucc`) applied to `n` is equal to the negation of the coersion (`↑`) of `n + 1` from a natural number to an integer. In simpler terms, it states that the negative successor of a natural number in the integer domain is the same as subtracting 1 from that number and making the result negative.

For every natural number `n`, `Int.negSucc (n : Int) = -(nat.succ n)`.


theorem CategoryTheory.ShortComplex.Exact.epi_f' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.Exact S →
        ∀ (h : CategoryTheory.ShortComplex.LeftHomologyData S),
          CategoryTheory.Epi (CategoryTheory.ShortComplex.LeftHomologyData.f' h) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.Exact.epi_f'` states that for any category `C` that is preadditive and any short complex `S` that is exact, for any left homology data `h` of the short complex `S`, the morphism `f'` from the left homology data `h` is an epimorphism. In category theory, an epimorphism is a morphism f: X -> Y such that for all objects Z, and all morphisms g1, g2: Y -> Z, if g1 ∘ f = g2 ∘ f then g1 = g2. In the context of this theorem, it means that `f'` is "surjective" in a categorical sense.

In a preadditive category `C` with exact short complexes, the morphism `f'` from the left homology data of an exact short complex is an epimorphism.


theorem Real.differentiable_arsinh : Differentiable ℝ Real.arsinh := by sorry

The theorem `Real.differentiable_arsinh` states that the function `arsinh`, which is defined for real numbers as `arsinh x = log (x + sqrt(1 + x^2))`, is differentiable at any point in its domain. In other words, for any real number `x`, the function `arsinh` has a derivative at `x`.

The function `arsinh` is differentiable for all real numbers `x` in its domain.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.37 : ∀ {p : NNReal}, (↑p < 1) = (p < 1) := by sorry

This theorem states that for every nonnegative real number `p` (denoted as `NNReal`), the condition of `p` being less than 1 when promoted (`↑p`) to a nonnegative extended real number is equivalent to `p` being less than 1 as a nonnegative real number. Essentially, this shows that the inequality relationship `< 1` stays consistent when `NNReal` values are converted to extended nonnegative real numbers.

For every nonnegative real number `p`, `p < 1` if and only if `↑p < 1` in the extended nonnegative real numbers.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.25 : ∀ {r : NNReal}, (0 < ↑r) = (0 < r) := by sorry

The theorem `Mathlib.Data.ENNReal.Basic._auxLemma.25` states that for all nonnegative real numbers `r` (represented by `NNReal`), the proposition that the real part of `r` (obtained by coercion `↑r`) is greater than 0 is equivalent to the proposition that `r` itself is greater than 0. In other words, it asserts the consistency between the inequality comparisons in the context of nonnegative real numbers and their real parts.

For any nonnegative real number `r`, the real part `↑r` is greater than 0 if and only if `r` itself is greater than 0.


/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is minimized when
`f` and `g` antivary together. Stated by permuting the entries of `g`.  -/
theorem AntivaryOn.sum_smul_le_sum_smul_comp_perm :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedRing α] [inst_1 : LinearOrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : OrderedSMul α β] {s : Finset ι} {σ : Equiv.Perm ι} {f : ι → α} {g : ι → β},
      AntivaryOn f g ↑s →
        {x | σ x ≠ x} ⊆ ↑s → (Finset.sum s fun i => f i • g i) ≤ Finset.sum s fun i => f i • g (σ i) :=
  by sorry

The **Rearrangement Inequality** theorem states that for any set `s` and any two functions `f` and `g` from `ι` to the ordered ring `α` and the ordered additive commutative group `β` respectively, if `f` antivaries with `g` on `s` and if the permutation `σ` of `ι` only permutes elements within `s`, then the sum of the products of `f(i)` and `g(i)` over all `i` in `s` is less than or equal to the sum of the products of `f(i)` and `g(σ(i))` over all `i` in `s`. Here, `f(i) • g(i)` denotes scalar multiplication of `f(i)` and `g(i)`. This theorem states that pointwise scalar multiplication of `f` and `g` is minimized when `f` and `g` are antivarying together.

For any set `s`, functions `f: ι -> α` and `g: ι -> β` from an ordered ring to an ordered additive commutative group respectively, and a permutation `σ` of `ι` that only permutes elements within `s`, if `f` antivaries with `g` on `s`, then the sum of the products of `f(i)` and `g(i)` over all `i` in `s` is less than or equal to the sum of the products of `f(i)` and `g(σ(i))` over all `i` in `s`.


theorem tendsto_nhdsWithin_mono_right :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f : β → α} {l : Filter β} {a : α} {s t : Set α},
      s ⊆ t → Filter.Tendsto f l (nhdsWithin a s) → Filter.Tendsto f l (nhdsWithin a t) :=
  by sorry

This theorem, `tendsto_nhdsWithin_mono_right`, states that for any types `α` and `β`, where `α` has a topological space structure, and any function `f` mapping type `β` to `α`, any filter `l` on `β`, any point `a` in `α`, and any sets `s` and `t` of type `α`, if set `s` is a subset of set `t`, then if the function `f` tends to the filter `nhdsWithin a s` (the neighborhood within `s` around `a`) along the filter `l`, it also tends to the filter `nhdsWithin a t` (the neighborhood within `t` around `a`) along the same filter `l`.

In other words, if the function `f` goes to the limit `a` within the smaller set `s` when `l` gets "large", it also goes towards the limit `a` within the larger set `t`.

If `f` is a function from `β` to `α` with `α` a topological space, `s ⊆ t` sets in `α`, and `f` tends to `a` in `α` with respect to filter `l` on `β` within `s`, then `f` also tends to `a` within `t` with respect to `l`.


theorem MeasureTheory.stoppedValue_lowerCrossingTime :
    ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω},
      MeasureTheory.lowerCrossingTime a b f N n ω ≠ N →
        MeasureTheory.stoppedValue f (MeasureTheory.lowerCrossingTime a b f N n) ω ≤ a :=
  by sorry

The theorem `MeasureTheory.stoppedValue_lowerCrossingTime` states that for any types `Ω`, real numbers `a` and `b`, a function `f` from natural numbers to a function from `Ω` to real numbers, and natural numbers `N` and `n`, and an element `ω` of `Ω`, if the `n`-th lower crossing time of `f` with respect to `a` and `b` before time `N` is not equal to `N`, then the stopped value of `f` at the `n`-th lower crossing time for `ω` is less than or equal to `a`. In simpler terms, it is saying that if a function crosses a certain high value and then dips below a certain low value before a specified time, the value of the function at the time it first dips below the low value (provided this time is not the end time) will indeed be less than or equal to the low value.

If the function `f` from natural numbers to real functions on type `Ω` does not have its `n`-th lower crossing time equal to `N` before time `N`, then for all `ω` in `Ω`, the stopped value of `f` at the `n`-th lower crossing time for `ω` is less than or equal to `a`.


theorem Polynomial.toLaurent_X_pow :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), Polynomial.toLaurent (Polynomial.X ^ n) = LaurentPolynomial.T ↑n := by
  sorry

This theorem establishes that for any semiring `R` and any natural number `n`, the ring homomorphism that takes a polynomial with coefficients in `R` to a Laurent polynomial, when applied to the `n`th power of the polynomial variable `X`, results in the `n`th element of the sequence `T` defined on the Laurent polynomial. In other words, the image of `X^n` under the polynomial to Laurent polynomial ring homomorphism is precisely `T^n`, where the power is interpreted in the integer sense. This relationship is fundamental in the manipulation and understanding of Laurent polynomials in terms of regular polynomials.

For any semiring `R` and natural number `n`, the ring homomorphism from polynomials to Laurent polynomials maps `X^n` to `T^n`, where `T` is a fixed Laurent polynomial and the powers are taken in the integer sense.


theorem List.append_ne_nil_of_ne_nil_right : ∀ {α : Type u_1} (s t : List α), t ≠ [] → s ++ t ≠ [] := by sorry

This theorem states that for any two lists `s` and `t` of a certain type `α`, if the list `t` is not empty, then the result of appending `t` to `s` (i.e., `s ++ t`) will also not be empty. This holds for all types `α` and lists `s` and `t` of type `α`.

For all types `α` and non-empty lists `s` and `t` of type `α`, the concatenation `s ++ t` is a non-empty list.


theorem PrimeSpectrum.isOpen_basicOpen :
    ∀ {R : Type u} [inst : CommSemiring R] {a : R}, IsOpen ↑(PrimeSpectrum.basicOpen a) := by sorry

This theorem states that for any given type `R` that is a commutative semiring, and any element `a` from `R`, the set generated by the function `PrimeSpectrum.basicOpen a` is an open set in the topological space of the prime spectrum of `R`. In other words, the basic open set containing all prime ideals of `R` that do not contain the element `a` is an open set in the topology of the prime spectrum of `R`.

For any commutative semiring `R` and element `a` in `R`, the set of prime ideals not containing `a` forms an open set in the prime spectrum of `R`.


theorem MeasureTheory.Measure.measure_pos_of_nonempty_interior :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X)
      [inst_1 : MeasureTheory.Measure.IsOpenPosMeasure μ] {s : Set X}, Set.Nonempty (interior s) → 0 < ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.Measure.measure_pos_of_nonempty_interior` states that for any type `X` with a topological space structure, a measurable space structure, and a measure `μ` that assigns positive values to open sets, if the interior of a set `s` is nonempty, then the measure of the set `s` is positive. In other words, if there exists at least one element in the interior of a set, the measure of the set according to the measure theory is strictly greater than zero.

If `X` is a topological space with a measurable structure and `μ` is a measure assigning positive values to open sets, then the measure of a nonempty set `s` with nonempty interior is positive.


theorem MulOpposite.semiconjBy_op :
    ∀ {α : Type u} [inst : Mul α] {a x y : α},
      SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x) ↔ SemiconjBy a x y :=
  by sorry

The theorem `MulOpposite.semiconjBy_op` states that for any type `α` equipped with a multiplication operation, and for any elements `a`, `x`, `y` of this type, `a` is semiconjugate to `x` by `y` if and only if the MulOpposite of `a` is semiconjugate to the MulOpposite of `y` by the MulOpposite of `x`. Semiconjugacy is defined here as `a` times `x` being equal to `y` times `a`. In other words, the theorem establishes an equivalence between the semiconjugacy relations of elements and their MulOpposite counterparts.

For any type equipped with multiplication and elements `a`, `x`, `y`, `a` is semiconjugate to `x` by `y` if and only if the MulOpposite of `a` is semiconjugate to the MulOpposite of `y` by the MulOpposite of `x` (i.e., `a * x = y * a` if and only if `-a * -x = -y * -a`).


theorem Ordinal.type_eq :
    ∀ {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
      Ordinal.type r = Ordinal.type s ↔ Nonempty (r ≃r s) :=
  by sorry

The theorem `Ordinal.type_eq` states that for any two types `α` and `β` with properties `r` and `s` respectively, that are well-ordered (meaning that every non-empty subset has a least element), the ordinal type of `r` is equal to the ordinal type of `s` if and only if there exists a nonempty order isomorphism between `r` and `s`. An order isomorphism `r ≃r s` is a bijective function that preserves order relations, meaning that for all elements `a` and `b`, `a` is related to `b` under `r` if and only if the image of `a` under the isomorphism is related to the image of `b` under `s`.

For well-ordered types `α` and `β` with order isomorphisms `r ≃s`, the ordinal types of `α` under relation `r` and `β` under relation `s` are equal.


/-- The `vectorSpan` is the span of the pairwise subtractions with a given point on the right.  -/
theorem vectorSpan_eq_span_vsub_set_right :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : Set P} {p : P},
      p ∈ s → vectorSpan k s = Submodule.span k ((fun x => x -ᵥ p) '' s) :=
  by sorry

This theorem states that for a given set `s` of points in a module over a ring, and a specific point `p` in that set, the `vectorSpan` of the set `s` is equal to the submodule spanned by the set of vectors obtained by subtracting `p` from each point in `s`. In mathematical terms, it says that if `s` is a subset of `P` and `p` is an element of `s`, then the vector span of `s` is the same as the span of the set `{x - p | x ∈ s}` in the module `V` over `k`, where `V` is an additive commutative group and `P` is an additive torsor over `V`.

Given a set `s` of points in an additive commutative group `V` over a ring `k`, with `p` as an element of `s`, the vector span of `s` equals the submodule spanned by the set `{x - p | x ∈ s}`.


theorem IsFractionRing.to_map_eq_zero_iff :
    ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_5} [inst_1 : CommRing K] [inst_2 : Algebra R K]
      [inst_3 : IsFractionRing R K] {x : R}, (algebraMap R K) x = 0 ↔ x = 0 :=
  by sorry

This theorem, `IsFractionRing.to_map_eq_zero_iff`, states that for any commutative ring `R`, any commutative ring `K` which is the field of fractions of `R` (as specified by the `IsFractionRing R K` condition), and any `x` in `R`, the result of applying the algebra map (that is, the function that embeds `R` into `K` as specified by the algebra structure) to `x` is zero if and only if `x` is zero. In other words, the algebra map sends zero in `R` to zero in `K` and is injective at other values; it doesn't map any non-zero element of `R` to zero in `K`.

For any commutative rings `R` and `K` with `IsFractionRing R K`, the algebra map from `R` to `K` sends `x` in `R` to zero in `K` if and only if `x` is zero in `R`.


theorem CategoryTheory.MorphismProperty.RespectsIso.isoClosure_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.RespectsIso P → CategoryTheory.MorphismProperty.isoClosure P = P :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.RespectsIso.isoClosure_eq` states that for any `MorphismProperty` P in a category C, if P respects isomorphisms (meaning that if a morphism has property P, then composing that morphism with any isomorphism will still result in a morphism with property P), then the "closure by isomorphisms" of P is P itself. The "closure by isomorphisms" of a property P is the property where a morphism f has the property if there exist some other morphisms and an isomorphism between f and another morphism that has property P.

If a morphism property P in a category respects isomorphisms, then the closure of P by isomorphisms equals P.


theorem Finset.infs_compls_eq_diffs :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : BooleanAlgebra α] (s t : Finset α),
      s ⊼ Finset.compls t = Finset.diffs s t :=
  by sorry

The theorem `Finset.infs_compls_eq_diffs` states that for any two finite sets `s` and `t` of a type `α`, where `α` is a Boolean algebra and has decidable equality, the supremum of `s` and the complement of each element in `t` (`s ⊼ Finset.compls t`) is equal to the set of all elements of the form `a \ b` where `a` is in `s` and `b` is in `t` (`Finset.diffs s t`). This theorem is essentially stating a property about operations on finite sets in a Boolean algebra.

For finite sets \(s, t \subseteq \alpha\) in a Boolean algebra with decidable equality, \(sup(s) \cap \bigcap_{x \in t} complement(x) = Finset.diffs(s, t)\).


Homeomorph.isProperMap

/-- A homeomorphism is proper.  -/
theorem Homeomorph.isProperMap :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
      IsProperMap ⇑e :=
  by sorry

This theorem states that for any two types `X` and `Y`, which have topological space structures, if there exists a homeomorphism (a bijective, continuous mapping whose inverse is also continuous) between `X` and `Y`, then the function represented by this homeomorphism is a proper map. A proper map, in this context, means a function that is precompact, i.e., the preimage of a compact set is also compact.

If `X` and `Y` are topological spaces with a homeomorphism between them, then the homeomorphism is a proper map.


theorem tendstoUniformly_iff_tendstoUniformlyOnFilter :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {p : Filter ι},
      TendstoUniformly F f p ↔ TendstoUniformlyOnFilter F f p ⊤ :=
  by sorry

The theorem `tendstoUniformly_iff_tendstoUniformlyOnFilter` states that, for any sequence of functions `F`, denoted as `F : ι → α → β`, a limiting function `f`, denoted as `f : α → β`, and a filter `p` over `ι`, the sequence `F` converges uniformly to `f` with respect to filter `p` if and only if `F` converges uniformly on the top filter to `f` with respect to the filter `p`. In mathematical terms, this means that for any given entourage of the diagonal `u` in the uniform space `β`, if `p`-eventually `(f x, Fₙ x) ∈ u` for all `x`, then it's also true that `p ×ˢ ⊤`-eventually `(f x, Fₙ x) ∈ u`.

For a sequence of functions `F : ι → α → β`, limiting function `f : α → β`, and filter `p` over `ι`, `F` converges uniformly to `f` with respect to `p` if and only if `F` converges uniformly on the top filter to `f` with respect to `p`.


theorem inv_ball :
    ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x : E), (Metric.ball x δ)⁻¹ = Metric.ball x⁻¹ δ := by sorry

The theorem `inv_ball` states that for every seminormed commutative group `E` of type `u_1`, and for every real number `δ` and element `x` of `E`, the inverse of the metric ball centered at `x` with radius `δ` is equal to the metric ball centered at the inverse of `x` with radius `δ`. In other words, inverting the elements of a metric ball does not change the metric ball itself.

For every seminormed commutative group `E` and real number `δ`, the inverse of the metric ball `{x : E | dist x x_0 < δ}` centered at `x_0` is equal to the metric ball `{x : E | dist x x_0^(-1) < δ}` centered at the inverse of `x_0` in `E`.


IsMaxFilter.inf

theorem IsMaxFilter.inf :
    ∀ {α : Type u} {β : Type v} [inst : SemilatticeInf β] {f g : α → β} {a : α} {l : Filter α},
      IsMaxFilter f l a → IsMaxFilter g l a → IsMaxFilter (fun x => f x ⊓ g x) l a :=
  by sorry

The theorem `IsMaxFilter.inf` states that for any type `α`, `β` where `β` forms a semilattice under the infimum operation, and for any two functions `f` and `g` from `α` to `β`, any point `a` in `α`, and any filter `l` on `α`, if `a` is a maximum point for both `f` and `g` with respect to `l`, then `a` is also a maximum point for the function defined by the infimum of `f` and `g` at each point, with respect to the same filter `l`. In other words, if `f(x) ≤ f(a)` and `g(x) ≤ g(a)` for all `x` in some `l`-neighborhood of `a`, then `(f(x) ⊓ g(x)) ≤ (f(a) ⊓ g(a))` for all such `x`.

Given types `α` and `β` with `β` being a semilattice under infimum, functions `f` and `g` from `α` to `β`, a filter `l` on `α`, and a point `a` in `α` maximizing both `f` and `g` with respect to `l`, then `a` maximizes the infimum of `f` and `g` with respect to the same filter `l`. In other words, if `f(x) ≤ f(a)` and `g(x) ≤ g(a)` for all `x` in some `l`-neighborhood of `a`, then `(f ⊓ g)(x) ≤ (f ⊓ g)(a)` for all such `x`.


theorem cauchy_iff :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {f : Filter α},
      Cauchy f ↔ Filter.NeBot f ∧ ∀ s ∈ uniformity α, ∃ t ∈ f, t ×ˢ t ⊆ s :=
  by sorry

The theorem named `cauchy_iff` states that for any type `α` that has a uniform space structure, and for any filter `f` on `α`, the filter `f` is Cauchy (in the sense defined above) if and only if two conditions are met. The first condition is that `f` is not the bottom filter, denoted by `Filter.NeBot f`. The second condition is that for every set `s` in the uniformity of `α`, there exists a set `t` in `f` such that the product of `t` with itself is a subset of `s`. This theorem essentially provides a characterisation of Cauchy filters in terms of non-bottom filters and the uniformity of the underlying space.

For any uniform space `(α, Υ)`, a filter `f` on `α` is Cauchy if and only if it is not the bottom filter and for every `s ∈ Υ`, there exists `t ∈ f` such that `t × t ⊆ s`.


theorem SimpleGraph.Walk.darts_reverse :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : SimpleGraph.Walk G u v),
      SimpleGraph.Walk.darts (SimpleGraph.Walk.reverse p) =
        List.reverse (List.map SimpleGraph.Dart.symm (SimpleGraph.Walk.darts p)) :=
  by sorry

This theorem states that for any simple graph `G` and any two vertices `u` and `v` in the graph, if there is a walk `p` from `u` to `v`, then the list of "darts" (i.e., edges) visited in the reverse walk from `v` to `u` is equivalent to the list of the darts visited in the original walk `p` but with their orientation reversed and listed in reverse order. Specifically, each dart in the reverse walk corresponds to the "symm" (i.e., the opposite orientation) of a dart in the original walk, and the sequence of darts in the reverse walk follows the reverse of the sequence in the original walk.

For any simple graph and vertices u, v connected by a walk, the list of reversed and oppositely oriented darts along the reverse walk from v to u is equivalent to the list of darts along the original walk from u to v.


theorem OrderHom.map_le_lfp :
    ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, a ≤ OrderHom.lfp f → f a ≤ OrderHom.lfp f := by
  sorry

The theorem `OrderHom.map_le_lfp` states that for any type `α` that forms a complete lattice, and for any monotone function `f : α → α`, if a certain element `a` of the type `α` is less than or equal to the least fixed point of the function `f` (denoted by `OrderHom.lfp f`), then the image of `a` under `f` (i.e., `f a`) is also less than or equal to the least fixed point of `f`. In other words, this theorem ensures the monotonicity property of the least fixed point operator with respect to the given monotone function `f`.

For any complete lattice `α` and monotone function `f : α → α`, if `a ≤ OrderHom.lfp f`, then `f a ≤ OrderHom.lfp f`.


theorem Tropical.trop_eq_iff_eq_untrop :
    ∀ {R : Type u} {x : R} {y : Tropical R}, Tropical.trop x = y ↔ x = Tropical.untrop y := by sorry

The theorem `Tropical.trop_eq_iff_eq_untrop` states that for any type `R` and any elements `x` of `R` and `y` of `Tropical R`, `x` being interpreted as an element of `Tropical R` is equal to `y` if and only if `x` is equal to `y` being interpreted back as an element of `R`. In other words, it establishes an equivalence between the equality of `x` and `y` in their respective spaces and the equality of their tropicalizations.

The theorem `Tropical.trop_eq_iff_eq_untrop` in Lean 4 states that the tropicalization of two elements in `Tropical R` is equal if and only if the original elements in `R` are equal.


theorem Equiv.transPartialEquiv_eq_trans :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ),
      Equiv.transPartialEquiv e f' = PartialEquiv.trans (Equiv.toPartialEquiv e) f' :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and any given equivalence `e` from `α` to `β` and a partial equivalence `f'` from `β` to `γ`, the operation of precomposing the partial equivalence `f'` with the equivalence `e` (using the `Equiv.transPartialEquiv` function) is the same as first converting the equivalence `e` to a partial equivalence (using the `Equiv.toPartialEquiv` function) and then composing this with `f'` (using the `PartialEquiv.trans` function). In other words, it's about the compatibility of the operations of precomposition and conversion to a partial equivalence with the operation of composition of partial equivalences.

For any equivalences `e : α ≈ β` and partial equivalences `f' : β →* γ`, `Equiv.transPartialEquiv e f' = Equiv.toPartialEquiv e <<< f'`.


theorem Pi.support_single_of_ne :
    ∀ {A : Type u_1} {B : Type u_2} [inst : DecidableEq A] [inst_1 : Zero B] {a : A} {b : B},
      b ≠ 0 → Function.support (Pi.single a b) = {a} :=
  by sorry

The theorem `Pi.support_single_of_ne` states that for any types A and B, given a decidable equality on A and a zero element on B, for any elements 'a' from A and 'b' from B, if 'b' is not zero, then the set of points where the function `Pi.single` (which maps A to B) is not zero is just the singleton set containing 'a'. In other words, the function `Pi.single a b` is only non-zero (i.e., not equal to the zero element of B) at 'a'.

Given types A and B with a decidable equality, a zero element in B, and for all a in A and b in B with b not equal to the zero element, `Pi.single a b` is a function equal to `a` as a map from A to B.


theorem Composition.sizeUpTo_zero : ∀ {n : ℕ} (c : Composition n), Composition.sizeUpTo c 0 = 0 := by sorry

This theorem states that for any natural number `n` and any composition `c` of `n`, the size up to the zeroth block in the composition is zero. In other words, there are no blocks to sum in the composition prior to the first block, so the sum is zero. This is analogous to the mathematical statement that the sum of an empty set of numbers is zero.

The size of the zeroth block in any composition is zero.


HasSum.unop

theorem HasSum.unop :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → αᵐᵒᵖ} {a : αᵐᵒᵖ},
      HasSum f a → HasSum (fun a => MulOpposite.unop (f a)) (MulOpposite.unop a) :=
  by sorry

The theorem `HasSum.unop` states that for any types `α` and `β`, where `α` is an additive commutative monoid and has a topological structure, if a function `f : β → αᵐᵒᵖ` (from `β` to the multiplicative opposite of `α`) has a sum `a` (i.e., the series formed by `f` sums up to `a`), then the function obtained by applying the operation `MulOpposite.unop` (which transforms elements from the multiplicative opposite space back to `α`) to `f` also has a sum, which is the `MulOpposite.unop` of `a`. In other words, summing the elements in the original space `α` gives the same result as summing their opposites and then taking the opposite of the sum.

For any additive commutative monoid `α` with a topological structure and any function `f : β → αᵐᵒᵖ` from `β` to the multiplicative opposite of `α`, if the series formed by `f` sums up to an element `a` in the multiplicative opposite space, then the series formed by applying `MulOpposite.unop` to the elements of `f` sums up to `MulOpposite.unop(a)` in `α`.


theorem MeasureTheory.MeasurePreserving.restrict_preimage_emb :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.MeasurePreserving f μa μb →
        MeasurableEmbedding f →
          ∀ (s : Set β), MeasureTheory.MeasurePreserving f (μa.restrict (f ⁻¹' s)) (μb.restrict s) :=
  by sorry

The theorem `MeasureTheory.MeasurePreserving.restrict_preimage_emb` states that, for any types `α` and `β`, given measurable spaces on `α` and `β` (represented as `inst : MeasurableSpace α` and `inst_1 : MeasurableSpace β` respectively), a measure `μa` on `α`, a measure `μb` on `β`, and a function `f` from `α` to `β`, if the function `f` is measure preserving (meaning the measure of any set under the function remains the same) with respect to measures `μa` and `μb`, and if `f` is a measurable embedding (which is a function that is both measurable and injective), then for any set `s` of type `β`, the function `f` is measure preserving with respect to the restriction of `μa` to the preimage of `s` under `f` and the restriction of `μb` to `s`.

In other words, when we restrict our measures to certain sets (the preimage of `s` under `f` for `μa` and `s` for `μb`), the function `f` still preserves the measure.

If `f: α → β` is a measure preserving and measurable embedding between measurable spaces `(α, μa)` and `(β, μb)`, then for any set `s ∈ β`, `f` preserves the measures of sets when restricted to the preimage of `s` under `f` for `μa` and `s` for `μb`.


Filter.EventuallyEq.isEquivalent

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

This theorem states that for any type `α`, any normed additive commutative group `β`, any filter `l` on `α`, and any two functions `u` and `v` from `α` to `β`, if `u` and `v` are eventually equal along `l` (meaning that there exists a neighborhood within `l` where `u` and `v` are equal), then `u` and `v` are asymptotically equivalent along `l`. In mathematical terms, if $u(x) = v(x)$ eventually as `x` converges along `l`, then $u(x) - v(x) = o(v(x))$ as `x` converges along `l`.

If two functions from a type `α` to a normed additive commutative group `β` are eventually equal along a filter `l`, then their difference is asymptotically equivalent to zero along `l`.


theorem AddMonoidAlgebra.divOf_apply :
    ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCancelCommMonoid G] (g : G)
      (x : AddMonoidAlgebra k G) (g' : G), (AddMonoidAlgebra.divOf x g) g' = x (g + g') :=
  by sorry

The theorem `AddMonoidAlgebra.divOf_apply` states that for any types `k` and `G` where `k` is a semiring and `G` is an additive cancel commutative monoid, given elements `g` and `g'` of `G` and an element `x` of the monoid algebra of `G` over `k`, applying the `divOf` function to `x` and `g`, and then applying the result to `g'`, is equal to applying `x` to the sum of `g` and `g'`. In other words, the operation of dividing by a given term `g` in the monoid algebra and then applying the result to another term `g'` is the same as applying the original element of the monoid algebra to the sum of the two terms `g` and `g'`.

For any semiring `k` and additive cancel commutative monoid `G`, the operation of dividing an element `x` of the monoid algebra of `G` over `k` by an element `g` of `G` and then applying the result to another element `g'` of `G`, is equivalent to applying `x` to the sum of `g` and `g'`.


theorem Set.inclusion.proof_1 : ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → ∀ (x : ↑s), ↑x ∈ t := by sorry

This theorem states that for any type `α`, and any two sets `s` and `t` of this type, if `s` is a subset of `t` (denoted `s ⊆ t`), then for any element `x` in the set `s` (denoted `x : ↑s`), this element `x` is also an element of the set `t` (denoted `↑x ∈ t`). In other words, if one set is a subset of another, then every element of the first set is also an element of the second set.

If `s ⊆ t` are sets, then for all `x : α`, if `x ∈ s`, then `x ∈ t`.


theorem IsPGroup.to_le :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {H K : Subgroup G}, IsPGroup p ↥K → H ≤ K → IsPGroup p ↥H := by sorry

The theorem `IsPGroup.to_le` states that for any natural number `p` and any group `G`, given two subgroups `H` and `K` of `G`, if `K` is a p-group (i.e., every element in `K` has an order that is a power of `p`), and if `H` is a subgroup of `K`, then `H` is also a p-group. In other words, if every element in subgroup `K` of some group `G` has an order that is a power of a prime number `p`, and if another subgroup `H` is a subset of `K`, then every element in `H` also has an order that is a power of `p`.

If `H` is a subgroup of the p-group `K` in a group `G`, then `H` is also a p-group.


theorem TrivSqZeroExt.fst_one : ∀ {R : Type u} {M : Type v} [inst : One R] [inst_1 : Zero M], TrivSqZeroExt.fst 1 = 1 :=
  by sorry

The theorem `TrivSqZeroExt.fst_one` states that for any types `R` and `M`, given that `R` has a multiplicative identity (denoted by `One R`) and `M` has an additive identity (denoted by `Zero M`), the first component (obtained via the function `TrivSqZeroExt.fst`) of the multiplicative identity in the trivial square zero extension of `R` and `M` is equal to the multiplicative identity in `R`. In other words, denoting the trivial square zero extension of `R` and `M` by `1`, we have `TrivSqZeroExt.fst 1 = 1` in `R`.

In the trivial square zero extension of rings `R` with identity `One R` and `M` with additive identity `Zero M`, the first component of the extension's identity equals the identity of `R`, i.e., `TrivSqZeroExt.fst 1 = One R`.


theorem ENNReal.top_pow : ∀ {n : ℕ}, 0 < n → ⊤ ^ n = ⊤ := by sorry

This theorem states that for any positive natural number `n`, the `n`th power of positive infinity (`⊤`) is also positive infinity. In other words, raising positive infinity to any positive natural number exponent does not change its value, it remains positive infinity. This is consistent with the general understanding of infinity in mathematics.

For any positive natural number `n`, `⊤^n = ⊤`.


theorem List.length_attach : ∀ {α : Type u} (L : List α), List.length (List.attach L) = List.length L := by sorry

This theorem, named `List.length_attach`, asserts that for any list `L` of type `α`, the length of the list obtained by attaching to each element of `L` the proof that it belongs to `L` (i.e., the list `List.attach L`) is equal to the length of `L` itself. In other terms, attaching proofs of membership to the elements of a list does not change the length of the list.

The length of `List.attach` a list `L` of type `α` is equal to the length of `L`.


theorem Setoid.ext_iff : ∀ {α : Type u_1} {r s : Setoid α}, r = s ↔ ∀ (a b : α), Setoid.Rel r a b ↔ Setoid.Rel s a b :=
  by sorry

This theorem states that for any type `α` and any two setoids `r` and `s` on this type, `r` equals `s` if and only if, for all pairs of elements `(a, b)` of type `α`, the relation `Setoid.Rel r a b` is equivalent to the relation `Setoid.Rel s a b`. In other words, two setoids are considered equal if they establish the same relationships between all pairs of elements in the set.

Two setoids on a type are equal if and only if they establish the same equivalence relation between all pairs of elements from that type.


theorem le_of_pow_le_pow_left :
    ∀ {R : Type u_3} [inst : LinearOrderedSemiring R] {a b : R} {n : ℕ}, n ≠ 0 → 0 ≤ b → a ^ n ≤ b ^ n → a ≤ b := by
  sorry

This theorem states that for any linearly ordered semiring `R`, given any two elements `a` and `b` from `R`, and a natural number `n` which is not zero, if `b` is non-negative and `a` to the power of `n` is less than or equal to `b` to the power of `n`, then `a` is less than or equal to `b`. In mathematical terms, this could be written as: for all $a, b \in R$ and $n \in \mathbb{N}$, if $n \neq 0$, $b \geq 0$ and $a^n \leq b^n$, then $a \leq b$.

If in a linearly ordered semiring, an element raised to a non-zero natural power is less than or equal to another element raised to the same power, then the first element is less than or equal to the second.


RingHom.IsIntegral.trans

theorem RingHom.IsIntegral.trans :
    ∀ {R : Type u_1} {S : Type u_4} {T : Type u_5} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
      (f : R →+* S) (g : S →+* T),
      RingHom.IsIntegral f → RingHom.IsIntegral g → RingHom.IsIntegral (RingHom.comp g f) :=
  by sorry

The theorem `RingHom.IsIntegral.trans` states that given three commutative rings `R`, `S`, and `T`, and two ring homomorphisms `f : R →+* S` and `g : S →+* T`, if `f` is integral (every element in `S` is integral with respect to `f`) and `g` is integral (every element in `T` is integral with respect to `g`), then the composition of `g` and `f` is also integral (every element in `T` is integral with respect to the composition of `g` and `f`). In other words, the integrality property of ring homomorphisms is preserved under composition.

If homomorphisms `f : R → S` and `g : S → T` are integral, then their composition `g ∘ f : R → T` is also integral.