theorem ProbabilityTheory.kernel.iIndepFun.indepFun_sub_left :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β}
      [inst : Sub β] [inst_1 : MeasurableSub₂ β] {f : ι → Ω → β} [inst_2 : ProbabilityTheory.IsMarkovKernel κ],
      ProbabilityTheory.kernel.iIndepFun (fun x => m) f κ μ →
        (∀ (i : ι), Measurable (f i)) →
          ∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.kernel.IndepFun (f i - f j) (f k) κ μ :=
  by sorry

This theorem, `ProbabilityTheory.kernel.iIndepFun.indepFun_sub_left`, states that in the context of probability theory, given a measurable space `α`, an underlying sample space `Ω`, an index type `ι`, a kernel `κ` of type `ProbabilityTheory.kernel α Ω`, a measure `μ` on `α`, and a type `β` equipped with a measurable space, a subtraction operation, and a measurable subtraction operation, if every function `f` from `ι` to `Ω` to `β` is measurable and `κ` is a Markov kernel, then if `f` is independent of the kernel `κ` under measure `μ` in the sense of `ProbabilityTheory.kernel.iIndepFun`, then for any three distinct indices `i`, `j`, and `k` from `ι`, the function `f i - f j` is independent of `f k` under the kernel `κ` and the measure `μ` in the sense of `ProbabilityTheory.kernel.IndepFun`.

In simpler terms, this theorem is about the preservation of independence in a certain sense under subtraction for a family of functions in the setting of probability theory involving Markov kernels.

Given a measurable space, a kernel, a measure, and a type with measurable subtraction, if every measurable function from the index type to the type is independent of the kernel under measure and the kernel is Markov, then for any three distinct indices, the difference of the functions is independent of the third function under the kernel and the measure.


theorem dslope_same :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (f : 𝕜 → E) (a : 𝕜), dslope f a a = deriv f a :=
  by sorry

The theorem `dslope_same` states that for any function `f` from a nontrivially normed field `𝕜` to a normed add commutative group `E` over `𝕜`, the `dslope` of `f` at any point `a` in `𝕜` when both slope points are the same (i.e., `dslope f a a`) is equal to the derivative of `f` at that point `a` (`deriv f a`). In other words, the `dslope` function coincides with derivative where the two input points are the same.

For any function from a nontrivially normed field to a normed add commutative group, the `dslope` is equal to the derivative at a point when both slope points are the same.


/-- A closed ball in a strictly convex space is strictly convex.  -/
theorem strictConvex_closedBall :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NormedLinearOrderedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : StrictConvexSpace 𝕜 E] (x : E) (r : ℝ),
      StrictConvex 𝕜 (Metric.closedBall x r) :=
  by sorry

The theorem `strictConvex_closedBall` states that for every normed linear ordered field `𝕜`, and for any type `E` that forms a normed add commutative group and a normed space over `𝕜`, and which is additionally a strictly convex space, any closed ball in `E` centered at a point `x` with radius `r` is strictly convex. Here, a set in `E` is strictly convex if for any two distinct points in the set, the open line segment connecting them lies entirely within the set's interior. A closed ball in `E` is the set of all points whose distance to `x` is less than or equal to `r`.

In a strictly convex normed linear ordered field `𝕜`, a closed ball in a strictly convex normed add commutative group and normed space `E` over `𝕜` is strictly convex.


theorem BoxIntegral.Box.le_iff_Icc :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, I ≤ J ↔ BoxIntegral.Box.Icc I ⊆ BoxIntegral.Box.Icc J := by sorry

This theorem establishes a relationship between two boxes in the context of box integrals in Lean 4. In particular, for any types `ι` and any two Boxes `I` and `J`, the box `I` is less than or equal to the box `J` if and only if the closed box corresponding to `I` is a subset of the closed box corresponding to `J`. Here, a "box" refers to a multi-dimensional interval in real number space, and the "closed box" is the set of all points between the lower and upper bounds of each interval in the box.

For any types ι and boxes I and J in Lean 4, I ≤ J if and only if the closed interval I.min ≤ I.max and I.min ≤ J.min, and I.max ≤ J.max hold.


/-- See `rank_subsingleton` that assumes `Subsingleton R` instead.  -/
theorem rank_subsingleton' :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : Nontrivial R]
      [inst_4 : Subsingleton M], Module.rank R M = 0 :=
  by sorry

The theorem `rank_subsingleton'` states that for any type `R` that has a ring structure and any type `M` that is an additive commutative group and a module over `R`, if `R` is nontrivial (meaning it contains at least two distinct elements) and `M` is a subsingleton (meaning it contains at most one distinct element), then the rank of the module `M` over the ring `R` is zero.

If `R` is a nontrivial ring and `M` is a subsingleton additive commutative group that is an `R`-module, then the rank of `M` over `R` is 0.


theorem Associated.of_mul_left :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {a b c d : α},
      Associated (a * b) (c * d) → Associated a c → a ≠ 0 → Associated b d :=
  by sorry

This theorem states that for any type `α` that has an instance of the `CancelCommMonoidWithZero` typeclass, and for any four elements `a`, `b`, `c`, `d` of this type, if the elements `a * b` and `c * d` are associated and the elements `a` and `c` are associated, and if `a` is not zero, then the elements `b` and `d` are also associated. In mathematical terms, if `a * b` is associated with `c * d` and `a` is associated with `c`, with `a` being non-zero, then `b` is associated with `d`. The `Associated` relation here means that one element can be obtained by multiplying the other by a unit.

If `a` is a non-zero element of a type `α` with `CancelCommMonoidWithZero`, and `a * b` is associative with `c * d` and `a` is associative with `c`, then `b` is associative with `d`.


theorem WithTop.coe_sInf' :
    ∀ {α : Type u_1} [inst : InfSet α] {s : Set α}, Set.Nonempty s → ↑(sInf s) = sInf ((fun a => ↑a) '' s) := by sorry

The theorem `WithTop.coe_sInf'` states that for any type `α` which has an infimum operation defined on its set of instances (`InfSet α`), and any non-empty set `s` of type `α`, the infimum of `s` when considered as an element of `WithTop α` (denoted by `↑(sInf s)`) is equal to the infimum of the image of `s` under the function that maps each element to an element of `WithTop α`. In other words, embedding the infimum of a non-empty set into `WithTop α` preserves the value of the infimum.

For any non-empty set `s` in a type `α` with an infimum operation, the infimum of `s` in `WithTop α` is equal to the infimum of the image of `s` under the function mapping elements to their `WithTop α` counterparts.


theorem Polynomial.irreducible_mul_leadingCoeff_inv :
    ∀ {K : Type u_1} [inst : DivisionRing K] {p : Polynomial K},
      Irreducible (p * Polynomial.C (Polynomial.leadingCoeff p)⁻¹) ↔ Irreducible p :=
  by sorry

This theorem states that for any division ring `K` and any polynomial `p` over `K`, the polynomial `p` is irreducible if and only if the product of `p` and the inverse of the constant polynomial of the leading coefficient of `p` is also irreducible. Here, irreducibility refers to the property of a polynomial that it cannot be factored into a product of two non-constant polynomials. In mathematical notation, this would read as `p` is irreducible if and only if `p * C(leadingCoeff(p))⁻¹` is irreducible, where `C(a)` represents a constant polynomial `a` and `leadingCoeff(p)` is the coefficient of the highest power of `X` in `p`.

A polynomial `p` over a division ring `K` is irreducible if and only if the constant polynomial `C(leadingCoeff(p))⁻¹ * p` is irreducible.


theorem differentiableAt_inv' :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {R : Type u_6} [inst_1 : NormedDivisionRing R]
      [inst_2 : NormedAlgebra 𝕜 R] [inst_3 : CompleteSpace R] {x : R}, x ≠ 0 → DifferentiableAt 𝕜 Inv.inv x :=
  by sorry

The theorem `differentiableAt_inv'` states that for any non-zero element `x` in a complete normed division ring `R`, which is also a normed algebra over a non-trivially normed field `𝕜`, the function representing the inverse operation `Inv.inv` is differentiable at `x`. In other words, there exists a derivative of the inverse operation at any non-zero point in the ring.

The inverse function in a complete normed division ring that is also a normed algebra over a non-trivially normed field is differentiable at any non-zero element.


theorem MvPolynomial.degrees_monomial :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (s : σ →₀ ℕ) (a : R),
      MvPolynomial.degrees ((MvPolynomial.monomial s) a) ≤ Finsupp.toMultiset s :=
  by sorry

The theorem `MvPolynomial.degrees_monomial` states that for any commutative semiring `R`, any type `σ`, any function `s` from `σ` to the natural numbers, and any element `a` of `R`, the multiset of degrees of the monomial formed by applying the function `MvPolynomial.monomial` to `s` and `a` is less than or equal to the multiset obtained from `s` by `Finsupp.toMultiset`. In simpler terms, in a multivariate polynomial, the degrees of any monomial won't exceed the corresponding degrees given by the function `s`.

For any commutative semiring R, function s from σ to Nat, and a in R, the degrees of monomials obtained from applying MvPolynomial.monomial to s and a are less than or equal to the multiset obtained from s using Finsupp.toMultiset.


theorem Ideal.comap_ne_top :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F) {K : Ideal S}, K ≠ ⊤ → Ideal.comap f K ≠ ⊤ :=
  by sorry

This theorem states that for any semirings `R` and `S`, any function `f` which is also a ring homomorphism from `R` to `S`, and any ideal `K` of `S`, if `K` is not the entire ring `S` (i.e., `K ≠ ⊤`), then the preimage of `K` under `f` (obtained using `Ideal.comap f K`) is not the entire ring `R` (i.e., `Ideal.comap f K ≠ ⊤`).

In other words, if an ideal in the codomain of a ring homomorphism is not the whole ring, then its preimage (under that homomorphism) in the domain is not the whole ring either.

If `f` is a ring homomorphism from semiring `R` to semiring `S` and ideal `K` of `S` is proper (i.e., `K ≠ S`), then the preimage `Ideal.comap f K` of `K` under `f` in `R` is also proper (i.e., `Ideal.comap f K ≠ R`).


theorem MeasureTheory.IsFundamentalDomain.lintegral_eq_tsum_of_ac :
    ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
      {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableSMul G α]
      [inst_5 : MeasureTheory.SMulInvariantMeasure G α μ] [inst_6 : Countable G] {ν : MeasureTheory.Measure α},
      MeasureTheory.IsFundamentalDomain G s μ →
        MeasureTheory.Measure.AbsolutelyContinuous ν μ →
          ∀ (f : α → ENNReal), ∫⁻ (x : α), f x ∂ν = ∑' (g : G), ∫⁻ (x : α) in g • s, f x ∂ν :=
  by sorry

This theorem, `MeasureTheory.IsFundamentalDomain.lintegral_eq_tsum_of_ac`, states that for any types `G` and `α` where `G` is a group and `α` is a mul-action of `G`, and for any sets `s` of `α`, `μ` as a measure on `α`, and `ν` as another measure on `α`, if `s` is a fundamental domain of `G` with respect to `μ`, and `ν` is absolutely continuous with respect to `μ`, then for any function `f` from `α` to extended nonnegative real numbers, the integral of `f` with respect to `ν` is equal to the sum over all elements `g` in `G` of the integral of `f` over the set `g • s` with respect to `ν`. In the context of measure theory, this theorem establishes a relationship between an integral over a measure space and a sum over a group action, under certain conditions.

If `G` is a group acting on a set `α` with measure `μ`, `ν` is an absolutely continuous measure on `α` with respect to `μ`, and `s` is a fundamental domain of `G` with respect to `μ`, then for any integrable function `f` on `α` with respect to `ν`, the integral of `f` with respect to `ν` is equal to the sum over all elements `g` in `G` of the integral of `f` over `g•s` with respect to `ν`.


theorem HomologicalComplex.p_fromOpcycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι)
      [inst_2 : HomologicalComplex.HasHomology K i],
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.pOpcycles K i) (HomologicalComplex.fromOpcycles K i j) =
        K.d i j :=
  by sorry

The theorem `HomologicalComplex.p_fromOpcycles` states that for any category `C` with zero morphisms, and for any homological complex `K` of a certain complex shape with homology in degree `i`, the composition of the projection to the opcycles of `K` at `i` and the morphism from opcycles of `K` between `i` and `j`, is equal to the differential `d` of `K` between `i` and `j`.

In other words, if you have a homological complex `K`, and pick two degrees `i` and `j`, the process of first projecting to the opcycles at `i` and then mapping from opcycles between `i` and `j`, is the same as directly applying the differential from `i` to `j`. This theorem essentially asserts a compatibility condition between the differential and the projection to/from the opcycles.

For any homological complex in a category with zero morphisms, the projection to opcycles followed by the morphism between opcycles is equal to the differential between the corresponding degrees.


theorem Mathlib.Data.Finsupp.Order._auxLemma.14 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) := by sorry

This theorem, `Mathlib.Data.Finsupp.Order._auxLemma.14`, states that for any type `α`, any type `M` that has a zero element (`inst : Zero M`), a function `f` from `α` to `M` and an element `a` of type `α`, `a` is in the support of `f` if and only if the function `f` applied to `a` is not equal to zero. In other words, the support of a function `f` in this context is the set of elements `a` such that `f(a)` is not zero.

The theorem `Mathlib.Data.Finsupp.Order._auxLemma.14` in Lean 4 states that for any function `f` from type `α` to a type `M` with a zero element, the element `a` is in the support of `f` if and only if `f(a)` is non-zero.


theorem DiscreteQuotient.isClopen_preimage :
    ∀ {X : Type u_2} [inst : TopologicalSpace X] (S : DiscreteQuotient X) (A : Set (Quotient S.toSetoid)),
      IsClopen (DiscreteQuotient.proj S ⁻¹' A) :=
  by sorry

This theorem states that given a type `X` equipped with a topological structure, a discrete quotient `S` of `X`, and a set `A` of elements in the quotient space under the equivalence relation defined by `S`, the preimage of `A` under the projection map from `X` to the quotient space, as implemented by `DiscreteQuotient.proj S`, is a clopen set. This means that this preimage is both a closed and open set in the topology of `X`.

Given a topological space `(X,τ)`, a discrete quotient `S` of `X`, and a set `A` in the quotient space `S/ⓝ` under the equivalence relation `ⓝ`, the preimage `(∘π_1∘inverse∘CHeadle_Quotient.core.coe)''(A)` is a clopen set in the topology `τ` on `X`, where `π_1 : X → S/ⓝ` is the quotient map.


theorem ENNReal.zero_lt_top : 0 < ⊤ := by sorry

This theorem states that zero is less than infinity in the set of extended non-negative real numbers. In mathematical terms, it confirms that 0 is strictly less than infinity (0 < ∞) when considering the spectrum that includes all non-negative real values as well as the concept of infinity.

In the extended non-negative real numbers, 0 is strictly less than infinity (0 < ∞).


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

This theorem states that for any two natural numbers `n` and `m`, `n` is less than the predecessor of `m` if and only if the successor of `n` is less than `m`. In mathematical terms, it expresses the equivalence $n < m-1 \iff n+1 < m$ for natural numbers $n$ and $m$. Here, `Nat.pred` refers to the predecessor function (subtracting 1), and `Nat.succ` refers to the successor function (adding 1).

For natural numbers `n` and `m`, `n < m` if and only if `Nat.succ n < m`.


theorem not_mem_tsupport_iff_eventuallyEq :
    ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : Zero β] {f : α → β} {x : α},
      x ∉ tsupport f ↔ f =ᶠ[nhds x] 0 :=
  by sorry

This theorem states that for any type `α` with a topology, type `β` with zero, a function `f` from `α` to `β`, and an element `x` of `α`, `x` is not in the topological support of `f` if and only if the function `f` is eventually equal to zero around `x`. In other words, `x` does not belong to the closure of the set where `f` is nonzero if and only if for all neighborhoods of `x` (as defined by the neighborhood filter `nhds x`), `f` equals zero almost everywhere in those neighborhoods.

For any continuous function $f : X \to Y$ where $X$ is a topological space, $Y$ has a zero element, and $x \in X$, $x$ is not in the closure of $f^{-1}(Y \setminus \{0\})$ if and only if $f(x) = 0$ and $f$ is zero in a neighborhood of $x$.


/-- If `A` is an `R`-algebra such that the induced morphism `R →+* A` is surjective, then the
`R`-module generated by a set `X` equals the `A`-module generated by `X`.  -/
theorem Submodule.restrictScalars_span :
    ∀ (R : Type u) (A : Type w) {M : Type v₁} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M],
      Function.Surjective ⇑(algebraMap R A) →
        ∀ (X : Set M), Submodule.restrictScalars R (Submodule.span A X) = Submodule.span R X :=
  by sorry

The theorem `Submodule.restrictScalars_span` states that for any commutative semiring `R`, any semiring `A`, and any type `M` forming a module over `R` and `A`, and assuming `R` is a scalar tower over `A` and `M`, if the morphism induced by the `R`-algebra structure on `A` is surjective (meaning every element in `A` is mapped from an element in `R`), then the `R`-module generated by any set `X` is the same as the `A`-module generated by the same set `X`. In mathematical terms, if every element of `A` can be expressed as a result of some `R`-algebra operation, then the span of a set `X` under `R` and `A` are the same.

If `R` is a commutative semiring that is a scalar tower over semiring `A`, `M` is a module over both `R` and `A`, and the `R`-algebra structure morphism from `A` to the `R`-algebra of `M` is surjective, then the `R`-module generated by a set `X` equals the `A`-module generated by `X`.


theorem List.range'_append :
    ∀ (s m n step : ℕ), List.range' s m step ++ List.range' (s + step * m) n step = List.range' s (n + m) step := by
  sorry

This theorem states that for any four natural numbers `s`, `m`, `n`, and `step`, the concatenation of the range from `s` to `s + step * m` with step size `step` and the range from `s + step * m` to `s + step * m + step * n` with step size `step` is equal to the range from `s` to `s + step * (n + m)` with step size `step`. The function `List.range'` generates a list of natural numbers starting from a specific number, increasing by a given step size.

For any natural numbers `s`, `m`, `n`, and `step`, the list of numbers from `s` to `s + step * (m + n)` with step size `step` is equal to the concatenation of the lists generated by `List.range'` with step `step` from `s` to `s + step * m` and from `s + step * m` to `s + step * (m + n)`.


/-- Transport a `HasColimitsOfSize` instance across an equivalence.  -/
theorem CategoryTheory.Adjunction.has_colimits_of_equivalence :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor C D)
      [inst_2 : CategoryTheory.IsEquivalence E] [inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₂, u₂} D],
      CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₁, u₁} C :=
  by sorry

This theorem states that for any two categories `C` and `D`, given an equivalence functor `E` from `C` to `D` and assuming that the category `D` has colimits of any size, then the category `C` also has colimits of any size. In other words, the presence of colimits in a category can be transported across an equivalence of categories.

If `C` and `D` are categories with `D` having colimits of any size, and `E: C -> D` is an equivalence functor, then `C` also has colimits of any size.


theorem AddConstMapClass.map_sub_nsmul :
    ∀ {F : Type u_1} {G : Type u_2} {H : Type u_3} {a : G} {b : H} [inst : AddGroup G] [inst_1 : AddGroup H]
      [inst_2 : AddConstMapClass F G H a b] (f : F) (x : G) (n : ℕ), f (x - n • a) = f x - n • b :=
  by sorry

This theorem states that for every types `F`, `G`, `H`, an element `a` in `G`, an element `b` in `H`, with `G` and `H` being AddGroups, and a `AddConstMapClass` instance for `F`, `G`, `H`, `a`, `b`, the map `f` from `F` to `G` has the property that for any `x` in `G` and any natural number `n`, applying `f` to the difference of `x` and `n` times `a` equals the difference of `f(x)` and `n` times `b`. In terms of mathematical notation, for all `f : F -> G`, `x : G`, and `n : ℕ`, we have `f(x - n*a) = f(x) - n*b`.

For any AddGroups G, H, types F with an AddConstMapClass instance, elements a in G, b in H, and functions f : F -> G, we have f(x - na) = f(x) - nb for all x in G and natural numbers n.


theorem multiplicity.not_finite_iff_forall :
    ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, ¬multiplicity.Finite a b ↔ ∀ (n : ℕ), a ^ n ∣ b := by sorry

The theorem `multiplicity.not_finite_iff_forall` states that for any type `α` that forms a Monoid, and for any elements `a` and `b` of that Monoid, the multiplicity of `a` in `b` is not finite if and only if `a` raised to any natural number `n` divides `b`. In other words, the multiplicity of `a` in `b` being infinite means that for every natural number, `a` to the power of that number will be a divisor of `b`.

For any Monoid type `α` and elements `a` and `b` of `α`, the multiplicity of `a` in `b` is not finite if and only if `a` raises to every natural number `n` is a divisor of `b`.


theorem Cardinal.mk_set : ∀ {α : Type u}, Cardinal.mk (Set α) = 2 ^ Cardinal.mk α := by sorry

This theorem states that for any type `α`, the cardinality of the Set of `α` is equal to 2 raised to the power of the cardinality of `α`. In other words, the number of distinct sets that can be formed using elements of type `α` is equivalent to the total number of subsets of a set with cardinality equal to that of type `α`. This is the mathematical concept of the power set, where the cardinality of the power set of a set with cardinality `n` is `2^n`.

For any type `α`, the cardinality of its power set is 2 raised to the power of the cardinality of `α`.


theorem Filter.Germ.const_le :
    ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : LE β] {x y : β}, x ≤ y → ↑x ≤ ↑y := by sorry

This theorem, `Filter.Germ.const_le`, states that for any types `α` and `β`, any filter `l` on `α`, any less-than-or-equal relation on `β`, and any two elements `x` and `y` of `β`, if `x` is less than or equal to `y` then the germ (or equivalence class) of `x`, denoted as `↑x`, is less than or equal to the germ of `y`, denoted as `↑y`, under the filter `l`. In other words, this relation preserves the order of elements when they are lifted to their germs in the context of a specific filter.

For any filter $l$ on type $\alpha$, relation $R$ on type $\beta$, and elements $x, y$ of $\beta$ with $x R y$, we have $↑\_xl ≤ ↑\_yl$ in the quotient structure of the filter $l$ on $\alpha$.


theorem Real.isLUB_sSup : ∀ (S : Set ℝ), Set.Nonempty S → BddAbove S → IsLUB S (sSup S) := by sorry

The theorem `Real.isLUB_sSup` states that for any given set `S` of real numbers, if `S` is not empty (`Set.Nonempty S`) and `S` is bounded above (`BddAbove S`), then the supremum of `S` (`sSup S`) is the least upper bound of `S`. In other words, for any non-empty set of real numbers that has an upper bound, the smallest value that is greater than or equal to every number in the set (supremum) is also the least upper bound of the set.

For any non-empty, bounded above set of real numbers S, the supremum of S is the least upper bound of S.


theorem continuous_sInf_dom :
    ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : Set (TopologicalSpace α)} {t₂ : TopologicalSpace β}
      {t : TopologicalSpace α}, t ∈ t₁ → Continuous f → Continuous f :=
  by sorry

This theorem states that given any types `α` and `β`, a function `f` from `α` to `β`, a set `t₁` of topological spaces over `α`, a topological space `t₂` over `β`, and a topological space `t` over `α`, if `t` is an element of `t₁`, and if the function `f` is continuous, then the function `f` is still continuous. Essentially, the theorem asserts the continuity of a function `f` does not change regardless of whether the topological space in the domain is in a set of such spaces or not.

Given types `α`, `β`, a function `f` from `α` to `β`, a topological space `t` over `α`, and a set `t₁` of topological spaces over `α`, if `t` is an element of `t₁` and `f` is continuous, then `f` is continuous with respect to `t₂`, the topological space over `β`.


theorem pow_eq_one_iff_of_nonneg :
    ∀ {R : Type u_3} [inst : LinearOrderedSemiring R] {a : R} {n : ℕ}, 0 ≤ a → n ≠ 0 → (a ^ n = 1 ↔ a = 1) := by sorry

This theorem, `pow_eq_one_iff_of_nonneg`, states that for any type `R` that is a Linear Ordered Semiring and any non-negative real number `a` and a non-zero natural number `n` in `R`, `a` raised to the power `n` equals 1 if and only if `a` itself equals 1. Essentially, for a non-negative number `a` and a non-zero exponent `n`, `a^n` is 1 only when `a` is 1.

For any non-negative element `a` in a Linear Ordered Semiring `R` and non-zero natural number `n`, `a^n = 1` if and only if `a = 1`.


theorem Mathlib.Algebra.Parity._auxLemma.12 :
    ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a := by sorry

This theorem states that for any type `α` that is a subtraction monoid (i.e., a structure with a subtraction operation that obeys certain properties), if an element `a` of `α` is even (meaning it can be expressed as the sum of two equal values), then the negation of `a` is also even. Conversely, if the negation of `a` is even, then `a` itself is also even. The "evenness" of a number is preserved under negation.

For any subtraction monoid type `α`, if `a` is an even element, then the negation of `a` is even, and vice versa.


/-- The sum of `f i` over `i ∈ {a}` equals `f a`. -/
theorem finsum_mem_singleton :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] {f : α → M} {a : α},
      (finsum fun i => finsum fun h => f i) = f a :=
  by sorry

This theorem states that for any given type `α` and `M` with `M` being an additive commutative monoid, and any function `f` mapping from `α` to `M`, and any element `a` of type `α`, the sum of the function `f` evaluated at `i` for each `i` in the singleton set `{a}` is equal to the function `f` evaluated at `a`. In other words, the finite sum over a singleton set is just the function evaluated at that single element.

For any additive commutative monoid M, function f from type α to M, and element a of α, the sum of f evaluated at the singleton set {a} equals f evaluated at a. In mathematical notation, ∏i ∈ {a} f i = f a.


theorem Mathlib.Algebra.Parity._auxLemma.20 :
    ∀ {α : Type u_2} [inst : Semiring α] {m : α}, Even m → ∀ (n : α), Even (m * n) = True := by sorry

This theorem states that for any type `α` that is a semiring, if an element `m` of `α` is even, then for any other element `n` of `α`, the product `m * n` is also even. In the mathematical terms, if `m` is an even number in the ring, meaning there exists another number `r` in the ring such that `m = r + r`, then for any number `n` in the ring, the statement that `m * n` is also an even number is always true.

If `α` is a semiring and `m` is an even element of `α`, then `m * n` is even for all `n` in `α`.


theorem MvPolynomial.coeff_zero :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (m : σ →₀ ℕ), MvPolynomial.coeff m 0 = 0 := by sorry

The theorem `MvPolynomial.coeff_zero` states that for any type `R` with a commutative semiring structure and any type `σ`, the coefficient of the monomial `m` (represented as a function from `σ` to `ℕ`) in the zero multi-variable polynomial over `R` is always zero. This is a standard property of polynomials: the zero polynomial has all coefficients equal to zero.

For any commutative semiring `R` and any monomial `m` of a multi-variable polynomial over `R`, the coefficient of `m` in the zero polynomial is zero.


theorem ConvexOn.convex_le :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] [inst_5 : OrderedSMul 𝕜 β] {s : Set E}
      {f : E → β}, ConvexOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ f x ≤ r} :=
  by sorry

The theorem `ConvexOn.convex_le` states that for any ordered semiring `𝕜`, a set `E`, an ordered additively commutative monoid `β`, with a suitable scalar multiplication (as specified by `SMul 𝕜 E`, `Module 𝕜 β`, and `OrderedSMul 𝕜 β`), a set `s` of type `E`, and a function `f` from `E` to `β`, if the function `f` is convex on the set `s`, then for any value `r` of type `β`, the subset of `s` where `f` is less than or equal to `r` is also a convex set.

In more informal terms, if a function is convex on a set, then the "level sets" of that function (the sets of points where the function value is below a certain level) are also convex.

If a function is convex on a convex subset of an ordered semiring with respect to a suitable scalar multiplication, then the level sets of the function are also convex.


theorem Filter.mem_prod_self_iff :
    ∀ {α : Type u_1} {la : Filter α} {s : Set (α × α)}, s ∈ la ×ˢ la ↔ ∃ t ∈ la, t ×ˢ t ⊆ s := by sorry

This theorem states that for any type `α`, any filter `la` on `α`, and any set `s` of pairs of `α`, `s` is in the product of `la` with itself if and only if there exists a set `t` in `la` such that the Cartesian product of `t` with itself is a subset of `s`. Here, the Cartesian product `t ×ˢ t` of `t` with itself is the set of all ordered pairs `(a, b)` where `a` and `b` are both elements of `t`. A filter `la` on a type `α` is a particular collection of subsets of `α` that satisfies certain mathematical conditions.

For any filter `la` on a type `α` and any set `s` of pairs from `α`, `s` is in the product of `la` with itself if and only if there exists a set `t` in `la` such that `t × t` is a subset of `s`.


Summable.neg

theorem Summable.neg :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] {f : β → α}, Summable f → Summable fun b => -f b :=
  by sorry

The theorem `Summable.neg` states that for any given types `α` and `β`, where `α` is an additive commutative group and topological space that forms a topological additive group, and a function `f` from `β` to `α` is summable (i.e., the series formed by the function `f` converges to a limit in `α`) then the function which maps each element `b` in `β` to the negative of `f(b)` is also summable. In other words, if a series converges, then its negated series also converges.

If `f` is a summable function from a topological additive group `β` to an additive commutative group and topological space `α`, then the function mapping each `b` in `β` to the negative of `f(b)` is also summable.


theorem min_add_add_left :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Add α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b c : α),
      min (a + b) (a + c) = a + min b c :=
  by sorry

This theorem, named `min_add_add_left`, states that for any type `α` that has a linear order, an addition operation, and is a covariant class with respect to addition and the less than or equal to relation, for any three elements `a`, `b`, and `c` of `α`, the minimum of the sums `a + b` and `a + c` is equal to `a` plus the minimum of `b` and `c`. In mathematical terms, it says that $\min(a + b, a + c) = a + \min(b, c)$.

For any type `α` with a linear order and covariant addition, the minimum of `a + b` and `a + c` equals `a + min(b, c)` for all elements `a, b, c` in `α`.


theorem IntermediateField.sup_toSubalgebra_of_isAlgebraic_right :
    ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
      (E1 E2 : IntermediateField K L),
      Algebra.IsAlgebraic K ↥E2 → (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra :=
  by sorry

The theorem `IntermediateField.sup_toSubalgebra_of_isAlgebraic_right` states that for any two `IntermediateField`s `E1` and `E2` of a field extension `L` over a field `K`, where all elements of `E2` are algebraic over `K`, the subalgebra corresponding to the supremum of `E1` and `E2` (denoted as `(E1 ⊔ E2).toSubalgebra`) is equal to the supremum of the subalgebras corresponding to `E1` and `E2` (denoted as `E1.toSubalgebra ⊔ E2.toSubalgebra`). This means when `E2` is algebraic over `K`, we can commute the operations of taking supremum and converting to a subalgebra between two intermediate fields.

Given an interval `[E1, E2]` of `IntermediateField`s over a field `K` with `E2` algebraic over `K`, the subalgebras of `K` generated by `E1` and `E2` respectively, `E1.toSubalgebra` and `E2.toSubalgebra`, have the same supremum, i.e., `(E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra`.


theorem Subgroup.exists_right_transversal :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (g : G), ∃ S ∈ Subgroup.rightTransversals ↑H, g ∈ S := by sorry

In the context of a group `G`, the theorem `Subgroup.exists_right_transversal` states that for any subgroup `H` of `G` and any element `g` in `G`, there exists a set `S` which is a right transversal of `H` (i.e., a set `S` that complements `H` in `G` such that every element of `G` can be uniquely written as the product of an element of `H` and an element of `S`), and this set `S` contains the element `g`.

For any group `G` and subgroup `H`, there exists a right transversal `S` of `H` in `G` containing an element `g` in `G`.


/-- **Riesz's theorem**: if a closed ball with center zero of positive radius is compact in a vector
space, then the space is finite-dimensional.  -/
theorem FiniteDimensional.of_isCompact_closedBall₀ :
    ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace 𝕜] {r : ℝ},
      0 < r → IsCompact (Metric.closedBall 0 r) → FiniteDimensional 𝕜 E :=
  by sorry

**Riesz's theorem**: For any nontrivially normed field `𝕜` and any normed additive commutative group `E` that is also a normed space over `𝕜` and is complete with respect to `𝕜`, if there exists a positive real number `r` such that the closed ball in `E` with center at zero and radius `r` is a compact set, then `E` is a finite-dimensional vector space over `𝕜`. In other words, this theorem states that compactness of a closed ball in a vector space implies finiteness of the dimension of the vector space.

If a complete, normed vector space over a nontrivially normed field with a compact closed ball has finite radius, then the space is finite-dimensional.


theorem MeasureTheory.Measure.dirac_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (a : α) (s : Set α),
      ↑↑(MeasureTheory.Measure.dirac a) s = Set.indicator s 1 a :=
  by sorry

The theorem `MeasureTheory.Measure.dirac_apply` states that for any type `α` that has a measurable space structure and a measurable singleton class structure, any element `a` of type `α`, and any set `s` of elements of type `α`, the measure of the set `s` under the dirac measure centered at `a` is equal to the indicator function of `s` evaluated at `a`. This indicator function is defined such that it equals 1 if `a` belongs to `s`, and 0 otherwise. In other words, the dirac measure of a set `s` at a point `a` is 1 if `a` is in `s`, and 0 otherwise.

For any measurable space and measurable singleton class structure on type `α`, the dirac measure of a set `s` at point `a` equals the indicator function of `s` evaluated at `a`.


theorem map_eq_bind_pure_comp :
    ∀ {α β : Type u} (m : Type u → Type v) [inst : Monad m] [inst_1 : LawfulMonad m] (f : α → β) (x : m α),
      f <$> x = x >>= pure ∘ f :=
  by sorry

This theorem, `map_eq_bind_pure_comp`, states that for any monad `m`, any types `α` and `β`, and any function `f` from `α` to `β`, the operation of mapping `f` over a monadic value `x` (`f <$> x`) is equivalent to first applying `f` to `x` using the monadic bind operator (`>>=`), and then lifting the result into the monadic context with `pure`. In mathematical terms, this is an expression of the interchange law for monads, which dictates how the operations of bind and map interact.

For any monad `m`, type `α`, function `f : α → β`, and value `x : m α`, `f <$> x` is equivalent to `lift (f x)` where `lift = pure . f`.


theorem Polynomial.sum_C_index :
    ∀ {R : Type u} [inst : Semiring R] {a : R} {β : Type u_1} [inst_1 : AddCommMonoid β] {f : ℕ → R → β},
      f 0 0 = 0 → Polynomial.sum (Polynomial.C a) f = f 0 a :=
  by sorry

The theorem `Polynomial.sum_C_index` states that for any semiring `R`, any element `a` of `R`, any type `β` that is an additive commutative monoid, and any function `f` from `ℕ` x `R` to `β`, if `f` maps `(0, 0)` to `0`, then the sum of the values of `f` applied to the coefficients of the constant polynomial `a` is equal to `f` applied to `(0, a)`. In simpler terms, this means that the sum of the function `f` applied to the coefficients of a constant polynomial only depends on the zeroth coefficient.

For any semiring `R`, any additive commutative monoid `β`, any function `f` from `ℕ x R` to `β` that maps `(0, 0)` to `0`, the sum of `f` applied to the coefficients of a constant polynomial equals `f` applied to `(0, coefficient of constant polynomial)`.


theorem Polynomial.natTrailingDegree_le_natDegree :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), Polynomial.natTrailingDegree p ≤ Polynomial.natDegree p := by
  sorry

The theorem `Polynomial.natTrailingDegree_le_natDegree` states that for any type `R` that is a semiring, and for any polynomial `p` over this type, the natural trailing degree of `p` is less than or equal to its natural degree. In terms of polynomial mathematics, this implies that the lowest degree of a non-zero term in the polynomial is always less than or equal to the highest degree of a term in the polynomial.

For any semiring R and polynomial p over R, the degree of the leading term of p is greater than or equal to the degree of any other non-zero term in p. (The theorem in Lean actually states the negative of this, as it defines trailing degree as the negative of the degree of the leading term, hence the inequality is reversed in the Lean theorem.)


AddSubgroup.coeSubtype

theorem AddSubgroup.coeSubtype :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), ⇑(AddSubgroup.subtype H) = Subtype.val := by sorry

The theorem `AddSubgroup.coeSubtype` asserts that for any additive group `G` and any subgroup `H` of `G`, the group homomorphism from the subgroup `H` to the group `G` (given by the `AddSubgroup.subtype` function) is equivalent to the underlying element in the base type (given by the `Subtype.val` function). In other words, applying the homomorphism to an element of the subgroup yields the same result as just taking the underlying element of the group.

For any additive group G and its subgroup H, the group homomorphism from H to G given by AddSubgroup.subtype is the same as the identity function on underling elements.


ContinuousMap.HomotopyWith.ext

theorem ContinuousMap.HomotopyWith.ext :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
      {P : C(X, Y) → Prop} {F G : ContinuousMap.HomotopyWith f₀ f₁ P}, (∀ (x : ↑unitInterval × X), F x = G x) → F = G :=
  by sorry

This theorem states that for any two topological spaces `X` and `Y`, and any two continuous functions `f₀` and `f₁` from `X` to `Y`, if `P` is a property of the continuous functions, and `F` and `G` are both homotopies from `f₀` to `f₁` satisfying the property `P`, then if `F` and `G` agree on all points in the product of the unit interval `[0,1]` and `X`, then `F` and `G` are the same. In other words, two homotopies satisfying a certain property are equal if they coincide on the unit interval cross the topological space.

Given topological spaces X and Y, continuous functions f₀, f₁ : X → Y, property P for continuous functions, and homotopies F, G : [0, 1] × X → Y satisfying P(F), P(G) and F = G on [0, 1] × X, then F = G.


theorem List.lt_length_left_of_zipWith :
    ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β},
      i < List.length (List.zipWith f l l') → i < List.length l :=
  by sorry

The theorem `List.lt_length_left_of_zipWith` establishes that for any types `α`, `β`, and `γ`, a function `f` that takes an element of type `α` and an element of type `β` and returns an element of type `γ`, and lists `l` of type `α` and `l'` of type `β`, if an index `i` is less than the length of the list resulting from zipping `l` and `l'` using function `f` (i.e., `List.zipWith f l l'`), then `i` is also less than the length of list `l`.

For any types `α`, `β`, and `γ`, and lists `l` of length `n` in `α` and `l'` of length `m` in `β`, if `i` is less than the length `(n + m)` of the list obtained by zipping `l` and `l'` with function `f : α × β → γ`, then `i` is less than the length `n` of `l`.


theorem Set.Finite.fin_embedding : ∀ {α : Type u} {s : Set α}, Set.Finite s → ∃ n f, Set.range ⇑f = s := by sorry

The theorem `Set.Finite.fin_embedding` states that for any type `α` and any set `s` of type `α`, if the set `s` is finite, then there exists a natural number `n` and a function `f` such that the range of `f` is exactly the set `s`. In other words, every finite set `s` of elements of some type `α` can be put into one-to-one correspondence (or "embedded") with a finite subset of the natural numbers, specified by the function `f`. This function `f` is essentially encoding the index of each element in the set `s`, allowing us to map each element of `s` to a unique natural number in the range 0 to `n-1`, where `n` is the size of the set `s`.

Every finite set can be embedded as a subset of the natural numbers.


theorem Associates.mem_factorSet_some :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [dec_irr : (p : Associates α) → Decidable (Irreducible p)]
      {p : Associates α} {hp : Irreducible p} {l : Multiset { a // Irreducible a }},
      p ∈ ↑l ↔ { val := p, property := hp } ∈ l :=
  by sorry

The theorem `Associates.mem_factorSet_some` asserts that for any type `α` with a structure of a cancel commutative monoid with zero, any element `p` of the `Associates` of `α` (i.e., the quotient of the monoid `α` by the `Associated` relation), and any multiset `l` of irreducible elements, the element `p` is a member of the underlying set of `l` if and only if it is a member of `l` itself when we consider `p` as an element with the property of irreducibility. In essence, this theorem is about the membership of irreducible elements in multisets, considering both the set and the specific irreducible property of elements.

For any cancel commutative monoid with zero `α`, an irreducible element `p` in `α` is a member of a multiset `l` of irreducible elements if and only if `p` is itself a member of `l` when regarded as an element of the underlying set.


theorem Real.sqrt_lt' : ∀ {x y : ℝ}, 0 < y → (Real.sqrt x < y ↔ x < y ^ 2) := by sorry

The theorem `Real.sqrt_lt'` asserts that for any two real numbers `x` and `y`, if `y` is greater than zero, then the square root of `x` is less than `y` if and only if `x` is less than the square of `y`. In mathematical terms, this can be written as ∀ {x y : ℝ}, 0 < y → (sqrt(x) < y ↔ x < y^2).

For any real numbers x and y with y > 0, sqrt(x) < y if and only if x < y^2.


theorem IsLinearMap.isLinearMap_add :
    ∀ {R : Type u_1} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      IsLinearMap R fun x => x.1 + x.2 :=
  by sorry

This theorem states that, for any semiring `R` and any additive commutative monoid `M` that also has the structure of an `R`-module, the function that takes a pair of elements `(x, y)` in `M` and adds them together is a linear map. In mathematical terms, given any scalar `r` and any two elements `m1`, `m2` of `M`, the function respects scalar multiplication (`f(r * m) = r * f(m)`) and addition (`f(m1 + m2) = f(m1) + f(m2)`).

For any semiring `R`, additive commutative monoid `M` being an `R`-module implies the addition function on `M` is a linear map with respect to scalars and vectors.


theorem Nat.abs_ofNat :
    ∀ {α : Type u_1} [inst : LinearOrderedRing α] (n : ℕ) [inst_1 : Nat.AtLeastTwo n],
      |OfNat.ofNat n| = OfNat.ofNat n :=
  by sorry

The theorem `Nat.abs_ofNat` states that for any type `α` which is a LinearOrderedRing and any natural number `n` that is at least two, the absolute value of `n` as an element of `α` (which is represented by `OfNat.ofNat n`) is equal to `n` as an element of `α`. In other words, this theorem asserts that the absolute value function preserves the natural number when it is embedded into any LinearOrderedRing, as long as the natural number is at least two.

For any LinearOrderedRing type `α` and natural number `n` ≥ 2, the absolute value of `OfNat.ofNat n` in `α` equals `n`.


theorem HasDerivAtFilter.tendsto_nhds :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {L : Filter 𝕜},
      L ≤ nhds x → HasDerivAtFilter f f' x L → Filter.Tendsto f L (nhds (f x)) :=
  by sorry

This theorem states that for a given function `f` from a non-trivially normed field to a normed additive commutative group, if `f` has a derivative `f'` at point `x` along the filter `L`, and `L` is less than or equal to the neighborhood filter of `x`, then the function `f` tends towards the filter of the neighborhood of `f(x)` as `x` tends towards `L`. Here, the filter is a mathematical construct that describes the limiting behavior of functions. The neighborhood of a point in a topological space is a set that includes an open set containing that point. A function has a derivative at a point if it can be approximated by a linear function at this point.

If `f` is a function from a non-trivially normed field to a normed additive commutative group, has a derivative `f'` at point `x` along filter `L` with `L` being a neighborhood filter of `x`, then `f(x)` tends to the filter of neighborhoods of `f(x)` as `x` tends to `L` through `f'`.


theorem IsLindelof.elim_nhds_subcover :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      IsLindelof s →
        ∀ (U : X → Set X), (∀ x ∈ s, U x ∈ nhds x) → ∃ t, Set.Countable t ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x :=
  by sorry

This theorem states that for any topological space `X` and any set `s` in `X`, if `s` is Lindelöf (i.e., every nontrivial filter with the countable intersection property that contains `s`, has a cluster point in `s`), then for any function `U` which maps each point `x` in `s` to a neighborhood of `x`, there exists a countable set `t` such that every element of `t` is in `s` and `s` is contained in the union of the neighborhoods `U x` for each `x` in `t`. In other words, if `s` has the property that every cover by open subsets has a countable subcover, then for any mapping of points in `s` to their neighborhoods, there is a countable subset of `s` whose associated neighborhoods cover `s`.

If a subset `s` of a topological space `X` is Lindelöf, then for any function mapping each point in `s` to a neighborhood of that point, there exists a countable subset of `s` whose neighborhoods cover `s`.


IsSeparable.isAlgebraic

theorem IsSeparable.isAlgebraic :
    ∀ (F : Type u_1) (K : Type u_2) [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K] [inst_3 : Nontrivial F]
      [inst_4 : IsSeparable F K], Algebra.IsAlgebraic F K :=
  by sorry

The theorem `IsSeparable.isAlgebraic` states that for any two types `F` and `K`, where `F` is a commutative ring, `K` is a ring, and `K` is an algebra over `F`, if `F` is nontrivial and `K` is separable over `F`, then every element of `K` is algebraic over `F`. In other words, if `K` is a separable algebra over a nontrivial commutative ring `F`, then all elements of `K` can be expressed as roots of some non-zero polynomial with coefficients in `F`.

If `F` is a nontrivial commutative ring and `K` is a separable algebra over `F`, then every element of `K` is algebraic over `F`.


theorem comap_coe_nhdsWithin_Iio_of_Ioo_subset :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {b : α} {s : Set α},
      s ⊆ Set.Iio b →
        (Set.Nonempty s → ∃ a < b, Set.Ioo a b ⊆ s) →
          Filter.comap Subtype.val (nhdsWithin b (Set.Iio b)) = Filter.atTop :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure, a linear order, an order topology, and a densely ordered structure, given any element `b` of type `α` and a subset `s` of type `α`, if `s` is a subset of the left-infinite right-open interval ending at `b` and if `s` is not empty, then there exists an element `a` less than `b` such that the left-open right-open interval between `a` and `b` is a subset of `s`. Under these conditions, the filter obtained by mapping elements of the neighborhood within the set `s` at `b` to their underlying elements in the base type (using the `comap` function and the value function for subtypes `Subtype.val`), is equal to the filter representing the limit `→ ∞` on an ordered set (given by `Filter.atTop`).

For any densely ordered and topological space `(α, ≤, top)`, given a non-empty subset `s` of the left-infinite right-open interval `(a, b]` with `a < b`, there exists an element `a' < b` such that the filter of neighborhoods of `b` in `s` equals the filter of elements approaching `b` in the order topology.


theorem MeasureTheory.Memℒp.snorm_mk_lt_top :
    ∀ {α : Type u_5} {E : Type u_6} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : NormedAddCommGroup E] {p : ENNReal} {f : α → E} (hfp : MeasureTheory.Memℒp f p μ),
      MeasureTheory.snorm (↑(MeasureTheory.AEEqFun.mk f ⋯)) p μ < ⊤ :=
  by sorry

The theorem `MeasureTheory.Memℒp.snorm_mk_lt_top` states that for any measurable space `α`, any normed add commutative group `E`, any measure `μ` on `α`, any extended nonnegative real number `p`, and any function `f` from `α` to `E` that satisfies the property `MeasureTheory.Memℒp` (which signifies that `f` is almost everywhere strongly measurable and its Lp-norm is finite), the seminorm in `ℒp` of the equivalence class `[f]` of `f` (constructed based on the equivalence relation of being almost everywhere equal) is strictly less than infinity. In mathematical terms, this says that if $\|f\|_p$ is finite, then the `ℒp` seminorm of the equivalence class of `f`, denoted as $\| [f] \|_p$, is also finite.

For any measurable space, normed add commutative group, measure, extended nonnegative real number, and almost everywhere strongly measurable function with finite Lp-norm, the Lp-seminorm of its equivalence class is finite.


theorem le_add_of_nonneg_of_le :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      0 ≤ a → b ≤ c → b ≤ a + c :=
  by sorry

The theorem `le_add_of_nonneg_of_le` states that for all types `α` that have addition and zero, and are preordered (meaning they have a 'less than or equal to' relation that is transitive and reflexive), and for this 'less than or equal to' relation, it is covariant with respect to the operation of swap addition (i.e., if `x ≤ y` then `x + z ≤ y + z` for all `z`), given any three elements `a`, `b`, and `c` of type `α`, if `a` is greater than or equal to zero and `b` is less than or equal to `c`, then `b` is less than or equal to the sum of `a` and `c`. In simple terms, if `a` is non-negative and `b` is less than or equal to `c`, then `b` is less than or equal to `a + c`.

If `α` is a type with addition, zero, and a preorder relation where the order is covariant with respect to addition, and `a ∈ α` is non-negative, `b, c ∈ α` are such that `b ≤ c`, then `b ≤ a + c`.


/-- Non-dependent version of `Function.update_comp_eq_of_injective'`  -/
theorem Function.update_comp_eq_of_injective :
    ∀ {α : Sort u} {α' : Sort w} [inst : DecidableEq α] [inst_1 : DecidableEq α'] {β : Sort u_1} (g : α' → β)
      {f : α → α'},
      Function.Injective f → ∀ (i : α) (a : β), Function.update g (f i) a ∘ f = Function.update (g ∘ f) i a :=
  by sorry

This theorem, named `Function.update_comp_eq_of_injective`, states the following: For any types `α`, `α'`, and `β`, given that `α` and `α'` have decidable equality, and given a function `g` from `α'` to `β`, and an injective function `f` from `α` to `α'`, for any element `i` of `α` and `a` of `β`, the composition of the function `g` updated at `(f i)` with the value `a` and the function `f` is equal to the function `g ∘ f` updated at `i` with the value `a`.

In other words, if we have an injective function `f` and another function `g`, then updating `g` at `f(i)` and then applying `f` is the same as first applying `f` and then updating `g ∘ f` at `i`. This is a property about function composition and updating a function's value at a particular point.

For injective functions `f: α → α'` and `g: α' → β`, the function update `(g : α' → β) ((f x) : α')` is equal to the composition `(g ∘ f) x` for all `x: α`. (Assuming `α`, `α'`, and `β` have decidable equality.)


theorem Matrix.vecAppend_eq_ite :
    ∀ {m n : ℕ} {α : Type u_4} {o : ℕ} (ho : o = m + n) (u : Fin m → α) (v : Fin n → α),
      Matrix.vecAppend ho u v = fun i =>
        if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := ⋯ } :=
  by sorry

This theorem `Matrix.vecAppend_eq_ite` states that for any natural numbers `m` and `n`, and for any type `α`, given a specific natural number `o` that equals `m + n`, and two functions `u` and `v` that map from `Fin m` and `Fin n` to `α` respectively, the `Matrix.vecAppend` function applied to `ho`, `u` and `v` results in a function that maps from `Fin o` to `α`. This resultant function behaves as follows: for any input `i`, if the coerced value of `i` is less than `m`, it returns the output of `u` for `i` (adjusted with respect to `m`); otherwise, it returns the output of `v` for `i` (adjusted with respect to `m`). Here, `Fin n` is a finite set of natural numbers less than `n`.

For any natural numbers m and n, and type α, the function `Matrix.vecAppend u v` on inputs from `Fin (m + n)` is equal to the function defined by `ite (< m) u (m + _ => v)`, where `u` is a function from `Fin m` to α and `v` is a function from `Fin n` to α.


CategoryTheory.IsSplitMono.id

theorem CategoryTheory.IsSplitMono.id :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
      [hf : CategoryTheory.IsSplitMono f],
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.retraction f) = CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem states that in any category `C`, for any two objects `X` and `Y` and any morphism `f` from `X` to `Y` that is a split monomorphism, the composition of `f` and its retraction (a morphism from `Y` back to `X`) is equal to the identity morphism on `X`. This result is a key property of split monomorphisms in category theory, reflecting the idea that a split monomorphism can be "undone" by its retraction.

In any category, for any split monomorphism `f`: `f ∘ r = id_X`, where `r` is `f`'s retraction and `id_X` is the identity morphism on `X`.


/-- The pigeonhole principle for finitely many pigeons counted by weight, non-strict inequality
version: if the total weight of a finite set of pigeons is greater than or equal to `n • b`, and
they are sorted into `n > 0` pigeonholes, then for some pigeonhole, the total weight of the pigeons
in this pigeonhole is greater than or equal to `b`.  -/
theorem Finset.exists_le_sum_fiber_of_maps_to_of_nsmul_le_sum :
    ∀ {α : Type u} {β : Type v} {M : Type w} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β}
      {w : α → M} {b : M} [inst_1 : LinearOrderedCancelAddCommMonoid M],
      (∀ a ∈ s, f a ∈ t) →
        t.Nonempty →
          (t.card • b ≤ Finset.sum s fun x => w x) →
            ∃ y ∈ t, b ≤ Finset.sum (Finset.filter (fun x => f x = y) s) fun x => w x :=
  by sorry

The theorem `Finset.exists_le_sum_fiber_of_maps_to_of_nsmul_le_sum` represents a version of the pigeonhole principle, which is weighted and involves non-strict inequality. It states that if we have a finite set `s` of elements of type `α` where each element is associated with a weight function `w : α → M` and a mapping `f : α → β` to another finite set `t` of elements of type `β`, then if the total weight of the elements in `s` (calculated as the sum of the weights of each element) is greater than or equal to the product of the cardinality of `t` and a certain value `b`, and `t` is nonempty, then there exists an element `y` in `t` such that the total weight of the elements in `s` that map to `y` is greater than or equal to `b`. This essentially means that if we distribute the elements of `s` into the "pigeonholes" represented by `t`, there is at least one "pigeonhole" whose total weight (sum of the weights of the elements in that pigeonhole) is at least `b`.

If `s` is a finite set of elements each with weight `w` and mapped to a nonempty set `t` via function `f`, and the total weight of `s` is greater than or equal to the product of `t`'s cardinality and a value `b`, then there exists an element `y` in `t` with the total weight of elements mapped to `y` being at least `b`.


/-- For nonzero `a : F`, `quadraticChar F a = 1 ↔ IsSquare a`.  -/
theorem quadraticChar_one_iff_isSquare :
    ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {a : F},
      a ≠ 0 → ((quadraticChar F) a = 1 ↔ IsSquare a) :=
  by sorry

The theorem `quadraticChar_one_iff_isSquare` states that for any given nonzero element `a` of any field `F`, the quadratic character of `F` evaluated at `a` equals `1` if and only if `a` is a square in the field `F`. In other words, if `a` in field `F` is not zero, then the function `quadraticChar F` returns `1` when applied to `a` if and only if there exists some `r` in field `F` such that `a = r * r`.

For any nonzero element `a` in a field `F`, the quadratic character of `F` evaluated at `a` equals 1 if and only if `a` is a square in `F`. (Equivalently, `a` is a root of some `x^2` in `F[x]`.)


theorem hasDerivAt_id' : ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜), HasDerivAt (fun x => x) 1 x := by
  sorry

The theorem `hasDerivAt_id'` states that for any value `x` in the non-trivially normed field `𝕜`, the function `f(x) = x` has a derivative of `1` at `x`. In other words, the change in the function `f(x) = x` with respect to `x` is constant and equal to `1` for all `x` in the field `𝕜`.

The function `f(x) = x` is differentiable with derivative `1` over the non-trivially normed field `𝕜`.


theorem PartialHomeomorph.IsImage.iff_preimage_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage e s t ↔ e.source ∩ ↑e ⁻¹' t = e.source ∩ s :=
  by sorry

This theorem states that for any given types `X` and `Y`, both equipped with a topology (i.e., they are topological spaces), a partial homeomorphism `e` from `X` to `Y`, and sets `s` of `X` and `t` of `Y`, the set `t` is an image of the set `s` under the partial homeomorphism `e` if and only if the intersection of the source of `e` with the preimage of `t` under `e` equals the intersection of the source of `e` with `s`. Essentially, this theorem establishes an equivalence between the definition of an image set under a partial homeomorphism and a particular condition involving set intersection and preimage.

For topological spaces X and Y, a partial homeomorphism e from X to Y maps set s to set t if and only if e⁁⁻¹(t) ∩ source(e) = s ∩ source(e).


theorem Mathlib.Data.Finset.NoncommProd._auxLemma.2 : ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) := by
  sorry

This theorem, `Mathlib.Data.Finset.NoncommProd._auxLemma.2`, states that for any type `α` and any element `a` of this type, as well as any list `l` of elements of type `α`, the condition of `a` being in the set representation (`↑l`) of the list `l` is equivalent to `a` being in the list `l` itself. In other words, an element is in a list if and only if it is in the set derived from that list.

For any type `α` and list `l` of elements from `α`, the set representation `{x : α | x ∈ l}` of `l` equals `l` itself.


/-- `eq_condition f f'`, for morphisms `f f' : j ⟶ j'`, is the proof that
`eqHom f f' ≫ f = eqHom f f' ≫ f'`.
 -/
theorem CategoryTheory.IsCofiltered.eq_condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C] {j j' : C}
      (f f' : j ⟶ j'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.IsCofiltered.eqHom f f') f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.IsCofiltered.eqHom f f') f' :=
  by sorry

The theorem `CategoryTheory.IsCofiltered.eq_condition` asserts that for any category `C` (that is either cofiltered or empty) and for any pair of morphisms `f` and `f'` from an object `j` to an object `j'` in `C`, the composition of the morphism `eqHom f f'` (which is an arbitrary choice of morphism) with `f` is the same as the composition of `eqHom f f'` with `f'`. In other words, it states that `eqHom f f' ≫ f = eqHom f f' ≫ f'`, where `≫` denotes the composition of morphisms. This condition is guaranteed by the property of the category `C` being cofiltered.

In any cofiltered category, for any pair of morphisms from object `j` to object `j'`, the commutativity of `eqHom f f'` with their compositions holds: `eqHom f f' ≫ f = eqHom f f' ≫ f'`.


theorem Mathlib.Data.Finset.Basic._auxLemma.17 : ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ s.val) := by
  sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.17`, states that for any type `α`, any element `a` of type `α`, and any finite set `s` of type `α`, the predicate of `a` being an element of `s` is equivalent to `a` being an element of the underlying value of `s`. In other words, checking if an element is in a `Finset` is the same as checking if it is in the underlying set of values.

For any type `α`, the membership relation between an element `a` of `α` and a finite set `s` of type `Finset α` is the same as the membership relation between `a` and the underlying set of `s`.


theorem Nat.coprime_one_left_eq_true : ∀ (n : ℕ), Nat.Coprime 1 n = True := by sorry

The theorem states that for every natural number `n`, `n` is coprime with 1. In other words, the greatest common divisor (gcd) of 1 and any natural number `n` is 1. This is a general property of numbers, as the gcd of 1 and any number is always 1, hence every number is relatively prime to 1.

For every natural number `n`, the greatest common divisor of `1` and `n` is equal to `1`.


theorem Mathlib.Data.Finset.Basic._auxLemma.19 : (¬False) = True := by sorry

This theorem, termed as `Mathlib.Data.Finset.Basic._auxLemma.19`, asserts that the negation of `False` is `True`. In the context of classical logic, the negation of a false statement always results in a true statement. Therefore, `¬False` is logically equivalent to `True`.

The negation of False is True. (In classical logic)


theorem Set.ncard_empty : ∀ (α : Type u_1), Set.ncard ∅ = 0 := by sorry

The theorem `Set.ncard_empty` states that for any type `α`, the cardinality of the empty set is zero. In other words, it says that the number of elements in the empty set, regardless of the type of the elements that could potentially be in the set, is always zero. In mathematical terms, if `s` is the empty set, then `|s| = 0`.

For any type `α`, the cardinality of the empty set is 0. (In mathematical notation: |∅| = 0)


/-- If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `Set.Ico (f n) (f (Order.succ n))` are pairwise disjoint.  -/
theorem Monotone.pairwise_disjoint_on_Ico_succ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : SuccOrder α] [inst_2 : Preorder β] {f : α → β},
      Monotone f → Pairwise (Disjoint on fun n => Set.Ico (f n) (f (Order.succ n))) :=
  by sorry

This theorem states that if `α` is a type with a linear order and a successor function, and `β` is a type with a preorder, and if we have a monotone function `f` from `α` to `β`, then the intervals of the form `Set.Ico (f n) (f (Order.succ n))` are pairwise disjoint. In other words, for any two distinct elements `n` and `m` in `α`, the interval starting from `f n` and ending just before `f (Order.succ n)` does not overlap with the interval starting from `f m` and ending just before `f (Order.succ m)`. This is a property related to the order-preserving nature of the function `f` and the definition of the successor function in the linear order.

If `f` is a monotonic function from a linearly ordered type `α` with successor function to a preordered type `β`, then for all distinct `n` and `m` in `α`, the intervals `[f n, f (Order.succ n))` and `[f m, f (Order.succ m))` are disjoint in `β`.


theorem Set.prod_self_subset_prod_self : ∀ {α : Type u_1} {s₁ s₂ : Set α}, s₁ ×ˢ s₁ ⊆ s₂ ×ˢ s₂ ↔ s₁ ⊆ s₂ := by sorry

This theorem states that for any type `α` and any sets `s₁` and `s₂` of this type, the cartesian product of `s₁` with itself is a subset of the cartesian product of `s₂` with itself if and only if `s₁` is a subset of `s₂`. Here, the cartesian product of two sets `s₁` and `s₂` is a set of ordered pairs, each consisting of one element from `s₁` and one element from `s₂`. A subset relationship between two sets implies that any element of the first set is also an element of the second set.

For any types `α` and sets `s₁` and `s₂` of type `α`, `s₁ × s₁ ⊆ s₂ × s₂` if and only if `s₁ ⊆ s₂`. Here, `×` denotes the cartesian product of sets.


Bornology.IsVonNBounded.neg

theorem Bornology.IsVonNBounded.neg :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : TopologicalSpace E]
      [inst_3 : TopologicalAddGroup E] [inst_4 : DistribMulAction 𝕜 E] {s : Set E},
      Bornology.IsVonNBounded 𝕜 s → Bornology.IsVonNBounded 𝕜 (-s) :=
  by sorry

The theorem `Bornology.IsVonNBounded.neg` states that for any seminormed ring `𝕜` and any set `s` in a topological vector space `E` over `𝕜` that forms a topological group under addition, if `s` is von Neumann bounded (meaning that every neighborhood of 0 absorbs `s`), then the negation of `s` (i.e., the set of all additive inverses of elements of `s`) is also von Neumann bounded. This theorem essentially asserts the symmetry of von Neumann boundedness under negation in a topological vector space.

In a topological vector space over a seminormed ring, if a set absorbs every neighborhood of zero, then the negation of the set also absorbs every neighborhood of zero.


theorem Nat.le_max_left : ∀ (a b : ℕ), a ≤ max a b := by sorry

This theorem states that for any two natural numbers `a` and `b`, `a` is less than or equal to the maximum of `a` and `b`. In other words, regardless of the values of `a` and `b`, the maximum of the two numbers is always greater than or equal to `a`. This is a fundamental property of the maximum function that holds true for any pair of natural numbers.

For all natural numbers `a` and `b`, `a` <= max a b.


theorem Mathlib.Data.Finset.Basic._auxLemma.21 : ∀ {α : Type u_1}, ∅.Nonempty = False := by sorry

This theorem states that for any type `α`, an empty set of that type is not nonempty. In mathematical terms, a set ∅ (empty set) is not nonempty, which means it doesn't contain any elements. This holds true for any type of elements we might consider; the empty set of integers, real numbers, strings, or any other type is not nonempty.

The empty set of any type is not nonempty.


theorem IsUnit.smul_left_cancel :
    ∀ {α : Type u} {β : Type v} [inst : Monoid α] [inst_1 : MulAction α β] {a : α},
      IsUnit a → ∀ {x y : β}, a • x = a • y ↔ x = y :=
  by sorry

The theorem `IsUnit.smul_left_cancel` states that for any types `α` and `β`, where `α` is a monoid and `β` is a mulAction of `α`, for any element `a` of `α` that is a unit, and for any elements `x` and `y` of `β`, the statement `a • x = a • y` is equivalent to `x = y`. In other words, if `a` is a unit in the monoid `α`, then scalar multiplication by `a` is a cancelable operation on the left side, meaning that if `a` is multiplied with two elements `x` and `y` from `β` and the results are equal, then the original elements `x` and `y` must also be equal.

If `α` is a monoid and `β` is a monoid action on `α`, for any unit `a` in `α` and any `x, y` in `β`, `a • x = a • y` implies `x = y`.


theorem Mathlib.Data.Finset.Basic._auxLemma.39 : ∀ {α : Type u_1} {s : Finset α} {a : α}, ({a} ⊆ s) = (a ∈ s) := by
  sorry

This theorem states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, the singleton set containing `a` is a subset of `s` if and only if `a` is an element of `s`. This theorem formalizes a basic fact about set theory: an element belongs to a set if and only if the set that contains only this element is a subset of the original set.

For any type `α`, set `s` of type `α`, and element `a` of type `α`, the singleton set `{a}` is a subset of `s` if and only if `a` is an element of `s`.


theorem Mathlib.Data.Finset.Basic._auxLemma.30 : ∀ {α : Type u_1} {a b : α}, ({a} = {b}) = (a = b) := by sorry

This theorem, from the `Mathlib.Data.Finset.Basic` library, states that for any type `α` and any two elements `a` and `b` of type `α`, the singleton set containing `a` equals the singleton set containing `b` if and only if `a` equals `b`. In mathematical terms, for all `α`, `a`, and `b`, `{a} = {b}` is equivalent to `a = b`.

For any type `α` and any elements `a` and `b` of type `α`, the singleton sets `{a}` and `{b}` are equal if and only if `a` and `b` are equal.


theorem Real.sqrt_mul_self_eq_abs : ∀ (x : ℝ), Real.sqrt (x * x) = |x| := by sorry

This theorem states that for any real number `x`, the square root of the square of `x` is equal to the absolute value of `x`. In mathematical terms, for all real numbers `x`, we have `sqrt(x^2) = |x|`.

For all real numbers `x`, `sqrt(x^2) = |x|`.


theorem Mathlib.Data.Finset.Basic._auxLemma.32 : ∀ {α : Type u_1} (a : α), ({a} = ∅) = False := by sorry

This theorem states that for any type `α`, and any element `a` of that type, the singleton set containing only `a` is not equal to the empty set. In other words, a set containing at least one element, `a`, cannot be empty. This statement holds universally, regardless of the particular type `α` and element `a`.

For any type `α` and element `a` of `α`, the singleton set `{a : α}` is not equal to the empty set.


theorem List.Palindrome.of_reverse_eq : ∀ {α : Type u_1} {l : List α}, List.reverse l = l → List.Palindrome l := by
  sorry

This theorem states that for any type `α` and any list `l` of type `α`, if the reverse of `l` is equal to `l` itself, then `l` is a Palindrome. In other words, a list is a Palindrome if and only if it remains the same when its elements are reversed.

For any list `l` of type `α`, `l` is a palindrome if and only if `l` is equal to its reverse.


theorem Function.Periodic.const_smul₀ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {c : α} [inst : AddCommMonoid α]
      [inst_1 : DivisionSemiring γ] [inst_2 : Module γ α],
      Function.Periodic f c → ∀ (a : γ), Function.Periodic (fun x => f (a • x)) (a⁻¹ • c) :=
  by sorry

This theorem states that if a function `f` is periodic with period `c`, then for any scalar `a`, the function obtained by scaling the argument of `f` by `a` is also periodic, with the period scaled by the inverse of `a`. This is formalized over a division semiring `γ`, a module `α` over `γ`, and an additive commutative monoid `α`, allowing scalar multiplication and division. The function `f` maps elements from `α` to another type `β`, and the periodicity of `f` is defined such that for all `x` in `α`, `f (x + c) = f x`.

If `f` is a periodic function with period `c` over a division semiring `γ`, a module `α` over `γ`, and an additive commutative monoid `α`, then the scaled function `a → f(xa)` is periodic with period `c/a` for any scalar `a` in `γ`.


theorem Set.star_mem_star : ∀ {α : Type u_1} {s : Set α} {a : α} [inst : InvolutiveStar α], star a ∈ star s ↔ a ∈ s :=
  by sorry

The theorem `Set.star_mem_star` states that for any type `α`, any set `s` of elements of type `α`, and any element `a` of type `α`, given that the operation `star` on `α` is involutive, the property `star a ∈ star s` is equivalent to `a ∈ s`. In other words, an element is in the set `s` if and only if its `star` image is in the `star` image of the set, under the condition that `star` is an operation that reverses itself when applied twice.

For any set `s` and involutive operation `star` on a type `α`, an element `a` belongs to `s` if and only if its `star` image belongs to the `star` image of `s`.


theorem FirstOrder.Language.Term.card_le :
    ∀ {L : FirstOrder.Language} {α : Type u'},
      Cardinal.mk (FirstOrder.Language.Term L α) ≤ max Cardinal.aleph0 (Cardinal.mk (α ⊕ (i : ℕ) × L.Functions i)) :=
  by sorry

This theorem states that for any first-order language `L` and any type `α`, the cardinality of the set of terms of `L` with variables from `α` is less than or equal to the maximum of `ℵ₀` (the smallest infinite cardinal number) and the cardinality of the disjoint union of `α` and the set of all functions from `ℵ₀` (the set of natural numbers) to the functions of `L`. In essence, it provides an upper bound for the size of the set of terms in a given first-order language and variable type, in terms of the language's functions and the variable type's cardinality.

For any first-order language L and type α, the number of terms of L with variables from α is below the cardinality of ℵ₀ + |α| + |L|^(|α|).


theorem Mathlib.Analysis.SpecialFunctions.Exp._auxLemma.25 : 1 = Real.exp 0 := by sorry

This theorem states that the exponential of 0, when calculated using the real exponential function (defined as the real part of the complex exponential), is equal to 1. In mathematical notation, it is expressed as \(e^{0} = 1\).

The real exponential function evaluates to 1 at 0, i.e., \(e^0 = 1\).


LinearEquiv.ker

theorem LinearEquiv.ker :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂}
      (e : M ≃ₛₗ[σ₁₂] M₂), LinearMap.ker ↑e = ⊥ :=
  by sorry

This theorem states that for any linear equivalence `e` between two modules `M` and `M₂` over semirings `R` and `R₂`, respectively, the kernel of the linear map corresponding to `e` is trivial, i.e., it contains only the zero vector. This is true under the conditions that `R` and `R₂` are semirings, `M` and `M₂` are additive commutative monoids, `M` and `M₂` have module structures over `R` and `R₂`, respectively, and there are ring homomorphisms `σ₁₂` : `R` → `R₂` and `σ₂₁` : `R₂` → `R` that are inverses to each other.

Given semirings `R` and `R₂`, additive commutative monoids `M` and `M₂` with module structures over `R` and `R₂`, and ring homomorphisms `σ₁₂ : R → R₂` and `σ₂₁ : R₂ → R` that are inverses, any linear equivalence between `M` and `M₂` over `R` and `R₂` implies that their corresponding kernel is the zero module.


theorem Matrix.vec3_add :
    ∀ {α : Type u} [inst : Add α] (a₀ a₁ a₂ b₀ b₁ b₂ : α),
      ![a₀, a₁, a₂] + ![b₀, b₁, b₂] = ![a₀ + b₀, a₁ + b₁, a₂ + b₂] :=
  by sorry

This theorem, `Matrix.vec3_add`, states that for any type `α` that supports an addition operation, given two 3-dimensional vectors (each represented as a list of three elements of type `α`), the addition of these two vectors results in a new vector where each corresponding pair of elements from the initial vectors is summed. This corresponds to the standard vector addition operation in mathematics, where vectors are added component-wise.

For any type `α` with addition, the sum of two 3-vector columns of length 3 over `α` is a 3-vector column of length 3 over `α`, obtained by applying the component-wise addition of the corresponding entries.


theorem Mathlib.Analysis.SpecialFunctions.Exp._auxLemma.10 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
      Filter.Tendsto (g ∘ f) a c = Filter.Tendsto f a (Filter.comap g c) :=
  by sorry

This theorem states that for any types α, β, γ, and any functions `f : α → β` and `g : β → γ`, and any filters `a` on α and `c` on γ, the "limit of a function" predicate `Filter.Tendsto` for the composition of functions `(g ∘ f)` from `a` to `c` is equivalent to the "limit of a function" predicate `Filter.Tendsto` for `f` from `a` to the comap of `g` on `c`. This essentially means that the limit of the composition of two functions is the same as the limit of the first function composed with the limit of the second function.

Given filters `a` on type `α`, `c` on type `γ`, and functions `f : α → β` and `g : β → γ`, the composition `g ∘ f` tends to `c` as `x` tends to `a` if and only if `f` tends to the composite map `g ∘ g^(-1)` as `x` tends to `a`, where `g^(-1)` is the inverse of `g` over its range.


/-- The push-forward of an ideal `I` of `R` to `R[X]` via inclusion
is exactly the set of polynomials whose coefficients are in `I`  -/
theorem Ideal.mem_map_C_iff :
    ∀ {R : Type u} [inst : CommSemiring R] {I : Ideal R} {f : Polynomial R},
      f ∈ Ideal.map Polynomial.C I ↔ ∀ (n : ℕ), Polynomial.coeff f n ∈ I :=
  by sorry

The theorem `Ideal.mem_map_C_iff` states that for any commutative semiring `R`, any ideal `I` of `R`, and any polynomial `f` with coefficients in `R`, the polynomial `f` is in the push-forward of the ideal `I` via the ring homomorphism `Polynomial.C` (which sends each ring element to a constant polynomial with that element as the coefficient) if and only if all the coefficients of `f` are in `I`. In other words, a polynomial belongs to the ideal generated by the image of `I` under the constant polynomial function if and only if every coefficient of that polynomial is an element of the initial ideal `I`.

A polynomial belongs to the ideal generated by the constant images of an ideal under the polynomial map if and only if all its coefficients are in the ideal.


theorem sub_self_div_two : ∀ {α : Type u_2} [inst : LinearOrderedField α] (a : α), a - a / 2 = a / 2 := by sorry

This theorem states that for any linear ordered field (which is a field with an order relation that is compatible with the field operations), the result of subtracting half of a certain element 'a' from itself is equal to half of that element 'a'. In mathematical terms, we can express this as: for all 'a' in a linear ordered field 'α', 'a - a/2 = a/2'.

In a linear ordered field, subtracting half an element from it is equal to half that element: i.e., for all 'a' in the field, 'a - a/2 = a/2'.


theorem AddSubgroup.map_sup :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (H K : AddSubgroup G) (f : G →+ N),
      AddSubgroup.map f (H ⊔ K) = AddSubgroup.map f H ⊔ AddSubgroup.map f K :=
  by sorry

The theorem `AddSubgroup.map_sup` states that for any two additively-structured subgroups `H` and `K` within a type `G` that forms an additive group, and a homomorphism `f` from `G` to another additive group `N`, the image of the additive subgroup resulting from the join (or superset) of `H` and `K` under the action of `f`, is equal to the join (or superset) of the respective images of `H` and `K` under the action of `f`. In other words, the image of the union of two additive subgroups under an additive monoid homomorphism is the same as the union of the images of the individual subgroups. This theorem is talking about the distributive property of the map function over the join operation in the context of additive subgroups and additive monoid homomorphisms.

For any additive subgroups H and K of an additive group G and any additive monoid homomorphism f from G to an additive group N, the image of H ∪ K under f is equal to the image of H under f ∪ the image of K under f.


theorem Finset.sum_range_add_sum_Ico :
    ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : ℕ → M) {m n : ℕ},
      m ≤ n →
        ((Finset.sum (Finset.range m) fun k => f k) + Finset.sum (Finset.Ico m n) fun k => f k) =
          Finset.sum (Finset.range n) fun k => f k :=
  by sorry

The theorem `Finset.sum_range_add_sum_Ico` states that for any type `M` that has a commutative addition operation, any function `f` from natural numbers to `M`, and any two natural numbers `m` and `n` such that `m` is less than or equal to `n`, the sum of `f(k)` for all `k` in the range from `0` to `m-1` plus the sum of `f(k)` for all `k` in the interval `[m, n)` (inclusive of `m` and exclusive of `n`) is equal to the sum of `f(k)` for all `k` in the range from `0` to `n-1`. This theorem essentially states that splitting the sum operation over a range at any point and summing the parts individually yields the same result as summing over the entire range.

For any commutative monoid M, function f from natural numbers to M, and natural numbers m ≤ n, the sum of f(k) for k in the range [0, m-1] plus the sum of f(k) for k in the range [m, n) equals the sum of f(k) for k in the range [0, n-1].


theorem Matrix.nonsing_inv_nonsing_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      IsUnit (Matrix.det A) → A⁻¹⁻¹ = A :=
  by sorry

This theorem, `Matrix.nonsing_inv_nonsing_inv`, states that for any finite type `n`, any type `α` that forms a commutative ring, and any matrix `A` of type `Matrix n n α`, if the determinant of `A` is a unit (i.e., it has a multiplicative inverse, which means the matrix `A` is invertible), then the double inverse of `A` (i.e., `(A⁻¹)⁻¹`) is equal to `A` itself. This theorem essentially asserts the fundamental property of invertible matrices in a generalised algebraic setting.

If a square matrix over a commutative ring with unit determinant is invertible, then its double inverse is equal to the original matrix.


theorem Computation.eq_of_pure_mem : ∀ {α : Type u} {a a' : α}, a' ∈ Computation.pure a → a' = a := by sorry

The theorem `Computation.eq_of_pure_mem` states that for any type `α` and any two elements `a` and `a'` of type `α`, if `a'` is in the computation that immediately terminates with result `a` (`Computation.pure a`), then `a'` must be equal to `a`. In other words, the only element that can be in the computation `Computation.pure a` is `a` itself.

For any type `α` and elements `a, a'` of type `α`, if `Computation.pure a` contains `a'`, then `a = a'`.


/-- If `η_A` is an isomorphism, then `A` is in the essential image of `i`.  -/
theorem CategoryTheory.mem_essImage_of_unit_isIso :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {i : CategoryTheory.Functor D C}
      [inst_2 : CategoryTheory.IsRightAdjoint i] (A : C)
      [inst_3 : CategoryTheory.IsIso ((CategoryTheory.Adjunction.ofRightAdjoint i).unit.app A)],
      A ∈ CategoryTheory.Functor.essImage i :=
  by sorry

This theorem states that for any categories `C` and `D` and a functor `i` from `D` to `C` that has a right adjoint, if the unit of the adjunction associated with the functor `i` at a particular object `A` in `C` is an isomorphism, then `A` is in the essential image of the functor `i`. In simple terms, if the transformation on `A` induced by the functor `i`'s adjunction creates an isomorphism, `A` is essentially 'reachable' by applying the functor `i` to objects in `D`.

If functor `i` from category `D` to category `C` has a right adjoint and the unit of the adjunction at object `A` in `C` is an isomorphism, then `A` is in the image of `i` under the essential embedding.


theorem ArithmeticFunction.coe_mul_zeta_apply :
    ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R} {x : ℕ},
      (f * ↑ArithmeticFunction.zeta) x = Finset.sum (Nat.divisors x) fun i => f i :=
  by sorry

This theorem states that for any semiring `R`, and for any arithmetic function `f` from natural numbers to `R`, the product of `f` and the Dirichlet zeta function (when the zeta function is viewed as an arithmetic function from natural numbers to `R`), evaluated at a natural number `x`, is equal to the sum of the function `f` evaluated at each divisor of `x`. In other words, it states that `(f * ζ)(x) = Σ (f i)`, where the sum is over all `i` that are divisors of `x`.

For any semiring `R` and arithmetic function `f` from natural numbers to `R`, the product of `f` and the Dirichlet zeta function equals the sum of `f` evaluated at each divisor of the natural number `x`. In mathematical notation, `(f * ζ)(x) = Σ (f i)`, where the sum is over all divisors `i` of `x`.


theorem Mathlib.MeasureTheory.Function.LpSeminorm.TriangleInequality._auxLemma.2 :
    ∀ {r q : NNReal}, (↑r ≤ ↑q) = (r ≤ q) := by sorry

This theorem, named `Mathlib.MeasureTheory.Function.LpSeminorm.TriangleInequality._auxLemma.2`, asserts a comparison property between nonnegative real numbers, denoted as `NNReal`. Specifically, for any two nonnegative real numbers `r` and `q`, the inequality expressed in terms of their natural embeddings into real numbers (`↑r ≤ ↑q`) is equivalent to the direct inequality between `r` and `q` itself (`r ≤ q`). In other words, comparing `r` and `q` directly or comparing their real number counterparts yields the same result.

For any nonnegative real numbers `r` and `q`, `↑r ≤ ↑q` if and only if `r ≤ q`.


HasStrictDerivAt.add

theorem HasStrictDerivAt.add :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {f' g' : F} {x : 𝕜},
      HasStrictDerivAt f f' x → HasStrictDerivAt g g' x → HasStrictDerivAt (fun y => f y + g y) (f' + g') x :=
  by sorry

This theorem states that if a function `f` has a strict derivative `f'` at a point `x` and similarly a function `g` has a strict derivative `g'` at the same point `x`, then the function formed by adding `f` and `g` has a strict derivative at `x` that is the sum of `f'` and `g'`. This describes the property of linearity of differentiation in the context of strict differentiability. In other words, the derivative of the sum of two functions at a point is equal to the sum of the derivatives of those functions at that point.

If functions `f` and `g` have strict derivatives `f'` and `g'` at a point `x` respectively, then the function `f + g` has a strict derivative `(f + g)' = f' + g'` at `x`.


theorem RatFunc.laurent_algebraMap :
    ∀ {R : Type u} [inst : CommRing R] [hdomain : IsDomain R] (r : R) (p : Polynomial R),
      (RatFunc.laurent r) ((algebraMap (Polynomial R) (RatFunc R)) p) =
        (algebraMap (Polynomial R) (RatFunc R)) ((Polynomial.taylor r) p) :=
  by sorry

This theorem states that for any commutative ring `R` which is also an integral domain, given a value `r` in `R` and a polynomial `p` with coefficients in `R`, applying the Laurent expansion of rational functions to the result of embedding the polynomial into the field of rational functions over `R` (via the algebra map) is equivalent to first applying the Taylor expansion of the polynomial at `r` and then embedding the result into the field of rational functions.

For any commutative ring `R` that is an integral domain, the Laurent expansion of the rational function obtained from embedding a polynomial `p` in `R` into the field of rational functions over `R`, is equivalent to first performing the Taylor expansion of `p` at `r` and then embedding the result into the field of rational functions.


theorem MeasureTheory.ProbabilityMeasure.mass_toFiniteMeasure :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.ProbabilityMeasure Ω),
      MeasureTheory.FiniteMeasure.mass (MeasureTheory.ProbabilityMeasure.toFiniteMeasure μ) = 1 :=
  by sorry

This theorem states that for any given measurable space 'Ω' and a probability measure 'μ' on that space, the total mass of the finite measure, obtained by interpreting the probability measure as a finite measure, is equal to 1. In other words, it ensures that when a probability measure is converted to a finite measure, its total mass (or the measure of the entire space) remains 1, preserving the key property of a probability measure.

For any measurable space 'Ω' and probability measure 'μ' on it, the total mass of the induced finite measure equals 1.


theorem Polynomial.leadingCoeff_X_pow_add_C :
    ∀ {R : Type u} [inst : Semiring R] {n : ℕ},
      0 < n → ∀ {r : R}, Polynomial.leadingCoeff (Polynomial.X ^ n + Polynomial.C r) = 1 :=
  by sorry

This theorem states that for any semiring `R`, any natural number `n` greater than 0, and any element `r` of `R`, the leading coefficient of the polynomial formed by adding `r` times the constant polynomial to the `n`-th power of the polynomial variable `X`, is equal to 1. In more mathematical terms, for any polynomial of the form `X^n + r`, where `n` is a positive natural number and `r` is a constant, the coefficient of the highest degree term (`X^n`) is 1.

For any semiring `R` and natural number `n` greater than 0, the leading coefficient of the polynomial `X^n + r` (where `r` is an element of `R`) is equal to 1.


theorem MvPolynomial.cardinal_mk_eq_max_lift :
    ∀ {σ : Type u} {R : Type v} [inst : CommSemiring R] [inst_1 : Nonempty σ] [inst_2 : Nontrivial R],
      Cardinal.mk (MvPolynomial σ R) =
        max (max (Cardinal.lift.{u, v} (Cardinal.mk R)) (Cardinal.lift.{v, u} (Cardinal.mk σ))) Cardinal.aleph0 :=
  by sorry

The theorem `MvPolynomial.cardinal_mk_eq_max_lift` states that for any type `σ`, any type `R` that has a `CommSemiring` instance, and assuming that `σ` is nonempty and `R` is nontrivial, the cardinality of the multivariate polynomial type with `σ` as the index set of the variables and `R` as the coefficient ring is equal to the maximum of three terms: the lifted cardinality of `R`, the lifted cardinality of `σ`, and `ℵ₀` (the smallest infinite cardinal). In other words, the cardinality of the multivariate polynomial space is determined by the larger of the cardinalities of the set of variables and coefficients, unless either is finite and smaller than `ℵ₀`, in which case the cardinality is `ℵ₀`.

The cardinality of the multivariate polynomial space over a nontrivial commutative semiring with infinite base set is the maximum of the lifted cardinalities of the base set and the coefficient ring, or `ℵ₀` if either is finite.


Dvd.dvd.natCast

/-- **Alias** of `Nat.cast_dvd_cast`. -/
theorem Dvd.dvd.natCast : ∀ {α : Type u_1} [inst : Semiring α] {m n : ℕ}, m ∣ n → ↑m ∣ ↑n := by sorry

This theorem, `Dvd.dvd.natCast`, is an alias of `Nat.cast_dvd_cast`. It states that for any semiring `α`, and for any natural numbers `m` and `n`, if `m` divides `n` then the cast of `m` to `α` divides the cast of `n` to `α`. In other words, the divisibility relationship is preserved when natural numbers are cast to elements of any semiring.

For any semiring `α`, if `m` divides `n` in the natural numbers, then the cast of `m` to `α` divides the cast of `n` to `α`.


theorem Nat.bodd_mul : ∀ (m n : ℕ), Nat.bodd (m * n) = (Nat.bodd m && Nat.bodd n) := by sorry

The theorem `Nat.bodd_mul` states that for any two natural numbers `m` and `n`, the binary oddity (being odd or even) of their product `m * n` is equivalent to the logical conjunction (AND) of the binary oddities of `m` and `n` individually. In other words, the product of two natural numbers is odd if and only if both numbers are odd.

The theorem `Nat.bodd_mul` asserts that for all natural numbers m and n, m * n is odd if and only if both m and n are odd.


theorem Array.foldl_data_eq_map :
    ∀ {α : Type u_1} {β : Type u_2} (l : List α) (acc : Array β) (G : α → β),
      (List.foldl (fun acc a => Array.push acc (G a)) acc l).data = acc.data ++ List.map G l :=
  by sorry

The theorem `Array.foldl_data_eq_map` states that for all types `α` and `β`, given a list `l` of elements of type `α`, an array `acc` of type `β`, and a function `G` that maps `α` to `β`, if we sequentially fold the list `l` by pushing each transformed element `(G a)` onto the array `acc`, then the resulting array's data is equivalent to appending the mapped list `(List.map G l)` to the original array's data. Specifically, it states that `(List.foldl (fun acc a => Array.push acc (G a)) acc l).data = acc.data ++ List.map G l`, where `++` represents list concatenation.

For all types α and β, the data of the array obtained by folding a list of α's with function G into an initially empty array of β, is equal to the concatenation of the arrays formed by mapping G to the original list and the initial array.


theorem CategoryTheory.InjectiveResolution.ι_f_succ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z) (n : ℕ),
      I.ι.f (n + 1) = 0 :=
  by sorry

This theorem states that for any category `C` that has a zero object and zero morphisms, and for any object `Z` in `C` for which we have an injective resolution `I`, the `n+1`-th morphism in the injective resolution is a zero morphism. Here, `n` is any natural number. In terms of category theory, it's saying that in the sequence of morphisms that make up the injective resolution, each morphism after the first one is a zero morphism.

For any category with a zero object and zero morphisms, the morphisms in an injective resolution of an object are zero morphisms from the second onwards.


theorem differentiableOn_univ :
    ∀ {𝕜 : 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] {f : E → F},
      DifferentiableOn 𝕜 f Set.univ ↔ Differentiable 𝕜 f :=
  by sorry

The theorem `differentiableOn_univ` states that for any nontrivially normed field `𝕜`, any normed add commutative group `E` and `F` in the normed space over `𝕜`, and any function `f` mapping from `E` to `F`, the function `f` is differentiable on the universal set (i.e., the set of all points in `E`) if and only if the function `f` is differentiable at any point in `E`. Essentially, it connects the concepts of being differentiable over the entire space (`Differentiable 𝕜 f`) and being differentiable at every point within a specific set (`DifferentiableOn 𝕜 f Set.univ`), where the set is the set of all points (universal set).

A function between two normed spaces is differentiable on the universal set if and only if it is differentiable at every point.


theorem WithBot.coe_one : ∀ {α : Type u} [inst : One α], ↑1 = 1 := by sorry

This theorem states that for any type `α` with a defined `One` instance (indicating that the type has a concept of the number one), the coercion of 1 (as a number in that type) to the type "with bottom" (`WithBot`) equals 1. The "with bottom" type is typically used to add a least element (often called "bottom" or ⊥) to a type that doesn't necessarily have a natural least element. So, this theorem is essentially saying that 1 stays the same even when we consider it in the context of a type that includes a bottom element.

For any type `α` with a defined `One` instance, the coercion of `1` to `α WithBot` equals `1`.


theorem OrderIso.complementedLattice_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
      [inst_3 : BoundedOrder β], α ≃o β → (ComplementedLattice α ↔ ComplementedLattice β) :=
  by sorry

The theorem `OrderIso.complementedLattice_iff` states that for any two types `α` and `β` with Lattice and BoundedOrder structures, if `α` is order-isomorphic to `β` (denoted as `α ≃o β`), then `α` is a complemented lattice if and only if `β` is a complemented lattice. In other words, the property of being a complemented lattice is preserved under order isomorphism. A complemented lattice is a lattice in which every element has a complement, i.e., for any element, there is another element such that their meet and join are the lattice's bottom and top elements, respectively.

If two types equipped with Lattice and BoundedOrder structures are order-isomorphic, then they have the same property of being complemented lattices.