List.Subperm.trans

theorem List.Subperm.trans :
    ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, List.Subperm l₁ l₂ → List.Subperm l₂ l₃ → List.Subperm l₁ l₃ := by sorry

The theorem `List.Subperm.trans` states that for any type `α` and any three lists `l₁`, `l₂`, and `l₃` of that type, if `l₁` is a subpermutation of `l₂` and `l₂` is a subpermutation of `l₃`, then `l₁` is a subpermutation of `l₃`. The relation "subpermutation" (`List.Subperm`) in this context refers to `l₁` being a sublist of a permutation of `l₂`. This theorem is essentially stating the transitivity of the subpermutation relation for lists.

If `l₁` is a subpermutation of `l₂` and `l₂` is a subpermutation of `l₃`, then `l₁` is a subpermutation of `l₃`.


Seminorm.ext

theorem Seminorm.ext :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E]
      {p q : Seminorm 𝕜 E}, (∀ (x : E), p x = q x) → p = q :=
  by sorry

This theorem states that given any two seminorms `p` and `q` on a vector space `E` over a seminormed ring `𝕜`, if for every `x` in `E`, `p(x)` equals `q(x)`, then `p` and `q` are the same seminorm. The essential idea is that two seminorms are identical if they assign the same seminorm value to every vector in the space.

If two seminorms on a vector space over a seminormed ring assign the same value to every vector, then they are equal.


theorem smooth_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {c : M'}, Smooth I I' fun x => c :=
  by sorry

The theorem `smooth_const` states that for any non-trivial normed field `𝕜`, normed additive commutative group structures `E` and `E'`, normed spaces over `𝕜` for `E` and `E'`, topological spaces `H`, `M`, `H'`, and `M'`, a manifold `M` with corners `I` modeled on `(E, H)`, a manifold `M'` with corners `I'` modeled on `(E', H')`, and a constant value `c` in `M'`, the function that maps every point in `M` to the constant `c` is a smooth function from `M` to `M'`. In other words, the theorem says that constant functions are smooth.

Given normed fields `𝕜`, normed spaces `E` and `E'`, and manifolds `M` modeled on `(E, H)` and `M'` modeled on `(E', H')`, the constant function from `M` to `M'` is smooth.


theorem MvPolynomial.eval₂Hom_C :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (g : σ → S₁) (r : R), (MvPolynomial.eval₂Hom f g) (MvPolynomial.C r) = f r :=
  by sorry

The theorem `MvPolynomial.eval₂Hom_C` states that for any types `R`, `S₁`, and `σ`, and for any commutative semirings `R` and `S₁`, given a ring homomorphism `f: R →+* S₁`, a function `g: σ → S₁`, and an element `r` of `R`, the evaluation of the constant polynomial `MvPolynomial.C r` under the homomorphism `MvPolynomial.eval₂Hom f g` is equal to the evaluation of `r` under `f`. In other words, the homomorphism `MvPolynomial.eval₂Hom f g` preserves the evaluation of constant polynomials.

For any commutative semirings R and S₁, ring homomorphism f : R →+* S₁, function g : σ → S₁, and element r in R, we have MvPolynomial.eval₂Hom f g (MvPolynomial.C r) = f r.


theorem ENNReal.coe_zero : ↑0 = 0 := by sorry

This theorem is stating that the coercion of zero from the extended non-negative reals (denoted by `ENNReal` in Lean) to some other type is equal to zero. In other words, when zero is considered as an element of the extended non-negative reals, and then translated ("coerced") into another type, it remains zero.

The theorem asserts that the coercion of the real number zero from the extended non-negative reals to any other type equals zero.


CategoryTheory.Endofunctor.Algebra.ext

theorem CategoryTheory.Endofunctor.Algebra.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
      {A B : CategoryTheory.Endofunctor.Algebra F} {f g : A ⟶ B}, autoParam (f.f = g.f) _auto✝ → f = g :=
  by sorry

The theorem `CategoryTheory.Endofunctor.Algebra.ext` states that if `C` is a type and a category, `F` is a functor from `C` to `C`, `A` and `B` are algebras of the endofunctor `F`, and `f` and `g` are morphisms from `A` to `B`, then if the underlying functions of `f` and `g` (denoted `f.f` and `g.f`) are equal (a condition which is automatically checked by the `autoParam` gadget), then `f` and `g` are equal as morphisms in the category.

If `C` is a category, `F` is a functor from `C` to `C`, `A` and `B` are algebras of the endofunctor `F`, `f` and `g` are morphisms from `A` to `B` with equal underlying functions, then `f` and `g` are equal as morphisms in `C`.


theorem Int.sub_eq_add_neg : ∀ {a b : ℤ}, a - b = a + -b := by sorry

This theorem states that for any two integers `a` and `b`, the operation of subtracting `b` from `a` is equivalent to the operation of adding the additive inverse of `b` to `a`. In other words, `a - b` is the same as `a + -b`. This is a fundamental property of integer arithmetic and can be extended to any ring, not just the integers.

For all integers `a` and `b`, `a - b` is equal to `a + (-b)`.


theorem MeasureTheory.map_mul_right_eq_self :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Mul G] (μ : MeasureTheory.Measure G)
      [inst_2 : MeasureTheory.Measure.IsMulRightInvariant μ] (g : G),
      MeasureTheory.Measure.map (fun x => x * g) μ = μ :=
  by sorry

The theorem `MeasureTheory.map_mul_right_eq_self` states that for every type `G` equipped with a measurable space structure and a multiplication operation, every measure `μ` on that type which is right multiplication invariant, and every element `g` of the type `G`, the pushforward of the measure `μ` by the function `(fun x => x * g)` (which multiplies every element by `g` on the right) is equal to the original measure `μ`. This is saying that, intuitively, the measure of sets doesn't change if we multiply each element in the set by a fixed element on the right.

For any measurable space `(G, Σ, μ)` and measurable function `x ↦ x * g` on `G`, if `μ` is right multiplication invariant, then `μ = ∫(x ↦ μ(dx)) * g`.


Algebra.gc

theorem Algebra.gc :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
      GaloisConnection (Algebra.adjoin R) SetLike.coe :=
  by sorry

This theorem, `Algebra.gc`, states that for any commutative semiring `R` and any semiring `A` where `A` is an algebra over `R`, a Galois connection exists between the function `Algebra.adjoin R` and `SetLike.coe`.

In other words, for any subset `s` in `A` and any subalgebra `a` in `A`, the property that `s` is contained in the set of the subalgebra `a` is equivalent to the property that the subalgebra generated by `s` is contained or equal to `a`.

For any commutative semiring `R` and its algebra `A`, there exists a Galois connection between the inclusion of subsets in `A` and the subalgebras of `A`, relating subset containment to subalgebra inclusion.


theorem Polynomial.monomial_mul_monomial :
    ∀ {R : Type u} [inst : Semiring R] (n m : ℕ) (r s : R),
      (Polynomial.monomial n) r * (Polynomial.monomial m) s = (Polynomial.monomial (n + m)) (r * s) :=
  by sorry

The theorem `Polynomial.monomial_mul_monomial` states that for any arbitrary type `R` equipped with a semiring structure, and for any two natural numbers `n` and `m` and any two elements `r` and `s` of `R`, the product of the monomial `r * X^n` and the monomial `s * X^m` equals the monomial `(r * s) * X^(n + m)`. In mathematical terms, it states that `(r * X^n) * (s * X^m) = (r * s) * X^(n + m)`. This theorem essentially describes the multiplicative behavior of monomials in a polynomial over a semiring.

For any semiring `R` and natural numbers `n` and `m`, the product of monomials `r * X^n` and `s * X^m` equals `(r * s) * X^(n + m)`.


theorem and_iff_left_of_imp : ∀ {a b : Prop}, (a → b) → (a ∧ b ↔ a) := by sorry

This theorem states that for any two propositions `a` and `b`, if `a` implies `b` (written as `a → b`), then `a ∧ b` is logically equivalent to `a`. In other words, if `a` being true always leads to `b` being true, then the statement "`a` and `b` are both true" is the same as just "`a` is true".

If `a` implies `b`, then `a ∧ b` is logically equivalent to `a`. (Or, `a → b` implies `a ∧ b ≡ a`.)


theorem AffineMap.lineMap_apply_module :
    ∀ {k : Type u_1} {V1 : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1] (p₀ p₁ : V1)
      (c : k), (AffineMap.lineMap p₀ p₁) c = (1 - c) • p₀ + c • p₁ :=
  by sorry

The theorem `AffineMap.lineMap_apply_module` states that for any ring `k`, an additive commutative group `V1`, a module `k V1`, two points `p₀` and `p₁` in `V1`, and any scalar `c` in `k`, applying the affine map `lineMap` defined from `k` to `P1` with `p₀` and `p₁` to `c` gives the result `(1 - c) • p₀ + c • p₁`. In other words, the output of `lineMap` for a scalar input interpolates linearly between `p₀` and `p₁` according to the scalar.

For any ring `k`, additive commutative group `V1`, module `k V1`, points `p₀, p₁ ∈ V1`, and scalar `c ∈ k`, the application of the affine map `lineMap` on `k V1` defined by `p₀` and `p₁` to the scalar `c` equals `(1 - c) • p₀ + c • p₁`.


theorem Mathlib.CategoryTheory.Iso._auxLemma.3 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
      {f : X ⟶ Z} {g : Y ⟶ Z},
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f = g) =
        (f = CategoryTheory.CategoryStruct.comp α g) :=
  by sorry

This theorem states that within a category `C` with objects `X`, `Y`, and `Z`, given an isomorphic morphism `α` from `X` to `Y`, and two morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the composition of the inverse of `α` and `f` is equal to `g` if and only if `f` is equal to the composition of `α` and `g`. In other words, it captures a form of commutativity of composition with respect to an isomorphism and its inverse in category theory.

Given an isomorphism α : X ↔ Y and morphisms f : X -> Z and g : Y -> Z in a category C, f ∘ α^(-1) = g if and only if f = α ∘ g.


theorem Mathlib.CategoryTheory.Iso._auxLemma.8 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ≅ Y) (g g' : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.comp f.hom g') = (g = g') :=
  by sorry

This theorem, "Mathlib.CategoryTheory.Iso._auxLemma.8", asserts that in any mathematical category 'C', for any three objects 'X', 'Y', and 'Z', and for any isomorphism 'f' from 'X' to 'Y' and any two morphisms 'g' and 'g'' from 'Y' to 'Z', the composition of the isomorphism 'f' with the morphisms 'g' and 'g'' are equal if and only if the two morphisms 'g' and 'g'' are themselves equal. This condition essentially says that the isomorphism 'f' preserves the equality of morphisms from 'Y' to 'Z'.

In any category, if two morphisms from an object to another have equal compositions with an isomorphism, then they are equal.


theorem List.get.proof_2 :
    ∀ {α : Type u_1} (head : α) (as : List α) (i : ℕ),
      Nat.succ i < List.length (head :: as) → Nat.succ i ≤ List.length as :=
  by sorry

This theorem states that for any type `α`, any list of `α` named `as`, any element of `α` named `head`, and any natural number `i`, if `i+1` is less than the length of the list created by prepending `head` to `as`, then `i+1` is less than or equal to the length of the list `as`. Roughly speaking, this says that if some index `i+1` is a valid index for a list `head :: as`, then `i+1` will also be a valid index or just one more than the length of the list `as`.

For any list `as : α :: list α` and natural number `i`, if `length (cons α as) > i + 1`, then `length as <= i + 1`.


OreLocalization.ind

theorem OreLocalization.ind :
    ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
      {β : OreLocalization R S → Prop}, (∀ (r : R) (s : ↥S), β (r /ₒ s)) → ∀ (q : OreLocalization R S), β q :=
  by sorry

This theorem, `OreLocalization.ind`, is a principle of induction for the Ore localization of a monoid and a submonoid fulfilling the Ore condition. It states that for any type `R` equipped with a `Monoid` structure, and any submonoid `S` of `R` that fulfills the Ore condition, if a property `β` holds for all elements of the form `r /ₒ s` (where `r` is an element of `R` and `s` is an element of `S`), then this property `β` holds for all elements of the Ore localization of `R` and `S`. Essentially, it allows us to make deductions about all elements of the Ore localization based on the behavior of a subset of elements.

If a property holds for all elements of the form r / s (r ∈ R, s ∈ S, where S is an Ore submonoid of the monoid R), then it holds for all elements in the Ore localization of R and S.


theorem CategoryTheory.ShortComplex.Exact.hasHomology :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.Exact S → CategoryTheory.ShortComplex.HasHomology S :=
  by sorry

This theorem states that for any type `C` that has a category structure (as specified by `CategoryTheory.Category`) and zero morphisms (as specified by `CategoryTheory.Limits.HasZeroMorphisms`), and for any short complex `S` of that category, if `S` is an exact sequence (as denoted by `CategoryTheory.ShortComplex.Exact S`), then `S` has homology (as denoted by `CategoryTheory.ShortComplex.HasHomology S`). In mathematical terms, this theorem is confirming the fundamental property of exact sequences in category theory, which ensures that the homology of any exact sequence is well defined.

Any short exact sequence in a category with zero morphisms has well-defined homology.


theorem Polynomial.X_pow_eq_monomial :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ), Polynomial.X ^ n = (Polynomial.monomial n) 1 := by sorry

This theorem states that for any semiring `R` and for any natural number `n`, the `n`-th power of the polynomial variable `X` is equal to the monomial `1 * X^n`. In other words, raising the polynomial variable `X` to the power of `n` creates a monomial where the coefficient is `1` and the exponent is `n`. This is valid in the context of any semiring, a mathematical structure that includes operations of addition and multiplication.

For any semiring `R` and natural number `n`, the `n`-th power of the polynomial variable `X` equals the monomial `1 * X^n`.


/-- The definition of `cyclotomic n R` commutes with any ring homomorphism.  -/
theorem Polynomial.map_cyclotomic :
    ∀ (n : ℕ) {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S),
      Polynomial.map f (Polynomial.cyclotomic n R) = Polynomial.cyclotomic n S :=
  by sorry

This theorem states that the definition of the `n`-th cyclotomic polynomial over a ring `R`, denoted as `Polynomial.cyclotomic n R`, is compatible with any ring homomorphism. Specifically, if we have a ring homomorphism `f` from `R` to another ring `S`, then mapping the `n`-th cyclotomic polynomial over `R` using `f` (i.e., `Polynomial.map f (Polynomial.cyclotomic n R)`) is the same as directly computing the `n`-th cyclotomic polynomial over `S` (i.e., `Polynomial.cyclotomic n S`).

The `n`-th cyclotomic polynomial over a ring `R` is mapped to the `n`-th cyclotomic polynomial over another ring `S` under any ring homomorphism `f` from `R` to `S`, i.e., `Polynomial.map f (Polynomial.cyclotomic n R) = Polynomial.cyclotomic n S`.


theorem LazyList.cons.sizeOf_spec :
    ∀ {α : Type u} [inst : SizeOf α] (hd : α) (tl : Thunk (LazyList α)),
      sizeOf (LazyList.cons hd tl) = 1 + sizeOf hd + sizeOf tl :=
  by sorry

This theorem is about the size of a lazy list in Lean 4, which is a type of list where the tail is computed on demand. Specifically, it states that for any type `α` that has a defined `SizeOf` instance (which gives the size of an object of that type), and for any head element `hd` of type `α` and tail `tl` of type `Thunk (LazyList α)`, the size of the lazy list constructed with `LazyList.cons hd tl` is equal to `1` (for the cons cell itself) plus the size of the head element `hd` plus the size of the tail `tl`.

The size of a lazy list `LazyList.cons hd tl` in Lean 4, where `hd` is of type `α` with a defined `SizeOf` instance and `tl` is of type `Thunk (LazyList α)`, is equal to 1 + `SizeOf hd` + `SizeOf tl`.


theorem csSup_empty : ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α], sSup ∅ = ⊥ := by sorry

This theorem states that, for any type `α` that is a conditionally complete linear order with a least element (denoted as `⊥`), the supremum (least upper bound) of an empty set is equal to this least element `⊥`. This is a property of order theory: the supremum of an empty set is the smallest possible element in the set's underlying order.

For any conditionally complete linear order `α` with least element `⊥`, the supremum of an empty set equals `⊥`.


theorem Finset.not_mem_singleton : ∀ {α : Type u_1} {a b : α}, a ∉ {b} ↔ a ≠ b := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of type `α`, `a` is not a member of the singleton set containing only `b` if and only if `a` is not equal to `b`. In other words, an element `a` is not in the one-element set `{b}` precisely when `a` is different from `b`.

For any type `α` and elements `a, b : α`, `a ∉ {b} ↔ a ≠ b`.


theorem measurable_smul_const :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {𝕜 : Type u_2} [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : CompleteSpace 𝕜] [inst_3 : MeasurableSpace 𝕜] [inst_4 : BorelSpace 𝕜] {E : Type u_3}
      [inst_5 : NormedAddCommGroup E] [inst_6 : NormedSpace 𝕜 E] [inst_7 : MeasurableSpace E] [inst_8 : BorelSpace E]
      {f : α → 𝕜} {c : E}, c ≠ 0 → ((Measurable fun x => f x • c) ↔ Measurable f) :=
  by sorry

The theorem `measurable_smul_const` states that for any two types `α` and `𝕜`, where `α` is a measurable space and `𝕜` is a non-trivially normed field with complete space, borel space, and measurable properties; for any type `E` which is a normed add commutative group, a normed space over `𝕜`, and also a borel and measurable space; for any function `f : α → 𝕜` and any constant `c : E` which is not equal to zero, the function `f` multiplied by the constant `c` (denoted as `f x • c`) is measurable if and only if `f` itself is measurable.

In mathematical terms, it essentially says that for a non-zero constant, the measurability of a scalar multiplication of a function is equivalent to the measurability of the function itself.

For any measurable function between measurable spaces and a non-trivially normed field with complete space, borel space, and measurable properties, the scalar multiplication of the function by a non-zero constant is measurable if and only if the function itself is measurable.


theorem AddMonoidAlgebra.single_mul_single :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Add G] {a₁ a₂ : G} {b₁ b₂ : k},
      AddMonoidAlgebra.single a₁ b₁ * AddMonoidAlgebra.single a₂ b₂ = AddMonoidAlgebra.single (a₁ + a₂) (b₁ * b₂) :=
  by sorry

The theorem `AddMonoidAlgebra.single_mul_single` states that for any types `k` and `G`, where `k` is a semiring and `G` is an additive monoid, and for any elements `a₁, a₂` in `G` and `b₁, b₂` in `k`, the product of two `AddMonoidAlgebra.single` functions, `AddMonoidAlgebra.single a₁ b₁` and `AddMonoidAlgebra.single a₂ b₂`, is equal to `AddMonoidAlgebra.single (a₁ + a₂) (b₁ * b₂)`. In other words, it asserts a distributive property of the `single` function in the context of the `AddMonoidAlgebra`: the multiplication of `single` functions distributes over the addition in the underlying `G` monoid and the multiplication in the semiring `k`.

For any semiring `k` and additive monoid `G`, the product of two `AddMonoidAlgebra.single` functions, `AddMonoidAlgebra.single a₁ b₁` and `AddMonoidAlgebra.single a₂ b₂`, equals `AddMonoidAlgebra.single (a₁ + a₂) (b₁ * b₂)`.


SemidirectProduct.ext

theorem SemidirectProduct.ext :
    ∀ {N : Type u_1} {G : Type u_2} {inst : Group N} {inst_1 : Group G} {φ : G →* MulAut N} (x y : N ⋊[φ] G),
      x.left = y.left → x.right = y.right → x = y :=
  by sorry

This theorem, `SemidirectProduct.ext`, states that for any two elements `x` and `y` in the semidirect product `N ⋊[φ] G` of two groups `N` and `G`, if the left components and the right components of `x` and `y` are equal then `x` and `y` are equal. Here, `N` and `G` are types with group structures, and `φ` is a homomorphism from `G` to the group of multiplicative automorphisms of `N`. The semidirect product `N ⋊[φ] G` typically encodes a nontrivial interaction between `N` and `G` mediated by the homomorphism `φ`.

In the semidirect product of groups `N ⋊[φ] G`, if `x` and `y` have equal left components and equal right components, then `x` and `y` are equal.


theorem contDiffAt_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      {n : ℕ∞} {c : F}, ContDiffAt 𝕜 n (fun x => c) x :=
  by sorry

This theorem, `contDiffAt_const`, states that for any nontrivially normed field `𝕜`, normed additive commutative group `E` that forms a normed space over `𝕜`, another normed additive commutative group `F` that also forms a normed space over `𝕜`, any element `x` of `E`, any natural number or infinity `n`, and any element `c` of `F`, the function that maps every element to `c` (i.e., a constant function) is continuously differentiable at the point `x` at the level `n`.

For any normed fields `𝕜`, normed additive commutative groups `E` and `F`, and a constant function `f : E → F` with `f(x) = c` for all `x ∈ E`, the function `f` is continuously differentiable at `x ∈ E` for any `x ∈ E` and any natural number or infinity `n` in the sense of `𝕜`-normed spaces.


theorem tendstoUniformlyOn_iff_tendstoUniformlyOnFilter :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι}, TendstoUniformlyOn F f p s ↔ TendstoUniformlyOnFilter F f p (Filter.principal s) :=
  by sorry

This theorem states that for any type `α`, `β`, and `ι`, with `β` having a uniform space structure, any sequence of functions `F` from `ι` to `α → β`, a function `f` from `α` to `β`, a set `s` of type `α`, and a filter `p` over `ι`, the condition that `F` converges uniformly to `f` on `s` with respect to `p` is equivalent to the condition that `F` converges uniformly to `f` on the principal filter of `s` with respect to `p`. In other words, uniform convergence of a sequence of functions on a set is the same as uniform convergence on the principal filter of that set.

For any type `α`, `β`, and `ι`, with `β` having a uniform space structure, the sequence of functions `F` from `ι` to `α → β` converges uniformly to `f` on a set `s` of type `α` with respect to filter `p` over `ι` if and only if it converges uniformly on the principal filter of `s` with respect to `p`.


theorem WittVector.zero_coeff :
    ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R] (n : ℕ), 0.coeff n = 0 := by sorry

The theorem `WittVector.zero_coeff` states that for every natural number `p`, a mathematical object of type `R` (where `R` is a commutative ring), and another natural number `n`, if `p` is a prime number, then the `n`-th coefficient of the zero Witt vector is zero. In other words, this theorem tells us that the coefficients of the zero vector in the Witt vector space over a commutative ring are all zeroes, regardless of the prime number used to define the Witt vector space.

For every prime number `p` and commutative ring `R`, the `n`-th coefficient of the zero Witt vector over `R` is zero.


theorem Finsupp.erase_same :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {a : α} {f : α →₀ M}, (Finsupp.erase a f) a = 0 := by sorry

The theorem `Finsupp.erase_same` asserts that for any type `α`, for any type `M` equipped with a zero element, for any element `a` of type `α`, and any finitely supported function `f` from `α` to `M`, applying the function `Finsupp.erase a f` to the argument `a` will yield the zero element of `M`. In other words, if we erase the value at `a` in `f`, we get zero when we look up `a`.

For any type `α` and type `M` with zero element, given an element `a` of type `α` and a finitely supported function `f` from `α` to `M`, `Finsupp.erase a f a = 0`.


theorem Filter.map₂_pure_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {g : Filter β} {a : α},
      Filter.map₂ m (pure a) g = Filter.map (m a) g :=
  by sorry

The theorem `Filter.map₂_pure_left` states that for any types `α`, `β`, `γ`, any binary function `m` from `α` and `β` to `γ`, any filter `g` of type `β` and any element `a` of type `α`, the image of the binary function `m` on the filter `pure a` (a filter that contains only `a`) and the filter `g` is the same as the image of the function `m a` (a function from `β` to `γ` obtained by fixing the first argument of `m` to `a`) on the filter `g`. In mathematical terms, this is saying that mapping a binary function over a singleton set and a filter is equivalent to mapping a unary function over the filter.

For any binary function `m` and filter `g`, the image of `m` on the filter `pure a` and `g` is equal to the application of the unary function `x ↦ m a x` to `g`.


theorem Nat.card_Ico : ∀ (a b : ℕ), (Finset.Ico a b).card = b - a := by sorry

This theorem states that for any two natural numbers `a` and `b`, the cardinality (or the number of elements) of the finite set `Finset.Ico a b` is equal to the difference `b - a`. Here, `Finset.Ico a b` represents the finite set of natural numbers `x` such that `a ≤ x` and `x < b`.

The cardinality of the finite set `{x | x is nat, a ≤ x < b}` is equal to `b - a`.


theorem Finsupp.equivMapDomain_eq_mapDomain :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_13} [inst : AddCommMonoid M] (f : α ≃ β) (l : α →₀ M),
      Finsupp.equivMapDomain f l = Finsupp.mapDomain (⇑f) l :=
  by sorry

This theorem establishes the equality between two methods of mapping the domain of a finitely supported function. Given a bijection `f` between types `α` and `β`, and a finitely supported function `l` from `α` to a monoidal type `M`, the theorem states that `Finsupp.equivMapDomain f l`, which applies the bijection to the support of `l` and the inverse of the bijection to the function values, is equal to `Finsupp.mapDomain (⇑f) l`, which replaces each input of `l` with its image under `f` and sums the results for each `β`.

Given a finitely supported function `l` from type `α` to a monoidal type `M`, a bijection `f` between `α` and `β`, the theorem states that `Finsupp.equivMapDomain f l` equals `Finsupp.mapDomain (f.continuous_apply l)`.


AffineEquiv.ext

theorem AffineEquiv.ext :
    ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] {e e' : P₁ ≃ᵃ[k] P₂}, (∀ (x : P₁), e x = e' x) → e = e' :=
  by sorry

The theorem `AffineEquiv.ext` states that given any ring `k`, types `P₁`, `P₂`, `V₁`, `V₂` representing points and vectors in affine spaces, and instances asserting that `V₁` and `V₂` are additive commutative groups and `k`-modules, and that they act on `P₁` and `P₂` via an operation that satisfies the properties of an additive torsor, then for any two affine equivalences `e` and `e'` from `P₁` to `P₂`, if for every point in `P₁`, `e` and `e'` map it to the same point in `P₂`, then `e` is equal to `e'`. Basically, it's saying that two affine transformations are equal if they map every point to the same point in the target space.

Given affine spaces `P₁` and `P₂` over a ring `k`, if `V₁` and `V₂` are additive commutative groups and `k`-modules acting on `P₁` and `P₂`, and if `e` and `e'` are affine equivalences from `P₁` to `P₂` such that `e(x) = e'(x)` for all `x` in `P₁`, then `e = e'`.


theorem Rat.add_def'' :
    ∀ {a b c d : ℤ}, b ≠ 0 → d ≠ 0 → Rat.divInt a b + Rat.divInt c d = Rat.divInt (a * d + c * b) (b * d) := by sorry

The theorem `Rat.add_def''` states that for any four integers `a`, `b`, `c`, and `d`, where both `b` and `d` are non-zero, the sum of the rational numbers `a / b` and `c / d` (which are represented as `Rat.divInt a b` and `Rat.divInt c d` in Lean 4) is equal to the rational number `(a * d + c * b) / (b * d)`. In other words, the theorem is a formalization of the standard rule for adding fractions, where the numerator is the sum of the cross-products, and the denominator is the product of the denominators.

For integers a, b, c, and d with b and d non-zero, (a/b + c/d) = ((a*d + b*c) / (b*d)).


theorem Finset.image₂_empty_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α},
      Finset.image₂ f s ∅ = ∅ :=
  by sorry

The theorem `Finset.image₂_empty_right` states that for all types `α`, `β`, and `γ` such that `γ` has decidable equality, and for any binary function `f` from `α` and `β` to `γ` and any finite set `s` of type `α`, the image of the binary function `f` applied to the finite set `s` and an empty set of type `β` is an empty set. In mathematical terms, given a function $f: \alpha \times \beta \rightarrow \gamma$ and a finite set $s \subseteq \alpha$, if we take the image of $f$ over the Cartesian product of $s$ with an empty set, we get an empty set.

For any function $f: \alpha \times \beta \rightarrow \gamma$ with decidable equality on $\gamma$, and any finite set $s \subseteq \alpha$, the image of $f$ applied to the Cartesian product of $s$ and the empty set of $\beta$ is the empty set of $\gamma$.


theorem Asymptotics.IsLittleO.trans_isBigO :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} {G' : Type u_8} [inst : Norm E] [inst_1 : Norm F]
      [inst_2 : SeminormedAddCommGroup G'] {l : Filter α} {f : α → E} {g : α → F} {k : α → G'},
      f =o[l] g → g =O[l] k → f =o[l] k :=
  by sorry

This theorem, `Asymptotics.IsLittleO.trans_isBigO`, states that for any types `α`, `E`, `F`, and `G'`, where `E` and `F` have a norm and `G'` is a semi-normed additive commutative group, and given a filter `l` and functions `f`, `g`, `k` from `α` to `E`, `F`, `G'` respectively, if `f` is little-o of `g` at `l` and `g` is big-O of `k` at `l`, then `f` is little-o of `k` at `l`. In terms of asymptotic notation, if $f(x)$ is $o(g(x))$ and $g(x)$ is $O(k(x))$ as $x$ approaches a point in the limit `l`, then $f(x)$ is $o(k(x))$.

If $f(x) = o(g(x))$ and $g(x) = O(k(x))$ as $x$ approaches $l$, then $f(x) = o(k(x))$.


theorem Polynomial.leadingCoeff_mul' :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.leadingCoeff p * Polynomial.leadingCoeff q ≠ 0 →
        Polynomial.leadingCoeff (p * q) = Polynomial.leadingCoeff p * Polynomial.leadingCoeff q :=
  by sorry

The theorem `Polynomial.leadingCoeff_mul'` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the product of the leading coefficients of `p` and `q` is nonzero, then the leading coefficient of the product polynomial `p * q` is equal to the product of the leading coefficients of `p` and `q`. In other words, if neither of the polynomials `p` and `q` is the zero polynomial (as indicated by their leading coefficients being nonzero), then when we multiply these two polynomials, the leading coefficient of the resulting polynomial will be the product of the leading coefficients of `p` and `q`.

If `R` is a semiring and `p` and `q` are polynomials over `R` with nonzero leading coefficients, then the leading coefficient of `p * q` is equal to the product of the leading coefficients of `p` and `q`.


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

This theorem, `dvd_mul_of_dvd_right`, states that for any commutative semigroup of type α, if a number `a` divides another number `b`, then `a` also divides the product of `b` and any other number `c`. In mathematical terms, if `a ∣ b` then `a ∣ c * b`, for all `c` in the semigroup. The commutative semigroup property ensures that the multiplication operation is both associative and commutative.

If `a` divides `b` in a commutative semigroup, then `a` divides the product `b * c` for all `c` in the semigroup.


theorem le_of_tendsto' :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : ClosedIicTopology α]
      {f : β → α} {a b : α} {x : Filter β} [inst_3 : Filter.NeBot x],
      Filter.Tendsto f x (nhds a) → (∀ (c : β), f c ≤ b) → a ≤ b :=
  by sorry

The theorem `le_of_tendsto'` asserts that, for any given types `α` and `β`, where `α` is a topological space with a pre-order relation and a closed interval (`-∞, c]`) topology, and `f` is a function mapping elements of `β` to `α`, if the function `f` tends to a value `a` (i.e., as elements from the filter `x` get closer to `a`, the images under `f` get closer to `a`), and if for every `c` in `β`, `f(c)` is less than or equal to `b`, then `a` is less than or equal to `b`. Here, the filter `x` is assumed to not be the "bottom" filter, a filter that contains no sets.

If a function from a pre-ordered topological space to another space, with the property that for every point in the domain and every accumulation point of the domain, the image under the function converges to a limit, and every point in the codomain is less than or equal to the limit for all points in the domain, then the limit is less than or equal to every point in the codomain.


theorem CategoryTheory.Limits.pullbackSymmetry_hom_comp_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Limits.HasPullback f g],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackSymmetry f g).hom
          CategoryTheory.Limits.pullback.fst =
        CategoryTheory.Limits.pullback.snd :=
  by sorry

The theorem `CategoryTheory.Limits.pullbackSymmetry_hom_comp_fst` states that in any category `C`, for any three objects `X`, `Y`, and `Z` in `C`, and for any pair of morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` that have a pullback, the composition of the symmetry homomorphism of the pullback of `f` and `g` with the first projection of the pullback is equal to the second projection of the pullback. In more mathematical terms, this theorem asserts that `(pullbackSymmetry f g).hom ≫ pullback.fst = pullback.snd` in the category theory context of pullbacks.

In any category, for morphisms `f : X ⟶ Z` and `g : Y ⟶ Z` with a pullback, the composition of the pullback symmetry isomorphism's homomorphism with the first projection equals the second projection of the pullback. That is, `(pullbackSymmetry f g).hom ≫ pullback.fst = pullback.snd`.


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

This theorem states that for any type `α` that has a linear ordering, if a certain value `a` of type `α` is less than another value `c` of the same type, then `a` is also less than the maximum of `b` and `c`, where `b` and `c` are also values of type `α`. This is a fairly intuitive result, as if `a` is less than `c`, then `a` is certainly less than the highest value between `b` and `c`.

For any linear ordered type `α`, if `a` is less than `c` in `α`, then `a` is also less than the maximum of `b` and `c` in `α`.


theorem tsub_add_eq_add_tsub :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      b ≤ a → a - b + c = a + c - b :=
  by sorry

This theorem states that for any type `α` that has the structures of an additive commutative semigroup, a partial order, and an ordered subtraction, and also satisfies certain properties related to addition and less-than-or-equal (`≤`) operation, if `b` is less than or equal to `a`, then subtracting `b` from `a` and then adding `c` (`a - b + c`) is equal to first adding `c` to `a` and then subtracting `b` (`a + c - b`).

For all additive commutative semigroups `α` with partial order and ordered subtraction where `a ≤ b` implies `(a + c) - b = a - b + c`, for all `a, b, c` in `α`.


Computable.fst

theorem Computable.fst :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β], Computable Prod.fst := by sorry

The theorem `Computable.fst` states that for any two types `α` and `β`, if these types are Primcodable (meaning there exists a primitive recursive encoding for elements of these types), then the function `Prod.fst` is computable. `Prod.fst` is a function that takes a pair of type `α × β` and returns its first element of type `α`. So, in essence, this theorem asserts that the process of extracting the first element from a pair is a computable operation when the types of the elements in the pair are Primcodable.

If types `α` and `β` are Primcodable, then the function `Prod.fst` that extracts the first element from a pair of type `α × β` is a computable function.


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

This theorem states that for all natural numbers `n₁`, `m₁`, `n₂`, `m₂`, if `n₁` is less than or equal to `n₂` and `m₁` is less than or equal to `m₂`, then the product of `n₁` and `m₁` is also less than or equal to the product of `n₂` and `m₂`. This is a property of multiplication in the set of natural numbers.

For all natural numbers `n₁`, `m₁`, `n₂`, `m₂`, if `n₁ ≤ n₂` and `m₁ ≤ m₂`, then `n₁ * m₁ ≤ n₂ * m₂`.


theorem Polynomial.count_roots :
    ∀ {R : Type u} {a : R} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DecidableEq R] (p : Polynomial R),
      Multiset.count a (Polynomial.roots p) = Polynomial.rootMultiplicity a p :=
  by sorry

This theorem states that for any type `R`, any element `a` of `R`, and any polynomial `p` of type `R`, given that `R` is a commutative ring, `R` is a domain, and `R` has decidable equality, the count of `a` in the roots of `p` is equal to the root multiplicity of `a` in `p`. In simpler terms, the number of times a value `a` appears as a root of a polynomial `p` is exactly the same as the largest power of `(X - a)` that divides `p`.

Given a commutative domain `R` with decidable equality, for any polynomial `p` in `R[X]`, the number of times an element `a` is a root of `p` is equal to the multiplicity of `(X - a)` as a factor of `p`.


Wbtw.symm

/-- **Alias** of the forward direction of `wbtw_comm`. -/
theorem Wbtw.symm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Wbtw R x y z → Wbtw R z y x :=
  by sorry

The theorem `Wbtw.symm` states that for any three points `x`, `y`, and `z` in a torsor `P`, where `P` is an affine space over a vector space `V` which is a module over an ordered ring `R`, if `y` is weakly between `x` and `z`, then `y` is also weakly between `z` and `x`. In other words, the "weakly between" relation is symmetrical.

For any points `x`, `y`, `z` in an affine space `P` over a vector space `V` as a module over an ordered ring `R`, if `y` is weakly between `x` and `z`, then `y` is also weakly between `z` and `x` (i.e., the weakly between relation is reflexive and symmetric).


theorem MeasureTheory.Measure.measure_univ_ne_zero :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, ↑↑μ Set.univ ≠ 0 ↔ μ ≠ 0 := by sorry

This theorem states that for any type `α`, any defined measurable space on `α` denoted by `m0`, and any measure `μ` on this measurable space, the measure of the universal set (which includes all elements of `α`) being non-zero is equivalent to the measure `μ` itself being non-zero. In other words, if the measure of every possible subset of `α` is not zero, then the measure itself cannot be zero, and vice versa.

If a measure `μ` on a measurable space `(α, m0)` is non-zero if and only if the measure of the universal set is non-zero.


theorem MeasureTheory.integral_univ :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f : X → E} {μ : MeasureTheory.Measure X},
      ∫ (x : X) in Set.univ, f x ∂μ = ∫ (x : X), f x ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_univ`, states that for any type `X` endowed with a measurable space structure, any type `E` endowed with a normed additive commutative group structure and a normed space structure over the field of real numbers, any function `f` from `X` to `E`, and any measure `μ` on `X`, the integral of `f` over the entire set of `X` (i.e., `Set.univ`) with respect to the measure `μ` is equal to the integral of `f` over `X` with respect to `μ`. In simple terms, it asserts that the integral of a function over the whole space is the same, regardless of whether we explicitly specify that the domain of integration is the whole space or leave the domain implicit.

For any measurable space `(X, Σ, μ)`, normed additive commutative group `(E, +)` with a real norm `|.|`, and measurable function `f : X → E`, the integral of `f` over the whole space `X` is equal to the integral over `X` with respect to `μ`. In symbols, `∫(f : X → E) dμ = ∫(f : X → E) d(μ \(|\) Set.univ)`.


/-- A subring `t` includes `closure s` if and only if it includes `s`.  -/
theorem Subring.closure_le :
    ∀ {R : Type u} [inst : Ring R] {s : Set R} {t : Subring R}, Subring.closure s ≤ t ↔ s ⊆ ↑t := by sorry

The theorem `Subring.closure_le` states that for any type `R` with a ring structure, and any set `s` of `R` and any subring `t` of `R`, the subring generated by the closure of set `s` is a subset of subring `t` if and only if the set `s` itself is a subset of `subring `t`. This means that a subring `t` includes the closure of `s` precisely when it includes `s` itself.

The subring generated by the closure of a set in a ring is contained in the given subring if and only if the original set is contained in the subring.


theorem CategoryTheory.ShortComplex.Hom.comm₁₂_assoc :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (self : CategoryTheory.ShortComplex.Hom S₁ S₂) {Z : C} (h : S₂.X₂ ⟶ Z),
      CategoryTheory.CategoryStruct.comp self.τ₁ (CategoryTheory.CategoryStruct.comp S₂.f h) =
        CategoryTheory.CategoryStruct.comp S₁.f (CategoryTheory.CategoryStruct.comp self.τ₂ h) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.Hom.comm₁₂_assoc` states that for any category `C` that has zero morphisms, for any two short complexes `S₁` and `S₂` within this category, and for any morphism `h` from `S₂.X₂` to some object `Z` in `C`, the composition of the morphism `self.τ₁` with the composition of `S₂.f` and `h` is equal to the composition of `S₁.f` with the composition of `self.τ₂` and `h`.

In more formal terms, it states that `(self.τ₁ ≫ (S₂.f ≫ h)) = (S₁.f ≫ (self.τ₂ ≫ h))`, where `≫` denotes the composition of morphisms in the category. This theorem asserts the associativity of morphism composition within the context of short complexes in a category.

For any category with zero morphisms, the composition of `self.τ₁` with `S₂.f` and any morphism `h` is equal to the composition of `S₁.f` with `self.τ₂` and `h`, i.e., `(self.τ₁ ≫ S₂.f ≫ h) = (S₁.f ≫ self.τ₂ ≫ h)` for short complexes `S₁` and `S₂`.


theorem DFinsupp.single_eq_same :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)] {i : ι} {b : β i},
      (DFinsupp.single i b) i = b :=
  by sorry

The theorem `DFinsupp.single_eq_same` states that for any types `ι` and `β` with `β` being a function type over `ι`, given a decidable equality on `ι`, a zero for each `β i`, and any `i` in `ι` and `b` in `β i`, the value of the direct sum of finitely supported functions at point `i` (created by the `DFinsupp.single` function) is equal to `b`. In other words, when we create a direct sum of finitely supported functions that sends `i` to `b` and all other points to `0`, querying this function at `i` will yield `b`.

For any types `ι` and `β`, given a decidable equality on `ι`, a zero for each `β i`, and any `i` in `ι` and `b` in `β i`, the function `DFinsupp.single ι β i b` equals the constant function from `ι` to `β` with value `b` at `i` when considered as an element of the direct sum of finitely supported functions `DFinsupp ι β`.


theorem Num.to_nat_inj : ∀ {m n : Num}, ↑m = ↑n ↔ m = n := by sorry

This theorem states that for any two numbers `m` and `n` of the numeric type `Num`, the condition of their conversions to natural numbers being equal is equivalent to `m` and `n` being equal themselves. In other words, if the natural number representation of `m` equals the natural number representation of `n`, then `m` equals `n` and vice versa. The function `↑` is used here to convert a number from type `Num` to type `Nat` (natural numbers in Lean 4).

For any numbers `m` and `n` of type `Num`, `↑m = ↑n` if and only if `m = n`.


theorem lt_max_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, a < max b c ↔ a < b ∨ a < c := by sorry

This theorem, `lt_max_iff`, states that for any type `α` that has a linear order, and for any three elements `a`, `b`, and `c` of this type, `a` is less than the maximum of `b` and `c` if and only if `a` is less than `b` or `a` is less than `c`. This theorem essentially captures the property of maximum in the context of linear orders.

For any type `α` with a linear order and any elements `a`, `b`, `c` of `α`, `a` is less than the maximum of `b` and `c` if and only if `a` is less than `b` or `a` is less than `c`.


theorem finite_or_infinite : ∀ (α : Sort u_3), Finite α ∨ Infinite α := by sorry

This theorem states that for any type `α`, it is either finite (`Finite α`) or infinite (`Infinite α`). In more traditional mathematical terms, given any set `α`, it either has a finite number of elements or an infinite number of elements. The `Finite` and `Infinite` classes in Lean are used to represent these two possibilities.

Every set can be classified as finite or infinite.


theorem neg_pos_of_neg :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a : α}, a < 0 → 0 < -a :=
  by sorry

This theorem states that for any type `α` that forms an additive group and has a less-than (`<`) relation, and if this less-than relation is compatible with addition (i.e., it's a covariant class), then for any element `a` of `α`, if `a` is less than zero, then the negation of `a` (i.e., `-a`) is greater than zero. In other words, it confirms the intuitive notion that the negative of a negative number is a positive number.

For any additive group type `α` with a covariant `<` relation, if `a` is an element of `α` with `a < 0`, then `-a > 0`.


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

The theorem `AddLECancellable.tsub_eq_of_eq_add` states that in the context of a partially ordered additive commutative semigroup with subtraction, which also has the property of ordered subtraction, if an element `b` is 'addition left-cancellable' (meaning that for all elements `b` and `c`, if `b + a ≤ c + a` then `b ≤ c`), and if another element `a` is equal to the sum of `c` and `b`, then the difference `a - b` is equal to `c`. This essentially says that you can 'undo' the addition of a cancellable element by subtracting it.

If `a = c + b` in a partially ordered additive commutative semigroup with subtraction and `b` is addition left-cancellable, then `a - b = c`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.38 : ∀ {G : Type u_1} [inst : Group G] (x : G), (x ∈ ⊤) = True :=
  by sorry

This theorem states that for any group `G` and any element `x` of `G`, `x` is an element of the group's top (or universal) subgroup. In the context of group theory, the top subgroup is the group itself. Therefore, this theorem is essentially saying that any element of a group is, by definition, an element of that group.

For any group `G` and any of its elements `x`, `x` is a member of group `G`.


theorem Quotient.inductionOn₃ :
    ∀ {α : Sort uA} {β : Sort uB} {φ : Sort uC} {s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid φ}
      {motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop} (q₁ : Quotient s₁) (q₂ : Quotient s₂)
      (q₃ : Quotient s₃), (∀ (a : α) (b : β) (c : φ), motive ⟦a⟧ ⟦b⟧ ⟦c⟧) → motive q₁ q₂ q₃ :=
  by sorry

This theorem, `Quotient.inductionOn₃`, provides a principle of induction for three quotient types. Given any three sort types `α`, `β` and `φ` with setoid relations `s₁`, `s₂` and `s₃` respectively, it states that for any property `motive` that applies to the respective quotient types, if this property holds for representatives `a` from `α`, `b` from `β`, and `c` from `φ`, then it also holds for any elements `q₁`, `q₂` and `q₃` of the respective quotient types. Thus, it allows us to reason about all elements of these quotient types by only considering a representative element from each equivalence class.

Given equivalence relations `s₁` on type `α`, `s₂` on type `β`, and `s₃` on type `φ`, if a property holds for representatives from each equivalence class, then it holds for all elements in the quotient types `α / s₁`, `β / s₂`, and `φ / s₃`.


theorem Function.Involutive.comp_self : ∀ {α : Sort u} {f : α → α}, Function.Involutive f → f ∘ f = id := by sorry

The theorem `Function.Involutive.comp_self` states that for any type `α` and any function `f` from `α` to `α`, if `f` is involutive (that is, applying `f` twice to any value `x` of type `α` results in `x` itself), then the composition of `f` with itself is the identity function. In terms of standard mathematical notation, if $f \circ f = Id$ for all `x` in `α`, then $f \circ f = Id$.

If `α` is a type and `f : α → α` is an involutive function, then `f ∘ f = Id`.


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

This theorem states that for any two types `α` and `β` that have a less than or equal to (`≤`) relationship, and for any order isomorphism `e` between `α` and `β`, the inequality `x ≤ (OrderIso.symm e) y` holds if and only if `e x ≤ y` holds, where `x` is an element of `α` and `y` is an element of `β`. In other words, applying the inverse of the order isomorphism to `y` and comparing it with `x` in `α` is equivalent to transforming `x` into `β` using the order isomorphism `e` and comparing it with `y` in `β`.

For any order isomorphism between types `α` and `β`, and for all `x` in `α` and `y` in `β`, `x ≤ y` if and only if `e x ≤ y` or `y ≤ e x`, where `e` is the order isomorphism.


padicNorm.zero

/-- The `p`-adic norm of `0` is `0`.  -/
theorem padicNorm.zero : ∀ {p : ℕ}, padicNorm p 0 = 0 := by sorry

The theorem `padicNorm.zero` states that the p-adic norm of `0` is `0` for any natural number `p`. In other words, for any natural number `p`, when we evaluate the p-adic norm function with `p` and `0` as inputs, the output is `0`.

For any prime number p, the p-adic norm of 0 is 0.


theorem finsum_zero : ∀ {M : Type u_2} {α : Sort u_4} [inst : AddCommMonoid M], (finsum fun x => 0) = 0 := by sorry

This theorem, `finsum_zero`, states that for any type `M` with an additive commutative monoid structure, and any type `α`, the finite sum (`finsum`) of the constant zero function (i.e., a function that maps every element of `α` to zero in `M`) is zero. In other words, adding up all the zeroes gives you zero, regardless of the set you're summing over.

For any additive commutative monoid `M` and type `α`, the finitesum of the constant zero function from `α` to `M` is the zero element of `M`.


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

The theorem 'LinearEquiv.symm_apply_eq' states that for any two types 'M' and 'M₂' that are modules over the semirings 'R' and 'S' respectively, and given a linear equivalence 'e' from 'M' to 'M₂' with associated ring homomorphisms 'σ' and 'σ', for any elements 'x' of 'M₂' and 'y' of 'M', the inverse of 'e' applied to 'x' equals 'y' if and only if 'x' equals 'e' applied to 'y'.

For linear equivalences $e : M \cong M'_s$ between $R$-modules $M$ and $S$-modules $M'_s$ with associated ring homomorphisms $\sigma : R \to S$ and $\sigma'_s : S \to R$, if $x \in M'_s$ and $y \in M$ satisfy $e(y) = x$, then $x = e(y)$.


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

The theorem `Finset.union_idempotent` asserts that for any type `α` with decidable equality (denoted by `[inst : DecidableEq α]`) and for any finite set `s` of type `α` (`s : Finset α`), taking the union of `s` with itself yields `s` again. In other words, if we combine a finite set with itself, the result is just the original set. This is denoted mathematically as `s ∪ s = s`. This is an illustration of the idempotent property in the context of finite sets, stating that the union operation is idempotent.

For any finite set `s` of type `α` with decidable equality, `s ∪ s = s`.


theorem Set.Ioc_subset_Ioc :
    ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α}, a₂ ≤ a₁ → b₁ ≤ b₂ → Set.Ioc a₁ b₁ ⊆ Set.Ioc a₂ b₂ := by
  sorry

The theorem `Set.Ioc_subset_Ioc` states that for any type `α` that has a preorder structure, and any four elements `a₁`, `a₂`, `b₁`, `b₂` of this type, if `a₂` is less than or equal to `a₁`, and `b₁` is less than or equal to `b₂`, then the left-open right-closed interval from `a₁` to `b₁` is a subset of the left-open right-closed interval from `a₂` to `b₂`. In other words, if we have two intervals such that the second interval starts no later and ends no sooner than the first interval, then all points in the first interval are also in the second interval.

For any type `α` with a preorder structure, and any `a₁ ≤ a₂` and `b₁ ≤ b₂` in `α`, the interval `[a₁, b₁) ⊆ [a₂, b₂)`.


theorem differentiableAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E}, DifferentiableAt 𝕜 id x :=
  by sorry

The theorem `differentiableAt_id` states that for all types `𝕜` and `E`, where `𝕜` is a nontrivial normed field and `E` is a normed vector space over `𝕜`, the identity function `id` is differentiable at every point `x` in `E`. This means that at any given point, the identity function has a derivative.

For every normed field `𝕜` and normed vector space `E` over `𝕜`, the identity function on `E` is differentiable at every point in `E`.


theorem Matrix.diagonal_one :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α],
      (Matrix.diagonal fun x => 1) = 1 :=
  by sorry

The theorem `Matrix.diagonal_one` asserts that for any type `n` with decidable equality and any type `α` that has both zero and one elements, the square matrix created by the function `Matrix.diagonal` with all entries uniformly set to one (i.e., `(Matrix.diagonal fun x => 1)`) is equal to the identity matrix `1`. Essentially, this theorem states that a diagonal matrix with all diagonal entries as one is an identity matrix.

For any type `n` with decidable equality and any type `α` having zero and one elements, the diagonal matrix with all entries equal to one is equal to the identity matrix.


IsOpenMap.id

theorem IsOpenMap.id : ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOpenMap id := by sorry

This theorem states that for any type `X` with a topology (that is, `X` forms a topological space), the identity function on `X` is an open map. In terms of mathematics, the theorem says that for all open sets `U` in the topological space `X`, the image of `U` under the identity function is also an open set in `X`. This is expected because the identity function does not change any elements of the set it is applied to.

For any topological space (X,τ), the identity function on X is an open map, that is, for all open sets U ∈ τ, the image of U under the identity function is also an open set in X.


theorem List.length_take : ∀ {α : Type u_1} (i : ℕ) (l : List α), List.length (List.take i l) = min i (List.length l) :=
  by sorry

This theorem, `List.length_take`, states that for any index `i` and any list `l` of arbitrary type `α`, the length of the list obtained by taking the first `i` elements of `l` is equal to the minimum of `i` and the length of `l`. In other words, it says that if you take `i` elements from a list `l`, the length of the resulting list will be `i` if `i` is less than or equal to the length of `l`, and the length of `l` if `i` is greater than the length of `l`.

Let `l` be a list of length `n` and `i` be an index. Then, the length of the list obtained by taking the first `i` elements of `l` is minimally `i` or `n`.


theorem Mathlib.Data.Finset.Lattice._auxLemma.4 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
      (Finset.sup s f ≤ a) = ∀ b ∈ s, f b ≤ a :=
  by sorry

This theorem states that for all types `α` and `β`, given a semilattice-supremum structure and an order-bottom structure on `α`, a finite set `s` of type `β`, a function `f` from `β` to `α`, and an element `a` of type `α`, the supremum of the images of the elements of `s` under `f` is less than or equal to `a` if and only if for every element `b` in `s`, the image of `b` under `f` is less than or equal to `a`. In other words, `a` is an upper bound for the image of the set `s` under `f` in the order structure of `α` if and only if `a` is an upper bound for each element in the image of `s` under `f`.

For all types `α` and `β`, given a semilattice-supremum and order-bottom structure on `α`, a finite set `s` of type `β`, a function `f` from `β` to `α`, and an element `a` of type `α`, the image of the supremum of `s` under `f` is less than or equal to `a` if and only if every image of an element in `s` under `f` is less than or equal to `a`.


theorem List.pmap.proof_4 :
    ∀ {α : Type u_1} {p : α → Prop} (a : α) (l : List α), (∀ a_1 ∈ a :: l, p a_1) → ∀ x ∈ l, p x := by sorry

This theorem states that for any type `α`, any property `p` that applies to elements of type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, if every element in the list `a :: l` (which is the list `l` with `a` added to the front) has property `p`, then for any element `x` in the list `l`, `x` must also have property `p`. In other words, if every element in the list that results from adding `a` to `l` has a certain property, then every element in `l` must also have this property.

If `a : α` has property `p` and every element in the list `a :: l` of type `α` has property `p`, then every element `x` in `l` also has property `p`.


theorem Complex.cpow_zero : ∀ (x : ℂ), x ^ 0 = 1 := by sorry

This theorem states that any complex number raised to the power of zero is equal to one. In other words, for all values of `x` in the complex number space ℂ, `x ^ 0` equals 1. This is a fundamental property of exponents, and holds true not just for real numbers, but also for complex numbers in Lean 4.

For all complex numbers x in ℂ, x^0 = 1.


theorem Int.natAbs_eq_zero : ∀ {a : ℤ}, Int.natAbs a = 0 ↔ a = 0 := by sorry

The theorem `Int.natAbs_eq_zero` states that for any integer `a`, the absolute value of `a` is equal to zero if and only if `a` itself is zero. In other words, the absolute value operation (`Int.natAbs`) on an integer value results in zero exactly when the original integer value is zero. This is a two-way implication, meaning if `a` is zero, then its absolute value is zero and vice versa.

For all integers a, |a| = 0 if and only if a = 0.


theorem Set.Iio_subset_Iic_self : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Iio a ⊆ Set.Iic a := by sorry

The theorem `Set.Iio_subset_Iic_self` states that for any type `α` that has a preorder relation, and for any element `a` of that type, the left-infinite right-open interval up to `a` is a subset of the left-infinite right-closed interval up to `a`. In mathematical terms, this means that for all `x` in `α`, if `x` is less than `a`, then `x` is also less than or equal to `a`.

For any type `α` with a preorder relation and any element `a` in `α`, the left-infinite right-open interval `(−∞, a)` is a subset of the left-infinite right-closed interval `[−∞, a]`.


theorem closure_ball :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E) {r : ℝ},
      r ≠ 0 → closure (Metric.ball x r) = Metric.closedBall x r :=
  by sorry

The theorem `closure_ball` states that for any given seminormed additive commutative group `E` equipped with a normed space over the real numbers, any point `x` in `E`, and any nonzero real number `r`, the closure of the open ball centered at `x` with radius `r` is equal to the closed ball with the same center and radius. In other words, the smallest closed set which contains the open ball (all points within a distance `r` from `x`, but not including the boundary) is the closed ball itself (all points within a distance `r` from `x`, including the boundary).

The closure of an open ball in a normed space equals the corresponding closed ball.


theorem Submodule.span_empty :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      Submodule.span R ∅ = ⊥ :=
  by sorry

The theorem `Submodule.span_empty` states that for any semiring `R` and any type `M` which is an additive commutative monoid and also a module over `R`, the span of the empty set is the bottom element of the lattice of submodules of `M`. This means the smallest submodule of `M` that contains no elements is the bottom submodule, typically the zero submodule.

The empty set generates the zero submodule in any additive commutative monoid and R-module.


theorem AddMonoidHom.map_multiset_sum :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : AddCommMonoid β] (f : α →+ β) (s : Multiset α),
      f (Multiset.sum s) = Multiset.sum (Multiset.map (⇑f) s) :=
  by sorry

This theorem states that for any two types `α` and `β` that have an additive commutative monoid structure, any homomorphism `f` from `α` to `β`, and any multiset `s` of type `α`, the result of applying `f` to the sum of `s` is equal to the sum of the multiset obtained by mapping `f` over `s`. In mathematical terms, it says that the sum operation commutes with the map operation under the homomorphism `f`, that is, $f(\sum s) = \sum (f \mapsto s)$, where $\sum$ denotes the sum operation on multisets and $\mapsto$ denotes the map operation on multisets.

For any additive commutative monoids types `α` and `β`, any homomorphism `f` from `α` to `β`, and any multiset `s` of type `α`, the application of `f` to the sum of `s` is equal to the sum of the image of `s` under `f`. In mathematical notation: $f(\sum s) = \sum (f(x) \mid x \in s)$.


theorem Polynomial.coeff_sub :
    ∀ {R : Type u} [inst : Ring R] (p q : Polynomial R) (n : ℕ),
      Polynomial.coeff (p - q) n = Polynomial.coeff p n - Polynomial.coeff q n :=
  by sorry

The theorem `Polynomial.coeff_sub` states that for any ring `R`, polynomials `p` and `q` in `R`, and a natural number `n`, the coefficient of `X^n` in the difference of `p` and `q` is equal to the difference of the coefficient of `X^n` in `p` and the coefficient of `X^n` in `q`. In mathematical terms, it means that if we subtract polynomial `q` from `p`, the `n`-th coefficient of the resultant polynomial is the difference between the `n`-th coefficients of `p` and `q`.

For any ring R and polynomials p and q in R, the coefficient of X^n in p - q is equal to the coefficient of X^n in p - the coefficient of X^n in q.


theorem smul_left_injective :
    ∀ (R : Type u_2) {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : NoZeroSMulDivisors R M] {x : M}, x ≠ 0 → Function.Injective fun c => c • x :=
  by sorry

The theorem `smul_left_injective` states that for any ring `R`, additive commutative group `M`, and module `M` over `R`, given the condition that there are no zero scalar multipliers and divisors in `R` and `M`, if a non-zero element `x` from `M` is given, then the function that maps each element `c` from `R` to the result of the scalar multiplication of `c` and `x` is injective. In other words, scalar multiplication by a non-zero element is an injective function: if `c1` and `c2` are two elements from `R` such that `c1 • x = c2 • x`, then `c1` must be equal to `c2`.

If `R` is a ring with no zero divisors, and `M` is an `R`-module with no zero scalar multipliers, then scalar multiplication by a non-zero element `x` in `M` is injective.


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

The theorem `Pi.mulSingle_eq_same` states that for any index set `I` and a function `f` from `I` to another type, whenever we have a decidable equality on the index set `I` and an identity element (which we call `One`) for each element in the range of `f`, for any specific index `i` in `I` and value `x` of the type `f i`, the value at index `i` of the function `Pi.mulSingle i x`, which creates a function that is `1` everywhere except at `i` where it is `x`, is indeed `x`. In essence, it shows that `Pi.mulSingle` correctly assigns the value `x` at the specified index `i`.

For any decidable equality relation on an index set `I`, function `f` from `I` to a type with identity elements `One` in its range, and index `i` in `I` and value `x` of type `f i`, `Pi.mulSingle i x` equals `x` as functions.


Relation.ReflTransGen.lift

theorem Relation.ReflTransGen.lift :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {p : β → β → Prop} {a b : α} (f : α → β),
      (∀ (a b : α), r a b → p (f a) (f b)) → Relation.ReflTransGen r a b → Relation.ReflTransGen p (f a) (f b) :=
  by sorry

This theorem states that for any two types `α` and `β`, relations `r` and `p` on `α` and `β` respectively, and a function `f` from `α` to `β`, if every pair `(a, b)` that satisfies the relation `r` also satisfies the relation `p` after being transformed by `f`, then `Relation.ReflTransGen r a b` implies `Relation.ReflTransGen p (f a) (f b)`. In other words, it lifts the reflexive transitive closure of a relation from one domain to another through a function, provided that the function respects the relation.

If function `f` preserves relation `r` that is reflexively transitive on type `α`, then `Relation.ReflTrans p (f x) (f y)` holds whenever `Relation.ReflTransGen r x y` does, for types `α` and `β` and relations `r` on `α` and `p` on `β`.


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

This theorem, `le_sub_comm`, states that for any type `α` that forms an additive commutative group and for which less than or equal (`≤`) is defined, and for any three elements `a`, `b`, and `c` of `α`, the statement "`a` is less than or equal to the difference of `b` and `c`" is equivalent to the statement "`c` is less than or equal to the difference of `b` and `a`". This is subject to the condition that the type `α` forms a covariant class under the operation of addition and the less than or equal to relation.

For any additive commutative group `α` with defined `≤`, `a ≤ b - c` if and only if `c ≤ b - a`.


theorem Localization.mk_zero :
    ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} (x : ↥S), Localization.mk 0 x = 0 := by sorry

The theorem `Localization.mk_zero` states that for any commutative monoid with zero `M` and any submonoid `S` of `M`, and for any element `x` in `S`, the localization of `M` at `S` of the pair `(0, x)` is equal to zero. Here, `0` represents the zero element of the monoid `M`. Essentially, this says that the zero of the original monoid maps to the zero in the localization.

For any commutative monoid with zero `M`, submonoid `S`, and element `x` in `S`, the localization of `M` at `S` of the pair `(0, x)` equals the zero element in the localization.


theorem monotone_const :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {c : β}, Monotone fun x => c := by sorry

The theorem `monotone_const` states that for any two types `α` and `β`, where `α` and `β` have preorder relations, and for any constant `c` of type `β`, the function that assigns to each element of `α` the constant `c` is monotone. In other words, if `a ≤ b` for any `a` and `b` in `α`, it always holds that `c ≤ c`.

For any preordered types `α` and `β`, and constant `c` in `β`, the function mapping each `α` element to `c` is monotone. (That is, if `a ≤ b` in `α`, then `c ≤ c`.)


theorem Nat.lt_succ : ∀ {m n : ℕ}, m < Nat.succ n ↔ m ≤ n := by sorry

This theorem, `Nat.lt_succ`, states that for any two natural numbers `m` and `n`, `m` is less than the successor of `n` if and only if `m` is less than or equal to `n`. In other words, it establishes an equivalence between `m` being less than `n + 1` and `m` being less than or equal to `n`. This is a fundamental property in the order theory of natural numbers.

For all natural numbers `m` and `n`, `m` < `n` if and only if `m` <= `n`.


theorem Ideal.IsPrime.mem_or_mem :
    ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, Ideal.IsPrime I → ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I := by
  sorry

This theorem states that for any type `α` with a semiring structure, given a prime ideal `I` in `α`, then for any two elements `x` and `y` from `α`, if the product `x * y` belongs to the ideal `I`, then either `x` belongs to `I` or `y` belongs to `I`. This is the principle of a prime ideal in ring theory, which mirrors the property of prime numbers where if a prime divides a product of numbers, then it must divide at least one of the factors.

Given a semiring `α` and a prime ideal `I` in `α`, if `x * y` is in `I` for any `x, y` in `α`, then `x` is in `I` or `y` is in `I`.


Derivation.leibniz

theorem Derivation.leibniz :
    ∀ {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) (a b : A), D (a * b) = a • D b + b • D a :=
  by sorry

This theorem, named "Derivation.leibniz", states that for any types `R`, `A`, and `M` where `R` is a commutative semiring, `A` is also a commutative semiring, `M` is an additive commutative monoid, `A` is an `R`-algebra, `M` is an `A`-module and also an `R`-module, and `D` is a derivation from `A` to `M` over `R`, the Leibniz rule holds: the derivative of the product of `a` and `b` (where `a` and `b` are elements of `A`) is equal to `a` times the derivative of `b` plus `b` times the derivative of `a`. This is a formal representation of the Leibniz product rule in differential calculus.

For a commutative semiring `R`, commutative `A`-algebra `A` over `R`, `A`-module and `R`-module `M`, and `R`-derivation `D` from `A` to `M`, the Leibniz rule holds: `D(a * b) = a * D(b) + b * D(a)`.


theorem Finset.image₂_singleton :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {a : α} {b : β},
      Finset.image₂ f {a} {b} = {f a b} :=
  by sorry

The theorem `Finset.image₂_singleton` states that for any types `α`, `β`, and `γ` where `γ` has decidable equality, given a binary function `f : α → β → γ` and elements `a : α` and `b : β`, the image of the function `f` when applied to the singleton sets `{a}` and `{b}` (denoted as `Finset.image₂ f {a} {b}`) is a singleton set containing the value `f a b`, i.e., `{f a b}`. This essentially means that applying a binary function to two singleton sets results in a singleton set of the function applied to the elements of these sets.

For any types `α`, `β`, and `γ` with decidable equality, the image of a binary function `f : α → β → γ` on singleton sets `{a : α}` and `{b : β}` is the singleton set `{f a b : γ}` containing the result `f a b`.


theorem DifferentiableAt.comp_differentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} (x : E) {s : Set E}
      {g : F → G}, DifferentiableAt 𝕜 g (f x) → DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 (g ∘ f) s x :=
  by sorry

The theorem `DifferentiableAt.comp_differentiableWithinAt` states that for any types `𝕜`, `E`, `F`, and `G` where `𝕜` is a nontrivially normed field, `E`, `F`, `G` are normed add commutative groups and normed spaces over `𝕜`, given a function `f` from `E` to `F`, a set `s` of `E`, a function `g` from `F` to `G`, and a point `x` in `E`, if `g` is differentiable at the point `f(x)`, and `f` is differentiable within the set `s` at the point `x`, then the composite function `g ∘ f` is differentiable within the set `s` at the point `x`. In other words, the differentiability of `g` at `f(x)` and `f` within `s` at `x` guarantees the differentiability of the composite function `g ∘ f` within `s` at `x`.

If `f: E -> F` is differentiable within `s ⊆ E` at `x ∈ E` and `g: F -> G` is differentiable at `f(x)`, then `g ∘ f` is differentiable at `x`.


theorem abs_choice : ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] (x : α), |x| = x ∨ |x| = -x := by
  sorry

This theorem, `abs_choice`, states that for any given type `α` which forms an additive group and has a linear order, the absolute value of any element `x` of this type is either equal to `x` itself or its negation. In other words, `|x| = x` or `|x| = -x` for any `x` in `α`. This is a typical property of absolute values in ordered additive groups.

In an additive group with a linear order, the absolute value of any element is either the element itself or its negation.


theorem ZMod.val_zero : ∀ {n : ℕ}, ZMod.val 0 = 0 := by sorry

The theorem `ZMod.val_zero` states that for any natural number `n`, the value of the zero element in the ring of integers modulo `n` is also zero. This holds regardless of the specific value of `n`. In mathematical terms, for ∀ `n ∈ ℕ`, the value of `0` in `Z/nZ` is `0`.

For all natural numbers n, the zero element in the ring of integers modulo n is equal to zero.


theorem neg_eq_of_add_eq_zero_right : ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, a + b = 0 → -a = b := by
  sorry

This theorem states that for any type `G` that forms a subtraction monoid, given any two elements `a` and `b` of type `G`, if the sum of `a` and `b` equals zero, then the negative of `a` is equal to `b`. In mathematical terms, this corresponds to the property $-a = b$ for any $a, b$ in a mathematical structure with subtraction such that $a + b = 0$.

For any subtraction monoid type `G` and elements `a, b` of type `G` with `a + b = 0`, it holds that `-a = b`.


theorem AlgebraicGeometry.QuasiCompact.affineProperty_isLocal :
    AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal AlgebraicGeometry.QuasiCompact.affineProperty := by sorry

This theorem, `AlgebraicGeometry.QuasiCompact.affineProperty_isLocal`, states that the property of being a quasi-compact scheme in algebraic geometry is a local property with respect to the target morphism. Concretely, this means that if we have a scheme `X` and for every point in `X`, its fiber (the inverse image of the point under the morphism) is a quasi-compact space (in the sense of CompactSpace), then the entire scheme `X` is said to be quasi-compact. The theorem's proof, which is not provided, would typically involve showing that this property holds regardless of the specific choice of point in `X`.

If each fiber of a morphism of schemes is quasi-compact, then the entire scheme is quasi-compact.


theorem Finset.single_le_sum :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f : ι → N} {s : Finset ι},
      (∀ i ∈ s, 0 ≤ f i) → ∀ {a : ι}, a ∈ s → f a ≤ Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.single_le_sum` states that for any type `ι`, type `N` which is an ordered additive commutative monoid, a function `f` from `ι` to `N`, and a finite set `s` of type `ι`, if each element `i` of the set `s` when applied to the function `f` results in a non-negative value, then for any element `a` of the set `s`, the value of the function `f` at `a` is less than or equal to the sum of the function `f` applied to each element of the set `s`. In other words, the value of a single application of the function `f` is always less than or equal to the sum of the values of the function `f` over all elements of the set `s`, given that the function `f` returns non-negative values for all elements of `s`.

For any ordered additive commutative monoid N, function f from a finite set s to N with non-negative values, and all a in s, we have f a ≤ ∑ i in s f i.


theorem TopologicalSpace.nhds_generateFrom :
    ∀ {α : Type u} {g : Set (Set α)} {a : α}, nhds a = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, Filter.principal s := by sorry

The theorem `TopologicalSpace.nhds_generateFrom` states that for any type `α`, any set `g` of subsets of `α`, and any element `a` of `α`, the neighborhood filter at `a` is equal to the infimum (greatest lower bound) of the principal filters of all sets `s` such that `a` is in `s` and `s` is in `g`. In other words, the neighborhood of a point in a space is generated from the collection of all supersets of sets that both contain the point and are elements of a given set of sets.

The neighborhood filter of a point in a topological space is the infimum of the principal filters of all sets containing the point that belong to a given set of subsets of the space.


/-- Shows that `fib` indeed satisfies the Fibonacci recurrence `Fₙ₊₂ = Fₙ + Fₙ₊₁.`  -/
theorem Nat.fib_add_two : ∀ {n : ℕ}, Nat.fib (n + 2) = Nat.fib n + Nat.fib (n + 1) := by sorry

This theorem verifies the correctness of the Fibonacci sequence implementation `Nat.fib` in Lean 4. It asserts that for all natural numbers `n`, the `n + 2`-th term of the Fibonacci sequence is equal to the sum of the `n`-th and `(n + 1)`-th terms, validating the recurrence relation `Fₙ₊₂ = Fₙ + Fₙ₊₁` which characterizes the Fibonacci sequence.

For all natural numbers n, the (n+2)-th Fibonacci number is equal to the sum of the n-th and (n+1)-th Fibonacci numbers.


theorem Finset.mem_biUnion :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
      b ∈ Finset.biUnion s t ↔ ∃ a ∈ s, b ∈ t a :=
  by sorry

The theorem `Finset.mem_biUnion` states that for any types `α` and `β`, a given `Finset` `s` of type `α`, a function `t` mapping from type `α` to `Finset` of type `β` where `β` has decidable equality, and an element `b` of type `β`, `b` is in the biUnion of `s` and `t` if and only if there exists an element `a` in `s` such that `b` is in `t a`. In other words, an element is in the biUnion of a set and a function if it is in the image of the function at some point in the set.

For any types `α` and `β` with decidable equality, and a Finset `s` of type `α` and a function `t : α → Finset β`, an element `b` is in the biUnion of `s` and `t` if and only if there exists an `a` in `s` such that `b` is in `t a`.


theorem CategoryTheory.Limits.IsColimit.ι_map :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F G : CategoryTheory.Functor J C}
      {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (d : CategoryTheory.Limits.Cocone G)
      (α : F ⟶ G) (j : J),
      CategoryTheory.CategoryStruct.comp (c.ι.app j) (CategoryTheory.Limits.IsColimit.map hc d α) =
        CategoryTheory.CategoryStruct.comp (α.app j) (d.ι.app j) :=
  by sorry

The theorem `CategoryTheory.Limits.IsColimit.ι_map` states the following:
For any category `J` and any type `C` that is also a category, given two functors `F` and `G` from `J` to `C`, a cocone `c` over `F`, and a morphism `α` from `F` to `G`, if `c` is a co-limit of `F`, then the composition of the application of `c.ι` to `j` and the mapping of `hc` (which is the property that `c` is a co-limit) to `d` under `α` is equal to the composition of the application of `α` to `j` and the application of `d.ι` to `j`.

In other words, this theorem is about the commutativity of a certain diagram involving co-limits in a category. It says that two different ways of getting from one object to another in the category, using the structures of the co-limits and the given morphism, are actually the same.

Given functors F and G from category J to C, a co-limit cocone c over F, and a morphism α from F to G, if c is the co-limit of F, then the diagram commutes, that is, c.ι ∘ j = α ∘ j ∘ d.ι for all objects j in J and d in the limit cone of G over j.


theorem AddOpposite.op_surjective : ∀ {α : Type u_1}, Function.Surjective AddOpposite.op := by sorry

The theorem `AddOpposite.op_surjective` states that for any type `α`, the function `AddOpposite.op` is surjective. In other words, for any element in the additive opposite type `αᵃᵒᵖ`, there exists at least one element in `α` such that, when the `AddOpposite.op` function is applied to it, the result is the given element in `αᵃᵒᵖ`.

For every element in the additive opposite type of a type α, there exists an element in α mapping to it under the AddOpposite.op function.


theorem List.length_cons : ∀ {α : Type u_1} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as) :=
  by sorry

The theorem `List.length_cons` asserts that for any type `α`, any element `a` of type `α`, and any list `as` of elements of type `α`, the length of the list formed by consing `a` onto `as` (denoted `a :: as`) is equal to the successor (`Nat.succ`) of the length of `as`. In other words, adding an element to the front of a list increases the length of the list by one.

For any type `α` and lists `a :: as` of elements of type `α`, the length of the list `a :: as` is the successor of the length of `as`. In Lean syntax, `(List.length (a :: as)) = Nat.succ (List.length as)`.


theorem MeasureTheory.SimpleFunc.lintegral_eq_lintegral :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (f : MeasureTheory.SimpleFunc α ENNReal) (μ : MeasureTheory.Measure α),
      ∫⁻ (a : α), ↑f a ∂μ = MeasureTheory.SimpleFunc.lintegral f μ :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.lintegral_eq_lintegral` states that for any measurable space `α`, any simple function `f` mapping from `α` to the extended nonnegative real numbers, and any measure `μ` on `α`, the Lebesgue integral of `f` with respect to `μ` is equal to the `lintegral` of `f` with respect to `μ`. In mathematical notation, for all `a` in `α`, the integral from negative infinity to infinity of `f(a)` with respect to `μ` (`∫⁻ (a : α), ↑f a ∂μ`) is equal to the `lintegral` of `f` with respect to `μ` (`MeasureTheory.SimpleFunc.lintegral f μ`). This theorem connects the concepts of Lebesgue integral and `lintegral` in the context of measure theory.

For any measurable space, simple function, and measure, the Lebesgue integral and `lintegral` of the simple function with respect to the measure are equal.


theorem Mathlib.Order.LocallyFinite._auxLemma.4 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      (x ∈ Finset.Ioo a b) = (a < x ∧ x < b) :=
  by sorry

This theorem states that for any type `α` with a preorder and locally finite order, and for any elements `a`, `b`, and `x` of type `α`, `x` is in the finite set of elements between `a` and `b` (exclusive of `a` and `b`) if and only if `x` is strictly greater than `a` and strictly less than `b`. In other words, it provides a characterization of the elements in the finite interval `(a, b)` in terms of strict inequalities.

For any type `α` with a preorder and locally finite order, an element `x` lies strictly between `a` and `b` if and only if `a` is strictly less than `x` and `x` is strictly less than `b`.


theorem Filter.mem_principal : ∀ {α : Type u} {s t : Set α}, s ∈ Filter.principal t ↔ t ⊆ s := by sorry

This theorem states that, for any type `α` and any two sets `s` and `t` of this type, `s` is in the principal filter of `t` if and only if `t` is a subset of `s`. In the context of filters in mathematics, the "principal filter of `t`" is the collection of all sets which contain `t`. Therefore, this theorem is saying that a set `s` is in this collection exactly when `t` is included in `s`.

A set `s` is the principal filter of set `t` if and only if `t` is a subset of `s`.


theorem not_finite_iff_infinite : ∀ {α : Sort u_1}, ¬Finite α ↔ Infinite α := by sorry

This theorem states that for any type `α`, it is not finite if and only if it is infinite. In other words, a type `α` is infinite if it is not finite, and vice versa. This provides a direct connection between the two concepts of finiteness and infiniteness.

A type `α` is infinite if and only if it is not finite.


theorem Metric.ball_mem_nhds :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α) {ε : ℝ}, 0 < ε → Metric.ball x ε ∈ nhds x := by sorry

The theorem `Metric.ball_mem_nhds` states that for any type `α`, endowed with a pseudometric space structure, and for any point `x` of type `α` and a positive real number `ε`, the metric ball centered at `x` with radius `ε` is a neighborhood of `x`. In mathematical terms, this means that the set of all points `y` such that the distance from `y` to `x` is less than `ε`, is a neighborhood of `x` according to the topology induced by the pseudometric space structure.

For any pseudometric space (α, d), and point x ∈ α, the metric ball B(x, ε) = {y ∈ α | d(x, y) < ε} is a neighborhood of x.


Set.Finite.bddAbove

/-- A finite set is bounded above. -/
theorem Set.Finite.bddAbove :
    ∀ {α : Type u} [inst : Preorder α] [inst_1 : IsDirected α fun x x_1 => x ≤ x_1] [inst_2 : Nonempty α] {s : Set α},
      Set.Finite s → BddAbove s :=
  by sorry

This theorem states that for any type `α` with a preorder (a binary relation that is reflexive and transitive) and a direction (for any two elements in the set, there is another element that is greater than or equal to both), and for any nonempty set `s` of this type, if the set `s` is finite, then `s` is bounded above. In other words, there exists an element in `α` that is greater than or equal to every element in `s`.

If `α` is a type with a preorder and direction, then any nonempty finite subset `s` of `α` has an upper bound.


theorem RatFunc.num_div_denom :
    ∀ {K : Type u} [inst : Field K] (x : RatFunc K),
      (algebraMap (Polynomial K) (RatFunc K)) (RatFunc.num x) /
          (algebraMap (Polynomial K) (RatFunc K)) (RatFunc.denom x) =
        x :=
  by sorry

This theorem states that for any field `K` and any rational function `x` over `K`, the rational function obtained by dividing the image of the numerator of `x` under the algebraic embedding from `Polynomial K` to `RatFunc K` by the image of the denominator of `x` under the same embedding, is equal to `x` itself. In other words, representing a rational function as the division of its numerator by its denominator under the algebraic ring homomorphism from polynomials to rational functions preserves the original rational function.

The algebraic embedding of polynomials to rational functions preserves the division of numerator by denominator of a rational function.


theorem CategoryTheory.ShortComplex.comp_τ₁ :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁₂ : S₁ ⟶ S₂) (φ₂₃ : S₂ ⟶ S₃),
      (CategoryTheory.CategoryStruct.comp φ₁₂ φ₂₃).τ₁ = CategoryTheory.CategoryStruct.comp φ₁₂.τ₁ φ₂₃.τ₁ :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.comp_τ₁`, is part of category theory in mathematics. It states that for any category `C`, that has zero morphisms, and any three short complexes `S₁`, `S₂`, and `S₃` in `C`, if there are morphisms `φ₁₂` from `S₁` to `S₂` and `φ₂₃` from `S₂` to `S₃`, then the `τ₁` component of the composition of `φ₁₂` and `φ₂₃` is equal to the composition of the `τ₁` components of `φ₁₂` and `φ₂₃`. In other words, the operation of taking the `τ₁` component commutes with the operation of taking compositions of morphisms.

For any category with zero morphisms `C` and short complexes `S₁`, `S₂`, `S₃`, the diagram `τ₁(φ₁₂ ∘ φ₂₃) = τ₁(φ₁₂) ∘ τ₁(φ₂₃)` commutes, where `φ₁₂` is a morphism from `S₁` to `S₂` and `φ₂₃` is a morphism from `S₂` to `S₃`.


LieSubmodule.ext

theorem LieSubmodule.ext :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M),
      (∀ (m : M), m ∈ N ↔ m ∈ N') → N = N' :=
  by sorry

This theorem states that for any two Lie submodules `N` and `N'` of the module `M` over the commutative ring `R`, with `L` as a Lie ring and `M` as a group under addition, if every element `m` of `M` is an element of `N` if and only if it is an element of `N'`, then `N` and `N'` are the same Lie submodule. In other words, two Lie submodules are the same if they contain exactly the same elements.

Two Lie submodules of a Lie module over a commutative ring are equal if and only if they contain the same elements.


theorem QuadraticForm.map_zero :
    ∀ {R : Type u_3} {M : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (Q : QuadraticForm R M), Q 0 = 0 :=
  by sorry

This theorem, `QuadraticForm.map_zero`, states that for any commutative semiring `R`, any additive commutative monoid `M`, and any module (in the sense of abstract algebra) structure over `M` with scalars in `R`, any quadratic form `Q` applied to the zero element in `M` is equal to zero. This is a general property of quadratic forms in linear algebra.

For any commutative semiring R, additive commutative monoid M with a module structure over R, and quadratic form Q over M, Q(0) = 0.


/-- A characterization lemma for the multiplication on the Ore localization, allowing for a choice
of Ore numerator and Ore denominator.  -/
theorem OreLocalization.oreDiv_mul_char :
    ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (r₁ r₂ : R) (s₁ s₂ : ↥S)
      (r' : R) (s' : ↥S), r₂ * ↑s' = ↑s₁ * r' → r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r' /ₒ (s₂ * s') :=
  by sorry

The theorem `OreLocalization.oreDiv_mul_char` states that for any type `R` that has a Monoid structure, a submonoid `S`, and an Ore set `S`, for any `r₁`, `r₂`, and `r'` in `R`, and `s₁`, `s₂`, and `s'` in `S`, if `r₂` times the canonical embedding of `s'` is equal to the canonical embedding of `s₁` times `r'`, then the Ore division of `r₁` by `s₁` times the Ore division of `r₂` by `s₂` equals the Ore division of `r₁` times `r'` by the multiplication of `s₂` and `s'`.
This theorem is a characterization of the multiplication operation in the Ore localization of a monoid, allowing for a choice of Ore numerator and Ore denominator.

For any Monoid `R` with an Ore set `S`, if `r₂` times the embedding of `s'` equals the embedding of `s₁` times `r'`, then the Ore divisions of `r₁` by `s₁` and `r₂` by `s₂` are equal to the Ore division of `r₁` by `r'` times the product of `s₁` and `s₂`.


theorem pow_le_pow_right :
    ∀ {R : Type u_3} [inst : OrderedSemiring R] {a : R} {n m : ℕ}, 1 ≤ a → n ≤ m → a ^ n ≤ a ^ m := by sorry

This theorem states that for any type `R` that has an ordered semiring structure, given a value of `a` from `R` and two natural numbers `n` and `m`, if `a` is greater than or equal to 1 and `n` is less than or equal to `m`, then `a` to the power `n` is less than or equal to `a` to the power `m`. In other words, for non-negative real numbers, increasing the exponent while keeping the base fixed (which is at least 1) will increase or keep the same the overall value.

For any ordered semiring `R` and natural numbers `n ≤ m` with base `a` (where `a > 0`), `a^n ≤ a^m`.


ContDiffWithinAt.comp

/-- The composition of `C^n` functions at points in domains is `C^n`.  -/
theorem ContDiffWithinAt.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ∞} {s : Set E} {t : Set F} {g : F → G}
      {f : E → F} (x : E),
      ContDiffWithinAt 𝕜 n g t (f x) → ContDiffWithinAt 𝕜 n f s x → s ⊆ f ⁻¹' t → ContDiffWithinAt 𝕜 n (g ∘ f) s x :=
  by sorry

The theorem `ContDiffWithinAt.comp` states that the composition of `C^n` functions at points within certain domains is also `C^n`, under certain conditions. More specifically, for any non-trivially normed field `𝕜`, normed additive commutative groups `E`, `F`, and `G` with `𝕜` as their scalar fields, any function `g` from `F` to `G`, `f` from `E` to `F`, sets `s` and `t` in `E` and `F` respectively, and a natural number `n` (or infinity), if the function `g` is `C^n` differentiable within `t` at `f(x)` and the function `f` is `C^n` differentiable within `s` at `x`, and if the set `s` is a subset of the preimage of `t` under `f`, then the composition of `g` and `f` is `C^n` differentiable within `s` at `x`.

If functions `f : E → F` and `g : F → G` are `C^n` differentiable at `x` and `f(x)` respectively, and `s ⊆ f⁻¹(t)` where `t = f(s)`, then `g ∘ f` is `C^n` differentiable at `x`.


theorem UniformSpace.Completion.continuous_extension :
    ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {f : α → β}
      [inst_2 : CompleteSpace β], Continuous (UniformSpace.Completion.extension f) :=
  by sorry

This theorem states that, for any types `α` and `β` that are equipped with uniform space structures, and for any function `f` from `α` to `β`, if `β` is a complete space, then the extension of the function `f` to the completion of `α` is continuous. This extension, called `UniformSpace.Completion.extension f`, is defined for any map `f`, although it returns an arbitrary constant value if `f` is not uniformly continuous.

If `α` and `β` are uniform spaces with `β` complete, and `f : α → β` is a uniformly continuous function, then the extension `UniformSpace.Completion.extension f` of `f` to the completions of `α` and `β` is a continuous function.


theorem Mathlib.Data.List.Nodup._auxLemma.2 : ∀ {α : Type u}, List.Nodup [] = True := by sorry

The theorem `Mathlib.Data.List.Nodup._auxLemma.2` states that for all types `α`, an empty list of type `α` has no duplicates. In other words, the property of having no duplicates is always true for an empty list, regardless of the specific type of its elements.

The empty list has no duplicates for any type α.


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

The theorem `CategoryTheory.Adjunction.homEquiv_naturality_left` states that for any two categories `C` and `D`, and functors `F` from `C` to `D` and `G` from `D` to `C` that form an adjunction, and given two objects `X'` and `X` in `C` and an object `Y` in `D`, with a morphism `f` from `X'` to `X` in `C` and a morphism `g` from `F(X)` to `Y` in `D`, the equivalence of hom-sets given by the adjunction commutes with the composition of morphisms. More specifically, applying the equivalence to the composition of `F.map f` and `g` is the same as first applying the morphism `f` and then applying the equivalence to `g`. This theorem demonstrates one of the key properties that adjunctions in category theory must satisfy, namely, naturality with respect to the morphisms in the categories involved.

For any adjunction between functors F from category C to D and G from D to C, and given objects X, X' in C and Y in D, morphisms f: X' -> X in C and g: F(X) -> Y in D, the commutativity of the hom-set equivalence: (∘)⁃₁(F.map f ∘ g) ≡ g ∘ F.map(f).


theorem Monotone.le_map_sup :
    ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] {f : α → β},
      Monotone f → ∀ (x y : α), f x ⊔ f y ≤ f (x ⊔ y) :=
  by sorry

The theorem `Monotone.le_map_sup` states that for any types `α` and `β` that are semilattices with a sup operation, and any function `f` from `α` to `β`, if `f` is a monotone function (i.e., if `a ≤ b` then `f a ≤ f b` for all `a` and `b`), then for all `x` and `y` of type `α`, the sup (least upper bound or join) of `f x` and `f y` is less than or equal to `f` of the sup of `x` and `y`. In LaTeX mathematics, this can be expressed as: if `f` is a monotone function, then for all `x, y` in `α`, we have `f(x) ⊔ f(y) ≤ f(x ⊔ y)`.

For any semilattice types `α` and `β` with a sup operation, and any monotone function `f` from `α` to `β`, `f(x ⊔ y) ≥ f(x) ⊔ f(y)` holds. (Note that the theorem states the opposite inequality in the given description, but mathematical conventions often prefer the stated form.)