theorem RingHomCompTriple.comp_apply :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
      {σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {x : R₁},
      σ₂₃ (σ₁₂ x) = σ₁₃ x :=
  by sorry

This theorem, "RingHomCompTriple.comp_apply", establishes that for any three semirings, R₁, R₂, and R₃, along with three ring homomorphisms σ₁₂ from R₁ to R₂, σ₂₃ from R₂ to R₃, and σ₁₃ from R₁ to R₃, if the three homomorphisms form a ring homomorphism composition triple, then for any element x in R₁, applying σ₂₃ to the result of applying σ₁₂ to x is equivalent to directly applying σ₁₃ to x. Essentially, this is showing a fundamental property of function composition in the context of ring homomorphisms.

Given semirings R₁, R₂, R₃ and ring homomorphisms σ₁₂ : R₁ → R₂, σ₂₃ : R₂ → R₃, and σ₁₃ : R₁ → R₃, if σ₁₃ = σ₂₃ ∘ σ₁₂, then for all x in R₁, σ₂₃ (σ₁₂ x) = σ₁₃ x.


theorem Set.preimage_singleton_true : ∀ {α : Type u_1} (p : α → Prop), p ⁻¹' {True} = {a | p a} := by sorry

This theorem, `Set.preimage_singleton_true`, states that for all types `α`, and for any predicate `p` on `α`, the preimage of the singleton set containing only `True` under `p` is equal to the set of all elements `a` in type `α` for which `p a` holds true. In other words, it's the set of all elements that satisfy the predicate `p`. The preimage under a function of a set is defined to be all the elements that get mapped to any element of that set by the function, so this theorem says that all elements that get mapped to `True` by `p` are exactly those that satisfy `p`.

For any type `α` and predicate `p` on `α`, the preimage of the singleton set {True} under `p` equals the set of elements `a` in `α` such that `p a` holds true.


theorem Set.ite_empty_right : ∀ {α : Type u} (t s : Set α), Set.ite t s ∅ = s ∩ t := by sorry

The theorem `Set.ite_empty_right` states that for any type `α` and any two sets `t` and `s` of type `α`, the intersection of `s` with `t` is equal to the result of the `Set.ite` function with `t`, `s`, and the empty set as arguments. In other words, given any two sets `t` and `s`, the set obtained by taking the intersection of `s` with `t` and then adding the empty set after removing `t` (i.e., `Set.ite t s ∅`) is just the intersection of `s` and `t` (i.e., `s ∩ t`).

For any sets `s` and `t`, `s ∩ t` equals the result of applying `Set.ite` with arguments `t`, `s`, and the empty set.


theorem Set.Finite.eq_of_subset_of_encard_le :
    ∀ {α : Type u_1} {s t : Set α}, Set.Finite t → s ⊆ t → Set.encard t ≤ Set.encard s → s = t := by sorry

This theorem states that for any two sets `s` and `t` of an arbitrary type `α`, if `t` is a finite set and `s` is a subset of `t`, and the cardinality of `t` is less than or equal to the cardinality of `s`, then `s` and `t` must be the same set. In other words, in the context of finite sets, a subset cannot have a cardinality greater than or equal to the set it is contained in unless it is the same set.

If `s` is a subset of finite set `t` of type `α` and the cardinality of `s` is greater than or equal to that of `t`, then `s` and `t` are equal.


theorem Finset.prod_range_succ' :
    ∀ {β : Type u_4} [inst : CommMonoid β] (f : ℕ → β) (n : ℕ),
      (Finset.prod (Finset.range (n + 1)) fun k => f k) = (Finset.prod (Finset.range n) fun k => f (k + 1)) * f 0 :=
  by sorry

The theorem `Finset.prod_range_succ'` states that for any commutative monoid `β` and any function `f` from natural numbers to `β`, the product of `f k` for `k` in the range `0` to `n + 1` (exclusive) is equal to the product of `f (k + 1)` for `k` in the range `0` to `n` (exclusive) times `f 0`. In other words, given a function `f` from the natural numbers to `β`, the product over the first `n + 1` natural numbers is equal to `f 0` times the product over the next `n` natural numbers.

For any commutative monoid β and function f from natural numbers to β, the product of f(k) for k in the range 0 to n is equal to the product of f(k+1) for k in the range 0 to n-1 times f(0).


/-- In a Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, if `x` and `y` commute, then
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)`.  -/
theorem NormedSpace.exp_add_of_commute :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : RCLike 𝕂] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕂 𝔸]
      [inst_3 : CompleteSpace 𝔸] {x y : 𝔸},
      Commute x y → NormedSpace.exp 𝕂 (x + y) = NormedSpace.exp 𝕂 x * NormedSpace.exp 𝕂 y :=
  by sorry

The theorem states that in a Banach-algebra `𝔸` over a field `𝕂` (which can be either the real numbers `ℝ` or the complex numbers `ℂ`), if two elements `x` and `y` commute (i.e., `x * y = y * x`), then the exponential of the sum of `x` and `y` (denoted as `exp 𝕂 (x + y)`) is equal to the product of the exponentials of `x` and `y` (denoted as `exp 𝕂 x * exp 𝕂 y`). This theorem essentially states a specific property of exponentials in the context of Banach algebras with commuting elements.

In a Banach algebra over a field, if two commuting elements have exponentially-valued functions, then their sum's exponential is equal to the product of their individual exponentials.


/-- Given a localization map `f : M →* N` for a submonoid `S ⊆ M`, for all `z : N` we have that if
`x : M, y ∈ S` are such that `z * f y = f x`, then `f x * (f y)⁻¹ = z`.  -/
theorem Submonoid.LocalizationMap.mk'_sec :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) (z : N),
      Submonoid.LocalizationMap.mk' f (Submonoid.LocalizationMap.sec f z).1 (Submonoid.LocalizationMap.sec f z).2 = z :=
  by sorry

This theorem states that for a given localization map `f` from a commutative monoid `M` to a commutative monoid `N`, corresponding to a submonoid `S` of `M`, for every element `z` of `N`, there exist elements `x` in `M` and `y` in `S` such that `z * f y = f x`. In this case, the resulting value of `f x * (f y)⁻¹` will be `z`. This theorem ensures that the process of localization is reversible for any `z` in the codomain `N`.

For every localization map from a commutative monoid to another and any element in the codomain, there exist preimages in the domain such that their product through the map equals the given element, and their quotients invert the image under the map.


theorem Fin.val_succEmb : ∀ {n : ℕ}, ⇑(Fin.succEmb n) = Fin.succ := by sorry

This theorem, `Fin.val_succEmb`, states that for every natural number `n`, the function `Fin.succEmb n` when applied to a value behaves the same way as `Fin.succ`. In other words, the operation of applying the order embedding `Fin.succEmb n` on a value is equivalent to applying the function `Fin.succ` on that same value, where `Fin.succ` is a function that takes an element from `Fin n` to `Fin (n+1)` by incrementing its underlying natural number. This implies a consistent behavior between the strictly monotonic function and its corresponding order embedding in terms of advancing to the next element in the finite sequence `Fin n`.

For every natural number `n`, the order embedding `Fin.succEmb n` and the successor function `Fin.succ` agree on their application to elements of `Fin n`, i.e., `Fin.succEmb (Fin.mk n x) = Fin.mk (n+1) (Fin.succ x)` for all `x : Fin n`.


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

This theorem states that for any continuous linear map `f` from a normed vector space `E` over a non-trivially normed field `𝕜` to another normed vector space `F` over a non-trivially normed field `𝕜₂`, the operator norm of `f` is always non-negative. In other words, the norm of a continuous linear map is never less than zero.

For any continuous linear map between two normed vector spaces over non-trivially normed fields, the operator norm is non-negative.


theorem sub_add_sub_comm :
    ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c d : α), a - b + (c - d) = a + c - (b + d) := by sorry

This theorem, `sub_add_sub_comm`, states that for any type `α` that forms a subtraction commutative monoid, the operation of subtracting `b` from `a`, adding the result to the difference of `c` and `d`, is equal to adding `a` and `c` first and then subtracting the sum of `b` and `d`. In mathematical terms, it states that for all `a`, `b`, `c`, and `d` in `α`, we have `a - b + (c - d) = a + c - (b + d)`.

For any commutative subtraction monoid `α`, the operation `a - b + (c - d)` is equal to `a + c - (b + d)` for all `a, b, c, d ∈ α`.


theorem Mathlib.SetTheory.Cardinal.ENat._auxLemma.9 : ∀ {m n : ℕ∞}, (↑m ≤ ↑n) = (m ≤ n) := by sorry

This theorem from the Set Theory Cardinal module in Mathlib states that for any two numbers `m` and `n` of potentially infinite natural numbers (`ℕ∞`), the condition that the cardinality of `m` (`↑m`) is less than or equal to the cardinality of `n` (`↑n`) is equivalent to `m` being less than or equal to `n`. In other words, the ordering of cardinalities of potentially infinite natural numbers corresponds to their natural order.

For any two potentially infinite natural numbers `m` and `n`, the cardinality `↑m` is less than or equal to `↑n` if and only if `m` is less than or equal to `n`.


theorem subset_of_eq :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1], a = b → a ⊆ b := by sorry

This theorem states that for any type `α` that has a subset operation, given any two elements `a` and `b` of this type, and assuming that the subset operation is reflexive, if `a` equals `b` then `a` is a subset of `b`. In other words, equality implies the subset relation for any two objects in a type where the subset operation is defined and is reflexive.

If `α` is a type with reflexive subset relation, then for all `a` and `b` in `α`, `a = b` implies `a ⊆ b`.


theorem Irrational.mul_cases : ∀ {x y : ℝ}, Irrational (x * y) → Irrational x ∨ Irrational y := by sorry

The theorem `Irrational.mul_cases` states that for all real numbers `x` and `y`, if the product of `x` and `y` is an irrational number, then at least one of `x` or `y` must be irrational. In other words, it is not possible to obtain an irrational number by multiplying two rational numbers.

If the product of two real numbers is irrational, then at least one of them is irrational.


theorem Complex.abs_cpow_of_imp :
    ∀ {z w : ℂ},
      (z = 0 → w.re = 0 → w = 0) → Complex.abs (z ^ w) = Complex.abs z ^ w.re / Real.exp (Complex.arg z * w.im) :=
  by sorry

This theorem, `Complex.abs_cpow_of_imp`, states that for any two complex numbers `z` and `w`, if `z` equals to zero implies that the real part of `w` equals to zero and `w` equals to zero, then the absolute value of `z` raised to the power of `w` equals to the absolute value of `z` raised to the power of the real part of `w` divided by the exponential of the product of the argument of `z` and the imaginary part of `w`. More formally, for all complex numbers `z` and `w`, if `z = 0` implies `(w.re = 0 and w = 0)`, then `|z ^ w| = |z|^(w.re) / exp(arg(z) * w.im)`.

If complex number `z` equals to zero implies real and imaginary parts of `w` are zero, then `|z|^(w.re) * exp(-arg(z) * w.im) = |z|^w`.


theorem Polynomial.degree_coe_units :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : NoZeroDivisors R] [inst_2 : Nontrivial R] (u : (Polynomial R)ˣ),
      Polynomial.degree ↑u = 0 :=
  by sorry

The theorem `Polynomial.degree_coe_units` states that for any type `R` that is a semiring, has no zero divisors, and is nontrivial, the degree of any unit `u` in the unit group of the polynomial ring over `R`, when considered as a polynomial itself, is always zero. In other words, if we have a unit in the polynomial ring, it must be a constant polynomial, as only constant polynomials have a degree of zero.

In a semiring without zero divisors and of positive size, every unit in the polynomial ring over it is a constant polynomial of degree 0.


theorem Cardinal.sum_le_sum :
    ∀ {ι : Type u_1} (f g : ι → Cardinal.{u_2}), (∀ (i : ι), f i ≤ g i) → Cardinal.sum f ≤ Cardinal.sum g := by sorry

The theorem `Cardinal.sum_le_sum` states that for any indexed type `ι` and any two functions `f` and `g` from this index type to Cardinal numbers, if for each index `i` the Cardinal number given by `f` at `i` is less than or equal to the Cardinal number given by `g` at `i`, then the sum of the Cardinal numbers given by `f` (which corresponds to the cardinality of the disjoint union indexed by `ι` with cardinalities given by `f`) is less than or equal to the sum of the Cardinal numbers given by `g` (which corresponds to the cardinality of the disjoint union indexed by `ι` with cardinalities given by `g`).

For any indexed type ι and functions f, g from ι to Cardinal numbers, if for all i in ι, f(i) ≤ g(i), then Σ i : ι, f(i) ≤ Σ i : ι, g(i).


theorem Subgroup.comap_top :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N), Subgroup.comap f ⊤ = ⊤ := by sorry

The theorem `Subgroup.comap_top` states that for any group homomorphism `f` from a group `G` to another group `N`, the preimage of the top (i.e., the whole group `N`) along `f` is the top of `G`. In other words, the preimage of the whole group `N` under `f` is the whole group `G`. This is akin to saying that the inverse image of the entire range of a function is the entire domain.

For any group homomorphism `f` from group `G` to group `N`, `f⁻¹(N) = G`.


theorem ENNReal.one_toReal : 1.toReal = 1 := by sorry

This theorem states that the real number representation of 1, as obtained by the 'toReal' function, is equal to 1. In other words, when the integer 1 is converted to a real number using the 'toReal' function, it remains 1.

The theorem asserts that the real number representation of the integer 1, obtained through the 'toReal' function, is equal to 1. (or) The 'toReal' function applied to the integer 1 results in the real number 1.


theorem Bool.decide_iff : ∀ (p : Prop) [d : Decidable p], decide p = true ↔ p := by sorry

This theorem, `Bool.decide_iff`, states that for any proposition `p` which is decidable (i.e., either `p` is true or `p` is false, but not both), the function `decide p` returns `true` if and only if `p` is true. Here, `Decidable p` is an instance of the `Decidable` typeclass, meaning that there is a specific function that can decide whether `p` is true or false. The `↔` symbol represents logical equivalence, so `decide p = true ↔ p` means that `decide p` being true is logically equivalent to `p` being true.

Thedecidable proposition `p` is logically equivalent to the Boolean value `decide p` being `true`.


theorem SameRay.zero_left :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (y : M), SameRay R 0 y :=
  by sorry

This theorem states that for any type `R` that is a strict ordered commutative semiring, and any type `M` that is an additive commutative monoid and also a module over `R`, any vector `y` from `M` is in the same ray as the zero vector. The concept of "same ray" here is defined as either one of the vectors being zero, or there exists two positive scalar multiples (from the semiring `R`) such that one vector is the scalar multiple of the other.

For any strict ordered commutative semiring `R`, any additive commutative monoid `M` that is an `R`-module, and any vectors `x, y` in `M`, either `x = 0` or `y = rx` for some positive scalar `r` in `R`.


theorem dist_midpoint_right :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] {𝕜 : Type u_6} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V]
      [inst_5 : Invertible 2] (p₁ p₂ : P), dist (midpoint 𝕜 p₁ p₂) p₂ = ‖2‖⁻¹ * dist p₁ p₂ :=
  by sorry

The theorem `dist_midpoint_right` states that for any two points `p₁` and `p₂` in a pseudo-metric space `P` with an associated seminormed add commutative group `V`, the distance from the midpoint of `p₁` and `p₂` to `p₂` is equal to the inverse of the norm of 2 times the distance from `p₁` to `p₂`. Here the space `P` is a normed add-torsor over `V`, `V` is a normed space over a normed field `𝕜`, and 2 is invertible. In mathematical notation, this is saying that $dist(midpoint(p₁, p₂), p₂) = ‖2‖⁻¹ * dist(p₁, p₂)$.

In a normed add-torsor P over a normed space V with invertible 2, the midpoint distance to V's additive inverse is equal to the reciprocal of twice the distance between the two points. ($dist(midpoint(p₁, p₂), -p₂) = ‖2‖⁻¹ * dist(p₁, p₂)$)


theorem CategoryTheory.isIso_op_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
      CategoryTheory.IsIso f.op ↔ CategoryTheory.IsIso f :=
  by sorry

This theorem states that for any category `C` and any morphism `f` from object `X` to object `Y` in the category, `f` is an isomorphism if and only if its opposite `f.op` is an isomorphism. In other words, a morphism in a category is an isomorphism if and only if its reverse morphism in the opposite category is also an isomorphism.

In any category, a morphism is an isomorphism if and only if its opposite morphism is an isomorphism.


theorem MeasureTheory.measurable_pdf :
    ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} (X : Ω → E)
      (ℙ : MeasureTheory.Measure Ω) (μ : autoParam (MeasureTheory.Measure E) _auto✝),
      Measurable (MeasureTheory.pdf X ℙ μ) :=
  by sorry

The theorem `MeasureTheory.measurable_pdf` states that for all types `Ω` and `E`, where `E` has a `MeasurableSpace` instance, and for any `MeasurableSpace Ω`, a mapping `X` from `Ω` to `E`, a measure `ℙ` on `Ω`, and an (optional) measure `μ` on `E`, the probability density function (pdf) of a random variable `X`, which is the Radon-Nikodym derivative of the push-forward measure of `ℙ` along `X` with respect to `μ`, is a measurable function. In other words, for every measurable set in the codomain, the preimage under the pdf is also a measurable set in the domain.

The Radon-Nikodym derivative of the push-forward measure of a probability measure along a measurable function is a measurable function.


/-- The complex hyperbolic cosine function is everywhere strictly differentiable, with the
derivative `sinh x`.  -/
theorem Complex.hasStrictDerivAt_cosh : ∀ (x : ℂ), HasStrictDerivAt Complex.cosh (Complex.sinh x) x := by sorry

The theorem `Complex.hasStrictDerivAt_cosh` states that the complex hyperbolic cosine function, denoted as `Complex.cosh`, is strictly differentiable at every point `x` in the complex plane. The derivative of this function at any point `x` is given by the complex hyperbolic sine function evaluated at that point, which is `Complex.sinh x`. Strict differentiability here implies that the difference between the function values at two points approaches the product of the difference of the points and the derivative, plus a term that becomes negligible, as the two points converge to `x`.

The complex hyperbolic cosine function `Complex.cosh` is strictly differentiable on the complex plane with derivative `Complex.sinh`.


Int.lt.dest

theorem Int.lt.dest : ∀ {a b : ℤ}, a < b → ∃ n, a + ↑(Nat.succ n) = b := by sorry

The theorem `Int.lt.dest` states that for any two integers `a` and `b`, if `a` is less than `b`, then there exists a natural number `n` such that `a` plus the successor of `n` (i.e., `n+1`) equals `b`. Essentially, this theorem formalizes the idea that if one integer is less than another, there is a specific positive difference between them.

For any integers `a` and `b` with `a < b`, there exists a natural number `n` such that `a + (Suc n) = b`.


theorem symmDiff_bot : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a : α), symmDiff a ⊥ = a := by sorry

The theorem `symmDiff_bot` states that for all types `α` which form a Generalized Coheyting Algebra, and for any element `a` of type `α`, the symmetric difference of `a` and the bottom element (`⊥`) is just `a` itself. In terms of set theory, the symmetric difference (denoted by `symmDiff`) between a set `a` and the empty set (`⊥`) is just the set `a` itself.

For any type `α` that forms a Generalized Coalgebra and any element `a` of type `α`, `symmDiff a ⊥ = a`.


theorem Monotone.seq_le_seq :
    ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x y : ℕ → α},
      Monotone f → ∀ (n : ℕ), x 0 ≤ y 0 → (∀ k < n, x (k + 1) ≤ f (x k)) → (∀ k < n, f (y k) ≤ y (k + 1)) → x n ≤ y n :=
  by sorry

The theorem `Monotone.seq_le_seq` states that for all types `α` equipped with a preorder, for any function `f` from `α` to `α`, and for any sequences `x` and `y` of elements in `α` indexed by natural numbers, if `f` is monotone, the first element of `x` is less than or equal to the first element of `y`, for all indices `k` less than any given natural number `n` the `(k+1)`-th element of `x` is less than or equal to `f` applied to the `k`-th element of `x`, and for all indices `k` less than `n`, `f` applied to the `k`-th element of `y` is less than or equal to the `(k+1)`-th element of `y`, then the `n`-th element of `x` is less than or equal to the `n`-th element of `y`.

In simpler terms, this theorem says that if `f` is a monotone function and sequences `x` and `y` are such that each element of `x` is stretched by `f` in a way that's not more than the corresponding stretching of `y` by `f` (starting from the same or lower initial value), then every element of `x` is less than or equal to the corresponding element of `y`.

If `f` is a monotone function and `x` and `y` are sequences such that `x[0] <= y[0]` and `f(x[i-1]) <= y[i]` for all `i < n`, then `x[n] <= y[n]`.


theorem Finset.piecewise_congr :
    ∀ {ι : Type u_1} {π : ι → Sort u_2} (s : Finset ι) [inst : (j : ι) → Decidable (j ∈ s)] {f f' g g' : (i : ι) → π i},
      (∀ i ∈ s, f i = f' i) → (∀ i ∉ s, g i = g' i) → Finset.piecewise s f g = Finset.piecewise s f' g' :=
  by sorry

This theorem, `Finset.piecewise_congr`, states that for any type `ι`, a function type `π : ι → Sort u_2`, a finite set `s` of type `ι`, and four functions `f`, `f'`, `g`, `g'` of type `ι → π i`, if `f` and `f'` are equal on the set `s` and `g` and `g'` are equal on the complement of `s`, then the piecewise function defined by `f` and `g` on `s` is equal to the piecewise function defined by `f'` and `g'` on `s`.

In other words, if two pairs of functions agree on a finite set and its complement respectively, the piecewise functions constructed from each pair (where each function is used on the set where it agrees with its counterpart) are the same.

If functions $f$, $f'$, $g$, and $g'$ agree with each other on a finite set $s$ and complementarily on their domains, then the piecewise functions $x \mapsto \begin{cases} f(x) & x \in s \\ g(x) & x \notin s \end{cases}$ and $x \mapsto \beginextit{piecewise}~ x \mapsto \begin{cases} f'(x) & x \in s \\ g'(x) & x \notin s \end{cases}$ are equal.


theorem Cardinal.mk_finsupp_lift_of_infinite' :
    ∀ (α : Type u) (β : Type v) [inst : Nonempty α] [inst : Zero β] [inst_1 : Infinite β],
      Cardinal.mk (α →₀ β) = max (Cardinal.lift.{v, u} (Cardinal.mk α)) (Cardinal.lift.{u, v} (Cardinal.mk β)) :=
  by sorry

The theorem `Cardinal.mk_finsupp_lift_of_infinite'` states that for any types `α` and `β`, if `α` is nonempty, `β` is a type with a zero element, and `β` is infinite, then the cardinality of the type of functions from `α` to `β` with finite support (denoted by `(α →₀ β)`) is equal to the maximum of the universe-lifted cardinalities of `α` and `β`. The universe lifting operation essentially allows comparing cardinalities of types from different universes.

If `α` is a nonempty type, `β` is an infinite type with a zero element, then the cardinality of `(α →₀ β)` is max (|α|^U, |β|^U), where `|.|` denotes the cardinality and `^U` denotes universe lifting.


theorem false_and_iff : ∀ (p : Prop), False ∧ p ↔ False := by sorry

This theorem states that for any given proposition `p`, the conjunction of `False` and `p` is logically equivalent to `False`. In other words, if you have a statement that is `False` AND something else (regardless of whether that something else is true or false), the overall statement will always be false. This is a fundamental principle of logic known as "and-falsity".

For all propositions p, False and p are logically equivalent. (Or equivalently, the conjunction of False and p is equal to False.)


theorem ENNReal.iUnion_Iio_coe_nat : ⋃ n, Set.Iio ↑n = {⊤}ᶜ := by sorry

This theorem states that the union of left-infinite right-open intervals for all natural numbers, where each interval is defined as the set of all extended non-negative real numbers less than the corresponding natural number, is equal to the complement of the set containing only the element `⊤` (which represents infinity in the context of extended non-negative real numbers). In other words, every extended non-negative real number that is not infinity is less than some natural number.

The set of all extended non-negative real numbers less than every natural number forms a set equal to the complement of {⊤} in the extended non-negative real numbers.


SetTheory.PGame.Numeric.moveRight

theorem SetTheory.PGame.Numeric.moveRight :
    ∀ {x : SetTheory.PGame},
      SetTheory.PGame.Numeric x →
        ∀ (j : SetTheory.PGame.RightMoves x), SetTheory.PGame.Numeric (SetTheory.PGame.moveRight x j) :=
  by sorry

The theorem `SetTheory.PGame.Numeric.moveRight` states that for any pre-game `x` in set theory, if `x` is a numeric game (meaning that every element in the left set `L` is less than every element in the right set `R`, and all the elements of `L` and `R` are also numeric), then for any allowable move `j` by the right player, the resulting game after the right player makes move `j`, denoted by `SetTheory.PGame.moveRight x j`, is also a numeric game.

For any pre-game `x` in set theory that is a numeric game, the resulting game obtained by a right player's move `j` is also a numeric game.


theorem OreLocalization.oreDiv_eq_iff :
    ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {r₁ r₂ : R} {s₁ s₂ : ↥S},
      r₁ /ₒ s₁ = r₂ /ₒ s₂ ↔ ∃ u v, r₂ * ↑u = r₁ * v ∧ ↑s₂ * ↑u = ↑s₁ * v :=
  by sorry

This theorem states that for any given type `R` with a Monoid structure, a submonoid `S` of `R`, an Ore set `inst_1` on `S`, and elements `r₁`, `r₂` of `R` and `s₁`, `s₂` of `S`, the division `r₁ /ₒ s₁` is equal to `r₂ /ₒ s₂` if and only if there exist elements `u` and `v` such that `r₂` times `u` equals `r₁` times `v` and `s₂` times `u` equals `s₁` times `v`. In other words, two fractions are equal in Ore's localization if and only if there is a cross-multiplication property between them.

For any Monoid `R`, submonoid `S`, Ore set `inst_1`, and elements `r₁`, `r₂`, `s₁`, `s₂` in `R` with `S`, the fractions `r₁ /ₒ s₁` and `r₂ /ₒ s₂` are equal in Ore localization if and only if there exist `u` and `v` such that `r₁ * u = r₂ * v` and `s₁ * u = s₂ * v`.


theorem Int.le_refl : ∀ (a : ℤ), a ≤ a := by sorry

This theorem states that for any integer `a`, `a` is less than or equal to itself. In mathematical terms, this is known as reflexivity of the less than or equal relationship over the set of integers (`ℤ`), and it is a fundamental property of the ordering of numbers.

For all integers `a`, `a` is less than or equal to `a` (`∀ a : ℤ, a ≤ a`).


/-- **Alias** of `Filter.eventually_all_finite`. -/
theorem Set.Finite.eventually_all :
    ∀ {α : Type u} {ι : Type u_2} {I : Set ι},
      Set.Finite I →
        ∀ {l : Filter α} {p : ι → α → Prop}, (∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x :=
  by sorry

The theorem `Set.Finite.eventually_all` is an alias for `Filter.eventually_all_finite`. It states that for any type `α` and any index type `ι`, given a finite set `I` of index type `ι`, for any filter `l` on `α` and any predicate `p` from `ι` to `α` to `Prop`, the property that for almost all `x` in `l`, the predicate `p i x` holds for all `i` in `I`, is equivalent to the property that for each `i` in `I`, for almost all `x` in `l`, the predicate `p i x` holds. In other words, switching the order of quantifiers over a finite index set and a filter doesn't change the truth value of the statement.

For any filter on a type, a finite index set, and a predicate, the properties "for almost all elements in the filter, the predicate holds for all indices in a finite set" and "for each index in the finite set, for almost all elements in the filter, the predicate holds" are equivalent.


theorem FractionalIdeal.coe_spanSingleton :
    ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      [loc : IsLocalization S P] (x : P), ↑(FractionalIdeal.spanSingleton S x) = Submodule.span R {x} :=
  by sorry

This theorem states that for any commutative ring `R`, any submonoid `S` of `R`, any commutative ring `P`, any `R`-algebra structure on `P`, and a localization `S` at `P`, for any element `x` in `P`, the ring-coercion of the fractional ideal generated by `x` (if `0` is not in `S`) is equal to the smallest submodule of `P` that contains the set `{x}`. In other words, the fractional ideal generated by a single element `x` in a localized ring corresponds to the span of the singleton set `{x}` in the module over the commutative ring `R`.

For any commutative ring `R`, submonoid `S` of `R`, commutative `R`-algebra `P`, and localization `S^(-1)P` of `P` at `S`, the fractional ideal generated by an element `x` in `P` equals the submodule of `P` generated by `{x}` over `R`.


theorem Mathlib.Computability.TuringMachine._auxLemma.14 :
    ∀ {α : Type u_1} {s : Finset α} {o : Option α}, (o ∈ Finset.insertNone s) = ∀ a ∈ o, a ∈ s := by sorry

This theorem states that for any type `α`, any finite set `s` of type `α`, and any optional value `o` of type `α`, `o` is an element of the finite set obtained by inserting 'None' into `s` (via the `Finset.insertNone` function) if and only if for all elements `a` in `o`, `a` is also an element of `s`. In other words, this theorem characterizes the membership of an optional value in the finite set formed by lifting `s` to 'Option α' and adding 'None' as an additional element.

For any type `α`, any finite set `s` of `α`, and optional value `o` of `α`, `o` is an element of the finite set `{None} ⊎ s` if and only if every component of `o` (if it is some value) is in `s`.


theorem Mathlib.Computability.TuringMachine._auxLemma.15 :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
      (b ∈ Finset.biUnion s t) = ∃ a ∈ s, b ∈ t a :=
  by sorry

The theorem `_auxLemma.15` from the `Mathlib.Computability.TuringMachine` module states that for any types `α` and `β`, a finite set `s` of type `α`, a function `t` which maps elements of `α` to finite sets of `β`, and a decidable equality on `β`, then for any element `b` of `β`, `b` is in the bi-union of `s` and `t` if and only if there exists an element `a` in `s` such that `b` is in `t(a)`. Here, `biUnion s t` represents the union of the sets `t a` for all `a` in `s`.

For any types α and β, finite set s of α, function t: α → β with values in finite sets, and decidable equality on β, an element b is in the bi-union of s and t if and only if there exists an a in s such that b is in t(a).


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

The theorem `AddOpposite.unop_surjective` states that for any type `α`, the function `AddOpposite.unop` is surjective. In other words, for every element `b` of type `α`, there exists an element `a` of type `αᵃᵒᵖ` such that applying the function `AddOpposite.unop` to `a` results in `b`. This means that every element of type `α` can be obtained by applying `AddOpposite.unop` to some element of its additive opposite type `αᵃᵒᵖ`.

For any type `α`, the function `AddOpposite.unop` from its additive opposite type `αᵃᵒᵖ` to `α` is surjective.


InitialSeg.eq

theorem InitialSeg.eq :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder β s] (f g : r ≼i s)
      (a : α), f a = g a :=
  by sorry

This theorem asserts that for any two types `α` and `β` with respective order relations `r` and `s`, and given `β` is a well-order, then for any two initial segment embeddings `f` and `g` from `α` into `β`, these embeddings are identical at every point `a` in `α`. In other words, if `f` and `g` are both initial segment embeddings of `α` into `β`, then they are the same function.

If `α` is a type with a well-order `r`, and `f` and `g` are initial segment embeddings of `α` into another well-order `β` with order relation `s`, then `f = g`.


theorem HasDerivWithinAt.mono_of_mem :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜},
      HasDerivWithinAt f f' t x → t ∈ nhdsWithin x s → HasDerivWithinAt f f' s x :=
  by sorry

The theorem `HasDerivWithinAt.mono_of_mem` states that if a function `f` has a derivative `f'` at a point `x` within a subset `t` of the domain, and the subset `t` is contained in the intersection of `s` and a neighborhood of `x`, then `f` also has the derivative `f'` at the point `x` within the subset `s`. Here `𝕜` is a field with a norm that is not trivial, `F` is a normed additively commutative group, and `F` is a normed space over `𝕜`.

If a function `f` has a derivative `f'` at `x` in subset `t` of the normed space `F` over field `ℝ` with a non-trivial norm, and `t` is contained in the intersection of `s` and a neighborhood of `x`, then `f` has derivative `f'` at `x` in subset `s`.


theorem Set.mk_preimage_prod_right :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α}, a ∈ s → Prod.mk a ⁻¹' s ×ˢ t = t := by sorry

This theorem states that for any given types `α` and `β`, a set `s` of type `α`, a set `t` of type `β`, and an element `a` of type `α`, if `a` is an element of `s`, then the preimage of the cartesian product of `s` and `t` under the function `Prod.mk a` (which pairs `a` with elements of `β`) is equal to `t`. In terms of set theory, if we have an element from one set, then the set of all pairs consisting of this element and an element from another set is equivalent to the second set.

For any sets `α`, `β`, a set `s` of type `α`, a set `t` of type `β`, and an element `a` of type `α` in `s`, the preimage of the cartesian product `s × t` under the function `Prod.mk a` is equal to `t`. In symbols: `{x : β | ∃ s. (a ∈ s) ∧ (x, a) ∈ s × t} = t`.


CategoryTheory.ThinSkeleton.skeletal

theorem CategoryTheory.ThinSkeleton.skeletal :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : Quiver.IsThin C],
      CategoryTheory.Skeletal (CategoryTheory.ThinSkeleton C) :=
  by sorry

This theorem states that for any type `C` that is both a category and a thin quiver (i.e., a category in which there are no parallel arrows), the thin skeleton of `C` is skeletal. Here, a category is said to be skeletal if any two objects in the category that are isomorphic are actually identical. It implies that in the thin skeleton of a thin category, isomorphic objects are necessarily identical.

In a thin quiver category `C`, the thin skeleton is a skeletal category, meaning isomorphic objects are identical.


theorem Mathlib.Data.Set.Lattice._auxLemma.49 :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {u : Set γ},
      (Set.image2 f s t ⊆ u) = ∀ x ∈ s, ∀ y ∈ t, f x y ∈ u :=
  by sorry

This theorem states that for all types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, and for any sets `s` of type `α`, `t` of type `β`, and `u` of type `γ`, the condition that the image of the binary function `f` applied to sets `s` and `t` is a subset of `u` is equivalent to the condition that for every element `x` in `s` and every element `y` in `t`, the function `f` applied to `x` and `y` results in an element that belongs to `u`. In other words, if we apply the function to each element of `s` and `t`, all resulting elements belong to `u`.

For any types `α`, `β`, `γ`, sets `s` of type `α`, `t` of type `β`, and binary function `f` from `α` and `β` to `γ`, the image of `f` applied to `s` and `t` is a subset of `u` if and only if for all `x` in `s` and `y` in `t`, `f x y` is in `u`.


theorem Nat.lt_or_eq_of_le : ∀ {n m : ℕ}, n ≤ m → n < m ∨ n = m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m`, then either `n` is strictly less than `m` or `n` is equal to `m`. This is a fundamental property of the ordering of natural numbers.

For all natural numbers `n` and `m`, if `n ≤ m`, then `n < m` or `n = m`.


theorem CategoryTheory.Subobject.le_of_comm :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B}
      (f : CategoryTheory.Subobject.underlying.obj X ⟶ CategoryTheory.Subobject.underlying.obj Y),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Subobject.arrow Y) = CategoryTheory.Subobject.arrow X →
        X ≤ Y :=
  by sorry

This theorem states that in any category `C`, for any objects `B`, `X` and `Y` of the subobject category of `B`, if there exists a morphism `f` from the underlying object of `X` to the underlying object of `Y` such that the composition of `f` and the arrow of `Y` equals the arrow of `X`, then `X` is less than or equal to `Y`. The arrow of a subobject is the morphism from an arbitrarily chosen underlying object of the subobject to the ambient object. The underlying object is the representative object in `C` for any `Subobject` of `X`.

In any category C, if there exists a morphism from the underlying object of a subobject X of an object B to the underlying object of another subobject Y of B such that the composition is equal to the inclusion morphism of X, then X is less than or equal to Y in the subobject lattice of B.


NormedAddGroupHom.continuous

theorem NormedAddGroupHom.continuous :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂), Continuous ⇑f :=
  by sorry

This theorem states that for any two types `V₁` and `V₂` that have the structure of a semi-normed additive commutative group, any normed additive group homomorphism `f` from `V₁` to `V₂` is continuous. In mathematical terms, it says that normed additive group homomorphisms between semi-normed additive commutative groups are always continuous functions.

Any normed additive group homomorphism between two semi-normed additive commutative groups is a continuous function.


theorem LinearLocallyFiniteOrder.succFn_spec :
    ∀ {ι : Type u_1} [inst : LinearOrder ι] (i : ι), IsGLB (Set.Ioi i) (LinearLocallyFiniteOrder.succFn i) := by sorry

The theorem `LinearLocallyFiniteOrder.succFn_spec` states that for any type ι that has a linear order, and for any element `i` of that type, the successor function `LinearLocallyFiniteOrder.succFn` provides a value that is a greatest lower bound (GLB) for the set of all elements greater than `i`. In other words, the result of the successor function is the smallest value that is greater than `i` in the given order, assuming such a value exists.

For any linear order type ι and its element i, the successor function `LinearLocallyFiniteOrder.succFn` gives the greatest lower bound of elements greater than i.


theorem CochainComplex.shiftFunctorAdd'.proof_1 : ∀ (n₁ n₂ n₁₂ : ℤ), n₁ + n₂ = n₁₂ → ∀ (i : ℤ), i + n₂ + n₁ = i + n₁₂ :=
  by sorry

This theorem states that for any integers `n₁`, `n₂`, and `n₁₂` such that `n₁ + n₂ = n₁₂`, and for any integer `i`, the equality `i + n₂ + n₁ = i + n₁₂` holds. In other words, if `n₁₂` is the sum of `n₁` and `n₂`, then adding `n₁` and `n₂` in any order to `i` gives the same result as adding `n₁₂` to `i`.

For any integers `n₁`, `n₂`, and `i`, if `n₁ + n₂ = n₁₂`, then `i + n₁ + n₂ = i + n₁₂`.


theorem EReal.top_mul_coe_of_pos : ∀ {x : ℝ}, 0 < x → ⊤ * ↑x = ⊤ := by sorry

This theorem states that for every real number `x`, if `x` is greater than zero, then the product of the extended real number positive infinity (`⊤`) and the coercion of `x` to an extended real number equals positive infinity (`⊤`). In other words, any positive real number, when multiplied with positive infinity, results in positive infinity in the context of extended real numbers.

For every real number `x > 0`, `x * ⊤ = ⊤` in the context of extended real numbers.


theorem NumberField.InfinitePlace.mk_eq_iff :
    ∀ {K : Type u_2} [inst : Field K] {φ ψ : K →+* ℂ},
      NumberField.InfinitePlace.mk φ = NumberField.InfinitePlace.mk ψ ↔
        φ = ψ ∨ NumberField.ComplexEmbedding.conjugate φ = ψ :=
  by sorry

The theorem `NumberField.InfinitePlace.mk_eq_iff` states that for any field `K` and any two complex embeddings `φ` and `ψ` from `K` into the complex numbers, the infinite place defined by `φ` equals the infinite place defined by `ψ` if and only if `φ` equals `ψ` or the complex conjugate of the embedding `φ` equals `ψ`.

The infinite places of a field `K` under complex embeddings `φ` and `ψ` are equal if and only if `φ` is equal to `ψ` or the complex conjugate of `φ`.


theorem IsCompl.isAtom_iff_isCoatom :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : IsModularLattice α] {a b : α},
      IsCompl a b → (IsAtom a ↔ IsCoatom b) :=
  by sorry

This theorem states that for any type `α` that forms a lattice, is a bounded order, and is a modular lattice, given any two elements `a` and `b` of this type, if `a` and `b` are complements (as indicated by `IsCompl a b`), then `a` is an atom (an element with no other element between it and the bottom element, and which is not the bottom element itself) if and only if `b` is a coatom (an element with no other element between it and the top element, and which is not the top element itself).

For any lattice type `α` that is bounded and modular, elements `a` and `b` are complements if and only if `a` is an atom if and only if `b` is a coatom.


IsGenericPoint.specializes

theorem IsGenericPoint.specializes :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x y : α} {S : Set α}, IsGenericPoint x S → y ∈ S → x ⤳ y := by sorry

This theorem states that for any topological space `α` and any two points `x` and `y` in `α`, along with a set `S` of points in `α`, if `x` is a generic point of `S` and `y` is an element of `S`, then `x` specializes to `y`. In the context of topology, "specializes to" means that every neighborhood of `x` also contains `y`, symbolized by `x ⤳ y`. This theorem essentially establishes a connection between the concept of a generic point and the specialization order in topological spaces.

Given any topological space `α`, if point `x` is a generic point of set `S` and `y` is an element of `S`, then `x` specializes to `y` (i.e., every neighborhood of `x` contains `y`).


/-- If `L : C ⥤ D` is a localization for `W : MorphismProperty C`, then it is also
the case of a functor obtained by post-composing `L` with an equivalence of categories.  -/
theorem CategoryTheory.Functor.IsLocalization.of_equivalence_target :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_6, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_7, u_2} D] (L : CategoryTheory.Functor C D)
      (W : CategoryTheory.MorphismProperty C) {E : Type u_4} [inst_2 : CategoryTheory.Category.{u_5, u_4} E]
      (L' : CategoryTheory.Functor C E) (eq : D ≌ E) [inst_3 : CategoryTheory.Functor.IsLocalization L W],
      (CategoryTheory.Functor.comp L eq.functor ≅ L') → CategoryTheory.Functor.IsLocalization L' W :=
  by sorry

The theorem `CategoryTheory.Functor.IsLocalization.of_equivalence_target` states that if a functor `L : C ⥤ D` is a localization for a MorphismProperty `W` in a category `C`, then this property also holds for a functor obtained by post-composing `L` with an equivalence of categories, provided that the composition of `L` and this equivalence functor is naturally isomorphic to another functor `L' : C ⥤ E`. In other words, if `L` has a certain localization property with respect to `W`, this property is preserved when we map the category `D` to another category `E` via an equivalence of categories.

If functor `L : C -> D` is a localization for property `W` in category `C`, and there exists an equivalence of categories `F : D -> E` such that `L` is naturally isomorphic to `L' : C -> E`, then `L'` also localizes `W`.


theorem symmDiff_def : ∀ {α : Type u_2} [inst : Sup α] [inst_1 : SDiff α] (a b : α), symmDiff a b = a \ b ⊔ b \ a := by
  sorry

This theorem states that for all types `α` that have a supremum (denoted as `Sup α`) and set difference operations (denoted as `SDiff α`), the symmetric difference `symmDiff` of any two elements `a` and `b` of type `α` is equal to the union (supremum, denoted as `⊔`) of the set difference of `a` and `b` and the set difference of `b` and `a`. In other words, `symmDiff a b` equals `(a \ b) ⊔ (b \ a)`. This corresponds to the mathematical concept of the symmetric difference of two sets, which consists of elements in either of the sets but not in their intersection.

For any type `α` with a supremum and set difference operations, the symmetric difference of two elements `a` and `b` equals the supremum of their set difference and the set difference of their reversed order: `symmDiff a b = (a \ b) ⊔ (b \ a)`.


theorem MeasureTheory.lintegral_const_mul' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (r : ENNReal) (f : α → ENNReal),
      r ≠ ⊤ → ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ :=
  by sorry

This theorem, `MeasureTheory.lintegral_const_mul'`, states that for any type `α`, given a measurable space `m` of type `α`, a measure `μ` on this space, a constant `r` in the set of extended nonnegative real numbers (which is denoted by `[0, ∞]` and does not include positive infinity), and a function `f` mapping from `α` to the extended nonnegative real numbers, if `r` is not positive infinity, then the Lebesgue integral of the product of `r` and `f a` with respect to measure `μ` (denoted as `∫⁻ (a : α), r * f a ∂μ`) is equal to the product of `r` and the Lebesgue integral of `f a` with respect to measure `μ` (denoted as `r * ∫⁻ (a : α), f a ∂μ`). In other words, the constant can be factored out of the Lebesgue integral when it is not positive infinity.

For any measurable space `(α, m)`, measure `μ`, constant `r ∈ [0, ∞)`, and measurable function `f` from `α` to `[0, ∞)`, if `r < ∞`, then `∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ`.


theorem CategoryTheory.Limits.IsTerminal.from_self :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} (t : CategoryTheory.Limits.IsTerminal X),
      CategoryTheory.Limits.IsTerminal.from t X = CategoryTheory.CategoryStruct.id X :=
  by sorry

This theorem, `CategoryTheory.Limits.IsTerminal.from_self`, states that for any category `C` and any object `X` in `C` that is terminal (as per the definition `CategoryTheory.Limits.IsTerminal`), the morphism from `X` to itself (obtained using `CategoryTheory.Limits.IsTerminal.from`) is the identity morphism on `X` (as per `CategoryTheory.CategoryStruct.id`). In category-theoretical terms, this expresses the property that in any category, the morphism from a terminal object to itself is always the identity morphism.

In any category, the morphism from a terminal object to itself is the identity morphism.


DenseInducing.continuous

theorem DenseInducing.continuous :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β},
      DenseInducing i → Continuous i :=
  by sorry

This theorem states that for any two types `α` and `β`, given that `α` and `β` are topological spaces, if a function `i` from `α` to `β` is dense inducing, then `i` is continuous. Here, dense inducing refers to a function that has the property of being both dense and inducing – the image of the function is a dense subset of the codomain, and the function induces the topology of the codomain on the domain. Hence, the theorem essentially establishes the continuity of any dense inducing function in a topological context.

If `α` and `β` are topological spaces, and `i : α → β` is a dense and inducing function, then `i` is continuous.


theorem Mathlib.Data.Set.Lattice._auxLemma.13 : ∀ {α : Type u} {s : Set α}, Set.Nonempty s = (s ≠ ∅) := by sorry

The theorem `Mathlib.Data.Set.Lattice._auxLemma.13` states that for all types `α` and for all sets `s` of type `α`, the property that the set `s` is nonempty is equivalent to the assertion that the set `s` is not the empty set. Here, a set is said to be nonempty if there exists at least one element in it, and is said to be empty if it contains no elements. This theorem provides an equivalence between these two ways of expressing the notion of a nonempty set.

The theorem asserts that a set is nonempty if and only if it is not empty.


IsMinFilter.neg

theorem IsMinFilter.neg :
    ∀ {α : Type u} {β : Type v} [inst : OrderedAddCommGroup β] {f : α → β} {a : α} {l : Filter α},
      IsMinFilter f l a → IsMaxFilter (fun x => -f x) l a :=
  by sorry

The theorem `IsMinFilter.neg` states that for any type `α`, any ordered additive commutative group `β`, any function `f` from `α` to `β`, any element `a` of type `α`, and any filter `l` on `α`, if `f` reaches its minimum value at `a` within the neighborhood of `a` defined by the filter `l` (i.e., `f(a)` is less than or equal to `f(x)` for all `x` in that neighborhood), then the negative of `f`, `-f`, reaches its maximum value at the same point `a` within the same neighborhood (i.e., `-f(a)` is greater than or equal to `-f(x)` for all `x` in that neighborhood). This theorem essentially states that the point of minimum value for a function in a certain neighborhood becomes the point of maximum value for the negative of that function in the same neighborhood.

For any function `f` from a type `α` to an ordered additive commutative group `β`, if `a` is the point where `f` achieves its minimum value within the neighborhood defined by filter `l` on `α`, then `-a` is the point where `-f` achieves its maximum value within the same neighborhood.


/-- For integrally closed rings, the minimal polynomial divides any polynomial that has the
integral element as root. See also `minpoly.dvd` which relaxes the assumptions on `S`
in exchange for stronger assumptions on `R`.  -/
theorem minpoly.isIntegrallyClosed_dvd :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R]
      [inst_3 : Algebra R S] [inst_4 : IsDomain S] [inst_5 : NoZeroSMulDivisors R S] [inst_6 : IsIntegrallyClosed R]
      {s : S}, IsIntegral R s → ∀ {p : Polynomial R}, (Polynomial.aeval s) p = 0 → minpoly R s ∣ p :=
  by sorry

This theorem states that for integrally closed rings, the minimal polynomial divides any polynomial that has the integral element as a root. This is generally applied in the setting where R and S are two commutative rings, S is an R-algebra, and both R and S are integral domains with no zero divisors of the form a * s = 0 with a in R and s in S. Given these conditions and the fact that an element s in S is integral over R, if a polynomial p over R evaluates to zero at s (using the algebra homomorphism that sends the indeterminate to s), then the minimal polynomial of s over R divides p. The theorem provides a key property of minimal polynomials in the context of integral elements and integrally closed domains.

If R is an integrally closed domain, and s is an element in the R-algebra S that is integral over R, then the minimal polynomial of s over R divides any polynomial in R[x] that evaluates to zero at s.


theorem CategoryTheory.DifferentialObject.Hom.ext :
    ∀ {S : Type u_1} {inst : AddMonoidWithOne S} {C : Type u} {inst_1 : CategoryTheory.Category.{v, u} C}
      {inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} {inst_3 : CategoryTheory.HasShift C S}
      {X Y : CategoryTheory.DifferentialObject S C} (x y : CategoryTheory.DifferentialObject.Hom X Y),
      x.f = y.f → x = y :=
  by sorry

This theorem states that in the category of differential objects over a category `C` with zero morphisms and a shift operation, and with coefficients in an additive monoid with one `S`, any two morphisms `x` and `y` between the same differential objects `X` and `Y` are equal if their underlying morphisms `x.f` and `y.f` are equal.

In the category of differential objects over a category with zero morphisms and a shift operation, and with coefficients in an additive monoid, any two morphisms between the same objects with equal underlying morphisms are equal.


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

The theorem `CategoryTheory.Limits.colimit.ι_post` states that for any object `J` in a category, a functor `F` from `J` to a category `C`, another functor `G` from `C` to a different category `D`, and given that the functors and categories satisfy certain conditions (being co-limits), the composition of the coprojection from a value of the composite functor `F` followed by `G` to the co-limit object of the composite functor and the post-composed co-limit of `F` with `G` is equal to the `G`-mapping of the coprojection from a value of the functor `F` to the co-limit object of `F`. In mathematical terms, this is expressing a property of the co-limit object in category theory, specifically the universality of the co-limit.

For any functors F from J to C and G from C to D, where J is an object in a category and F and G have co-limits, the post-composition of the coprojection of F's co-limit with G and the coprojection of F's co-limit is equal to G's mapping of F's coprojection.


theorem Submonoid.LocalizationMap.mk'_spec :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      (f : Submonoid.LocalizationMap S N) (x : M) (y : ↥S),
      Submonoid.LocalizationMap.mk' f x y * (Submonoid.LocalizationMap.toMap f) ↑y =
        (Submonoid.LocalizationMap.toMap f) x :=
  by sorry

The theorem `Submonoid.LocalizationMap.mk'_spec` establishes a property of localization maps between two commutative monoids. Given a commutative monoid `M`, a submonoid `S` of `M`, a commutative monoid `N`, and a localization map `f` from `S` to `N`, for any element `x` from `M` and `y` from `S`, the product of the map of `x` and `y` under `f` equals the map of `x` under `f`. In other words, for any `x` in `M` and `y` in `S`, it ensures that `f(x,y) * f(y) = f(x)`, where `f(x,y)` denotes the image of the pair `(x, y)` under the localization map `f`.

Given a localization map from a submonoid of a commutative monoid to another commutative monoid, the image of the product of any two elements under the map is equal to the product of their images.


theorem noncompactSpace_of_neBot :
    ∀ {X : Type u} [inst : TopologicalSpace X], Filter.NeBot (Filter.cocompact X) → NoncompactSpace X := by sorry

The theorem `noncompactSpace_of_neBot` states that for any topological space `X`, if the filter generated by complements to compact sets in `X` (denoted as `Filter.cocompact X`) is not the trivial filter (i.e., it contains more than just the entire set), then `X` is a noncompact space. In other words, if there exists a sequence in `X` that does not have any convergent subsequence, which implies that the filter generated by complements to compact sets is not trivial, then `X` is not compact.

If the filter of cocompact sets in a topological space is nontrivial, then the space is noncompact.


/-- When one splits a list along a composition `c`, the number of sublists thus created is
`c.length`.  -/
theorem List.length_splitWrtComposition :
    ∀ {n : ℕ} {α : Type u_1} (l : List α) (c : Composition n),
      List.length (List.splitWrtComposition l c) = Composition.length c :=
  by sorry

The theorem `List.length_splitWrtComposition` states that if you split a list `l` according to a composition `c`, the total number of sublists created in this process is equal to the number of blocks in the composition `c`. In other words, the length of the list obtained by splitting list `l` with respect to composition `c` is equal to the length of the composition `c`.

The length of a list split by a composition equals the number of blocks in the composition.


theorem Mathlib.ModelTheory.Satisfiability._auxLemma.16 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {φ ψ : FirstOrder.Language.BoundedFormula L α l} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.iff φ ψ) v xs =
        (FirstOrder.Language.BoundedFormula.Realize φ v xs ↔ FirstOrder.Language.BoundedFormula.Realize ψ v xs) :=
  by sorry

This theorem states that for any first-order language `L`, structure `M`, a type `α`, a natural number `l`, two bounded formulas `φ` and `ψ` of the language `L`, a function `v` from `α` to `M`, and a function `xs` from the finite sequence of length `l` to `M`, the realization of the biimplication (logical equivalence) of the bounded formulas `φ` and `ψ` given the functions `v` and `xs` is equivalent to the biimplication (logical equivalence) of the realizations of `φ` and `ψ` given the same functions. In other words, the realization process preserves logical equivalence between two formulas in a first-order language.

For any first-order language L, structure M, type α, natural number l, functions v : α -> M, xs : fin l -> M, and bounded formulas φ and ψ of L, the realizability of φ iff ψ given v and xs is equivalent to φ(v, xs) iff ψ(v, xs).


theorem dvd_of_mul_right_dvd : ∀ {α : Type u_1} [inst : Semigroup α] {a b c : α}, a * b ∣ c → a ∣ c := by sorry

This theorem states that for any type `α` that forms a semigroup, and for any three elements `a`, `b`, and `c` of this type, if `a` multiplied by `b` divides `c`, then `a` also divides `c`. Here, "divides" is represented by the `∣` symbol: `a ∣ c` means that `c` is an integer multiple of `a`.

For any semigroup type `α`, if `a` multiplies `b` and the result divides `c` (`a * b ∣ c`), then `a` divides `c` (`a ∣ c`).


theorem AddSubgroup.mem_zmultiples_iff :
    ∀ {G : Type u_1} [inst : AddGroup G] {g h : G}, h ∈ AddSubgroup.zmultiples g ↔ ∃ k, k • g = h := by sorry

This theorem states that for any additively group-structured type `G` and any two elements `g` and `h` of `G`, `h` is in the subgroup generated by `g` if and only if there exists an integer `k` such that `k` times `g` equals `h`. In other words, an element `h` is in the subgroup produced by repeatedly adding `g` to itself if and only if `h` itself can be expressed as `g` added to itself a certain number of times.

An element `h` of an additively group-structured type `G` is in the subgroup generated by an element `g` if and only if there exists an integer `k` such that `h = k * g`.


theorem MeasureTheory.AEStronglyMeasurable.comp_measurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {g : α → β} {γ : Type u_5} {x : MeasurableSpace γ}
      {x_1 : MeasurableSpace α} {f : γ → α} {μ : MeasureTheory.Measure γ},
      MeasureTheory.AEStronglyMeasurable g (MeasureTheory.Measure.map f μ) →
        Measurable f → MeasureTheory.AEStronglyMeasurable (g ∘ f) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.comp_measurable` states that for any two types `α` and `β` with `β` being a topological space, and any function `g : α → β`, along with another type `γ` and measurable spaces `x` and `x_1` associated to `γ` and `α` respectively, and a function `f : γ → α`, and a measure `μ` on `γ`, if `g` is `AEStronglyMeasurable` with respect to the measure `μ` pushed forward by `f`, and if `f` is a measurable function, then the composition function `g ∘ f` is also `AEStronglyMeasurable` with respect to the measure `μ`.

In simpler terms, if a function `g` is almost everywhere equal to the limit of a sequence of simple functions with respect to a measure `μ` transformed by another function `f`, and if `f` is a function such that the preimage of every measurable set is measurable, then the combination of these two functions (i.e., `g ∘ f`) is also almost everywhere equal to the limit of a sequence of simple functions with respect to the original measure `μ`.

If `g : α → β` is `AEStronglyMeasurable` with respect to the measure `μ` pushed forward by a measurable function `f : γ → α`, then the composition `g ∘ f` is `AEStronglyMeasurable` with respect to the measure `μ` on `γ`.


theorem nnnorm_ne_zero_iff : ∀ {E : Type u_6} [inst : NormedAddGroup E] {a : E}, ‖a‖₊ ≠ 0 ↔ a ≠ 0 := by sorry

This theorem states that for any Type `E` which is a `NormedAddGroup`, the nonnegative norm, denoted as `‖a‖₊`, of an element `a` from `E` is not equal to zero if and only if `a` is not equal to zero. In other words, an element of the `NormedAddGroup` is zero if and only if its nonnegative norm is also zero.

For any `NormedAddGroup` `E`, the nonnegative norm of an element `a` is zero if and only if `a` is the additive identity of `E`.


theorem continuous_stoneCechExtend :
    ∀ {α : Type u} [inst : TopologicalSpace α] {γ : Type u} [inst_1 : TopologicalSpace γ] [inst_2 : T2Space γ]
      [inst_3 : CompactSpace γ] {f : α → γ} (hf : Continuous f), Continuous (stoneCechExtend hf) :=
  by sorry

The theorem `continuous_stoneCechExtend` states that for any function `f` from a topological space `α` to a compact Hausdorff space `γ`, if `f` is continuous, then the extension of `f` to the Stone-Čech compactification of `α`, denoted by `stoneCechExtend hf`, is also continuous. This extension uses the ultrafilter extension of `f`. In mathematical terms, if $\alpha$ and $\gamma$ are topological spaces, with $\gamma$ also being a compact Hausdorff space, and $f: \alpha \rightarrow \gamma$ is a continuous function, then the function extending $f$ to the Stone-Čech compactification of $\alpha$ is also a continuous function.

If $f : \alpha \rightarrow \gamma$ is a continuous function between a topological space $\alpha$ and a compact Hausdorff space $\gamma$, then the extension of $f$ to the Stone-Čech compactification of $\alpha$ is also a continuous function.


theorem Finset.sdiff_inter_self_left : ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), s \ (s ∩ t) = s \ t :=
  by sorry

This theorem states that for any type `α` that has a decidable equality, and for any two finite sets `s` and `t` of elements of type `α`, the difference of `s` and the intersection of `s` and `t` is equal to the difference of `s` and `t`. In mathematical terms, it means that for all sets `s` and `t`, we have `s \ (s ∩ t) = s \ t`. This is a property related to set operations.

For any finite sets `s` and `t` of a type `α` with decidable equality, the difference `s \ (s ∩ t)` equals `s \ t`.


theorem Set.projIcc_of_right_le :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α},
      b ≤ x → Set.projIcc a b h x = { val := b, property := ⋯ } :=
  by sorry

This theorem states that for any type `α` with a linear order, given two elements `a` and `b` such that `a` is less than or equal to `b`, and any element `x` of `α`, if `b` is less than or equal to `x`, then the projection of `x` onto the closed interval `[a, b]` is equal to `b`. This essentially means that any element greater than or equal to `b` gets mapped to `b` when projected onto the interval `[a, b]`.

For any linear order `α`, if `a ≤ b` in `α` and `x ∈ α` with `b ≤ x`, then the projection of `x` onto the interval `[a, b]` equals `b`.


TopologicalSpace.IsSeparable.iUnion

theorem TopologicalSpace.IsSeparable.iUnion :
    ∀ {α : Type u} [t : TopologicalSpace α] {ι : Sort u_2} [inst : Countable ι] {s : ι → Set α},
      (∀ (i : ι), TopologicalSpace.IsSeparable (s i)) → TopologicalSpace.IsSeparable (⋃ i, s i) :=
  by sorry

The theorem `TopologicalSpace.IsSeparable.iUnion` states that, for any type `α` that has a topological space structure, any countable index set `ι`, and any indexed collection of sets `s : ι → Set α` where each set `s i` is separable, the union of all these sets (`⋃ i, s i`) is also separable. In other words, if each set in a countable collection of sets is separable in a given topological space, then the union of all these sets is also separable in that topological space.

If `α` is a topological space, `ι` is a countable index set, and each `s : ι → Set α` is a separable family of sets, then their union `⋃ i, s i` is separable in `α`.


theorem AddMonoidHom.comp_assoc :
    ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} {Q : Type u_10} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : AddZeroClass P] [inst_3 : AddZeroClass Q] (f : M →+ N) (g : N →+ P) (h : P →+ Q),
      AddMonoidHom.comp (AddMonoidHom.comp h g) f = AddMonoidHom.comp h (AddMonoidHom.comp g f) :=
  by sorry

The theorem `AddMonoidHom.comp_assoc` states that for any four types `M`, `N`, `P`, `Q` that form additive monoids (meaning they have a zero and a binary add operation), if `f` is an additive monoid homomorphism from `M` to `N`, `g` is an additive monoid homomorphism from `N` to `P`, and `h` is an additive monoid homomorphism from `P` to `Q`, then the composition of morphisms is associative. That is, composing `h` and `g` first and then `f` (i.e., `(h ∘ g) ∘ f`) is the same as composing `h` with the composition of `g` and `f` (i.e., `h ∘ (g ∘ f)`). This is the category-theoretic notion of associativity applied to additive monoid homomorphisms.

For any additive monoid homomorphisms `f : M → N`, `g : N → P`, and `h : P → Q` between additive monoids `M`, `N`, `P`, and `Q`, the composition `h ∘ (g ∘ f)` is equal to `(h ∘ g) ∘ f`.


theorem gcd_eq_zero_iff :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] (a b : α),
      gcd a b = 0 ↔ a = 0 ∧ b = 0 :=
  by sorry

This theorem states that for any type `α` that is a cancel commutative monoid with zero and a GCD monoid, the greatest common divisor (gcd) of two values `a` and `b` of this type equals zero if and only if both `a` and `b` are zero. In mathematical terms, for all `a` and `b` in `α`, gcd(`a`, `b`) = 0 is equivalent to `a` = 0 and `b` = 0.

For any cancel commutative monoid with zero and a GCD operation, the greatest common divisor of two elements is equal to zero if and only if both elements are zero.


FreeAddGroup.lift.of

theorem FreeAddGroup.lift.of :
    ∀ {α : Type u} {β : Type v} [inst : AddGroup β] {f : α → β} {x : α},
      (FreeAddGroup.lift f) (FreeAddGroup.of x) = f x :=
  by sorry

The theorem `FreeAddGroup.lift.of` states that for any types `α` and `β`, where `β` is an additive group, and for any function `f` from `α` to `β`, and for any element `x` of type `α`, the result of applying the group homomorphism, produced by `FreeAddGroup.lift` on the function `f`, to the `FreeAddGroup` representation of `x` (which is obtained by the function `FreeAddGroup.of`) is equal to the result of applying the function `f` to `x`. In other words, lifting the function to a homomorphism and then applying it to the free group element of `x` is equivalent to applying the function directly to `x`.

For any function `f` from type `α` to an additive group `β`, and for any `x` in `α`, the group homomorphism obtained from `f` through `FreeAddGroup.lift` applied to `FreeAddGroup.of x` equals `f(x)`.


/-- A function is `C^(n + 1)` if and only if it is differentiable,
and its derivative (formulated in terms of `deriv`) is `C^n`.  -/
theorem contDiff_succ_iff_deriv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f₂ : 𝕜 → F} {n : ℕ},
      ContDiff 𝕜 (↑(n + 1)) f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 (↑n) (deriv f₂) :=
  by sorry

The theorem `contDiff_succ_iff_deriv` states that for any nontrivially normed field `𝕜`, any normed add commutative group `F` that is also a normed space over `𝕜`, any function `f₂` from `𝕜` to `F`, and any natural number `n`, the function `f₂` is continuously differentiable up to level `n + 1` if and only if the function `f₂` is differentiable and its derivative (expressed using the `deriv` function) is continuously differentiable up to level `n`. Essentially, this theorem connects the concept of a function being continuously differentiable at a certain level with the differentiability of the function and its derivatives.

A function from a nontrivially normed field to a normed add commutative group, which is both differentiable and has a continuously differentiable derivative up to level `n`, is continuously differentiable up to level `n+1`.


Subgroup.coeSubtype

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

The theorem `Subgroup.coeSubtype` states that for any group `G` and any subgroup `H` of `G`, the function produced by `Subgroup.subtype H`, when applied to an element, is equivalent to retrieving the underlying element from the subtype with `Subtype.val`. This means that the natural group homomorphism from a subgroup `H` to group `G` simply extracts the underlying elements from the subgroup.

For any group `G` and subgroup `H`, the function `Subgroup.subtype H` is equal to the constant function that maps each element `x` in `H` to `x` itself.


theorem Mathlib.Data.Set.Lattice._auxLemma.4 :
    ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t := by sorry

This theorem, from the Mathlib library in Lean 4, states that for any type `α` and any sort `ι`, given a function `s` from `ι` to a set of `α` and a set `t` of `α`, the statement that the union over `i` of `s i` is a subset of `t` is equivalent to the statement that for all `i` in `ι`, `s i` is a subset of `t`. In other words, all the sets `s i` are subsets of `t` if and only if their union is a subset of `t`.

For any function from a sort to a set of types and a set, the union of the images of the function equals the set if and only if each image is a subset of the set.


theorem List.le_count_iff_replicate_sublist :
    ∀ {α : Type u_1} [inst : DecidableEq α] {n : ℕ} {a : α} {l : List α},
      n ≤ List.count a l ↔ List.Sublist (List.replicate n a) l :=
  by sorry

The theorem `List.le_count_iff_replicate_sublist` states that for any type `α` with decidable equality, any natural number `n`, any value `a` of type `α`, and any list `l` of elements of type `α`, the count of `a` in `l` is greater than or equal to `n` if and only if the list that consists of `n` copies of `a` is a sublist of `l`. In other words, having at least `n` occurrences of `a` in `l` is equivalent to the condition that `n` copies of `a` form a sublist of `l`.

For any type `α` with decidable equality, natural number `n`, value `a` of type `α`, and list `l` of elements of type `α`, the number of occurrences of `a` in `l` is greater than or equal to `n` if and only if `l` has `n` consecutive elements equal to `a`.


theorem Matroid.Indep.exists_base_superset :
    ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → ∃ B, M.Base B ∧ I ⊆ B := by sorry

The theorem `Matroid.Indep.exists_base_superset` states that for any type `α`, any matroid `M` on `α`, and any independent set `I` in `M`, there exists a base `B` of `M` such that `I` is a subset of `B`. In other words, every independent set in a matroid can be extended to form a base of the matroid.

For every matroid and every independent set, there exists a base containing that set.


theorem Real.arsinh_zero : Real.arsinh 0 = 0 := by sorry

This theorem states that the inverse hyperbolic sine (also known as `arsinh` or `sinh^-1`) of zero is zero itself. In other words, if we input zero into the `arsinh` function, which is defined as `arsinh x = log (x + sqrt(1 + x^2))` where `log` is the natural logarithm and `sqrt` stands for the square root, the output will be zero. This is congruent with the mathematical property of the `arsinh` function.

The theorem asserts that that the inverse hyperbolic sine of zero equals zero. In Lean 4, this is expressed as `arsinh 0 = 0`.


/-- The `DFinsupp` version of `Finsupp.comp_liftAddHom`, -/
theorem DFinsupp.comp_liftAddHom :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] {δ : Type u_1}
      [inst_1 : (i : ι) → AddZeroClass (β i)] [inst_2 : AddCommMonoid γ] [inst_3 : AddCommMonoid δ] (g : γ →+ δ)
      (f : (i : ι) → β i →+ γ),
      AddMonoidHom.comp g (DFinsupp.liftAddHom f) = DFinsupp.liftAddHom fun a => AddMonoidHom.comp g (f a) :=
  by sorry

The theorem `DFinsupp.comp_liftAddHom` states that for any types `ι`, `γ`, `β` and `δ`, where `β` is a type function indexed by `ι`, `γ` and `δ` are additive commutative monoids, `β i` for each `i` in `ι` is an additive monoid with zero, and equality between elements of `ι` is decidable, for any additive monoid homomorphism `g` from `γ` to `δ` and any function `f` that for each `i` in `ι` gives an additive monoid homomorphism from `β i` to `γ`, the composition of `g` with the additive monoid homomorphism obtained by lifting `f` to a function from `Π₀ (i : ι), β i` to `γ` (using `DFinsupp.liftAddHom`) is the same as the additive monoid homomorphism obtained by lifting the function that for each `a` in `ι` gives the composition of `g` with `f a` (using the same `DFinsupp.liftAddHom`).

For any additive monoid homomorphisms `g : γ → δ` and `f : ι → (β i → γ)` with `β i` additive monoids, the composition of `g` with the lifted homomorphism of `f` is equal to the lifted homomorphism of the composition of `g` and `f`.


theorem Metric.uniformity_eq_comap_nhds_zero :
    ∀ {α : Type u} [inst : PseudoMetricSpace α], uniformity α = Filter.comap (fun p => dist p.1 p.2) (nhds 0) := by
  sorry

The theorem `Metric.uniformity_eq_comap_nhds_zero` states that for any type `α` that has a `PseudoMetricSpace` structure, the uniformity on `α` is equal to the preimage (comap) under the distance function (where the distance function maps a pair of points to the distance between them) of the neighborhood filter at 0. In other words, the uniformity filter on `α` can be constructed by taking the set of all pairs of points whose distance falls within some neighborhood of zero. This theorem is crucial in linking the concepts of the uniformity and the topology in a pseudometric space.

The uniformity on a PseudoMetricSpace equals the preimage under the distance function of the neighborhood filter at 0.


theorem List.drop_suffix : ∀ {α : Type u_1} (n : ℕ) (l : List α), List.drop n l <:+ l := by sorry

The theorem `List.drop_suffix` states that for any type `α`, any natural number `n`, and any list `l` of type `α`, the result of dropping the first `n` elements from `l` is a suffix of `l`. In other words, the list obtained by removing the first `n` elements from `l` is a sequence that can be found at the end of `l`.

For any type `α`, natural number `n`, and list `l` of length `m` over `α`, `List.drop n l` is a suffix of `l` of length `m-n`.


Nat.Primrec.const

theorem Nat.Primrec.const : ∀ (n : ℕ), Nat.Primrec fun x => n := by sorry

This theorem states that for any natural number `n`, a function that always returns `n` is a primitive recursive function. In other words, regardless of the input, if a function simply outputs a specific value - in this case, `n` - then it qualifies as a primitive recursive function according to the principles of Natural numbers and primitive recursion in Lean 4.

Any constant function from natural numbers to natural numbers is primitive recursive.


theorem Submodule.span_insert_eq_span :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M}
      {s : Set M}, x ∈ Submodule.span R s → Submodule.span R (insert x s) = Submodule.span R s :=
  by sorry

This theorem, `Submodule.span_insert_eq_span`, states that for any semiring `R`, any commutative add monoid `M` and any module `M` over `R`, if an element `x` of `M` is already in the span of a set `s` in `M`, then the span of the set obtained by inserting `x` into `s` is the same as the span of `s`. In other words, if `x` is a linear combination of elements in `s`, then adding `x` to `s` does not change its span in the module.

If `x` is in the span of a set `s` in a module `M` over a semiring `R`, then the span of `s ∪ {x}` equals the span of `s`.


/-- If the distance between any two points in a set is bounded by some constant `C`,
then `ENNReal.ofReal C` bounds the emetric diameter of this set.  -/
theorem Metric.ediam_le_of_forall_dist_le :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {C : ℝ},
      (∀ x ∈ s, ∀ y ∈ s, dist x y ≤ C) → EMetric.diam s ≤ ENNReal.ofReal C :=
  by sorry

The theorem `Metric.ediam_le_of_forall_dist_le` states that in any pseudometric space, if the distance between any two points in a set is bounded by a constant `C`, then the extended non-negative real representation of `C` (`ENNReal.ofReal C`) is an upper bound for the extended metric diameter of the set. The extended metric diameter of a set in this context is defined as the supremum of the distances between all pairs of points in the set. This theorem, therefore, provides a connection between the concepts of bounded distance and the extended metric diameter in pseudometric spaces.

In a pseudometric space, the extended non-negative real representation of the supremum of distances between any two points in a set is an upper bound for the extended metric diameter of that set.


Substring.ValidFor.bsize

theorem Substring.ValidFor.bsize :
    ∀ {l m r : List Char} {s : Substring}, Substring.ValidFor l m r s → Substring.bsize s = String.utf8Len m := by sorry

The theorem `Substring.ValidFor.bsize` states that for any three lists of characters `l`, `m`, `r` and any substring `s`, if the substring `s` is valid for the concatenation of the lists `l`, `m` and `r` (meaning that `s` is a substring of the string formed by concatenating `l`, `m`, and `r`), then the byte length of the substring `s` (as calculated by the function `Substring.bsize`) is equal to the UTF-8 byte length of the list of characters `m` (as calculated by the function `String.utf8Len`). This theorem essentially establishes a relationship between the byte length of a valid substring and the UTF-8 byte length of a segment of the original string.

For any lists of characters `l`, `m`, `r`, and substring `s`, if `s` is a valid substring of the concatenation of `l`, `m`, and `r`, then `Substring.bsize s = String.utf8Len m`.


/-- For integrally closed domains, the minimal polynomial over the ring is the same as the minimal
polynomial over the fraction field. Compared to `minpoly.isIntegrallyClosed_eq_field_fractions`,
this version is useful if the element is in a ring that is already a `K`-algebra.  -/
theorem minpoly.isIntegrallyClosed_eq_field_fractions' :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R]
      [inst_3 : Algebra R S] (K : Type u_3) [inst_4 : Field K] [inst_5 : Algebra R K] [inst_6 : IsFractionRing R K]
      [inst_7 : IsIntegrallyClosed R] [inst_8 : IsDomain S] [inst_9 : Algebra K S] [inst_10 : IsScalarTower R K S]
      {s : S}, IsIntegral R s → minpoly K s = Polynomial.map (algebraMap R K) (minpoly R s) :=
  by sorry

This theorem states that for integrally closed domains, the minimal polynomial over the ring is the same as the minimal polynomial over the field of fractions. More precisely, given a commutative ring `R` and another ring `S` with `R` being a domain and integrally closed, and `K` being a field which is the field of fractions of `R`, an element `s` of `S` which is integral over `R`, then the minimal polynomial of `s` over `K` is equal to the minimal polynomial of `s` over `R` mapped across the ring homomorphism from `R` to `K`. This version of the theorem is useful when the element is in a ring that is already a `K`-algebra.

For an integrally closed domain `R`, the minimal polynomial of an integral element `s` over the field of fractions `K` equals the minimal polynomial of `s` over `R`, when viewed as a polynomial in `K[X]` via the natural homomorphism from `R[X]` to `K[X]`.


theorem AlgebraicGeometry.RingedSpace.mem_basicOpen :
    ∀ (X : AlgebraicGeometry.RingedSpace) {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace}
      (f : ↑(X.presheaf.obj (Opposite.op U))) (x : ↥U),
      ↑x ∈ AlgebraicGeometry.RingedSpace.basicOpen X f ↔ IsUnit ((TopCat.Presheaf.germ X.presheaf x) f) :=
  by sorry

This theorem states that for any Ringed Space `X`, an open subset `U` of the topological space associated with `X`, a section `f` from the presheaf of `X` on the opposite of `U`, and a point `x` in `U`, the point `x` belongs to the basic open of `X` determined by `f` if and only if the germ of `f` at `x` is a unit in the stalk of the presheaf at `x`. In other words, a point `x` is in the set of all points where the germ of `f` is a unit (i.e., has an inverse) if and only if the germ of `f` at that point is indeed a unit.

For any Ringed Space X, open subset U, section f over U, and point x in U, x lies in the basic open set of f if and only if the germ of f at x is a unit in the stalk of the presheaf at x.


theorem Ideal.map_bot :
    ∀ {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}, Ideal.map f ⊥ = ⊥ :=
  by sorry

The theorem `Ideal.map_bot` states that for any semirings `R` and `S`, any function `f` of type `F` that is `FunLike`, and for which there exists a `RingHomClass` instance, the image (under `f`) of the bottom ideal (denoted as `⊥`, the smallest ideal, containing only the zero element) in `R` is also the bottom ideal in `S`. In other words, when the smallest ideal in `R` is mapped into `S` via a function `f` that is a ring homomorphism, it still remains the smallest ideal in `S`.

For any semirings R and S, any FunLike function f between them with a RingHomClass instance, the image of the bottom ideal in R under f is the bottom ideal in S.


theorem isOpen_iff_forall_mem_open :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, ∃ t ⊆ s, IsOpen t ∧ x ∈ t := by sorry

This theorem, `isOpen_iff_forall_mem_open`, states that for any type `X` and any set `s` of type `X` in the context of a given topological space, the set `s` is open if and only if for every element `x` in `s`, there exists an open set `t` such that `t` is a subset of `s`, and `x` is an element of `t`. In other words, a set is open in a topological space if every point in the set is contained in an open set that is itself contained in the original set.

A set in a topological space is open if and only if every element in the set is contained in some open subset of the set.


theorem Mathlib.Algebra.Order.Rearrangement._auxLemma.4 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) := by sorry

This theorem, `Mathlib.Algebra.Order.Rearrangement._auxLemma.4`, states that for all types `α` that have a partial order, given any two elements `a` and `b` of type `α`, `a < b` is equivalent to `a ≤ b` and `a ≠ b`. In other words, `a` is less than `b` if and only if `a` is less than or equal to `b` and `a` is not equal to `b`. This assertion is a common definition in the concept of ordering in algebra.

For all types `α` with a partial order, `a < b` if and only if `a ≤ b` and `a ≠ b`.


theorem map_nhds_subtype_val :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} (x : ↑s),
      Filter.map Subtype.val (nhds x) = nhdsWithin (↑x) s :=
  by sorry

This theorem states that for any topological space `X` and a subset `s` of `X`, the image under the function `Subtype.val` (which extracts the underlying element from a subtype) of the neighborhood filter of an element `x` of the subtype of `s` is equal to the neighborhood filter of `x` within the set `s`. In simpler terms, it's saying that the neighborhoods of a point in the subtype correspond to the neighborhoods of the point in the original space restricted to the subset.

For any topological space X and a subset s of X, the neighborhood filter of an element x in the subtype of s is equal to the restriction to s of the neighborhood filter of x in X.


theorem AddSubgroup.nontrivial_iff_exists_ne_zero :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 0 := by sorry

This theorem states that for any given type `G` that has an additive group structure, and any additive subgroup `H` of `G`, `H` is nontrivial if and only if there exists an element `x` in `H` such that `x` is not the zero element of the group. Nontrivial in this context means that the subgroup `H` is not just the singleton set containing the zero element of the group.

A subgroup of an additive group is nontrivial if and only if it contains a non-zero element.


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

This theorem, named `_auxLemma.1` under the `Mathlib.Data.Set.Intervals.ProjIcc` namespace, states that for any sort `α` and any predicate `p` over `α`, given two elements `a1` and `a2` of the subtype `{ x // p x }`, they are equal (i.e., `a1 = a2`) if and only if their underlying or coerced values in `α` are equal (i.e., `↑a1 = ↑a2`). Essentially, this theorem asserts the fact that two elements of a subtype are equal if their corresponding elements in the parent type are equal.

For any sort `α` and predicate `p` over `α`, two elements `a1` and `a2` of the subtype `{ x // p x }` are equal if and only if their underlying values in `α` are equal.


ContDiffWithinAt.congr

theorem ContDiffWithinAt.congr :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f f₁ : E → F} {x : E} {n : ℕ∞},
      ContDiffWithinAt 𝕜 n f s x → (∀ y ∈ s, f₁ y = f y) → f₁ x = f x → ContDiffWithinAt 𝕜 n f₁ s x :=
  by sorry

This theorem states that, given a nontrivially normed field `𝕜` and normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, for any set `s` of elements of type `E`, two functions `f` and `f₁` from `E` to `F`, a point `x` in `E`, and a natural number `n` or infinity, if the function `f` is continuously differentiable within the set `s` at the point `x` of order `n`, and for all points `y` in `s`, `f₁` at `y` is equal to `f` at `y`, and `f₁` at `x` is equal to `f` at `x`, then the function `f₁` is also continuously differentiable within the set `s` at the point `x` of order `n`. In other words, if two functions coincide on a set and at a particular point, and one of the functions is continuously differentiable at that point within the set, then the other function is also continuously differentiable at that point within the set.

If two continuously differentiable functions of order `n` agree on a set `s` and at a point `x`, then they are equal in continuity and differentiability of order `n` at `x` within `s`.


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

This theorem states that for any type `R` that has a `Ring` structure, any element `x` of `R` belongs to the top (i.e., the whole set `R` itself), denoted as `⊤`. In other words, all elements of a given ring are part of the universal subring.

For any ring `R`, every element `x` in `R` belongs to the additive monoid generated by `R`, i.e., `{∃ s : Set, ∀ x : R, x ∈ s ∧ ∀ (a b : R), a + b ∈ s}`.


theorem Finset.sup_congr :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s₁ s₂ : Finset β} {f g : β → α},
      s₁ = s₂ → (∀ a ∈ s₂, f a = g a) → Finset.sup s₁ f = Finset.sup s₂ g :=
  by sorry

The theorem `Finset.sup_congr` asserts that for any two types `α` and `β`, where `α` is a semilattice with a least element, if we have two finite sets `s₁` and `s₂` of type `β`, and two functions `f` and `g` from `β` to `α`, if `s₁` equals `s₂` and `f a` is equal to `g a` for all `a` in `s₂`, then the supremum of `s₁` under `f` is equal to the supremum of `s₂` under `g`. In mathematical terms, this is stating that if two sets are equal and a function `f` is equal to a function `g` at every point in one of these sets, then the supremum of the set under `f` is equal to the supremum of the set under `g`.

If `α` is a semilattice with a least element, `s₁ = s₂` are finite sets of type `β`, and `f(a) = g(a)` for all `a` in `s₂`, then `sup (f ∘ incl s₁) = sup (g ∘ incl s₂)`, where `incl s i` denotes the inclusion map from `s i` to `β`.


theorem SimpleGraph.mem_edgeSet :
    ∀ {V : Type u} (G : SimpleGraph V) {v w : V}, s(v, w) ∈ SimpleGraph.edgeSet G ↔ G.Adj v w := by sorry

The theorem `SimpleGraph.mem_edgeSet` states that for any type `V`, any simple graph `G` of type `V`, and any vertices `v` and `w` of type `V`, the pair `(v, w)` is an element of the edge set of `G` if and only if `v` and `w` are adjacent in `G`. In other words, the edge `(v, w)` exists in the graph `G` exactly when `v` and `w` are directly connected by an edge in `G`.

For any simple graph G of type V and vertices v, w of type V, (v, w) is in the edge set of G if and only if v and w are adjacent in G.


theorem expMapCircle_zero : expMapCircle 0 = 1 := by sorry

This theorem states that when the function `expMapCircle`, which maps real numbers to the unit circle in the complex plane by exponentiating the product of the real number and the imaginary unit, is applied to the number zero, it returns one. In mathematical terms, this is essentially stating that $e^{0i} = 1$ in the context of complex numbers, which aligns with the well-known principle that any number raised to the power of zero is one.

The theorem asserts that expMapCircle 0 = 1 in the complex plane.


theorem isIntegralCurveAt_iff :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2}
      [inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M]
      [inst_4 : ChartedSpace H M] [inst_5 : SmoothManifoldWithCorners I M] {γ : ℝ → M} {v : (x : M) → TangentSpace I x}
      {t₀ : ℝ}, IsIntegralCurveAt γ v t₀ ↔ ∃ s ∈ nhds t₀, IsIntegralCurveOn γ v s :=
  by sorry

The theorem `isIntegralCurveAt_iff` states that for all real-valued functions `γ` and tangent vectors `v` at a point `t₀` in a smooth manifold `M` with corners associated with a model `I`, the function `γ` is an integral curve at `t₀` if and only if there exists a set `s` that is a neighborhood of `t₀` such that `γ` is an integral curve on `s`. This holds in a normed add commutative group `E` over the reals with a normed space structure, a topological space `H`, and a charted space structure on `M` over `H`.

A real-valued function γ on a smooth manifold M with corners is an integral curve at a point t₀ if and only if there exists a neighborhood s of t₀ such that γ restricts to an integral curve on s.


theorem Nat.testBit_to_div_mod : ∀ {i x : ℕ}, Nat.testBit x i = decide (x / 2 ^ i % 2 = 1) := by sorry

The theorem `Nat.testBit_to_div_mod` states that for any natural numbers `i` and `x`, the `i+1`-th least significant bit of `x` is `1` if and only if the integer division of `x` by `2` to the power `i`, taken modulo `2`, equals `1`. In other words, this bit is determined by the remainder when `x` is divided by `2` to the power `i`.

For any natural numbers `i` and `x`, the `i`-th binary digit of `x` is `1` if and only if `x` mod (2 ^ `i`) = 1.


theorem two_add_one_eq_three : ∀ {α : Type u_1} [inst : AddMonoidWithOne α], 2 + 1 = 3 := by sorry

This theorem states that, for any type `α` that has an associated `AddMonoidWithOne` instance (which means that `α` has both an addition operation and a distinct element identified as 'one'), the value of adding `2` and `1` is `3`. This needs to hold true regardless of what the specific type `α` might be; it could be integers, rational numbers, real numbers, or any other type that supports the required operations.

For any type `α` with an `AddMonoidWithOne` structure, `(2 : α) + (1 : α) = 3 : α`.


theorem MeasureTheory.SimpleFunc.coe_sub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Sub β] (f g : MeasureTheory.SimpleFunc α β),
      ↑(f - g) = ↑f - ↑g :=
  by sorry

This theorem states that for any two simple functions `f` and `g` of type `MeasureTheory.SimpleFunc` that map from a measurable space `α` to an arbitrary type `β` that supports subtraction operation, the coercion of the difference between `f` and `g` (i.e., `f - g`) is equal to the difference between the coercion of `f` and the coercion of `g` (i.e., `↑f - ↑g`). This means that taking the difference of two simple functions and then coercing the result is the same as coercing the functions first and then taking their difference.

For any measurable spaces α and simple functions f, g : α → β with β having subtraction, the coercion of (f - g) is equal to ↑f - ↑g.


ContMDiff.continuous

theorem ContMDiff.continuous :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {n : ℕ∞}, ContMDiff I I' n f → Continuous f :=
  by sorry

The theorem `ContMDiff.continuous` states that for any function `f` from a manifold `M` to another manifold `M'`, given certain conditions on the underlying field, additional vector spaces, and topological spaces (including the charted spaces), if `f` is continuously differentiable to any order `n` (possibly infinite), then `f` is also a continuous function. This means that any function that has derivatives of all orders (up to `n`) that are continuous also preserves the property of continuity itself.

If a continuously differentiable function `f` from manifold `M` to manifold `M'` satisfies given conditions, then `f` is continuous.


theorem Antitone.reflect_lt :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
      Antitone f → ∀ {a b : α}, f a < f b → b < a :=
  by sorry

The theorem `Antitone.reflect_lt` states that for any types `α` and `β`, where `α` is a linear order and `β` is a preorder, and for any function `f` from `α` to `β` that is antitone (i.e., if `a ≤ b` then `f(b) ≤ f(a)`), then for any `a` and `b` of type `α`, if `f(a) < f(b)`, it implies that `b < a`. In other words, if `f` is an antitone function, it reflects the strict order from its range to its domain.

If `f` is an antitone function from a linear order `α` to a preorder `β`, then `f(a) < f(b)` implies `a > b`.


theorem toZ_le_iff :
    ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
      {i0 : ι} (i j : ι), toZ i0 i ≤ toZ i0 j ↔ i ≤ j :=
  by sorry

The theorem `toZ_le_iff` states that for any type `ι` under certain conditions - it has a linear order, it has a successor order, it is Archimedean with respect to the successor function, and it has a predecessor order - and for any `i0`, `i`, and `j` of this type, the integer value of `toZ i0 i` is less than or equal to the integer value of `toZ i0 j` if and only if `i` is less than or equal to `j`. In other words, the function `toZ` preserves the order of elements in `ι`.

For any type `ι` satisfying certain conditions, the function `toZ : ι → ℤ` preserves order, i.e., `toZ i0 ≤ toZ i1` if and only if `i0 ≤ i1` for all `i0, i1 : ι`.


/-- The symbol `J(a | 0)` has the value `1`.  -/
theorem jacobiSym.zero_right : ∀ (a : ℤ), jacobiSym a 0 = 1 := by sorry

The theorem `jacobiSym.zero_right` asserts that for every integer `a`, the Jacobi symbol `J(a | 0)` is equal to `1`. In other words, if the second argument of the Jacobi symbol is `0`, the symbol always evaluates to `1` regardless of the value of the first argument.

For all integers `a`, the Jacobi symbol `J(a | 0)` equals 1.


ContDiffOn.ftaylorSeriesWithin

/-- When a function is `C^n` in a set `s` of unique differentiability, it admits
`ftaylorSeriesWithin 𝕜 f s` as a Taylor series up to order `n` in `s`.  -/
theorem ContDiffOn.ftaylorSeriesWithin :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {n : ℕ∞},
      ContDiffOn 𝕜 n f s → UniqueDiffOn 𝕜 s → HasFTaylorSeriesUpToOn n f (ftaylorSeriesWithin 𝕜 f s) s :=
  by sorry

This theorem states that for a function `f` that is continuously differentiable up to order `n` within a set `s` of unique differentiability, the function admits the formal Taylor series `ftaylorSeriesWithin 𝕜 f s` up to order `n` in `s`. Here, `𝕜` is a normed field, `E` and `F` are normed additive commutative groups over `𝕜`, and `n` can be any natural number or infinity. The theorem therefore provides a relationship between the notions of differentiability and the existence of a Taylor series for a function within a particular set.

For a continuously differentiable up to order n function f from a normed additive commutative group E into another normed additive commutative group F over a normed field 𝕜, there exists a formal Taylor series ftaylorSeriesWithin 𝕜 f s up to order n in the set s of unique differentiability.