theorem CategoryTheory.CostructuredArrow.eqToHom_left :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D}
      {X Y : CategoryTheory.CostructuredArrow S T} (h : X = Y),
      (CategoryTheory.eqToHom h).left = CategoryTheory.eqToHom ⋯ :=
  by sorry

This theorem states that for any two objects `X` and `Y` in the category of Costructured Arrows from functor `S` to object `T`, if `X` is equal to `Y` (denoted by `h : X = Y`), then the left component of the morphism created by `CategoryTheory.eqToHom` from `X` to `Y` is equal to the morphism created by `CategoryTheory.eqToHom` corresponding to some other equality. Here, `CategoryTheory.eqToHom` is a function that creates a morphism from an equality between two objects in a category.

Given objects `X` and `Y` in the category of Arrows from functor `S` to object `T`, if `X = Y`, then the morphism from `X` to `Y` given by `CategoryTheory.eqToHom` is equal to the morphism given by some other equality `h`.


theorem OmegaCompletePartialOrder.Continuous'.to_monotone :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β] {f : α → β},
      OmegaCompletePartialOrder.Continuous' f → Monotone f :=
  by sorry

The theorem `OmegaCompletePartialOrder.Continuous'.to_monotone` states that for all types `α` and `β`, given any function `f` that maps `α` to `β`, if `f` is continuous in the sense of the `OmegaCompletePartialOrder`, then `f` is also monotone. Here, a function is said to be continuous in the `OmegaCompletePartialOrder` if it is both monotone and continuous. Being monotone means that for any elements `a` and `b` in the domain, if `a` is less than or equal to `b`, then the value of the function at `a` is less than or equal to the value of the function at `b`.

If a function between two types is continuous in the sense of an Omega Complete Partial Order, then it is monotone.


theorem List.get?_append_right :
    ∀ {α : Type u_1} {l₁ l₂ : List α} {n : ℕ},
      List.length l₁ ≤ n → List.get? (l₁ ++ l₂) n = List.get? l₂ (n - List.length l₁) :=
  by sorry

The theorem `List.get?_append_right` states that for any two lists `l₁` and `l₂` of type `α` and a non-negative integer `n`, if the length of `l₁` is less than or equal to `n`, then fetching the `n`th element of the concatenated list `l₁ ++ l₂` is equivalent to fetching the `(n - length of l₁)`th element of `l₂`. In other words, if `n` is beyond the range of the first list, the `n`th element in the combined list is dependent on the second list `l₂` only.

For any lists `l₁` and `l₂` of length `m` and `n` respectively, and non-negative integer `n`, if `m <= n`, then the `n`-th element of `l₁ ++ l₂` is equal to the `(n - m)`-th element of `l₂`.


theorem Polynomial.as_sum_range :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R),
      p =
        Finset.sum (Finset.range (Polynomial.natDegree p + 1)) fun i =>
          (Polynomial.monomial i) (Polynomial.coeff p i) :=
  by sorry

The theorem `Polynomial.as_sum_range` states that for any polynomial `p` over a semiring `R`, `p` can be expressed as the sum of its monomials, where each monomial `a*X^i` is obtained by multiplying the coefficient of `X^i` in `p` by `X^i` (obtained using the `Polynomial.monomial` function), and the sum ranges over all natural numbers `i` from `0` to the degree of `p` (obtained using `Polynomial.natDegree` function). This is the formalization of the standard representation of a polynomial as a sum of monomials.

For any polynomial `p` over a semiring `R`, `p` can be expressed as the sum of monomials `a*X^i` with coefficients `a` taken from `R` and indices `i` ranging from `0` to the degree of `p`.


theorem PrimeSpectrum.zeroLocus_iUnion :
    ∀ {R : Type u} [inst : CommSemiring R] {ι : Sort u_1} (s : ι → Set R),
      PrimeSpectrum.zeroLocus (⋃ i, s i) = ⋂ i, PrimeSpectrum.zeroLocus (s i) :=
  by sorry

The theorem `PrimeSpectrum.zeroLocus_iUnion` states that for any commutative semiring `R` and any indexed collection of sets `s` of type `R` (indexed by some index type `ι`), the zero locus of the union of these sets is equal to the intersection of their zero loci. In mathematical terms, it says that for all indexed families of sets $(s_i)_{i\in\mathcal{I}}$, we have that the zero locus of the union (i.e., $\bigcup_{i\in\mathcal{I}} s_i$) equals the intersection of their zero loci (i.e., $\bigcap_{i\in\mathcal{I}} \text{ZeroLocus}(s_i)$). This theorem essentially encapsulates the property that the zero locus commutes with indexed unions.

For any commutative semiring `R` and indexed collection `(s_i)` of sets over `R` (indexed by `ι`), the zero locus of their union equals the intersection of their zero loci: `ZeroLocus(⋃i∈I si) = ∩i∈I ZeroLocus(si)`.


theorem Multiset.le_ndinter :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ≤ Multiset.ndinter t u ↔ s ≤ t ∧ s ⊆ u := by sorry

The theorem `Multiset.le_ndinter` states that for any type `α` with decidable equality and any three multiset objects `s`, `t`, and `u` of type `α`, `s` is a subset of the intersection of `t` and `u` (denoted as `Multiset.ndinter t u`) if and only if `s` is a subset of `t` and every element of `s` is also an element of `u`. Here, `Multiset.ndinter t u` represents the intersection of multisets `t` and `u`, but unlike the standard intersection operation, it does not take into account the multiplicities of elements. The symbol "⊆" is used to denote the subset relationship.

For any type `α` with decidable equality and multisets `s`, `t`, and `u` of type `α`, `s ⊆ Multiset.ndinter t u` if and only if `s ⊆ t` and each element of `s` is an element of `u`.


Nat.Prime.properDivisors

theorem Nat.Prime.properDivisors : ∀ {p : ℕ}, Nat.Prime p → Nat.properDivisors p = {1} := by sorry

This theorem states that for every natural number `p`, if `p` is a prime number, then the set of proper divisors of `p` is the set that contains only the number `1`. In mathematical terms, it establishes that the proper divisors of a prime number `p` are only `1`, since prime numbers are defined as those natural numbers greater than 1 that have no other divisors besides `1` and themselves.

The theorem asserts that the set of proper divisors of a prime number is empty or, equivalently, that a prime number's only proper divisor is 1.


theorem WittVector.truncate_surjective :
    ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ) (R : Type u_1) [inst : CommRing R],
      Function.Surjective ⇑(WittVector.truncate n) :=
  by sorry

This theorem states that for any prime number `p`, any natural number `n`, and any commutative ring `R`, the function `WittVector.truncate n` is surjective. In more mathematical terminology, given any `TruncatedWittVector` over the ring `R` with base `p` and length `n`, there exists a `WittVector` over the ring `R` with base `p` whose truncation to the first `n` entries equals the given `TruncatedWittVector`. This means that `WittVector.truncate n` maps onto the entire set of `n`-length `TruncatedWittVector`s.

For any prime number `p`, any natural number `n`, and any commutative ring `R`, the function `WittVector.truncate n` maps every `n`-length `TruncatedWittVector` over `R` with base `p` to some `WittVector` over `R` with base `p`.


MeasureTheory.StronglyMeasurable.inv

theorem MeasureTheory.StronglyMeasurable.inv :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Inv β]
      [inst_2 : ContinuousInv β], MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable f⁻¹ :=
  by sorry

This theorem states that for any function `f` from type `α` to `β`, where `α` is a measurable space and `β` is a topological space with an inversion function that is continuous, if `f` is `StronglyMeasurable` (i.e., it can be represented as the limit of simple functions), then the inverse of `f` (denoted as `f⁻¹`) is also `StronglyMeasurable`. In other words, the property of being `StronglyMeasurable` is preserved under continuous inversion.

If `f : α → β` is a Strongly Measurable function between measurable space `α` and topological space `β` with a continuous inversion function, then the inverse `f⁻¹ : β → α` is also Strongly Measurable.


/-- To prove a property of a finite product, it suffices to prove that the property is
multiplicative and holds on the factors.  -/
theorem finprod_induction :
    ∀ {M : Type u_2} {α : Sort u_4} [inst : CommMonoid M] {f : α → M} (p : M → Prop),
      p 1 → (∀ (x y : M), p x → p y → p (x * y)) → (∀ (i : α), p (f i)) → p (finprod fun i => f i) :=
  by sorry

The theorem `finprod_induction` states that to prove a property `p` holds for the finite product of a function `f` mapping from type `α` to a commutative monoid `M`, it is sufficient to prove three things:

1. The property `p` holds for the identity element `1` of the commutative monoid `M`.
2. The property `p` is stable under multiplication, that is, if `p` holds for two elements `x` and `y` of the monoid `M`, then it also holds for their product `x * y`.
3. The property `p` holds for every value `f i` where `i` is an element of `α`.

If these three conditions are met, then the property `p` holds for the finite product, represented as `finprod fun i => f i`.

If `f` is a function from type `α` to a commutative monoid `M`, and `p` is a property stable under multiplication such that `p` holds for the identity element `1` of `M` and for every `f i` where `i` is an element of `α`, then `p` holds for the finite product `finprod fun i => f i`.


theorem Submodule.map_comap_eq_self :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] {f : F} {q : Submodule R₂ M₂},
      q ≤ LinearMap.range f → Submodule.map f (Submodule.comap f q) = q :=
  by sorry

Theorem `Submodule.map_comap_eq_self` states that for any semirings `R` and `R₂`, additively commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a function `f` of type `F` where `F` is a class that can be injectively coerced to a function from `M` to `M₂`, a semilinear map class over `F`, `τ₁₂`, `M` and `M₂`, a surjective ring homomorphism `τ₁₂`, and a submodule `q` of `M₂` over `R₂`, if `q` is a subset of the range of `f`, then the mapping of the comapping of `q` using `f` equals `q` itself. In other words, if we first comap `q` using `f` and then map the result again using `f`, we end up with `q` itself, provided `q` is within the range of `f`. This theorem is a formal statement of the property about the interplay between mapping and comapping in the context of module theory.

If `f` is a semilinear map from a module `M` over a ring `R` to a module `M₂` over a ring `R₂`, `τ₁₂` is a surjective ring homomorphism from `R` to `R₂`, `q` is a submodule of `M₂` that is contained in the image of `f`, then the image of `q` under `f` and the image of `q` under the comappling of `f` are equal.


theorem Equiv.Perm.IsCycle.existsUnique_cycle_nontrivial_subtype :
    ∀ {α : Type u_1} [inst : Finite α] [inst : DecidableEq α] {f : Equiv.Perm α},
      Equiv.Perm.IsCycle f → ∃! s, Cycle.formPerm ↑s ⋯ = f :=
  by sorry

This theorem states that for every type `α` that is finite and has decidable equality, if a permutation `f` on this type forms a cycle (i.e., it is a non-identity permutation where any two non-fixed points are related by repeated application of the permutation), then there exists a unique cycle `s` such that the permutation formed by `s` (given no duplicate elements) is exactly `f`. In other words, for any cyclic permutation on a finite set with decidable equality, there is a unique corresponding cycle representation.

Given a finite type `α` with decidable equality, every cyclic permutation on `α` has a unique corresponding cycle representation.


theorem Stream'.WSeq.join_nil : ∀ {α : Type u}, Stream'.WSeq.join Stream'.WSeq.nil = Stream'.WSeq.nil := by sorry

The theorem `Stream'.WSeq.join_nil` states that for all types `α`, joining an empty weak sequence (`Stream'.WSeq.nil`) results in an empty weak sequence. In other words, the operation of joining does not produce any elements when applied to an empty weak sequence, irrespective of the type `α` of the elements that could potentially be in the sequence.

For all types `α`, the join of an empty weak sequence `Stream'.WSeq.nil` is the empty weak sequence.


theorem CategoryTheory.MonoOver.pullback.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f : X ⟶ Y) (g : CategoryTheory.MonoOver Y),
      CategoryTheory.Mono CategoryTheory.Limits.pullback.snd :=
  by sorry

This theorem states that for any category `C` with pullbacks, given any morphisms `f` (from object `X` to object `Y`) and `g` (which is a monomorphism over `Y`), the second projection of the pullback of `f` and `g` is a monomorphism. Here, a monomorphism is a morphism that is left-cancellable, and a pullback is a universal construction that comes with two morphisms such that their composition is equal to the original morphisms. This theorem is a part of the categorical theory and it is instrumental in understanding the properties of categories with certain limits.

Given a category with pullbacks, if `f: X → Y` is a morphism and `g: Y' → Y` is a monomorphism, then the second projection of the pullback of `f` and `g` is a monomorphism.


/-- **Alias** of the forward direction of `isMin_iff_eq_bot`. -/
theorem IsMin.eq_bot : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsMin a → a = ⊥ := by sorry

The theorem `IsMin.eq_bot` states that for any type `α` endowed with a partial order and a least element, denoted by `⊥`, if an element `a` of `α` is minimal (in the sense that there is no element strictly less than `a`), then `a` must be equal to `⊥`. In other words, the least element `⊥` is the only minimal element in such a partially ordered set.

In a partially ordered type with a least element, any minimal element equals the least element.


theorem edist_congr_right :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y z : α}, edist x y = 0 → edist x z = edist y z := by sorry

This theorem states that in any pseudoemetric space, if the extended distance between two points `x` and `y` is zero, then the extended distance between `x` and a third point `z` is the same as the extended distance between `y` and `z`. In other words, if `x` and `y` are at the exact same location in the space, then the distance from either of them to `z` is the same.

In a pseudometric space, if the extended distance between two points is zero, then the extended distance between any one of them and a third point is equal.


theorem Rat.eq_iff_mul_eq_mul : ∀ {p q : ℚ}, p = q ↔ p.num * ↑q.den = q.num * ↑p.den := by sorry

This theorem states that for any two rational numbers `p` and `q`, `p` is equal to `q` if and only if the numerator of `p` multiplied by the denominator of `q` is equal to the numerator of `q` multiplied by the denominator of `p`. In mathematical terms, we have p = q if and only if p.num * q.den = q.num * p.den. This is essentially a restatement of the cross-multiplication rule in the context of rational numbers.

For rational numbers p and q, p = q if and only if p.num * q.den = q.num * p.den (cross-multiplication rule).


/-- If a function `f` is continuous on a convex set `D ⊆ ℝ`, is differentiable on its interior,
and `f'` is monotone on the interior, then `f` is convex on `D`.  -/
theorem MonotoneOn.convexOn_of_deriv :
    ∀ {D : Set ℝ},
      Convex ℝ D →
        ∀ {f : ℝ → ℝ},
          ContinuousOn f D → DifferentiableOn ℝ f (interior D) → MonotoneOn (deriv f) (interior D) → ConvexOn ℝ D f :=
  by sorry

The theorem states that if a function `f`, mapping real numbers to real numbers, satisfies the following conditions:

1. `f` is continuous on a convex set `D` in the set of real numbers.
2. `f` is differentiable on the interior of `D`.
3. The derivative of `f`, denoted as `f'` or `deriv f`, is a monotone function on the interior of `D`.

Then, the function `f` is convex on the set `D`. That is, for any two points in `D`, the function `f` evaluated at any point on the line segment between the two points (inclusive) is less than or equal to the weighted average of the function values at the two points, where the weights are the proportions of the line segment that the point divides it into.

If a real-valued function `f` is continous on a convex set `D`, differentiable on the interior of `D`, and its derivative is a monotone function on the interior of `D`, then `f` is convex on `D`, meaning `f(tx+(1-t)y) <= tf(x) + (1-t)f(y)` for all `x, y in D` and `t in [0, 1]`.


theorem List.sublists'_reverse :
    ∀ {α : Type u} (l : List α), List.sublists' (List.reverse l) = List.map List.reverse (List.sublists l) := by sorry

This theorem states that for any list `l` of elements of some type `α`, the list of all non-contiguous sublists of the reversed list `l` (obtained using `List.sublists'`) is equal to the list obtained by applying the reverse operation to each of the non-contiguous sublists of the original list `l` (obtained using `List.sublists`). In other words, reversing a list before or after extracting its non-contiguous sublists, but adjusting for the different sublist orderings, results in the same list of sublists.

For any list `l` of elements `α`, the list of non-contiguous sublists of the reversed list `l` is equal to the list obtained by reversing each non-contiguous sublist of `l`.


theorem contDiff_add :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {n : ℕ∞}, ContDiff 𝕜 n fun p => p.1 + p.2 :=
  by sorry

The theorem `contDiff_add` asserts that for any nontrivially normed field `𝕜` and any normed additive commutative group `F` that is also a normed space over `𝕜`, the addition operation is continuously differentiable of any order `n`. In simpler terms, it means that the function which adds together two elements of the vector space `F` has derivatives of all orders, and these derivatives are continuous functions.

For any nontrivially normed field `𝕜` and normed additive commutative group `F` that is also a normed space over `𝕜`, the addition function `F × F → F` is continuously differentiable of all orders.


theorem mul_pos_iff_of_pos_right :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : MulPosStrictMono α]
      [inst_3 : MulPosReflectLT α], 0 < b → (0 < a * b ↔ 0 < a) :=
  by sorry

The theorem `mul_pos_iff_of_pos_right` states that for any type `α` equipped with multiplication and zero, and any elements `a` and `b` of `α`, under the conditions that `α` has a multiplication-zero structure (`MulZeroClass`), a preorder structure, follows the strict monotonicity of multiplication by positive elements on the right (`MulPosStrictMono`), and the strict reverse monotonicity of multiplication by nonnegative elements on the right (`MulPosReflectLT`), then if `b` is strictly positive, the product `a * b` is strictly positive if and only if `a` is strictly positive. This theorem basically provides a criterion for determining whether a number is positive based on the positivity of its product with another positive number.

Given a type `α` with multiplication and zero, and assuming `α` has a multiplication-zero structure, a preorder, multiplication is strict monotonic on the right by positive elements, and multiplication is strict reverse monotonic on the left by nonnegative elements, then `a * b` is strictly positive if and only if `a` is strictly positive, for all `a, b` in `α` with `b` strictly positive.


theorem FreeAlgebra.lift.proof_2 :
    ∀ (R : Type u_1) [inst : CommSemiring R] {X : Type u_2} {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (F : FreeAlgebra R X →ₐ[R] A), FreeAlgebra.liftAux R ((fun F => ⇑F ∘ FreeAlgebra.ι R) F) = F :=
  by sorry

This theorem states that for any commutative semiring `R`, any type `X`, any semiring `A` equipped with an algebra structure over `R`, and any algebra homomorphism `F` from the free algebra of `X` over `R` to `A`, the lift of the composition of `F` and the canonical injection from `X` to the free algebra of `X` over `R` is equal to `F` itself. Essentially, this encapsulates the universal property of the free algebra in the context of algebra homomorphisms.

 For any commutative semiring `R`, any type `X`, any semiring `A` with an algebra structure over `R`, and any algebra homomorphism `F` from the free algebra of `X` over `R` to `A`, the following diagram commutes:

```
 FreeAlgebra X R ───────── F ─── A
        │                │
        └─── sink(x) ───┐
        │               │
X ──────┘─── injection ───┐
```

Or in mathematical notation, `F ∘ injection = F ∘ sink(x)`, where `sink(x)` is the sink map from `X` to the free algebra of `X` over `R`.


theorem FreeAlgebra.lift.proof_1 :
    ∀ (R : Type u_3) [inst : CommSemiring R] {X : Type u_1} {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (f : X → A), (fun F => ⇑F ∘ FreeAlgebra.ι R) (FreeAlgebra.liftAux R f) = f :=
  by sorry

The theorem `FreeAlgebra.lift.proof_1` states that for any types `R`, `X`, `A`, any commutative semiring structure on `R`, any semiring structure on `A`, any algebra structure over `R` on `A`, and any function `f` from `X` to `A`, the function obtained by composing the function `f` with the canonical embedding `FreeAlgebra.ι R` of `X` into the free algebra over `R` on `X` and then applying `FreeAlgebra.liftAux R f`, is equal to the original function `f`.
In other words, this indicates that the `FreeAlgebra.liftAux` operation essentially "undoes" the mapping performed by the canonical embedding `FreeAlgebra.ι R`, returning us back to our original function `f`.

The theorem asserts that applying `FreeAlgebra.liftAux` to the composite of a function with the canonical embedding of a set into its free algebra over a commutative semiring yields the original function.


theorem not_tendsto_atTop_of_tendsto_nhds :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : NoTopOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : ClosedIciTopology α] {a : α} {l : Filter β} [inst_4 : Filter.NeBot l] {f : β → α},
      Filter.Tendsto f l (nhds a) → ¬Filter.Tendsto f l Filter.atTop :=
  by sorry

This theorem states that for any types `α` and `β`, if `α` has a preorder and there is no top element, and `α` is also topological space with a closed Ici topology, then given an element `a` of `α`, a filter `l` over `β` which is not the bottom filter, and a function `f` from `β` to `α`, if the function `f` satisfies the condition that the limit as `f` approaches `l` is a neighborhood of `a` (i.e., `Filter.Tendsto f l (nhds a)`), then it cannot be the case that the function `f` also tends to infinity at `l` (i.e., `¬Filter.Tendsto f l Filter.atTop`).

In simpler terms, for a given function, if the limit of the function at a certain point is a certain value, then the function cannot also tend to infinity at that point.

If `α` is a preorder without a top element, a topological space with a closed Ici topology, and `f: β -> α` satisfies `Filter.Tendsto f l (nhds a)`, then `¬Filter.Tendsto f l Filter.atTop`.


theorem ContinuousMultilinearMap.norm_ofSubsingleton :
    ∀ {𝕜 : Type u} {ι : Type v} {G : Type wG} {G' : Type wG'} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : SeminormedAddCommGroup G] [inst_3 : NormedSpace 𝕜 G] [inst_4 : SeminormedAddCommGroup G']
      [inst_5 : NormedSpace 𝕜 G'] [inst_6 : Subsingleton ι] (i : ι) (f : G →L[𝕜] G'),
      ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G' i) f‖ = ‖f‖ :=
  by sorry

This theorem states that for a continuous multilinear map specifically defined over a subsingleton set, the norm of that map equals the norm of the input function. Here, the set ι is a subsingleton (i.e., it contains at most one element), 𝕜 is a nontrivially normed field, G and G' are semi-normed additive commutative groups with 𝕜 as their scalar field. The function `f` is a bounded linear map from G to G', and `i` is an element of ι. The theorem applies to the special case where a continuous multilinear map is created from a bounded linear map with respect to a subsingleton set, asserting that the norm of such a multilinear map is the same as the norm of the original linear map.

The norm of a continuous, multilinear map defined over a subsingleton set from a nontrivially normed field to a semi-normed additive commutative group, derived from a bounded linear map, equals the norm of the original linear map.


theorem Matrix.kroneckerMap_smul_right :
    ∀ {R : Type u_1} {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10}
      {p : Type u_11} [inst : SMul R β] [inst_1 : SMul R γ] (f : α → β → γ) (r : R),
      (∀ (a : α) (b : β), f a (r • b) = r • f a b) →
        ∀ (A : Matrix l m α) (B : Matrix n p β), Matrix.kroneckerMap f A (r • B) = r • Matrix.kroneckerMap f A B :=
  by sorry

The theorem `Matrix.kroneckerMap_smul_right` states that for any types `R`, `α`, `β`, `γ`, `l`, `m`, `n`, and `p`, and given a scalar multiplication operation on `β` and `γ` (denoted `SMul R β` and `SMul R γ`), a function `f` from `α` and `β` to `γ`, a scalar `r` of type `R`, and a matrix `A` of type `Matrix l m α` and a matrix `B` of type `Matrix n p β`, if for all `a` of type `α` and `b` of type `β`, `f a (r • b)` equals to `r • f a b`, then the Kronecker map of `f` applied to `A` and `r` scaled `B` equals to `r` scaled Kronecker map of `f` applied to `A` and `B`. This theorem essentially states that the scalar multiplication can be distributed over the Kronecker map operation under certain conditions.

If for all `a` in `α` and `b` in `β`, `f(a) (r * b) = r * (f(a) * b)`, then `(kroneckerMap f A) * (r * B) = r * (kroneckerMap f A * B)`.


theorem symmDiff_sup_inf :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), symmDiff a b ⊔ a ⊓ b = a ⊔ b := by sorry

The theorem `symmDiff_sup_inf` states that for every type `α` that forms a Generalized Coheyting Algebra, and for every pair of elements `a` and `b` from `α`, the sup (union or "or") of the symmetric difference of `a` and `b` and the inf (intersection or "and") of `a` and `b` is equal to the sup of `a` and `b`. In other words, it combines the concepts of symmetric difference ("elements in `a` or `b`, but not in both"), intersection ("elements in both `a` and `b`"), and union ("elements in `a` or `b` or in both") to show a certain identity relationship that holds in this algebraic structure.

For every type `α` forming a Generalized Lattice and every pair of elements `a, b` in `α`, the sup of the symmetric difference `a ⊎ b` and the inf of `a` and `b` equals the sup of `a` and `b`.


Equiv.Perm.SameCycle.trans

theorem Equiv.Perm.SameCycle.trans :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y z : α},
      Equiv.Perm.SameCycle f x y → Equiv.Perm.SameCycle f y z → Equiv.Perm.SameCycle f x z :=
  by sorry

The theorem `Equiv.Perm.SameCycle.trans` states that for any type `α`, for any permutation `f` of `α`, and for any elements `x`, `y`, and `z` of `α`, if `x` and `y` are in the same cycle of the permutation `f` and `y` and `z` are also in the same cycle of `f`, then `x` and `z` must be in the same cycle of `f`. This theorem captures the transitive property of the `SameCycle` relation in the context of permutations.

If `x`, `y`, and `z` are elements of type `α` such that `x` and `y`, as well as `y` and `z`, are in the same cycle of a permutation `f` on `α`, then `x` and `z` are in the same cycle of `f`.


/-- To prove a proposition about `S : Finset α`,
it suffices to prove it for the empty `Finset`,
and to show that if it holds for some `Finset α ⊆ S`,
then it holds for the `Finset` obtained by inserting a new element of `S`.
 -/
theorem Finset.induction_on' :
    ∀ {α : Type u_4} {p : Finset α → Prop} [inst : DecidableEq α] (S : Finset α),
      p ∅ → (∀ {a : α} {s : Finset α}, a ∈ S → s ⊆ S → a ∉ s → p s → p (insert a s)) → p S :=
  by sorry

This theorem establishes an induction principle for finite sets, or `Finset`s, in Lean 4. Given a property `p` that applies to `Finset`s of a certain type `α`, if we can verify that `p` holds for the empty set, and that whenever `p` holds for any `Finset` subset of `S` it also holds for the larger `Finset` obtained by adding an element from `S` not already in the subset, then we can conclude that `p` holds for the `Finset` `S` itself.

This process requires the type `α` to have decidable equality, meaning for any two elements of type `α`, we can decide whether they are equal. The induction principle can be applied to any property of `Finset`s and this principle allows mathematical reasoning about all `Finset`s by successively considering larger and larger subsets.

If `α` is a type with decidable equality, then any property `p` holding for the empty `Finset` and satisfying the monotonicity condition that `p` holds for any subset of a `Finset` `S` and any element not in that subset implies `p` holds for `S` union the element, also holds for `S` itself.


theorem NNReal.mul_finset_sup :
    ∀ {α : Type u_1} (r : NNReal) (s : Finset α) (f : α → NNReal), r * Finset.sup s f = Finset.sup s fun a => r * f a :=
  by sorry

The theorem `NNReal.mul_finset_sup` asserts that for any type `α`, any nonnegative real number `r`, any finite set `s` of elements of type `α`, and any function `f` from `α` to nonnegative real numbers, the product of `r` and the supremum (greatest element) of the set obtained by applying `f` to every element of `s` is equal to the supremum of the set obtained by multiplying `r` with the application of `f` to each element of `s`. In mathematical terms, it can be denoted as `r * sup(f(s)) = sup(r * f(a))` for all `a` in `s`.

For any nonnegative real number `r`, finite set `s` of elements from type `α`, and function `f` from `α` to nonnegative real numbers, `r * sup(f(s)) = sup(r * f(x) | x ∈ s)`.


theorem Complex.inv_def : ∀ (z : ℂ), z⁻¹ = (starRingEnd ℂ) z * ↑(Complex.normSq z)⁻¹ := by sorry

This theorem states that for any complex number `z`, the multiplicative inverse of `z` (denoted `z⁻¹`) is equal to the product of the conjugate of `z` (denoted `(starRingEnd ℂ) z`), and the reciprocal of the norm squared of `z` (denoted `↑(Complex.normSq z)⁻¹`). Here, the norm squared of a complex number is the sum of the square of the real part and the square of the imaginary part of the complex number, and the conjugate of a complex number is obtained by changing the sign of its imaginary part.

For any complex number `z`, its multiplicative inverse is equal to the product of the conjugate of `z` and the reciprocal of the square of its norm, i.e., `z⁻¹ = (starRingEnd ℂ z) / (↑(Complex.normSq z)`) where the norm of `z` is the square root of the sum of the squares of its real and imaginary parts.


theorem UniformSpace.Completion.uniformEmbedding_coe :
    ∀ (α : Type u_1) [inst : UniformSpace α] [inst_1 : T0Space α], UniformEmbedding ↑α := by sorry

The theorem `UniformSpace.Completion.uniformEmbedding_coe` states that for any type `α` that has a uniform space structure and a T0 space structure, the canonical embedding of `α` into its completion is a uniform embedding. In the language of mathematics, given any topological space `α` that is both uniform and T0, the function that maps each point in `α` to the corresponding point in the completion of `α` is a uniform embedding, which preserves all the uniform properties of the space.

The canonical embedding of a uniform and T0 space into its completion is a uniform embedding.


theorem Cardinal.aleph'_succ : ∀ {o : Ordinal.{u_1}}, Cardinal.aleph' (Order.succ o) = Order.succ (Cardinal.aleph' o) :=
  by sorry

The theorem `Cardinal.aleph'_succ` states that for any ordinal `o`, the cardinal number `aleph'` of the successor of `o` is equal to the successor of the cardinal number `aleph'` of `o`. In other words, when applied to the successor of an ordinal, the `aleph'` function commutes with the `Order.succ` function. Thus, the sequence of cardinal numbers indexed by the ordinals respects the order of the ordinals.

The cardinal number `aleph'` of the successor ordinal is the successor of the cardinal number `aleph'` of the given ordinal.


theorem Commute.isNilpotent_mul_left :
    ∀ {R : Type u_1} {x y : R} [inst : Semiring R], Commute x y → IsNilpotent x → IsNilpotent (x * y) := by sorry

The theorem states that if two elements `x` and `y` of a given semiring `R` commute, and if the element `x` is nilpotent, then the product `x * y` is also nilpotent. In other words, if the multiplication operation between `x` and `y` is commutative (i.e., `x * y = y * x`) and there exists a natural number `n` such that `x` raised to the power `n` equals zero, then there also exists a natural number for which the power of the product `x * y` equals zero.

If `x` and `y` are commuting elements of a semiring, and `x` is nilpotent, then `x * y` is nilpotent.


theorem ClassGroup.mk_eq_one_iff :
    ∀ {R : Type u_1} {K : Type u_2} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K]
      [inst_3 : IsFractionRing R K] [inst_4 : IsDomain R] {I : (FractionalIdeal (nonZeroDivisors R) K)ˣ},
      ClassGroup.mk I = 1 ↔ Submodule.IsPrincipal ↑↑I :=
  by sorry

The theorem `ClassGroup.mk_eq_one_iff` states that for any commutative ring `R`, field `K`, and a non-zero fractional ideal `I` of `R` in `K`, the class of `I` in the class group is one if and only if `I` is a principal ideal. Here, `R` is assumed to be an integral domain and `K` is the field of fractions of `R`. In mathematical terms, this theorem indicates that the isomorphism class of a non-zero fractional ideal under the operation of ideal multiplication is trivial in the class group precisely when the ideal itself is principal.

A non-zero fractional ideal in the field of fractions of a commutative domain is in the trivial class of the class group if and only if it is principal.


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

The theorem `Nat.minFac_le` states that for every natural number `n` that is greater than zero, the smallest prime factor of `n` (represented by the function `Nat.minFac n`) is less than or equal to `n` itself. This means if you find the least prime number that divides `n`, this number will always be less than or equal to `n`.

For every natural number $n > 0$, the smallest prime factor of $n$ (denoted as $\operatorname{minFac}(n)$ in Lean) is less than or equal to $n$.


theorem unitInterval.symm_symm : ∀ (x : ↑unitInterval), unitInterval.symm (unitInterval.symm x) = x := by sorry

This theorem states that for any real number `x` in the unit interval `[0,1]`, applying the function `unitInterval.symm` twice returns the original number. In other words, `unitInterval.symm` is its own inverse when restricted to the unit interval in the real numbers.

For any real number `x` in the unit interval `[0,1]`, `unitInterval.symm x = x`.


theorem one_div_le_one_div_of_le :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → a ≤ b → 1 / b ≤ 1 / a := by sorry

This theorem states that for any type `α` that is a linear ordered semifield, given two elements `a` and `b` of this type, if `a` is greater than 0 and less than or equal to `b`, then the reciprocal of `b` is less than or equal to the reciprocal of `a`. In mathematical terms, it states: for all `a` and `b` in `α`, if `0 < a ≤ b`, then `1/b ≤ 1/a`.

For any linear ordered semifield type `α`, if `0 < a <= b` in `α`, then `1/b <= 1/a`.


theorem Bornology.isBounded_univ :
    ∀ {α : Type u_2} [inst : Bornology α], Bornology.IsBounded Set.univ ↔ BoundedSpace α := by sorry

This theorem states that for any type `α` with a specified bornology (a collection of bounded sets), the universal set `Set.univ` (which contains all elements of `α`) is considered to be a bounded set if and only if `α` itself is a bounded space. In other words, it establishes an equivalence between the property of the entire space `α` being bounded and the universal set of `α` being bounded in the context of the given bornology.

The universal set of a type `α` is bounded in its bornology if and only if `α` is a bounded space.


theorem ZNum.cast_zneg : ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : One α] (n : ZNum), ↑(-n) = -↑n := by sorry

This theorem, `ZNum.cast_zneg`, states that for any type `α`, where `α` is an additive group and has an identity element under multiplication, if `n` is a number of type `ZNum` (signed integers), then the negation of `n` cast to type `α` is equal to the negation of `n` cast to type `α`. In other words, casting doesn't change the relationship between `-n` and `n`: if you negate `n` first and then cast, you get the same result as if you cast `n` first and then negate.

For any additive group type `α` with identity multiplication, the operation of casting `ZNum` signed integers to `α` preserves negation: `-(CAST α n) = CAST α (-n)`.


/-- **Alias** of `le_of_le_of_eq'`. -/
theorem LE.le.trans_eq' : ∀ {α : Type u} [inst : Preorder α] {a b c : α}, b ≤ c → a = b → a ≤ c := by sorry

This theorem, `LE.le.trans_eq'`, states that for any type `α` with a preorder structure and any three elements `a`, `b`, and `c` of that type, if `b` is less than or equal to `c` and `a` is equal to `b`, then `a` is less than or equal to `c`. This is essentially an alternative formulation of the transitive property of inequality, allowing substitution of equal elements, in the context of a particular preorder.

If `α` is a preordered type, `a`, `b`, and `c` are elements of `α`, and `b` is less than or equal to `c` and `a` equals `b`, then `a` is less than or equal to `c`.


theorem Finsupp.single_eq_update :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] (a : α) (b : M),
      (⇑fun₀ | a => b) = Function.update 0 a b :=
  by sorry

The theorem `Finsupp.single_eq_update` states that for any types `α` and `M`, where `M` is a type with a defined zero element and `α` has decidable equality, for any elements `a` of type `α` and `b` of type `M`, the function that maps `a` to `b` and everything else to zero is the same as the function obtained by updating the zero function at `a` with the value `b`. In other words, creating a function that is zero everywhere except at `a` where it is `b` can be achieved in two ways: either directly defining it as such, or by taking the zero function and updating its value at `a` to `b`, and these two methods yield the same result. This theorem can be useful in functional programming and mathematical contexts where sparse representations are used (like in the case of the `Finsupp` or "finite support" structure in Lean).

For any type `α` with decidable equality and type `M` with a zero element, the function mapping `a` to `b` and zero to all other elements of `α × M` equals the function obtained by updating the zero function at `a` with `b`.


theorem Set.IccExtend_val :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] {a b : α} (h : a ≤ b) (f : ↑(Set.Icc a b) → β)
      (x : ↑(Set.Icc a b)), Set.IccExtend h f ↑x = f x :=
  by sorry

The theorem `Set.IccExtend_val` states that for any types `α` and `β` where `α` has a LinearOrder structure, for any elements `a` and `b` of `α` where `a ≤ b`, and any function `f` from the closed interval `[a, b]` to `β`, the value of the function `f` at any point `x` within the interval `[a, b]` remains the same even when the function `f` is extended to the entire domain `α` using `Set.IccExtend`. In other words, the extension of the function `f` to the whole domain `α` using `Set.IccExtend` does not affect the values of `f` within the interval `[a, b]`.

For any type `α` with a LinearOrder structure, any `a ≤ b` in `α`, and any function `f` from the interval `[a, b]` to a type `β`, the value `f x` is equal to the value of the extension of `f` by `Set.IccExtend at x` for all `x` in `[a, b]`.


theorem ENNReal.mul_le_of_le_div' : ∀ {a b c : ENNReal}, a ≤ b / c → c * a ≤ b := by sorry

This theorem states that for all extended nonnegative real numbers `a`, `b`, and `c`, if `a` is less than or equal to the quotient of `b` divided by `c`, then the product of `c` and `a` is less than or equal to `b`. This essentially represents the property of order preservation under multiplication and division in the context of extended nonnegative real numbers.

For all extended nonnegative real numbers `a`, `b`, and `c`, if `a ≤ b / c`, then `ac ≤ b`.


theorem NormedField.exists_norm_lt :
    ∀ (α : Type u_1) [inst : NontriviallyNormedField α] {r : ℝ}, 0 < r → ∃ x, 0 < ‖x‖ ∧ ‖x‖ < r := by sorry

This theorem states that for any nontrivially normed field `α` and any positive real number `r`, there exists an element `x` in `α` such that the norm of `x` is positive and less than `r`. In other words, we can always find an element in the normed field whose norm is between 0 and any given positive real number.

For any nontrivially normed field `α` and positive real number `r`, there exists an element `x` in `α` with `0 < ||x|| < r`.


theorem DFinsupp.neLocus_comm :
    ∀ {α : Type u_1} {N : α → Type u_2} [inst : DecidableEq α] [inst_1 : (a : α) → DecidableEq (N a)]
      [inst_2 : (a : α) → Zero (N a)] (f g : Π₀ (a : α), N a), DFinsupp.neLocus f g = DFinsupp.neLocus g f :=
  by sorry

This theorem states that for any type `α`, and any type `N` that depends on `α`, with both `α` and `N a` having decidable equality and `N a` having a zero element, the function `DFinsupp.neLocus` is commutative. This means that for any two finitely supported functions `f` and `g` (each mapping elements of type `α` to elements of type `N a`), the set of elements of `α` where `f` and `g` differ (given by `DFinsupp.neLocus f g`) is the same as the set of elements where `g` and `f` differ (given by `DFinsupp.neLocus g f`). In other words, the order in which the functions `f` and `g` are presented to `DFinsupp.neLocus` does not affect the outcome.

For any type `α` and type `N` depending on `α` with decidable equality and a zero element, the sets `DFinsupp.neLocus` of two finitely supported functions `f` and `g` mapping elements of type `α` to `N a` are equal: `DFinsupp.neLocus f g = DFinsupp.neLocus g f`.


theorem Nat.bodd_add_div2 : ∀ (n : ℕ), (bif Nat.bodd n then 1 else 0) + 2 * Nat.div2 n = n := by sorry

The theorem `Nat.bodd_add_div2` states that for any natural number `n`, if `n` is odd (determined by `Nat.bodd n`), then adding `1` to twice the greatest integer smaller than `n/2` (`2 * Nat.div2 n`) gives `n` itself. If `n` is not odd (i.e., even), then adding `0` to twice of `⌊n/2⌋` still gives `n`. Essentially, this theorem is expressing an integer as the sum of an odd/even indicator (1 or 0) and twice a rounded-down half.

For any natural number `n`, `n = Nat.bodd n * 2 * Nat.div2 n + Nat.abs (Nat.sub n (2 * Nat.div2 n))`.


theorem Real.logb_rpow : ∀ {b x : ℝ}, 0 < b → b ≠ 1 → Real.logb b (b ^ x) = x := by sorry

The theorem `Real.logb_rpow` states that for all real numbers `b` and `x`, if `b` is greater than 0 and `b` is not equal to 1, then the logarithm base `b` of `b` raised to the power of `x` is equal to `x`. In mathematical terms, this can be written as: for all \(b, x \in \mathbb{R}\) such that \(b > 0\) and \(b \neq 1\), we have \(\log_b(b^x) = x\).

For all real numbers `b` greater than 0 and not equal to 1, `logb (b^x) = x`.


theorem MeasureTheory.intervalIntegral_tendsto_integral_Ioi :
    ∀ {ι : Type u_1} {E : Type u_2} {μ : MeasureTheory.Measure ℝ} {l : Filter ι} [inst : Filter.IsCountablyGenerated l]
      [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {b : ι → ℝ} {f : ℝ → E} (a : ℝ),
      MeasureTheory.IntegrableOn f (Set.Ioi a) μ →
        Filter.Tendsto b l Filter.atTop →
          Filter.Tendsto (fun i => ∫ (x : ℝ) in a..b i, f x ∂μ) l (nhds (∫ (x : ℝ) in Set.Ioi a, f x ∂μ)) :=
  by sorry

This theorem states that given any real-valued function `f` that is integrable over the interval `(a, ∞)` with respect to a measure `μ`, and a sequence of real numbers `b(i)` that tends to infinity, the limit of the function `f` integrated over the interval `[a, b(i)]` as `i` tends to infinity is equal to the integral of the function `f` over the interval `(a, ∞)`. In other words, as we extend the upper limit `b(i)` of our integral to infinity, the value of the integral becomes the integral of the function over the entire interval `(a, ∞)`.

If `f` is an integrable real-valued function on the interval `(a, ∞)` with respect to `μ`, then `∫(a, ∞) f(x) dμ(x) = lim(i→∞) ∫(a, b(i)) f(x) dμ(x)`, where `b(i)` is a sequence tending to infinity.


theorem MeasureTheory.Lp.nnnorm_def :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), ‖f‖₊ = (MeasureTheory.snorm (↑↑f) p μ).toNNReal :=
  by sorry

The theorem `MeasureTheory.Lp.nnnorm_def` states that for any measure space `α`, any extended nonnegative real number `p`, any measure `μ` on `α`, and any element `f` in the `Lp` space of a normed add commutative group `E`, the non-negative norm of `f`, denoted as `‖f‖₊`, is equal to the `ℒp` seminorm of `f`, denoted as `MeasureTheory.snorm (↑↑f) p μ`, converted to a non-negative real number. This `ℒp` seminorm might be defined differently based on the value of `p`: it's `0` if `p=0`, it's `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, and it's `essSup ‖f‖ μ` for `p = ∞`.

For any measure space, extended nonnegative real number `p`, measure `μ`, and `Lp` space element `f`, the non-negative norm `‖f‖₊` equals the `ℒp` seminorm `Measure Theory.snorm (↑↑f) p μ` of `f`. The `ℒp` seminorm's value depends on `p`: it's `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and `essSup ‖f‖ μ` for `p = ∞`.


/-- The measure equivalence between `EuclideanSpace ℝ ι` and `ι → ℝ` is volume preserving.  -/
theorem EuclideanSpace.volume_preserving_measurableEquiv :
    ∀ (ι : Type u_4) [inst : Fintype ι],
      MeasureTheory.MeasurePreserving (⇑(EuclideanSpace.measurableEquiv ι)) MeasureTheory.volume MeasureTheory.volume :=
  by sorry

The theorem `EuclideanSpace.volume_preserving_measurableEquiv` establishes that for any finite type `ι`, the measure equivalence between the Euclidean space of real numbers parameterized by `ι` and the function space from `ι` to real numbers, as defined by `EuclideanSpace.measurableEquiv ι`, preserves volume. In other words, this measure equivalence doesn't change the measure (in this case the "volume") of sets under the transformation.

The measure equivalence between Euclidean spaces parameterized by a finite type `ι` and real-valued functions on `ι`, as defined by `EuclideanSpace.measurableEquiv ι`, preserves volumes of sets.


theorem MeasureTheory.intervalIntegral_tendsto_integral_Iic :
    ∀ {ι : Type u_1} {E : Type u_2} {μ : MeasureTheory.Measure ℝ} {l : Filter ι} [inst : Filter.IsCountablyGenerated l]
      [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a : ι → ℝ} {f : ℝ → E} (b : ℝ),
      MeasureTheory.IntegrableOn f (Set.Iic b) μ →
        Filter.Tendsto a l Filter.atBot →
          Filter.Tendsto (fun i => ∫ (x : ℝ) in a i..b, f x ∂μ) l (nhds (∫ (x : ℝ) in Set.Iic b, f x ∂μ)) :=
  by sorry

The theorem `MeasureTheory.intervalIntegral_tendsto_integral_Iic` states that for all types `ι` and `E`, a measure `μ` on the real numbers, a filter `l` on `ι` that is countably generated, a normed additively commutative group `E` that is also a normed space over the real numbers, a function `a` from `ι` to the real numbers, a function `f` from the real numbers to `E`, and a real number `b`, if `f` is integrable on the set of real numbers less than or equal to `b` with respect to the measure `μ`, and if `a` tends to negative infinity with respect to the filter `l`, then the integral of `f` from `a(i)` to `b` with respect to `μ` tends to the integral of `f` over the set of real numbers less than or equal to `b` with respect to `μ` as `i` tends to negative infinity with respect to the filter `l`.

In simpler terms, this theorem relates the integral of a function over a semi-infinite interval to the limit of integrals of the function over finite intervals within that semi-infinite interval as one endpoint of the finite interval tends to negative infinity.

For a countably generated filter `l` on `ι`, measure `μ` on the real numbers, normed additively commutative group `E`, integrable function `f` from the real numbers to `E`, and real number `b`, if `a(i)` tends to negative infinity with respect to `l` and the integral of `f` from `a(i)` to `b` tends to a limit with respect to `i` in `l`, then this limit is equal to the integral of `f` over the real numbers less than or equal to `b` with respect to `μ`.


theorem Rat.cast_inj : ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α] {m n : ℚ}, ↑m = ↑n ↔ m = n := by
  sorry

This theorem states that given any type `α` which is a division ring and has a characteristic of zero, for any two rational numbers `m` and `n`, the condition of their casted values (to the type `α`) being equal is equivalent to the condition of `m` and `n` being equal. Here, casting refers to the operation of changing one data type into another, in this case, from rational numbers to any type `α` which is a division ring with characteristic zero. In simple words, for this specific kind of type `α`, if the casted values of two rational numbers are equal, then the two rational numbers are also equal.

For any division ring `α` of characteristic zero, the function `α.cast` from the rational numbers to `α` is a bijection.


theorem LieModule.nilpotencyLength_eq_succ_iff :
    ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (k : ℕ),
      LieModule.nilpotencyLength R L M = k + 1 ↔
        LieModule.lowerCentralSeries R L M (k + 1) = ⊥ ∧ LieModule.lowerCentralSeries R L M k ≠ ⊥ :=
  by sorry

This theorem states that for any commutative ring `R`, Lie ring `L`, and Lie module `M`, and for any natural number `k`, the nilpotency length of the module `M` is `k + 1` if and only if the `(k + 1)`-th term of the lower central series of `M` is the zero module and the `k`-th term of the series is not the zero module. The nilpotency length of a module is the number of inclusions in the lower central series until reaching the zero module, and the lower central series is a sequence of nested submodules of `M` defined using Lie bracket operations.

For any commutative ring `R`, Lie ring `L`, and Lie module `M` over `L`, the nilpotency length of `M` is `k+1` if and only if the `(k+1)`-th term of its lower central series is the zero module but the `k`-th term is not.


theorem MeasureTheory.hasFiniteIntegral_iff_ofReal :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae μ] f →
        (MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ENNReal.ofReal (f a) ∂μ < ⊤) :=
  by sorry

The theorem `MeasureTheory.hasFiniteIntegral_iff_ofReal` states that for any measurable space `α`, any measure `μ` on `α`, and any function `f` from `α` to the real numbers, if the function `f` is nonnegative almost everywhere (with respect to the measure `μ`), then `f` has a finite integral with respect to `μ` if and only if the integral of the nonnegative real extension of `f` is finite. In other words, `f` is integrable in the sense of Lebesgue Integration (i.e., the integral of the absolute value of `f` is finite) if and only if the integral of the nonnegative real part of `f` is finite.

For any measurable space, measure, and measurable function, if the function is nonnegative almost everywhere and its nonnegative real extension has a finite integral, then the original function is integrable with respect to the measure.


theorem TopologicalSpace.isSeparable_univ_iff :
    ∀ {α : Type u} [t : TopologicalSpace α],
      TopologicalSpace.IsSeparable Set.univ ↔ TopologicalSpace.SeparableSpace α :=
  by sorry

This theorem states that for any type `α` with a topological space structure `t`, the property of the universal set `Set.univ` (the set containing all elements of `α`) being separable is equivalent to the topological space `α` being separable. Here, a set is considered separable if it is contained in the closure of a countable set. Similarly, a topological space is called separable if there exists a countable dense subset. Thus, the theorem provides a characterization of separable topological spaces in terms of the separability of the universal set.

A topological space is separable if and only if its universal set is separable as a set.


theorem Mathlib.RingTheory.NonUnitalSubring.Basic._auxLemma.10 :
    ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (x : R), (x ∈ ⊤) = True := by sorry

This theorem states that for any type `R` that forms a non-unital, non-associative ring, any element `x` of `R` is an element of the top-level (or universal) subring. In the language of set theory, it states that the set of all elements in `R` is a subset of the universal subring, represented by ⊤.

In any non-unital, non-associative ring `R`, every element `x` in `R` is contained in the universal subring ⊤.


/-- Given a pullback square assembled from a commuting square on the top and
a pullback square on the bottom, the top square is a pullback square.  -/
theorem CategoryTheory.IsPullback.of_bot :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C} {h₁₁ : X₁₁ ⟶ X₁₂}
      {h₂₁ : X₂₁ ⟶ X₂₂} {h₃₁ : X₃₁ ⟶ X₃₂} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₂₁ : X₂₁ ⟶ X₃₁} {v₂₂ : X₂₂ ⟶ X₃₂},
      CategoryTheory.IsPullback h₁₁ (CategoryTheory.CategoryStruct.comp v₁₁ v₂₁)
          (CategoryTheory.CategoryStruct.comp v₁₂ v₂₂) h₃₁ →
        CategoryTheory.CategoryStruct.comp h₁₁ v₁₂ = CategoryTheory.CategoryStruct.comp v₁₁ h₂₁ →
          CategoryTheory.IsPullback h₂₁ v₂₁ v₂₂ h₃₁ → CategoryTheory.IsPullback h₁₁ v₁₁ v₁₂ h₂₁ :=
  by sorry

The theorem `CategoryTheory.IsPullback.of_bot` states that in the context of a category `C`, given three objects `X₁₁`, `X₁₂`, `X₂₁`, `X₂₂`, `X₃₁`, `X₃₂` in `C`, and morphisms `h₁₁ : X₁₁ ⟶ X₁₂`, `h₂₁ : X₂₁ ⟶ X₂₂`, `h₃₁ : X₃₁ ⟶ X₃₂`, `v₁₁ : X₁₁ ⟶ X₂₁`, `v₁₂ : X₁₂ ⟶ X₂₂`, `v₂₁ : X₂₁ ⟶ X₃₁`, `v₂₂ : X₂₂ ⟶ X₃₂`, if we have a commuting square composed of the top square and a pullback square on the bottom, and if the composition of `h₁₁` and `v₁₂` equals the composition of `v₁₁` and `h₂₁`, then if the bottom square is a pullback square, the top square is also a pullback square.

In categorical language, a pullback square is a diagram that depicts a certain limit in a category. If we can show that the bottom square is a pullback, and the top square commutes, then the whole square is also a pullback.

If a commutative square in a category has a pullback square at its bottom and the compositions of the outer two rectangular paths are equal, then the whole square is a pullback square.


theorem Filter.iInf_sets_eq_finite :
    ∀ {α : Type u} {ι : Type u_2} (f : ι → Filter α), (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i).sets := by sorry

This theorem states that for any given type `α` and another type `ι`, and a function `f` from `ι` to `Filter α`, the intersection of the sets generated by the function `f` applied across all of `ι` is equal to the union of the sets generated by the function `f` applied across each finite subset `t` of `ι`. In the context of filters, this result ties together the concept of intersection (represented by `⨅`) and union (represented by `⋃`), showing how they relate when applied to all elements versus finite subsets.

For any type `α` and type `ι`, and a function `f` from `ι` to filters on `α`, the intersection of images `⨅ i ∈ ι. f i` equals the union of images `⋃ t ⊆ ι. {⨅ j ∈ t. f j}`.


theorem Ordinal.mul_add_div :
    ∀ (a : Ordinal.{u_4}) {b : Ordinal.{u_4}}, b ≠ 0 → ∀ (c : Ordinal.{u_4}), (b * a + c) / b = a + c / b := by sorry

This theorem states that for any ordinal number `a` and `c`, and any non-zero ordinal number `b`, the division of `b * a + c` by `b` is equal to `a + c / b`. This is essentially the division version of the distributive law for ordinal multiplication and addition.

For any ordinal numbers `a`, `b` (non-zero), and `c`, `(b * a + c) / b = a + c / b`.


theorem Cardinal.le_powerlt : ∀ {b c : Cardinal.{u}} (a : Cardinal.{u}), c < b → a ^ c ≤ a ^< b := by sorry

The theorem `Cardinal.le_powerlt` states that for any three cardinal numbers `a`, `b`, and `c` in a specific type `u`, if `c` is less than `b`, then `a` raised to the power of `c` is less than or equal to `a` raised to the cardinal exponent of `b`. This theorem essentially deals with the properties of exponents in the context of cardinal numbers.

For any cardinal numbers `a`, `b`, and `c`, if `c` is less than `b`, then `a^c <= a^b`.


/-- If `α` is a seminormed ring, then `‖a ^ n‖ ≤ ‖a‖ ^ n` for `n > 0`. See also `norm_pow_le`.  -/
theorem norm_pow_le' : ∀ {α : Type u_1} [inst : SeminormedRing α] (a : α) {n : ℕ}, 0 < n → ‖a ^ n‖ ≤ ‖a‖ ^ n := by sorry

This theorem states that if `α` is a type that has a structure of a seminormed ring, then for any element `a` of type `α` and any natural number `n` greater than zero, the norm of `a` raised to the power `n` is less than or equal to the norm of `a` itself raised to the power `n`. In other words, in a seminormed ring, the norm of the power of an element does not exceed the power of the element's norm, for positive powers.

In a seminormed ring, the norm of an element raised to any positive power is less than or equal to the norm of that element raised to the power of one.


theorem Finset.attach_image_val :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α}, Finset.image Subtype.val (Finset.attach s) = s := by sorry

This theorem states that for any given type `α` with decidable equality and any finite set `s` of type `α`, the image of the attached set of `s` under the value function `Subtype.val` is equal to the original set `s`. In more layman's terms, when we attach each element of a finite set to the property of being in that set, creating a new set of subtypes, and then apply a function that retrieves the original element from each subtype, we get back the original set.

For any finite type `α` with decidable equality, the image of a set `s` under the `Subtype.val` function is equal to `s` itself.


/-- An equivalent expression of `Submonoid.FG` in terms of `Set.Finite` instead of `Finset`.  -/
theorem Submonoid.fg_iff :
    ∀ {M : Type u_1} [inst : Monoid M] (P : Submonoid M),
      Submonoid.FG P ↔ ∃ S, Submonoid.closure S = P ∧ Set.Finite S :=
  by sorry

This theorem states that a submonoid `P` of a monoid `M` is finitely generated (as per the definition of `Submonoid.FG`) if and only if there exists a set `S` such that `S` is the generating set of `P` (i.e., the submonoid closure of `S` is `P`) and `S` is a finite set. In other words, a submonoid is finitely generated if it can be created by the closure operation on a finite set of elements.

A submonoid of a monoid is finitely generated if and only if it can be generated by a finite set.


theorem PartialEquiv.trans_source' :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (e' : PartialEquiv β γ),
      (PartialEquiv.trans e e').source = e.source ∩ ↑e ⁻¹' (e.target ∩ e'.source) :=
  by sorry

The theorem `PartialEquiv.trans_source'` states that for any three types `α`, `β`, and `γ`, and for any two partial equivalences `e` from `α` to `β` and `e'` from `β` to `γ`, the source of the partial equivalence obtained by composing `e` and `e'` is equal to the intersection of the source of `e` and the preimage under `e` of the intersection of the target of `e` and the source of `e'`. In mathematical terms, this states that if we have two partial equivalences `e : α ⇀ β` and `e' : β ⇀ γ`, the domain where their composition is defined is `e.source ∩ e⁻¹(e.target ∩ e'.source)`.

The source of the partial equivalence obtained by composing `e` and `e'` is the intersection of `e.source` and the preimage of `e.target ∩ e'.source` under `e`.


theorem Set.apply_indicator_symmDiff :
    ∀ {α : Type u_1} {β : Type u_2} {G : Type u_6} [inst : AddGroup G] {g : G → β},
      (∀ (x : G), g (-x) = g x) →
        ∀ (s t : Set α) (f : α → G) (x : α),
          g (Set.indicator (symmDiff s t) f x) = g (Set.indicator s f x - Set.indicator t f x) :=
  by sorry

This theorem, named `Set.apply_indicator_symmDiff`, states that for any types `α`, `β` and `G` with `G` being an additive group, and any function `g` from `G` to `β` satisfying the property `g (-x) = g x` for all `x` in `G`, and for any sets `s` and `t` of type `α` with a function `f` from `α` to `G`, the application of `g` to the set indicator of the symmetric difference of `s` and `t` at any point `x` is equal to the application of `g` to the difference of the set indicators of `s` and `t` at `x`.

In simpler terms, it says that for a suitable function `g` and any sets `s` and `t`, the value of `g` at the `Set.indicator` of the symmetric difference of `s` and `t` is the same as the value of `g` at the difference of the `Set.indicator`s of `s` and `t`. This holds true for any point `x` in the sets.

For any additive group G, functions g from G to a type β satisfying g (-x) = g x for all x in G, and sets s and t, the application of g to the set indicator of the symmetric difference of s and t is equal to the application of g to the difference of the set indicators of s and t at any point x in the sets.


theorem Set.preimage_empty : ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, f ⁻¹' ∅ = ∅ := by sorry

This theorem states that for any function `f` from a type `α` to another type `β`, the preimage of an empty set under this function is also an empty set. In mathematical terms, given a function `f: α → β`, if you try to find elements in `α` that `f` maps to an empty set, you will end up with an empty set.

For any function `f: α → β`, the preimage `f⁁⁻¹(∅)` of the empty set under `f` is an empty set.


PUnit.subsingleton

theorem PUnit.subsingleton : ∀ (a b : PUnit.{u_1}), a = b := by sorry

This theorem states that for any two elements `a` and `b` of the type `PUnit`, `a` is always equal to `b`. In other words, `PUnit` is a subsingleton type, meaning it has at most one distinct element, so any two instances of `PUnit` must necessarily be equal.

The type `PUnit` has at most one element, hence any two elements `a` and `b` of `PUnit` are equal: `a = b`.


PowerBasis.finrank

theorem PowerBasis.finrank :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S]
      [inst_3 : StrongRankCondition R] (pb : PowerBasis R S), FiniteDimensional.finrank R S = pb.dim :=
  by sorry

The theorem `PowerBasis.finrank` states that for any commutative ring `R`, any ring `S`, given `S` is an algebra over `R`, and `R` has the strong rank condition, the rank of the module `S` over `R`, defined to be the finite dimension of `S` over `R`, is equal to the dimension of a power basis `pb` of `S` over `R`. The strong rank condition ensures that every increasing chain of left ideals in `R` stabilizes.

For a commutative ring `R` with the strong rank condition and an algebra `S` over `R`, the rank of `S` as an `R`-module equals the dimension of a power basis of `S`.


/-- The `v`-adic valuation on `R` is bounded above by 1.  -/
theorem IsDedekindDomain.HeightOneSpectrum.valuation_le_one :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
      [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R),
      (IsDedekindDomain.HeightOneSpectrum.valuation v) ((algebraMap R K) r) ≤ 1 :=
  by sorry

The theorem `IsDedekindDomain.HeightOneSpectrum.valuation_le_one` states that for every Dedekind domain `R`, field `K` such that `K` is the field of fractions of `R`, and for any `v` from the height one spectrum of `R`, and any element `r` of `R`, the `v`-adic valuation of the image of `r` under the natural embedding from `R` to `K` (given by the Algebra structure) is less than or equal to 1. In other words, for any Dedekind domain and its field of fractions, the `v`-adic valuation of any element of the domain mapped to the field is bounded above by 1.

For any Dedekind domain R with field of fractions K, and for every height one prime ideal p of R and any element r in R, the v-adic valuation of the image of r in K is less than or equal to 1.


theorem StalkSkyscraperPresheafAdjunctionAuxs.fromStalk_to_skyscraper :
    ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v}
      [inst_1 : CategoryTheory.Category.{u, v} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
      [inst_3 : CategoryTheory.Limits.HasColimits C] {𝓕 : TopCat.Presheaf C X} {c : C}
      (f : TopCat.Presheaf.stalk 𝓕 p₀ ⟶ c),
      StalkSkyscraperPresheafAdjunctionAuxs.fromStalk p₀
          (StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf p₀ f) =
        f :=
  by sorry

This theorem states that for a given topological space `X`, a point `p₀` in `X`, a category `C` with terminal objects and colimits, a presheaf `𝓕` of `C` on `X`, and a morphism `f` from the stalk of the presheaf at the point `p₀` to an object `c` in `C`, the composition of the morphism `f` with the function `fromStalk` applied to the result of `toSkyscraperPresheaf` applied to `f` is equal to `f` itself. Essentially, it expresses a kind of round-trip property: if you map a stalked presheaf to a 'skyscraper presheaf' and then map it back again, you get the original presheaf.

For any topological space X, presheaf 𝓕 on X, point p0 in X, object c in the category C with terminal objects and colimits, and morphism f from the stalk of 𝓕 at p0 to c, the diagram commutes: fromStalk (toSkyscraperPresheaf f) = f.


theorem ofAdd_add :
    ∀ {α : Type u} [inst : Add α] (x y : α),
      Multiplicative.ofAdd (x + y) = Multiplicative.ofAdd x * Multiplicative.ofAdd y :=
  by sorry

The theorem `ofAdd_add` states that for all types `α` with addition (`Add α`), given any two elements `x` and `y` of this type, the multiplicative interpretation of the sum of `x` and `y` equals to the product of the multiplicative interpretations of `x` and `y` respectively. This theorem essentially demonstrates that the function `Multiplicative.ofAdd` respects the algebraic structure, converting addition into multiplication in the `Multiplicative α` context.

For all types `α` with additions, the multiplicative interpretation of the sum of two elements is equal to the product of their multiplicative interpretations.


theorem nhdsWithin_le_iff :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α} {x : α},
      nhdsWithin x s ≤ nhdsWithin x t ↔ t ∈ nhdsWithin x s :=
  by sorry

This theorem states that for any type `α` equipped with a topology (i.e., a `TopologicalSpace α`), for any two sets `s` and `t` of type `α`, and for any element `x` of type `α`, the "neighborhood within" `s` of `x` is less than or equal to the "neighborhood within" `t` of `x` if and only if `t` is in the "neighborhood within" `s` of `x`.

In more mathematically precise terms: given a topological space $(\alpha, \tau)$, two subsets $s, t \subset \alpha$, and a point $x \in \alpha$, the filter generated by the intersection of `s` and a neighborhood of `x` is a subset of the filter generated by the intersection of `t` and a neighborhood of `x` if and only if `t` is an element of the filter generated by the intersection of `s` and a neighborhood of `x`.

For any topological space $(\alpha, \tau)$, and for any sets $s, t \subseteq \alpha$ and point $x \in \alpha$, the filter generated by $s \cap N$ contains the filter generated by $t \cap N$ if and only if $t \in s \cap N$, where $N$ is a neighborhood of $x$.


theorem CategoryTheory.Limits.WidePushout.arrow_ι :
    ∀ {J : Type w} {D : Type u_1} [inst : CategoryTheory.Category.{v₂, u_1} D] {B : D} {objs : J → D}
      (arrows : (j : J) → B ⟶ objs j) [inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] (j : J),
      CategoryTheory.CategoryStruct.comp (arrows j) (CategoryTheory.Limits.WidePushout.ι arrows j) =
        CategoryTheory.Limits.WidePushout.head arrows :=
  by sorry

The theorem `CategoryTheory.Limits.WidePushout.arrow_ι` states that for all types `J` and `D`, where 'D' is a category, and for all objects `B` in `D` and a function `objs` from `J` to `D`, if a `widePushout` exists for `B` and `objs` with a specified set of arrows, then for each `j` in `J`, the composite of the arrow from `B` to `objs j` and the unique arrow from `objs j` to the `widePushout` is equal to the unique arrow from the head, `B`, to the `widePushout`. This is a property of the universal property of `widePushout` in category theory which says that given a diagram with a specified set of arrows (functions) from `B` to `objs j` for all `j` in `J`, there exists a unique arrow from the head of the diagram, `B`, to the `widePushout` such that the diagram commutes.

Given a category `D`, an object `B` in `D`, a function `objs : J -> D` from a type `J` to `D`, and a wide pushout of `B` and `objs` with a specified set of arrows, the composite of the arrow from `B` to `objs j` and the unique arrow from `objs j` to the wide pushout equals the unique arrow from `B` to the wide pushout for all `j` in `J`.


theorem mul_le_mul_right₀ :
    ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] {a b c : α}, c ≠ 0 → (a * c ≤ b * c ↔ a ≤ b) := by sorry

This theorem states that for any type `α` which is a linearly ordered commutative group with an identity element that is distinguished as zero, given any three elements `a`, `b`, and `c` of this type, if `c` is not zero, then the product of `a` and `c` is less than or equal to the product of `b` and `c` if and only if `a` is less than or equal to `b`. This essentially means that in such a group, multiplication by a non-zero element preserves the order of elements.

For any commutative group with identity and total ordering where multiplication by a non-zero element preserves the order, the product of two elements is less than or equal to the product of another element if and only if the first element is less than or equal to the second.


theorem zorn_nonempty_partialOrder :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : Nonempty α],
      (∀ (c : Set α), IsChain (fun x x_1 => x ≤ x_1) c → Set.Nonempty c → BddAbove c) → ∃ m, ∀ (a : α), m ≤ a → a = m :=
  by sorry

The theorem `zorn_nonempty_partialOrder` states that for any type `α`, given a partial order on `α` and the assumption that `α` is not empty, if every chain in `α` (a chain being a set where for any two elements `x` and `y`, either `x ≤ y` or `y ≤ x`) that is non-empty is bounded above, then there exists an element `m` in `α` such that for all other elements `a` in `α`, if `m ≤ a` then `a` must be equal to `m`. Essentially, this is a formulation of Zorn's Lemma, a foundational result in set theory and abstract algebra. It indicates that in certain structures, every chain has an upper bound.

If every non-empty chain in a partially ordered set has an upper bound, then the set has a greatest element.


theorem CategoryTheory.CartesianClosed.curry_eq_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A X Y : C}
      [inst_1 : CategoryTheory.Limits.HasFiniteProducts C] [inst_2 : CategoryTheory.Exponentiable A] (f : A ⨯ Y ⟶ X)
      (g : Y ⟶ A ⟹ X), CategoryTheory.CartesianClosed.curry f = g ↔ f = CategoryTheory.CartesianClosed.uncurry g :=
  by sorry

This theorem states that in a category `C` with finite products and an exponentiable object `A`, for morphisms `f : A ⨯ Y ⟶ X` and `g : Y ⟶ A ⟹ X`, `f` is the uncurrying of `g` if and only if `g` is the currying of `f`. In other words, the currying and uncurrying operations are inverses of each other. These operations stem from the concept of a Cartesian closed category, where there exists an adjunction between the -⨯ Y and Y⟹- functors, with currying as the unit and uncurrying as the counit of the adjunction.

In a Cartesian closed category with finite products, the currying and uncurrying operations are mutually inverse morphism transformations between the product and function types.


theorem CategoryTheory.ShortComplex.leftHomologyMap'_nullHomotopic :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (H₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁)
      (H₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂) (h₀ : S₁.X₁ ⟶ S₂.X₁)
      (h₀_f : CategoryTheory.CategoryStruct.comp h₀ S₂.f = 0) (h₁ : S₁.X₂ ⟶ S₂.X₁) (h₂ : S₁.X₃ ⟶ S₂.X₂)
      (h₃ : S₁.X₃ ⟶ S₂.X₃) (g_h₃ : CategoryTheory.CategoryStruct.comp S₁.g h₃ = 0),
      CategoryTheory.ShortComplex.leftHomologyMap'
          (CategoryTheory.ShortComplex.nullHomotopic S₁ S₂ h₀ h₀_f h₁ h₂ h₃ g_h₃) H₁ H₂ =
        0 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.leftHomologyMap'_nullHomotopic` states that for any category `C` that is preadditive, and any two short complexes `S₁` and `S₂` in `C` with given left homology data `H₁` and `H₂`, the left homology map of a null-homotopic map between `S₁` and `S₂`, given by morphisms `h₀`, `h₁`, `h₂`, and `h₃`, where the composition of `h₀` with `S₂.f` is 0 and the composition of `S₁.g` with `h₃` is also 0, is equal to 0. In simpler terms, under these conditions, null-homotopic maps do not change the left homology of short complexes.

In a preadditive category, the left homology map of a null-homotopic morphism between short complexes is the identity on their respective left homology groups.


theorem Set.image_compl_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α}, Function.Bijective f → f '' sᶜ = (f '' s)ᶜ := by sorry

The theorem `Set.image_compl_eq` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `α`, if the function `f` is bijective (i.e., both injective and surjective), then the image under `f` of the complement of `s` (denoted by `f '' sᶜ` in Lean) is equal to the complement of the image under `f` of `s` (denoted by `(f '' s)ᶜ`). In other words, the image of the complement of a set under a bijective function equals the complement of the image of the set.

For any bijective function `f` from type `α` to type `β` and any set `s` of type `α`, the image of `s`'s complement under `f` equals the complement of `f(s)`.


IsGLB.union

/-- If `a` is the greatest lower bound of `s` and `b` is the greatest lower bound of `t`,
then `a ⊓ b` is the greatest lower bound of `s ∪ t`.  -/
theorem IsGLB.union :
    ∀ {γ : Type w} [inst : SemilatticeInf γ] {a₁ a₂ : γ} {s t : Set γ},
      IsGLB s a₁ → IsGLB t a₂ → IsGLB (s ∪ t) (a₁ ⊓ a₂) :=
  by sorry

The theorem `IsGLB.union` states that for any type `γ` that forms a semilattice under the operation "infimum" (denoted by `⊓`), if `a₁` is the greatest lower bound of a set `s` and `a₂` is the greatest lower bound of another set `t`, then the infimum of `a₁` and `a₂` is the greatest lower bound of the union of `s` and `t`. In other words, for any two sets `s` and `t`, their greatest lower bounds' infimum is the greatest lower bound of the union of `s` and `t`.

For any semilattices `γ` and sets `s` and `t` with greatest lower bounds `a₁` and `a₂` respectively, the infimum of `a₁` and `a₂` is equal to the greatest lower bound of `s ∪ t`.


theorem IsExtrFilter.comp_antitone :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α}
      {a : α}, IsExtrFilter f l a → ∀ {g : β → γ}, Antitone g → IsExtrFilter (g ∘ f) l a :=
  by sorry

The theorem `IsExtrFilter.comp_antitone` states that for all types `α`, `β`, and `γ`, given a preorder on `β` and `γ`, for any function `f` from `α` to `β`, any filter `l` on `α`, and any member `a` of `α`, if `f` is an extremal filter at `a` and `g` is an antitone function from `β` to `γ`, then the composition `g ∘ f` is also an extremal filter at `a`. In other words, the composition of an extremal function and an antitone function preserves the extremality at any given point under a specified filter.

If `f: α → β` is an extremal filter function at `a ∈ α`, `g: β → γ` is an antitone function, and `l` is a filter on `α`, then `g ∘ f` is an extremal filter at `a` with respect to `l`.


theorem Mathlib.Algebra.Ring.Divisibility.Basic._auxLemma.5 :
    ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : HasDistribNeg α] {a b : α}, (a ∣ -b) = (a ∣ b) := by sorry

This theorem, named `Mathlib.Algebra.Ring.Divisibility.Basic._auxLemma.5`, states that for any type `α` that forms a semigroup and has the property of distributive negation (`HasDistribNeg`), if we have any two elements `a` and `b` of type `α`, then `a` divides negative `b` if and only if `a` divides `b`. In mathematical terms, it asserts that for any given semigroup elements `a` and `b`, $a | -b$ is equivalent to $a | b$.

In a semigroup with distributive negation, the relations $a | b$ and $a | -b$ are equivalent for any $a, b$ in the semigroup.


theorem Mathlib.Algebra.Ring.Divisibility.Basic._auxLemma.4 :
    ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) := by sorry

This theorem, `Mathlib.Algebra.Ring.Divisibility.Basic._auxLemma.4`, states that for any type `G` equipped with an `InvolutiveNeg` operation, and for any elements `a` and `b` of type `G`, the statement "-a equals -b" is equivalent to the statement "a equals b". In mathematical terms, this theorem says that negating both sides of an equation does not change the truth of the equation.

For any type `G` with an `InvolutiveNeg` operation, the negation of an element is the additive inverse, hence `-a = -b` if and only if `a = b`.


theorem Derivation.map_algebraMap :
    ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
      [inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
      (D : Derivation R A M) (r : R), D ((algebraMap R A) r) = 0 :=
  by sorry

The theorem `Derivation.map_algebraMap` asserts that for any commutative semiring `R`, any commutative semiring `A`, any additive commutative monoid `M`, any `R`-algebra structure on `A`, any `A`-module structure on `M`, and any `R`-module structure on `M`, for any derivation `D` from `A` to `M` over `R` and any element `r` of `R`, the derivation `D` applied to the image of `r` under the algebra map from `R` to `A` is equal to zero. In mathematical terms, if $R$ and $A$ are commutative semirings, $M$ is an additive commutative monoid, $A$ is an $R$-algebra, $M$ is an $A$-module and an $R$-module, and $D: A \rightarrow M$ is a derivation, then for all $r \in R$, $D(\phi(r)) = 0$ where $\phi: R \rightarrow A$ is the algebra map, i.e., $\phi(r)$ is the image of $r$ under the structure of the $R$-algebra.

For any commutative semiring $R$, commutative semiring $A$, additive commutative monoid $M$, $R$-algebra structure on $A$, $A$-module and $R$-module structure on $M$, and derivation $D$ from $A$ to $M$ over $R$, $D(\phi(r)) = 0$ for all $r \in R$, where $\phi: R \rightarrow A$ is the algebra map.


theorem t0Space_iff_inseparable :
    ∀ (X : Type u) [inst : TopologicalSpace X], T0Space X ↔ ∀ (x y : X), Inseparable x y → x = y := by sorry

The theorem `t0Space_iff_inseparable` states that for any topological space `X`, `X` is a T0-space (also known as a Kolmogorov space) if and only if for any two points `x` and `y` in `X`, if `x` and `y` are inseparable (meaning the neighborhoods of `x` and `y` are identical), then `x` must be equal to `y`. This theorem thus establishes a connection between the topological property of being a T0-space and the notion of inseparability of points in that space.

A topological space is T0 (Kolmogorov) if and only if inseparable points are equal.


theorem CategoryTheory.Limits.inl_eq_inr_of_epi_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Epi f],
      CategoryTheory.Limits.pushout.inl = CategoryTheory.Limits.pushout.inr :=
  by sorry

This theorem states that in any category `C`, for any objects `X` and `Y` in `C` and for any morphism `f` from `X` to `Y` that is an epimorphism (surjective), the first inclusion into the pushout of `f` and some morphism `g` is equal to the second inclusion into the pushout of `f` and `g`. In other words, if `f` is an epimorphism, then the pushout inclusions from `Y` and `Z` into the pushout of `f` and `g` are identical. This result is significant in category theory as it provides a condition under which the two different paths into a pushout coincide.

In any category, if a morphism is an epimorphism, then the first and second inclusions into the pushout are equal.


/-- The symmetric case of `iInf_and`, useful for rewriting into an infimum over a conjunction  -/
theorem iInf_and' :
    ∀ {α : Type u_1} [inst : CompleteLattice α] {p q : Prop} {s : p → q → α},
      ⨅ (h₁ : p), ⨅ (h₂ : q), s h₁ h₂ = ⨅ (h : p ∧ q), s ⋯ ⋯ :=
  by sorry

This theorem, `iInf_and'`, is about the concept of infimum in complete lattices. More specifically, it asserts that for any type `α` that is a complete lattice, and any propositions `p` and `q`, as well as any function `s` that takes proof of `p` and `q` to produce an instance of `α`, the infimum over `h₁ : p` and `h₂ : q`, i.e., all pairs of proofs of `p` and `q`, is equal to the infimum over `h : p ∧ q`, i.e., all proofs of the conjunction `p ∧ q`. This theorem is especially useful for rewriting expressions involving infimums over conjunctions.

In a complete lattice, the infimum of all pairs of proofs of `p` and `q` is equal to the infimum of all proofs of `p ∧ q`.


theorem Set.mulIndicator_eq_self :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {s : Set α} {f : α → M},
      Set.mulIndicator s f = f ↔ Function.mulSupport f ⊆ s :=
  by sorry

This theorem states that for any set `s` of type `α` and a function `f` from `α` to some type `M` equipped with a distinguished "one" element, the "multiplicative indicator function" of `s` and `f` is equal to `f` if and only if the "multiplicative support" of `f` is a subset of `s`. In mathematical terms, the "multiplicative indicator function" `Set.mulIndicator s f a` is defined to be `f(a)` if `a` is in `s`, and `1` otherwise. The "multiplicative support" `Function.mulSupport f` of a function `f` is the set of all points `x` such that `f(x)` is not equal to `1`. Hence, this theorem links the equality of a function to its multiplicative indicator function with the containment of its multiplicative support within a certain set.

For any set `s` and function `f` from type `α` to a type with a distinguished "one" element, the multiplicative indicator function of `s` and `f` equals `f` if and only if the multiplicative support of `f` is contained in `s`.


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

The theorem `div_lt_div_left` states that for any linear ordered semifield `α` and any three elements `a`, `b`, `c` of that field, if `a`, `b`, and `c` are all greater than zero, then the inequality `a / b < a / c` holds if and only if `c < b`. In other words, for positive numbers `a`, `b`, and `c`, `a` divided by `b` is less than `a` divided by `c` precisely when `c` is less than `b`.

Given a linear ordered semifield `α` and positive elements `a`, `b`, `c` in `α`, the inequality `a / b < a / c` holds if and only if `c < b`.


MeasureTheory.StronglyMeasurable.div

theorem MeasureTheory.StronglyMeasurable.div :
    ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Div β]
      [inst_2 : ContinuousDiv β],
      MeasureTheory.StronglyMeasurable f →
        MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable (f / g) :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.div` states that for any two functions `f` and `g` from a measurable space `α` to a topological space `β` that supports division and has continuous division, if both `f` and `g` are strongly measurable (meaning, each of them is the limit of a sequence of simple functions), then the function obtained by dividing `f` by `g` (i.e., `(f / g)`) is also strongly measurable.

If `f` and `g` are strongly measurable functions from a measurable space to a topological space supporting and having continuous division, then their quotient `f / g` is also strongly measurable.


theorem MeasureTheory.ofReal_integral_norm_eq_lintegral_nnnorm :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {P : Type u_7} [inst : NormedAddCommGroup P]
      {f : α → P}, MeasureTheory.Integrable f μ → ENNReal.ofReal (∫ (x : α), ‖f x‖ ∂μ) = ∫⁻ (x : α), ↑‖f x‖₊ ∂μ :=
  by sorry

This theorem states that for any measurable space `α`, any measure `μ` on `α`, any normed additively commutative group `P`, and any function `f` from `α` to `P` that is integrable with respect to `μ`, the extended non-negative real number obtained by applying the `ofReal` function to the integral (over `α`) of the norm of `f` is equal to the integral (over `α`) of the non-negative part of the norm of `f`. In other words, when you integrate the norm of `f` and then apply the `ofReal` function, it is the same as if you first apply the non-negative part function to the norm of `f` and then integrate.

For any measurable space `α`, measure `μ`, normed additively commutative group `P`, integrable function `f` from `α` to `P`, the integral of the norm of `f` with respect to `μ` equals the integral of the non-negative part of the norm of `f` with respect to `μ`, when considered as real numbers using `ofReal`.


theorem Complex.restrictScalars_one_smulRight :
    ∀ (x : ℂ), ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 x) = x • 1 := by sorry

This theorem states that for every complex number `x`, when we restrict the scalars from complex to real numbers in the continuous linear map that multiplies `x` on the right by 1 (represented as `ContinuousLinearMap.smulRight 1 x`), the result is equivalent to `x` being scaled by 1 (`x • 1`). The `ContinuousLinearMap.restrictScalars ℝ` part ensures that the computation only involves real numbers.

For every complex number x, the restriction of the continuous linear map that multiplies x on the right by 1 to real scalars is equivalent to scaling x by 1.


theorem Polynomial.natSepDegree_X_sub_C :
    ∀ {F : Type u} [inst : Field F] (x : F), Polynomial.natSepDegree (Polynomial.X - Polynomial.C x) = 1 := by sorry

The theorem `Polynomial.natSepDegree_X_sub_C` states that for any given field `F` and for any element `x` of this field, the separable degree of the polynomial `X - Cx` is equal to 1. Here, `X` is the polynomial variable and `Cx` is the constant polynomial `x`. The separable degree of a polynomial, denoted as `Polynomial.natSepDegree`, is defined as the number of distinct roots of the polynomial over its splitting field.

The separable degree of the polynomial `X - Cx` over any field `F` is equal to 1 for any constant `C` in `F`.


/-- The cosine of the angle between two vectors.  -/
theorem InnerProductGeometry.cos_angle :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      Real.cos (InnerProductGeometry.angle x y) = ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) :=
  by sorry

This theorem states that, in a real inner product space, the cosine of the angle between two vectors is equal to the inner product of the vectors divided by the product of their norms. Specifically, for any vectors `x` and `y` in a given space, the cosine of the angle between `x` and `y` equals the inner product of `x` and `y` divided by the product of the norms of `x` and `y`. This relates the geometric concept of angle between vectors to the algebraic operation of inner product and norms in the space.

In a real inner product space, the cosine of the angle between two vectors is equal to their inner product divided by the product of their norms.


theorem Mathlib.Data.Sum.Order._auxLemma.4 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a b : β}, (Sum.inr a < Sum.inr b) = (a < b) := by
  sorry

This theorem, named `Mathlib.Data.Sum.Order._auxLemma.4`, states that for any types `α` and `β` where `α` and `β` have a less-than (`<`) relation defined, the less-than relation between 'right' elements (`Sum.inr`) of the sum type is equivalent to the less-than relation between the elements themselves. Specifically, if `a` and `b` are elements of type `β`, then `Sum.inr a` is less than `Sum.inr b` if and only if `a` is less than `b`. This theorem essentially connects the comparison operation in the context of the sum type with the comparison operation in the original type.

For types `α` and `β` with a defined less-than relation, the less-than relation between `Sum.inr a` and `Sum.inr b` of type `Sum α β` holds if and only if `a` is less than `b` in type `β`.


theorem Mathlib.Data.Sum.Order._auxLemma.3 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a b : α}, (Sum.inl a < Sum.inl b) = (a < b) := by
  sorry

This theorem from the Mathlib library in Lean 4 states that for any types `α` and `β`, provided `α` and `β` have a less than (`<`) operation, and for any two elements `a` and `b` of type `α`, the inequality `Sum.inl a < Sum.inl b` (where `Sum.inl` constructs a sum type from the left component) is equivalent to `a < b`. Essentially, it says that comparing two elements in the sum type where both elements come from the left type is the same as just comparing the elements in the original type.

For any types `α` with a total order and any `a, b : α`, `Sum.inl a < Sum.inl b` if and only if `a < b`.


theorem Mathlib.Data.Sum.Order._auxLemma.8 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a : α} {b : β}, (Sum.inr b < Sum.inl a) = False := by
  sorry

This theorem states that for any types `α` and `β` that have defined "less than" (`<`) operations, and for any instances `a` of type `α` and `b` of type `β`, it is always false that `b` (wrapped in the `Sum.inr` constructor) is less than `a` (wrapped in the `Sum.inl` constructor). In other words, no right element of a sum type is less than any left element of the sum type.

For all types `α` and `β` with defined "<" operations, and for all `a : α` and `b : β`, `Sum.inr b < Sum.inl a` always holds false.


theorem Mathlib.Data.Sum.Order._auxLemma.6 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a : α} {b : β}, (Sum.inl b < Sum.inr a) = False := by
  sorry

This theorem from Mathlib, named `Mathlib.Data.Sum.Order._auxLemma.6`, states that for any two types `α` and `β` that have a less-than (`<`) relation defined on them, any value `b` of type `β` wrapped in a `Sum.inl` is not less than any value `a` of type `α` wrapped in a `Sum.inr`. In other words, no `Sum.inl b` can be less than `Sum.inr a` under any circumstances. This theorem is part of the formalization of order relations on sum types in Lean.

For any types `α` and `β` with a defined less-than relation, `Sum.inl b < Sum.inr a` does not hold for any `a : α` and `b : β`.


theorem Rat.toNNRat.proof_1 : ∀ (q : ℚ), 0 ≤ max q 0 := by sorry

This theorem states that for any rational number `q`, the maximum of `q` and `0` is always non-negative. This makes sense, as the maximum of a given rational number and zero would either be that rational number (if it is positive) or zero (if the rational number is negative or zero), both of which are non-negative numbers.


theorem Subalgebra.coe_iSup_of_directed :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {ι : Type u_1}
      [inst_3 : Nonempty ι] {K : ι → Subalgebra R A}, Directed (fun x x_1 => x ≤ x_1) K → ↑(iSup K) = ⋃ i, ↑(K i) :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `A`, algebra structure of `A` over `R`, index type `ι` (which is nonempty), and a family `K` of subalgebras of `A` over `R`, if the family `K` is directed with respect to the inclusion relation (meaning that for any two subalgebras in the family, there is another subalgebra in the family that contains both), then the supremum of the family `K` (considered as elements of the complete lattice of subsets of `A`) is equal to the union of the sets of elements of the subalgebras in the family `K`.

In other words, in this scenario, the supremum of a family of subalgebras is the subalgebra generated by the union of the subalgebras in the family.

If `K` is a directed family of subalgebras of a commutative semiring `A` over semiring `R`, then the supremum of `K` equals the subalgebra generated by the union of the sets of elements of subalgebras in `K`.


theorem List.lookmap_map_eq :
    ∀ {α : Type u} {β : Type v} (f : α → Option α) (g : α → β),
      (∀ (a b : α), b ∈ f a → g a = g b) → ∀ (l : List α), List.map g (List.lookmap f l) = List.map g l :=
  by sorry

This theorem states that for any types `α` and `β`, and any two functions `f : α → Option α` and `g : α → β`, if for every pair of `α` elements `a` and `b` such that `b` is in the option returned by `f(a)`, `g(a)` equals `g(b)`, then for any list `l` of elements of type `α`, the result of applying `g` to each element of the list obtained by applying `lookmap` with `f` to `l` is equal to the result of directly applying `g` to each element of `l`. Essentially, this theorem asserts the preservation of the mapping `g` on a list even after a `lookmap` operation with `f` on the list, under certain conditions on `f` and `g`.

If `f : α -> Option α` and `g : α -> β` are functions such that `g(a) = g(b)` whenever `b` is in the option returned by `f(a)`, then `map (lookmap f) l = map g l`.


theorem Set.mem_sUnion_of_mem : ∀ {α : Type u_1} {x : α} {t : Set α} {S : Set (Set α)}, x ∈ t → t ∈ S → x ∈ ⋃₀ S := by
  sorry

The theorem `Set.mem_sUnion_of_mem` states that for any type `α`, any element `x` of type `α`, and any two sets `t` and `S` of type `α` and set of sets of type `α` respectively, if `x` is an element of `t` and `t` is an element of `S`, then `x` is an element of the union of sets in `S`. In mathematical notation, this can be written as: if $x \in t$ and $t \in S$, then $x \in \bigcup S$. This theorem is essentially stating a property of unions of sets: an element belongs to the union of a collection of sets if and only if it belongs to at least one of the sets in the collection.

If a set `t` contains an element `x` and `t` is an element of a set `S` of sets, then `x` is in the union of sets in `S`. In mathematical notation: `x ∈ t` and `t ∈ S` imply `x ∈ ⋃ S`.


theorem Array.map_data :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (arr : Array α), (Array.map f arr).data = List.map f arr.data := by
  sorry

The theorem `Array.map_data` states that for any function `f` that maps an element of type `α` to an element of type `β`, and for any array `arr` of type `α`, the data of the array obtained by mapping `f` over `arr` is the same as the list obtained by mapping `f` over the data of `arr`. In other words, mapping a function over an array, and then converting it to a list, gives the same result as first converting the array to a list and then mapping the function over the list.

For any function `f` and array `arr` of type `α`, the data of the array obtained by mapping `f` is equal to the list obtained by mapping `f` to the list obtained from the array's data. In Lean notation, `(Array.map f arr) = List.map f (Array.toList arr)`.


theorem FreeAlgebra.lift_symm_apply :
    ∀ (R : Type u_1) [inst : CommSemiring R] {X : Type u_2} {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      (F : FreeAlgebra R X →ₐ[R] A), (FreeAlgebra.lift R).symm F = ⇑F ∘ FreeAlgebra.ι R :=
  by sorry

The theorem `FreeAlgebra.lift_symm_apply` states that for any commutative semiring `R`, any type `X`, an `R`-algebra `A`, and any `R`-algebra homomorphism `F` from the free algebra over `X` and `R` to `A`, the inverse of the lift of `F` (obtained via the `FreeAlgebra.lift R` function) is equal to the composition of `F` and the canonical function `FreeAlgebra.ι R` from `X` to the free algebra over `X` and `R`. In other words, it expresses a relationship between the lift of an algebra homomorphism and the canonical function into a free algebra.

For any commutative semiring `R`, type `X`, `R`-algebra `A`, and `R`-algebra homomorphism `F` from the free algebra over `X` and `R` to `A`, the inverse of `FreeAlgebra.lift R F` is equal to `FreeAlgebra.ι R` composed with `F`.


theorem Nat.pow_le_of_le_log : ∀ {b x y : ℕ}, y ≠ 0 → x ≤ Nat.log b y → b ^ x ≤ y := by sorry

The theorem `Nat.pow_le_of_le_log` states that for any natural numbers `b`, `x`, and `y`, if `y` is not equal to zero and `x` is less than or equal to the logarithm of `y` in base `b` (i.e., `x ≤ Nat.log b y`), then `b` raised to the power `x` is less than or equal to `y` (i.e., `b ^ x ≤ y`). In mathematical terms, for $b, x, y \in \mathbb{N}$ with $y \neq 0$ and $x \leq \log_b y$, we have $b^x \leq y$.

For any natural numbers $b$, $x$, and $y$ with $y \neq 0$ and $x \leq \log_b y$, we have $b^x \leq y$.


theorem Multiset.dvd_gcd :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Multiset α} {a : α},
      a ∣ Multiset.gcd s ↔ ∀ b ∈ s, a ∣ b :=
  by sorry

This theorem states that for any type `α` that is a cancellative commutative monoid with zero and a normalized greatest common divisor (GCD) monoid, a member `a` of this type, and a multiset `s` of elements of this type, `a` divides the GCD of `s` if and only if `a` divides every element `b` in `s`. A cancellative commutative monoid with zero is a mathematical structure where addition and multiplication are defined, multiplication is commutative, there is a zero element, and cancellation law holds for multiplication. A normalized GCD monoid is a monoid where every element has a greatest common divisor and each greatest common divisor can be normalized (its unit factor is removed). This theorem essentially connects the property of one element dividing the GCD of a set to the property of that element dividing each element of the set.

For any cancellative commutative monoid with zero and normalized GCD, an element divides the GCD of a set if and only if it divides every element in the set.