theorem MeasureTheory.AEEqFun.coeFn_add :
    ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace γ] [inst_2 : Add γ] [inst_3 : ContinuousAdd γ] (f g : α →ₘ[μ] γ),
      ↑(f + g) =ᶠ[MeasureTheory.Measure.ae μ] ↑f + ↑g :=
  by sorry

This theorem states that for any measurable space 'α' and topological space 'γ' with defined addition and continuity under addition, the function evaluation of the sum of two almost everywhere equal functions 'f' and 'g' (under the measure 'μ') is almost everywhere equal to the sum of the function evaluations of 'f' and 'g' individually. In simpler terms, it asserts that the addition operation for almost everywhere equal functions distributes over the function evaluations almost everywhere. This is under the condition that the functions are defined almost everywhere with respect to the measure 'μ'.

For measurable functions $f, g : \alpha \rightarrow \gamma$ that are almost everywhere equal with respect to a measure $\mu$, the almost everywhere pointwise sum $f + g$ is almost everywhere equal to the pointwise sum of $f$ and $g$.


theorem Filter.isCountablyGenerated_principal :
    ∀ {α : Type u_1} (s : Set α), Filter.IsCountablyGenerated (Filter.principal s) := by sorry

This theorem states that for any given set `s` of some type `α`, the principal filter of `s` is countably generated. In other words, the collection of all supersets of `s` (which form the principal filter of `s`) can be generated by a countable collection. In the context of topology, this means that the topology generated by the set `s` is countable. This is significant as countability is a key concept in the study of set theory and topology, and it provides information about the complexity and structure of the set and the topology it generates.

The principal filter of any set `s` of type `α` is countably generated. Equivalently, the topology generated by `s` is countable.


theorem Quaternion.continuous_re : Continuous fun q => q.re := by sorry

This theorem states that the real part function, which extracts the real part from a quaternion, is a continuous function. This means that for any small change in the input quaternion, there will be correspondingly small changes in its real part, satisfying the formal definition of continuity in the context of mathematical functions.

The real part function on quaternions is continuous.


theorem Mathlib.Analysis.InnerProductSpace.PiL2._auxLemma.2 :
    ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a := by sorry

This theorem states that for any type `α`, any value `a` of `α`, and any predicate `p` on `α`, the condition of `a` being in the set of all `x` of type `α` that satisfy `p` is equivalent to `p a` being true. In other words, the membership of `a` in the set defined by `p` is the same as the truth of `p` when applied to `a`.

For any type `α`, predicate `p` on `α`, and value `a` of type `α`, `a` is in the set `{x : α | p x}` if and only if `p a` is true.


theorem Polynomial.map_toSubring :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) (T : Subring R) (hp : ↑(Polynomial.frange p) ⊆ ↑T),
      Polynomial.map (Subring.subtype T) (Polynomial.toSubring p T hp) = p :=
  by sorry

The theorem `Polynomial.map_toSubring` states that for any given ring `R`, a polynomial `p` of `R`, and a subring `T` of `R` that contains all the nonzero coefficients of the polynomial `p`, when we map the polynomial created by replacing the coefficients of `p` with their corresponding elements in `T` (using `Polynomial.toSubring`) back to `R` (using `Subring.subtype T`), we get the original polynomial `p`. In more mathematical terms, the theorem shows that the mapping of the polynomial in the subring `T` back to `R` is an identity operation on the set of polynomials whose coefficients are all in `T`.

For any ring R, subring T containing all nonzero coefficients of a polynomial p in R, the application of `Polynomial.toSubring p T` followed by `Subring.subtype T` equals p.


theorem DifferentiableAt.add_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E}, DifferentiableAt 𝕜 f x → ∀ (c : F), DifferentiableAt 𝕜 (fun y => f y + c) x :=
  by sorry

The theorem `DifferentiableAt.add_const` states that given any nontrivial normed field `𝕜`, normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, a function `f` from `E` to `F`, a point `x` in `E`, and a constant `c` in `F`, if `f` is differentiable at `x`, then the function obtained by adding the constant `c` to `f` at every point (i.e., `(fun y => f y + c)`) is also differentiable at `x`. This theorem is a formalisation of the fact that the derivative of a constant-added function is the same as the derivative of the original function.

If `f` is differentiable at `x` in the normed space `E` over the field `𝕜`, then the function `(y => f y + c)` is differentiable at `x` in `E` for any constant `c` in the normed space `F`.


theorem PartialHomeomorph.image_eq_target_inter_inv_preimage :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y) {s : Set X}, s ⊆ e.source → ↑e '' s = e.target ∩ ↑(PartialHomeomorph.symm e) ⁻¹' s :=
  by sorry

This theorem states that for any two types `X` and `Y` equipped with topological spaces, and for a partial homeomorphism `e` from `X` to `Y`, if we have a set `s` which is a subset of the source of `e`, then the image of `s` under the partial homeomorphism `e` is equal to the intersection of the target of `e` and the preimage of `s` under the inverse of the partial homeomorphism `e`. This theorem essentially describes how a subset of a source set maps under a partial homeomorphism and its inverse.

For any partial homeomorphism between topological spaces `e : X ↪ Y`, and subset `s ⊆ X`, the image of `s` under `e` is equal to the intersection of `e(`X`)` and the preimage of `s` under the inverse of `e`. In symbols: `e(s) = e(X) ∩ e⁻¹(s)`.


theorem Set.Finite.iSup_biInf_of_monotone :
    ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [inst_1 : Nonempty ι']
      [inst_2 : IsDirected ι' fun x x_1 => x ≤ x_1] [inst_3 : Order.Frame α] {s : Set ι},
      Set.Finite s → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Monotone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j :=
  by sorry

This theorem, `Set.Finite.iSup_biInf_of_monotone`, states that for any two types `ι` and `ι'`, where `ι'` is a preordered set and is also nonempty and directed with respect to the order relation, and for any type `α` which forms a frame, and any finite set `s` of elements of type `ι`, the following holds: if we have a function `f` from `ι` to `ι'` to `α` such that for every element `i` in the set `s`, the function `f i` is monotone, then the supremum of the infimum (over elements in the set `s`) of `f i j` over all `j` is equal to the infimum (over elements in the set `s`) of the supremum of `f i j` over all `j`.

In mathematical notation, this is saying that $\sup_j \inf_{i \in s} f(i, j) = \inf_{i \in s} \sup_j f(i, j)$ provided that each function $f(i, \cdot)$ is monotone for each $i \in s$ and the set $s$ is finite. This is a generalisation of the min-max theorem in order theory.

For a finite, nonempty and directed preordered set `ι`, type `α` forming a frame, and monotone functions `f : ι → ι' → α`, the supremum of the infimum of `f i j` over `i ∈ s` and `j` is equal to the infimum of the supremum of `f i j` over `i ∈ s` for any finite set `s ⊆ ι`.


theorem EuclideanSpace.inner_single_left :
    ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜)
      (v : EuclideanSpace 𝕜 ι), ⟪EuclideanSpace.single i a, v⟫_𝕜 = (starRingEnd 𝕜) a * v i :=
  by sorry

The theorem `EuclideanSpace.inner_single_left` states that for any type `ι` (representing the dimensions of the Euclidean space), any type `𝕜` that behaves like a ring-complemented lattice (indicated by `RCLike 𝕜`), if there exists a decidable equality for `ι` (indicated by `DecidableEq ι`) and the `ι` type is finite (`Fintype ι`), then for any `i` of type `ι`, any `a` of type `𝕜`, and any vector `v` in the Euclidean space of `ι` dimensions over `𝕜`, the inner product of the vector given by `1 : 𝕜` at coordinate `i` and `0 : 𝕜` at all other coordinates with `v` is equal to the conjugate of `a` (given by `(starRingEnd 𝕜) a`) multiplied by the `i`th coordinate of `v`. This theorem essentially describes the behavior of the inner product operation in the standard real/complex Euclidean space when one of the vectors is a standard basis vector.

For a finite-dimensional Euclidean space over a ring-complemented lattice `𝕜` with decidable equality, the inner product of the standard basis vector `1` at coordinate `i` and a vector `v`, and `(starRingEnd 𝕜) a` times the `i`th coordinate of `v`, is equal.


theorem Polynomial.derivative_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ),
      Polynomial.derivative (Polynomial.X ^ n) = Polynomial.C ↑n * Polynomial.X ^ (n - 1) :=
  by sorry

This theorem states that for any semiring `R` and any natural number `n`, the derivative of the polynomial `X` to the power `n` is equal to the constant polynomial of `n` times the polynomial `X` to the power `n - 1`. In mathematical terms, it expresses the familiar rule from calculus that the derivative of `x^n` is `n*x^{n-1}`, but here in the context of polynomials over a general semiring.

For any semiring `R` and natural number `n`, the derivative of `X^n` is equal to `n * X^(n-1)`.


theorem Metric.tendsto_nhds_nhds :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {a : α} {b : β},
      Filter.Tendsto f (nhds a) (nhds b) ↔ ∀ ε > 0, ∃ δ > 0, ∀ {x : α}, dist x a < δ → dist (f x) b < ε :=
  by sorry

The theorem `Metric.tendsto_nhds_nhds` states that for any two types `α` and `β`, with each type having a pseudo metric space structure, and a function `f : α → β`, the function `f` tends to `b` at `a` (represented as `Filter.Tendsto f (nhds a) (nhds b)`) if and only if for every positive real number `ε`, there exists a positive real number `δ` such that for all `x` in `α`, if the distance between `x` and `a` is less than `δ`, then the distance between `f(x)` and `b` is less than `ε`.

In simpler terms, this theorem is a formalization of the epsilon-delta definition of a limit in the context of metric spaces. It says that a function `f` approaches a limit `b` as its argument approaches `a` if we can make the function value `f(x)` arbitrarily close to `b` (closer than any given positive number `ε`), by choosing `x` sufficiently close to `a` (closer than some `δ` which depends on `ε`).

A function between two pseudo metric spaces tends to a limit at a point if and only if for every ε > 0, there exists δ > 0 such that the distance between any point in the domain closer than δ to the point and the image of that point under the function is less than ε.


theorem MeasureTheory.laverage_zero_measure :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (f : α → ENNReal), ⨍⁻ (x : α), f x ∂0 = 0 := by sorry

This theorem states that for any type `α` and a measurable space `m0` of this type, the lower Lebesgue integral (also known as the Lebesgue expectation) of any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`) with respect to the zero measure is always equal to zero. In mathematical terms, we can write this as $\int_{0}^{\infty} f(x) \, d\mu = 0$ where $\mu$ is the zero measure. This means that when we are measuring a function with a measure that assigns zero measure to all sets, the total accumulation (integral) of the function over all elements in the space is zero.

For any measurable space with zero measure `m0` and any measurable function `f` from a type `α` to the extended nonnegative real numbers, their lower Lebesgue integral is equal to zero: $\int_{0}^{\infty} f(x) \, d\mu = 0$.


theorem TruncatedWittVector.truncateFun_out :
    ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R] (x : TruncatedWittVector p n R),
      WittVector.truncateFun n (TruncatedWittVector.out x) = x :=
  by sorry

The theorem `TruncatedWittVector.truncateFun_out` states that for any natural number `p` and `n` and any type `R` that forms a commutative ring, if we take any truncated Witt vector `x`, convert it into a full Witt vector using the `out` function, and then truncate it back to the original size using the `truncateFun` function, we will end up with the original truncated Witt vector `x`. This theorem shows that the operations of truncating and extending Witt vectors commute with each other.

For any natural numbers `p` and `n`, and commutative ring `R`, the truncation and extension functions for truncated Witt vectors commute: `TruncatedWittVector.truncateFun (TruncatedWittVector.out R p n x) = x`.


theorem CircleDeg1Lift.mono : ∀ (f : CircleDeg1Lift) {x y : ℝ}, x ≤ y → f x ≤ f y := by sorry

This theorem states that for any function `f` of type `CircleDeg1Lift` and for any real numbers `x` and `y`, if `x` is less than or equal to `y`, then `f(x)` is less than or equal to `f(y)`. In other words, the function `f` is monotonic: it preserves or increases the order of its inputs.

For any function `f` of type `CircleDeg1Lift`, if `x <= y` then `f x <= f y`.


theorem partialSups_succ :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] (f : ℕ → α) (n : ℕ),
      (partialSups f) (n + 1) = (partialSups f) n ⊔ f (n + 1) :=
  by sorry

The theorem `partialSups_succ` states that for any semilattice (a partially ordered set with a supremum for any nonempty finite subset) of type `α` and any function `f` from natural numbers to `α`, the value of the sequence `partialSups f` at `n + 1` is equal to the sup (supremum) of the value of the sequence `partialSups f` at `n` and the value of `f` at `n + 1`. Essentially, this theorem shows how expanding the sequence `partialSups f` by one more term involves taking the supremum of the previous maximum and the next term of `f`.

For any semilattice α and function f from natural numbers to α, the sequence of suprema of finite nonempty subsets of the image of f forms a monotonically increasing sequence, and the value at n + 1 is the supremum of the values at n and f(n + 1).


theorem Mathlib.MeasureTheory.Integral.IntervalIntegral._auxLemma.1 :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {f : ℝ → E} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
      IntervalIntegrable f μ a b = MeasureTheory.IntegrableOn f (Ι a b) μ :=
  by sorry

This theorem states that for any normed additive commutative group `E`, a real-valued function `f`, and two real numbers `a` and `b`, and a measure `μ` of real numbers, the function `f` is interval integrable with respect to measure `μ` on an unordered interval `a..b` if and only if it is integrable on the interval `Ι a b`. In mathematical terms, a function `f` is interval integrable between two points `a` and `b` if it is integrable (almost everywhere strongly measurable, and the integral of its pointwise norm is finite) over both the intervals `(a, b]` and `(b, a]`. This theorem says that this is equivalent to the function being integrable over the interval `Ι a b`, which represents the interval from `min(a, b)` to `max(a, b)`.

A real-valued function `f` is interval integrable with respect to a measure `μ` over an unordered interval `[a, b]` if and only if it is integrable over the interval `[min(a, b) max(a, b)]`.


theorem zsmul_nonneg :
    ∀ {G : Type u_2} [inst : SubNegMonoid G] [inst_1 : Preorder G]
      [inst_2 : CovariantClass G G (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {x : G},
      0 ≤ x → ∀ {n : ℤ}, 0 ≤ n → 0 ≤ n • x :=
  by sorry

This theorem, `zsmul_nonneg`, asserts that for any type `G` that has a subtraction and negation operation (i.e., it's a `SubNegMonoid`), is ordered (i.e., it's a `Preorder`), and satisfies a certain covariance property, if `x` is a non-negative element of `G`, then the result of scaling `x` by any non-negative integer `n` (denoted `n • x`) is also non-negative. In other words, scaling a non-negative number by a non-negative integer will yield a non-negative result in an ordered subtraction-negation monoid.

If `G` is a subtraction-negation monoid that is ordered and satisfies the covariance property, then for all non-negative integers `n` and non-negative elements `x` of `G`, `n • x` is also non-negative.


theorem SetTheory.PGame.Impartial.fuzzy_zero_iff_lf :
    ∀ (G : SetTheory.PGame) [inst : SetTheory.PGame.Impartial G], SetTheory.PGame.Fuzzy G 0 ↔ SetTheory.PGame.LF G 0 :=
  by sorry

This theorem, in the field of set theory and game theory, states that for any impartial pre-game `G`, the pre-game `G` is fuzzy relative to the zero game if and only if the less or fuzzy relation holds between `G` and the zero game.

In this context, an impartial game is one in which the available moves and resulting positions are identical for both players, the fuzzy relation indicates that the first player can always win, and the less or fuzzy relation indicates that the Left player can win when they play first. So, essentially, the theorem is about a certain equivalence between two different win conditions in the pre-game `G`.

For an impartial pre-game G in set theory, G is fuzzy relative to the zero game if and only if the Left player can win the less or fuzzy version of G.


theorem Fintype.sum_prod_type :
    ∀ {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [inst : Fintype α₁] [inst_1 : Fintype α₂]
      [inst_2 : AddCommMonoid γ] {f : α₁ × α₂ → γ},
      (Finset.sum Finset.univ fun x => f x) =
        Finset.sum Finset.univ fun x => Finset.sum Finset.univ fun y => f (x, y) :=
  by sorry

The theorem `Fintype.sum_prod_type` states that for any types `α₁` and `α₂`, each having a finite number of distinct values (denoted by `Fintype α₁` and `Fintype α₂`), and for any type `γ` that has an addition operation obeying the commutative property (denoted by `AddCommMonoid γ`), given a function `f` that maps pairs `(α₁, α₂)` to `γ`, the sum of the function `f` values over all pairs in the universal finite set (denoted by `Finset.univ`) is equal to the sum of the function `f` values over all individual elements of `α₁` and `α₂` in the universal finite set. In essence, this theorem is expressing the distributive property of multiplication over addition set in the context of finite sums over finite types.

For any type `γ` with commutative addition, and functions `f : (Fintype α₁ × Fintype α₂) → γ`, the sum of `f` over the universal finite set is equal to the sum of the function values over `α₁` and `α₂` separately.


theorem Int.floor_eq_on_Ico :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (n : ℤ),
      ∀ a ∈ Set.Ico (↑n) (↑n + 1), ⌊a⌋ = n :=
  by sorry

This theorem states that for any integer `n` and any real number `a` that lies in the left-closed right-open interval from `n` to `n + 1` (denoted as `[n, n+1)`), the floor function of `a` equals `n`. In other words, if `a` is any number in the interval `[n, n+1)` then the greatest integer less than or equal to `a` is `n`.

For any integer `n` and real number `a` with `n ≤ a < n+1`, the floor function `⌊a⌋ = n`.


theorem HahnSeries.embDomain_notin_image_support :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] {Γ' : Type u_3} [inst_2 : PartialOrder Γ']
      {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'},
      b ∉ ⇑f '' HahnSeries.support x → (HahnSeries.embDomain f x).coeff b = 0 :=
  by sorry

This theorem states that for any types `Γ` and `Γ'` with a partial order, type `R` with a zero element, an order-embedding `f` from `Γ` to `Γ'`, a Hahn series `x` over `Γ` with coefficients in `R`, and an element `b` of `Γ'`, if `b` is not in the image of the support of `x` under `f`, then the coefficient of `b` in the Hahn series obtained by extending the domain of `x` using `f` is zero.
In other words, when we extend the domain of a Hahn series, the new series will have zero coefficients at all indices that are not the image of the support of the original series.

If `f` is an order-embedding from partially ordered types `Γ` to `Γ'`, `x` is a Hahn series over `Γ` with coefficients in a type `R` with zero element, and `b` is not in the image of the support of `x` under `f`, then the coefficient of `b` in the extended Hahn series of `x` is zero.


theorem matPolyEquiv_coeff_apply :
    ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
      (m : Matrix n n (Polynomial R)) (k : ℕ) (i j : n),
      Polynomial.coeff (matPolyEquiv m) k i j = Polynomial.coeff (m i j) k :=
  by sorry

This theorem, `matPolyEquiv_coeff_apply`, states that for any commutative semiring `R`, any type `n` with decidable equality and which is finite (i.e., it has a finite number of elements), any matrix `m` with entries being polynomials over `R` and indexed by `n`, any natural number `k`, and any two indices `i` and `j` of type `n`, the coefficient of `X^k` in the polynomial located at the `(i, j)` entry of the matrix after applying the `matPolyEquiv` function is the same as the coefficient of `X^k` in the polynomial at the `(i, j)` entry of the original matrix `m`. In other words, applying `matPolyEquiv` to a matrix of polynomials doesn't change the coefficients of the individual polynomials.

For any commutative semiring R, finite type n with decidable equality, matrix m of polynomials over R indexed by n, natural number k, and indices i and j of type n, the coefficient of X^k in the polynomial at (i, j) in the original matrix m equals the coefficient of X^k in the polynomial at (i, j) in the matrix m obtained by applying matPolyEquiv.


theorem mul_zpow : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α) (n : ℤ), (a * b) ^ n = a ^ n * b ^ n := by
  sorry

This theorem states that for any type `α` that forms a commutative division monoid, for any elements `a` and `b` of this type `α`, and for any integer `n`, the `n`th power of the product of `a` and `b` is equal to the product of the `n`th power of `a` and the `n`th power of `b`. In mathematical notation, this is saying that for all `a`, `b` in `α` and all integers `n`, `(a * b) ^ n = a ^ n * b ^ n`.

For any commutative division monoid type `α` and elements `a, b` in `α`, and for any integer `n`, their `n`th powers satisfy the commutative property: `(a * b) ^ n = a ^ n * b ^ n`.


theorem Mathlib.Topology.Order.UpperLowerSetTopology._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Topology.IsUpperSet α] {s : Set α},
      IsOpen s = IsUpperSet s :=
  by sorry

This theorem, `Mathlib.Topology.Order.UpperLowerSetTopology._auxLemma.1`, states that for any type `α`, under the conditions that `α` has a preorder structure, a topological space structure, and a topology that respects this preorder as an upper set, for any set `s` of type `α`, `s` is open in the topological space if and only if `s` is an upper set in the preorder. In other words, a set is open in the given topological space if it has the property that any element greater than one of its members is also a member. The theorem creates an equivalence between the topological concept of 'openness' and the order-theoretic concept of 'being an upper set'.

A set in a preordered topological space is open if and only if it is an upper set with respect to the preorder.


theorem List.forall_mem_map_iff :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {P : β → Prop},
      (∀ i ∈ List.map f l, P i) ↔ ∀ j ∈ l, P (f j) :=
  by sorry

This theorem states that for any two types `α` and `β`, a function `f` from `α` to `β`, a list `l` of type `α`, and a property `P` applicable on elements of type `β`, the property `P` holds for all elements in the list obtained by mapping `f` over `l` if and only if the property `P` holds for the result of applying `f` to all elements in `l`. In other words, applying `f` to each element of `l` and then checking if `P` holds for all elements is equivalent to checking if `P` holds for `f` of each element in `l`.

For any types `α`, `β`, property `P` on `β`, function `f` from `α` to `β`, and list `l` of type `α`, if `P` holds for all `x ∈ l` implies `P` holds for `f(x)`, then `P` holds for the list obtained by mapping `f` over `l`. Conversely, if `P` holds for each `f(x)` with `x ∈ l`, then `P` holds for the entire mapped list.


theorem hasSum_sum :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : ContinuousAdd α] {f : γ → β → α} {a : γ → α} {s : Finset γ},
      (∀ i ∈ s, HasSum (f i) (a i)) → HasSum (fun b => Finset.sum s fun i => f i b) (Finset.sum s fun i => a i) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, given `α` has an additive commutative monoid structure and a topological space structure such that addition is continuous, if you have a function `f` mapping each `γ` to a function from `β` to `α`, and you have a finset `s` of `γ` and a function `a` mapping each `γ` to `α` such that for each `i` in `s`, the function `f i` has a sum equivalent to `a i` (as expressed by `HasSum (f i) (a i)`), then the function mapping each `β` to the sum of `f i b` for each `i` in `s` has a sum equal to the sum of `a i` for each `i` in `s` (as expressed by `HasSum (fun b => Finset.sum s fun i => f i b) (Finset.sum s fun i => a i)`). In simpler terms, this is a generalization of the idea that the sum of the sums is the sum of the total.

Given types `α` with additive commutative monoid and topological space structures where addition is continuous, and functions `f: γ → β → α` and `a: γ → α` such that `HasSum (f i) (a i)` for all `i` in a finite set `s`, the function `β → Finset.sum s (λ i, f i) b` has a sum equal to `Finset.sum s a`.


theorem variationOnFromTo.nonneg_of_le :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) (s : Set α)
      {a b : α}, a ≤ b → 0 ≤ variationOnFromTo f s a b :=
  by sorry

This theorem states that for any type `α` that has a linear order and any type `E` that is a pseudo emetric space, for any function `f` from `α` to `E` and any set `s` of `α`, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b`, then the signed variation of `f` on the interval from `a` to `b` that intersects with the set `s`, which is converted to a real number, is always nonnegative. This means that the amount `f` changes (taking into account direction) over the interval `[a, b]` intersecting `s` is at least 0 if `a` is less than or equal to `b`.

For any function `f` from a linearly ordered type `α` to a pseudo metric space `E`, and any set `s` of `α`, the signed variation of `f` on the interval of `α` intersecting `s` is nonnegative for any pair of elements `a` and `b` with `a` less than or equal to `b`.


theorem Function.invFunOn_pos :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Nonempty α] {s : Set α} {f : α → β} {b : β},
      (∃ a ∈ s, f a = b) → Function.invFunOn f s b ∈ s ∧ f (Function.invFunOn f s b) = b :=
  by sorry

The theorem `Function.invFunOn_pos` states that for any types `α` and `β` (with `α` being nonempty), a set `s` of type `α`, a function `f` from `α` to `β`, and an element `b` of type `β`, if there exists an element `a` in set `s` such that `f(a) = b`, then the inverse function of `f` on `s` evaluated at `b` is an element of `s` and applying `f` to this inverse function evaluated at `b` gives `b` back. In simpler terms, the theorem asserts that the inverse function is a right inverse of `f` on its image under `f` in the set `s`.

For any nonempty type `α`, set `s` of `α`, function `f` from `α` to `β`, and `b` in `β`, if `f(a) = b` for some `a` in `s`, then `(f.inv | s).(b) = a` and `f((f.inv | s).(b)) = b`.


theorem fourierCoeffOn_eq_integral :
    ∀ {E : Type} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ} (f : ℝ → E) (n : ℤ) (hab : a < b),
      fourierCoeffOn hab f n = (1 / (b - a)) • ∫ (x : ℝ) in a..b, (fourier (-n)) ↑x • f x :=
  by sorry

This theorem states that for any function `f` mapping real numbers to a normed space `E`, and for any integers `n`, the Fourier coefficient of `f` on an interval `[a, b]` (where `a` is less than `b`) is equal to `(1 / (b - a))` times the integral from `a` to `b` of the exponential monomial (associated with `-n`) evaluated at `x` times `f(x)`. This essentially relates the Fourier coefficient of a function on an interval to a weighted integral involving Fourier series components.

For any function `f` from real numbers to a normed space `E`, and for any integer `n` and interval `[a, b]` with `a < b`, the Fourier coefficient of `f` on `[a, b]` is equal to `(1 / (b - a)) * ∫[a, b] (e^(-i * n * x) * f(x) dx)`, where `∫` denotes integration.


theorem Set.compl_iInter₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} (s : (i : ι) → κ i → Set α),
      (⋂ i, ⋂ j, s i j)ᶜ = ⋃ i, ⋃ j, (s i j)ᶜ :=
  by sorry

This theorem states that for any type `α` and any two indexed collections of sets `(s i j)` indexed by `ι` and `κ i` respectively, the complement of the intersection over all `i` and `j` of the sets `(s i j)` is equal to the union over all `i` and `j` of the complements of the sets `(s i j)`. In mathematical terms, this corresponds to the statement that the complement of an intersection is equal to the union of the complements, generalized to two levels of indexing.

 For any indexed collections of sets (s i j) indexed by ι and κ i, the complement of their intersection is equal to the union of the complements of each set (s i j). Mathematically, �� /******/ᶜ i, j. ∣s i j∣∥ = ∱/_i. ∣s i j∣∣'.

This statement can be read as "the complement of the intersection of all sets s i j with respect to their common index i, for all index j, is equal to the union of the complements of all sets s i j with respect to their individual index i."


theorem Mathlib.MeasureTheory.Constructions.Cylinders._auxLemma.1 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

The theorem `Mathlib.MeasureTheory.Constructions.Cylinders._auxLemma.1` states that for any type `α`, any type `ι`, any element `x` of type `α`, and any function `s` from `ι` to the set of `α`, the condition that `x` belongs to the union over `i` of the sets `s i` is equivalent to the existence of some `i` such that `x` belongs to `s i`. In mathematical terms, this is expressing the property that an element is in the union of a collection of sets if and only if it is in at least one of the sets in the collection.

For any type `α`, any type `ι`, any element `x` of type `α`, and any function `s` from `ι` to `α`, the element `x` belongs to the union of the sets `s i` if and only if there exists some `i`, such that `x` belongs to `s i`.


theorem List.reduceOption_cons_of_none :
    ∀ {α : Type u_1} (l : List (Option α)), List.reduceOption (none :: l) = List.reduceOption l := by sorry

The theorem `List.reduceOption_cons_of_none` states that for any list of optional values `l` of any type `α`, the operation of reducing the list by eliminating `none` values and replacing `some a` values with `a` remains unaffected by prepending a `none` to this list. In other words, for any list `l`, `List.reduceOption (none :: l)` equals `List.reduceOption l`.

For any list `l` of optional values and any type `α`, `List.reduceOption (none :: l) = List.reduceOption l`.


theorem Int.abs_lt_one_iff : ∀ {a : ℤ}, |a| < 1 ↔ a = 0 := by sorry

This theorem states that for any integer `a`, the absolute value of `a` is less than 1 if and only if `a` equals 0. In other words, the only integer that has an absolute value strictly less than 1 is 0, and conversely, if an integer has an absolute value strictly less than 1, it must be 0.

For any integer `a`, |a| < 1 if and only if a = 0.


theorem AddSemiconjBy.neg_neg_symm_iff :
    ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a x y : G}, AddSemiconjBy (-a) (-x) (-y) ↔ AddSemiconjBy a y x := by
  sorry

The theorem `AddSemiconjBy.neg_neg_symm_iff` states that for any type `G` that forms a subtraction monoid (a type with addition, zero and negation such that addition is associative and each element has an additive inverse), and for any elements `a`, `x`, and `y` in `G`, the statement that `-a` is additive semiconjugate to `-x` by `-y` (which means `-y + -a = -x + -y`) is equivalent to the statement that `a` is additive semiconjugate to `y` by `x` (which means `x + a = y + x`).

For any type `G` with add, zero, and negation making it a subtraction monoid, and for any elements `a`, `x`, and `y` in `G`, the subtractions `-a - x = y` and `x + a = y` are equivalent.


theorem sdiff_lt : ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], y ≤ x → y ≠ ⊥ → x \ y < x := by sorry

This theorem states that for any type `α` that is a Generalized Boolean Algebra, given any two elements `x` and `y` of `α` such that `y` is less than or equal to `x` and `y` is not the bottom element, the operation `x \ y` (set difference of `x` and `y`) results in a value strictly less than `x`. Essentially, subtracting a non-zero and non-maximum element from another element reduces the value.

For any Generalized Boolean Algebra `α` and elements `x` and `y` in `α` with `y` being less than or equal to `x` and not the bottom element, `x \ y` (the set difference of `x` and `y`) is strictly less than `x`.


theorem Equiv.Perm.cycleOf_pow_apply_self :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] (f : Equiv.Perm α) (x : α) (n : ℕ),
      (Equiv.Perm.cycleOf f x ^ n) x = (f ^ n) x :=
  by sorry

The theorem `Equiv.Perm.cycleOf_pow_apply_self` states that for any type `α` having decidable equality and is a finite type, and given a permutation `f` of `α`, an element `x` of `α`, and a natural number `n`, applying the `n`-th power of the cycle of `f` that `x` belongs to, to `x`, is the same as applying the `n`-th power of `f` to `x`. In other words, cycling `n` times in the cycle of `f` containing `x` and applying `f` `n` times to `x` lead to the same result.

For any finite type `α` with decidable equality and permutation `f`, the `n`-th power of the cycle containing `x` and the `n`-th power of `f` applied to `x` yield equal results, i.e., `(cycleOf f x).pow n x = f.pow n x`.


/-- The cokernel morphism of an epimorphism is a zero morphism  -/
theorem CategoryTheory.Limits.cokernel.π_of_epi :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasZeroObject C]
      [inst_3 : CategoryTheory.Limits.HasCokernel f] [inst_4 : CategoryTheory.Epi f],
      CategoryTheory.Limits.cokernel.π f = 0 :=
  by sorry

This theorem states that in any category `C` with zero morphisms and a zero object, if a morphism `f` from `X` to `Y` has a cokernel and is an epimorphism, then the cokernel morphism of `f` is a zero morphism. Simply put, in the context of category theory, the cokernel of an "onto" morphism (or epimorphism) is essentially a "zero" morphism.

In any category with zero morphisms and a zero object, the cokernel of an epimorphism is a zero morphism.


theorem Polynomial.toLaurent_C :
    ∀ {R : Type u_1} [inst : Semiring R] (r : R), Polynomial.toLaurent (Polynomial.C r) = LaurentPolynomial.C r := by
  sorry

This theorem states that for any semiring `R` and any element `r` of `R`, applying the function `Polynomial.C` to `r` to get a constant polynomial and then converting this polynomial to a Laurent polynomial using `Polynomial.toLaurent` is the same as directly mapping `r` to a constant Laurent polynomial using `LaurentPolynomial.C`. In other words, the process of converting a constant from `R` into a polynomial and then into a Laurent polynomial is equivalent to directly converting the constant into a Laurent polynomial.

For any semiring `R` and its element `r`, `Polynomial.toLaurent (Polynomial.C r) = LaurentPolynomial.C r`.


theorem MvPolynomial.quotientEquivQuotientMvPolynomial.proof_1 :
    ∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (I : Ideal R) (r : R),
      (MvPolynomial.eval₂Hom
            (Ideal.Quotient.lift I (RingHom.comp (Ideal.Quotient.mk (Ideal.map MvPolynomial.C I)) MvPolynomial.C) ⋯)
            fun i => (Ideal.Quotient.mk (Ideal.map MvPolynomial.C I)) (MvPolynomial.X i))
          (MvPolynomial.C ((Ideal.Quotient.mk I) r)) =
        (Ideal.Quotient.lift I (RingHom.comp (Ideal.Quotient.mk (Ideal.map MvPolynomial.C I)) MvPolynomial.C) ⋯)
          ((Ideal.Quotient.mk I) r) :=
  by sorry

The theorem `MvPolynomial.quotientEquivQuotientMvPolynomial.proof_1` states that for any commutative ring `R`, type `σ`, ideal `I` of `R`, and ring element `r`, the value of the multivariate polynomial `MvPolynomial.C ((Ideal.Quotient.mk I) r)` under the evaluation map `MvPolynomial.eval₂Hom` is equal to the image of `((Ideal.Quotient.mk I) r)` under the lift of a ring homomorphism from `R` to the quotient ring `R/I`. This evaluation map is constructed with a ring homomorphism that maps an element of `R` to the constant polynomial with that element as coefficient, and a function which maps each index `i` to the degree `1` monomial in the quotient ring `R/I`. This lift of a ring homomorphism is also constructed with the same ring homomorphism as the evaluation map.

For any commutative ring `R`, ideal `I` of `R`, and ring element `r`, the evaluation of the multivariate polynomial `MvPolynomial.C ((Ideal.Quotient.mk I) r)` under `MvPolynomial.eval₂Hom` equals the image of `((Ideal.Quotient.mk I) r)` under the homomorphism-induced evaluation homomorphism from `R` to `R/I`.


CategoryTheory.Subgroupoid.ext

theorem CategoryTheory.Subgroupoid.ext :
    ∀ {C : Type u} {inst : CategoryTheory.Groupoid C} (x y : CategoryTheory.Subgroupoid C),
      x.arrows = y.arrows → x = y :=
  by sorry

This theorem states that within the context of a groupoid `C` of a certain type `u`, for any two subgroupoids `x` and `y` of `C`, if the set of morphisms (arrows) in `x` is equal to the set of morphisms in `y`, then `x` and `y` are the same subgroupoid. In other words, two subgroupoids of a groupoid are identical if they have the same morphisms.

In a groupoid `C` of type `u`, two subgroupoids `x` and `y` are equal if and only if they have the same set of morphisms.


theorem Ne.nhdsWithin_compl_singleton :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x y : X}, x ≠ y → nhdsWithin x {y}ᶜ = nhds x :=
  by sorry

This theorem states that for any type `X` with a topological space structure and a `T1Space` structure (i.e., any singleton set is closed), and for any two distinct points `x` and `y` from `X`, the neighborhood within the complement of the singleton set `{y}` at the point `x` is the same as the neighborhood of `x`. In other words, if `x` and `y` are different points in a topological space where singletons are closed, then the filter of sets that intersect the complement of `{y}` and contain an open set around `x`, is the same as the filter of all open sets containing `x`.

In a T1 topological space, for distinct points `x` and `y`, the neighborhood filters of `x` in the complement of `{y}` and at `x` are equal.


theorem CategoryTheory.MonoOver.map.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Mono f] (g : CategoryTheory.MonoOver X),
      CategoryTheory.Mono (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoOver.arrow g) f) :=
  by sorry

This theorem states that in the category theory context, given a category `C`, objects `X` and `Y` in `C`, a morphism `f` from `X` to `Y` which is a monomorphism, and a monomorphism `g` over `X`, the composition of the underlying arrow of `g` and `f` (i.e., `CategoryTheory.MonoOver.arrow g` followed by `f`) is also a monomorphism.

In the category theory context, given a monomorphism `g` over `X` and a monomorphism `f` from `X` to `Y`, their composition `g ∘ f` is also a monomorphism.


theorem AlternatingMap.measure_def :
    ∀ {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] [inst_2 : MeasurableSpace G]
      [inst_3 : BorelSpace G] [inst_4 : FiniteDimensional ℝ G] {n : ℕ} [_i : Fact (FiniteDimensional.finrank ℝ G = n)]
      (ω : G [⋀^Fin n]→ₗ[ℝ] ℝ),
      AlternatingMap.measure ω =
        ‖ω ⇑(FiniteDimensional.finBasisOfFinrankEq ℝ G ⋯)‖₊ •
          Basis.addHaar (FiniteDimensional.finBasisOfFinrankEq ℝ G ⋯) :=
  by sorry

This theorem, `AlternatingMap.measure_def`, is about the measure associated with an alternating multilinear map `ω` on a finite-dimensional real vector space `G`. If `G` is an `n`-dimensional real vector space (i.e., `FiniteDimensional.finrank ℝ G = n`), then the measure of `ω` is defined as the product of the operator norm of `ω` applied to a basis of `G` (obtained using `FiniteDimensional.finBasisOfFinrankEq`) and the Lebesgue measure associated with that basis (`Basis.addHaar`). This Lebesgue measure is defined such that the volume of the parallelepiped spanned by the basis vectors is `1`.

The measure of an alternating multilinear map on a finite-dimensional real vector space is equal to the product of its operator norm with respect to a basis and the Lebesgue measure associated with that basis, where the Lebesgue measure is such that the volume of the basis's parallelepiped is 1.


AEMeasurable.add

theorem AEMeasurable.add :
    ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Add M] {m : MeasurableSpace α} {f g : α → M}
      {μ : MeasureTheory.Measure α} [inst_2 : MeasurableAdd₂ M],
      AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (fun a => f a + g a) μ :=
  by sorry

This theorem states that, given two functions `f` and `g` from a type `α` to a type `M` where `M` is a measurable space with a defined addition operation, if both `f` and `g` are almost everywhere measurable with respect to a measure `μ`, then the function that maps `a` to the sum of `f(a)` and `g(a)` is also almost everywhere measurable with respect to the same measure. Here, almost everywhere measurable means that the functions coincide almost everywhere with a measurable function.

If `f` and `g` are almost everywhere measurable functions from a measurable space `(α, μ)` to a measurable additive group `M`, then their pointwise sum is also almost everywhere measurable.


theorem CompHaus.isSheaf_iff_preservesFiniteProducts_and_equalizerCondition' :
    ∀ {A : Type (u + 2)} [inst : CategoryTheory.Category.{u + 1, u + 2} A] (G : CategoryTheory.Functor A (Type (u + 1)))
      [inst_1 : CategoryTheory.Limits.HasLimits A] [inst_2 : CategoryTheory.Limits.PreservesLimits G]
      [inst_3 : CategoryTheory.ReflectsIsomorphisms G] (F : CategoryTheory.Functor CompHausᵒᵖ A),
      CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology CompHaus) F ↔
        Nonempty (CategoryTheory.Limits.PreservesFiniteProducts (CategoryTheory.Functor.comp F G)) ∧
          CategoryTheory.regularTopology.EqualizerCondition (CategoryTheory.Functor.comp F G) :=
  by sorry

This theorem states that for a given category 'A' and a functor 'G' from 'A' to the category of Types, assuming that 'A' has all limits and 'G' preserves these limits and reflects isomorphisms, for any functor 'F' from the opposite category of compact Hausdorff spaces to 'A', 'F' is a sheaf with respect to the coherent Grothendieck topology on compact Hausdorff spaces if and only if there exists a functor that not only preserves finite products when composed with 'F' and 'G' but also satisfies the equalizer condition when so composed. The equalizer condition here means that the composed functor takes kernel pairs of effective epimorphisms to equalizer diagrams.

A functor F from the opposite category of compact Hausdorff spaces to a category A with all limits, preserving these limits and reflecting isomorphisms is a sheaf for the coherent Grothendieck topology if and only if there exists a functor H from A to Types such that F and G (where G is a functor from A to Types) preserve finite products and the composite F ∘ H takes kernel pairs of effective epimorphisms to equalizer diagrams.


CategoryTheory.FinallySmall.mk'

/-- Constructor for `FinallySmall C` from an explicit small category witness.  -/
theorem CategoryTheory.FinallySmall.mk' :
    ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {S : Type w} [inst_1 : CategoryTheory.SmallCategory S]
      (F : CategoryTheory.Functor S J) [inst_2 : CategoryTheory.Functor.Final F], CategoryTheory.FinallySmall J :=
  by sorry

The theorem `CategoryTheory.FinallySmall.mk'` states that for any types `J` and `S` where `J` is a category and `S` is a small category, and given a functor `F` from `S` to `J` which is also final, then `J` is finally small. In category theory terms, a category is finally small if there exists a small category and a final functor from the small category to it.

If `J` is a category, `S` is a small category, and `F` is a final functor from `S` to `J`, then `J` is finally small.


theorem WeakBilin.eval_continuous :
    ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : TopologicalSpace 𝕜] [inst_1 : CommSemiring 𝕜]
      [inst_2 : AddCommMonoid E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid F] [inst_5 : Module 𝕜 F]
      (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) (y : F), Continuous fun x => (B x) y :=
  by sorry

This theorem states that, for any type `𝕜` equipped with a topological space structure and a commutative semiring structure, types `E` and `F` equipped with an additive commutative monoid structure and a module structure over `𝕜`, and a bilinear form `B` from `E` to `F` (denoted `E →ₗ[𝕜] F →ₗ[𝕜] 𝕜`), the function `x => (B x) y` is continuous for any `y` in `F`. In mathematical terms, this theorem shows the continuity of the evaluation of a weakly bilinear form.

Given a topological space `𝕜` with a commutative semiring structure, types `E` and `F` with additive commutative monoid and `𝕜`-module structures, and a weakly bilinear form `B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜`, the evaluation map `x ↦ B x y` is continuous for all `y` in `F`.


theorem Multiset.sup_dedup :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] (s : Multiset α),
      Multiset.sup (Multiset.dedup s) = Multiset.sup s :=
  by sorry

The theorem `Multiset.sup_dedup` states that for all types `α` equipped with a SemilatticeSup structure, an OrderBot structure and a DecidableEq structure, and for all multisets `s` of type `α`, the supremum of the multiset obtained by removing duplicates from `s` (`Multiset.dedup s`) is equal to the supremum of the multiset `s`. In other words, removing duplicates from a multiset does not change its supremum. This supremum is the join (`⊔`) of all elements in the multiset.

For any semilattice-supplied, ordered type α with decidable equality, the supremum of a multiset equals the supremum of its deduplicated version.


/-- Given a wide pullback in `C`, construct a product in `C/B`.  -/
theorem CategoryTheory.Over.ConstructProducts.over_product_of_widePullback :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C] {B : C},
      CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) (CategoryTheory.Over B) :=
  by sorry

The theorem `CategoryTheory.Over.ConstructProducts.over_product_of_widePullback` states that for any type `J`, any category `C` with wide pullbacks (which are a type of limit), and any object `B` in `C`, the over category `C/B` has limits of discrete shape `J`. In other words, if you have a category where you can construct wide pullbacks, then you are able to construct products in the over category of any object in the original category.

For any category with wide pullbacks `C` and object `B` in `C`, the over category `C/B` has products indexed by any type `J`.


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

This theorem states that for all types `α`, the operation of joining an empty sequence of sequences (conducted by the function `Stream'.Seq.join`) results in an empty sequence. The function `Stream'.Seq.join` flattens a sequence of sequences, and `Stream'.Seq.nil` represents an empty sequence. This theorem essentially asserts that joining or flattening an empty sequence of sequences does not produce any elements, hence the result remains an empty sequence.

For all types `α`, the operation of joining an empty sequence of sequences of `α` results in an empty sequence.


theorem WithLp.prod_edist_eq_sup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : EDist α] [inst_1 : EDist β] (f g : WithLp ⊤ (α × β)),
      edist f g = edist f.1 g.1 ⊔ edist f.2 g.2 :=
  by sorry

The theorem `WithLp.prod_edist_eq_sup` states that for any two values `f` and `g` of type `WithLp ⊤ (α × β)`, where `α` and `β` are types equipped with an `edist` (extended distance) function, the extended distance between `f` and `g` is equal to the supremum of the extended distances between the first elements of `f` and `g` and the second elements of `f` and `g`. Essentially, this means that the distance between two pairs is the greatest distance between their corresponding elements.

For any `WithLp` functions `f` and `g` of type `α × β`, the extended distance `∥f - g∥∞` is equal to the supremum of the extended distances `∥f.1 - g.1∥∞` and `∥f.2 - g.2∥∞`.


/-- If `x` is an adherent (cluster) point for a Cauchy filter `f`, then it is a limit point
for `f`.  -/
theorem le_nhds_of_cauchy_adhp :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {f : Filter α} {x : α}, Cauchy f → ClusterPt x f → f ≤ nhds x := by
  sorry

This theorem states that if `x` is a cluster point (also known as an adherent point) for a Cauchy filter `f` in a uniform space `α`, then `x` is also a limit point for `f`. In other words, any Cauchy filter that has `x` as a cluster point is contained within the neighborhood of `x`. This implies that the values in the filter `f` get arbitrarily close to `x`, which is the definition of `x` being a limit point for the filter `f`.

If a Cauchy filter `f` in a uniform space `α` has `x` as a cluster point, then `x` is a limit point of `f`.


theorem Mathlib.CategoryTheory.Idempotents.FunctorExtension._auxLemma.1 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      {f g : P ⟶ Q}, (f = g) = (f.f = g.f) :=
  by sorry

This theorem states that in the context of category theory, for any category `C` and any two objects `P` and `Q` in the Karoubi envelope of `C`, if `f` and `g` are morphisms from `P` to `Q`, then `f` is equal to `g` if and only if the underlying morphisms `f.f` and `g.f` are equal. The Karoubi envelope is a construction in category theory that encapsulates the concept of idempotents.

In the category theory of Karoubi envelopes, two morphisms from the same object to another have equal underlying morphisms if and only if they represent the same morphism.


ExistsUnique.intro

theorem ExistsUnique.intro : ∀ {α : Sort u_1} {p : α → Prop} (w : α), p w → (∀ (y : α), p y → y = w) → ∃! x, p x := by
  sorry

This theorem, named `ExistsUnique.intro`, states that for any type `α` and any proposition `p` that depends on `α`, given an element `w` of type `α` for which the proposition `p` holds, and assuming that `w` is the unique element of type `α` for which proposition `p` holds, there exists a unique `x` such that the proposition `p` holds for `x`. This basically asserts the existence and uniqueness of an element satisfying a certain proposition.

Given a type `α` and a proposition `p(α)` depending on `α`, if there exists a unique `w` of type `α` such that `p(w)` holds, then there exists a unique `x` of type `α` with `p(x)` holding.


theorem Filter.map_snd_prod :
    ∀ {α : Type u_1} {β : Type u_2} (f : Filter α) (g : Filter β) [inst : Filter.NeBot f],
      Filter.map Prod.snd (f ×ˢ g) = g :=
  by sorry

This theorem states that for all types `α` and `β`, given a filter `f` of type `α` and a filter `g` of type `β`, if `f` is a proper (non-bottom) filter, then the filter obtained by mapping the function `Prod.snd` (which projects out the second component of a pair) over the filter product of `f` and `g` is equal to `g`. In other words, it extracts the second component of the filter product, effectively "ignoring" the first.

For all filters $f$ on type $\alpha$ and $g$ on type $\beta$, if $f$ is proper, then $(f \times g).\text{snd} = g$.


theorem Int.coe_nat_pow : ∀ (m n : ℕ), ↑(m ^ n) = ↑m ^ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, the operation of raising m to the power of n, then coercing the result to an integer, is the same as first coercing m to an integer and then raising it to the power of n. In mathematical terms, it says that for all natural numbers `m` and `n`, `(m^n)` coerced to an integer equals `(m coerced to an integer)^n`.

For all natural numbers m and n, (m^n) converted to an integer equals (m converted to an integer)^n.


theorem toIcoMod_add_toIcoDiv_zsmul :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α),
      toIcoMod hp a b + toIcoDiv hp a b • p = b :=
  by sorry

This theorem states that for any type `α` that forms an Archimedean linear ordered additive commutative group, and for any real number `p` that is greater than zero, and for any real numbers `a` and `b`, the value obtained by adding `p` multiplied by the unique integer from function `toIcoDiv` to the result of function `toIcoMod` is equal to `b`. This essentially transforms `b` into an element of the interval [a, a+p) and then adds back the integer multiple of `p` that was subtracted, thus recovering the original value `b`.

For any Archimedean linear ordered additive commutative group type `α`, real number `p > 0`, and real numbers `a` and `b`, `b = a + p * (toIcoMod int p b + toIcoDiv int p a)`, where `toIcoMod` and `toIcoDiv` are the functions from Lean 4 used to convert real numbers to integers in the interval modulo and division operations, respectively.


theorem Mathlib.RingTheory.IntegralClosure._auxLemma.7 :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      (n ∈ Polynomial.support p) = (Polynomial.coeff p n ≠ 0) :=
  by sorry

This theorem states that for any semiring `R`, natural number `n`, and polynomial `p` over `R`, the number `n` is in the support of polynomial `p` if and only if the coefficient of `X^n` in `p` is not zero. In the context of polynomials, the support of a polynomial is the set of all powers of `X` that have a non-zero coefficient. Therefore, this theorem is essentially a characterization of the support of a polynomial in terms of its non-zero coefficients.

For any semiring `R`, natural number `n`, and polynomial `p` over `R`, the power `X^n` is in the support of `p` if and only if the coefficient of `X^n` in `p` is non-zero.


theorem Nat.exists_lt_card_nth_eq :
    ∀ {p : ℕ → Prop} {x : ℕ},
      p x → ∃ n, (∀ (hf : Set.Finite (setOf p)), n < (Set.Finite.toFinset hf).card) ∧ Nat.nth p n = x :=
  by sorry

The theorem `Nat.exists_lt_card_nth_eq` states that for any predicate `p` on natural numbers and any natural number `x` that satisfies the predicate `p`, there exists a natural number `n` having two properties: first, for every finite set that represents the set of natural numbers satisfying `p`, the number `n` is less than the cardinality of that finite set; second, `n` is the index of `x` in the sequence of natural numbers satisfying `p`, where indexing starts from `0`. If `p` is true for an infinite number of natural numbers, the sequence is ordered using a canonical order isomorphism with the set of natural numbers.

For any predicate `p` on natural numbers, if there exists a natural number `x` satisfying `p`, then there exists a natural number `n` less than the cardinality of the finite or infinite set of natural numbers satisfying `p` and equal to the index of `x` in that set (zero-indexed).


theorem Metric.smul_ball :
    ∀ {G : Type v} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : Group G] [inst_2 : MulAction G X]
      [inst_3 : IsometricSMul G X] (c : G) (x : X) (r : ℝ), c • Metric.ball x r = Metric.ball (c • x) r :=
  by sorry

The theorem `Metric.smul_ball` states that for any pseudometric space `X`, group `G` and multiplication action of `G` on `X` that is isometric, the scalar multiplication of a given element `c` from `G` with the metric ball of radius `r` around a point `x` in `X` results in the same set as the metric ball of radius `r` around the point obtained by the same scalar multiplication of `c` and `x`. In other words, the action of the group element `c` on the metric ball `Metric.ball x r` is equivalent to the action of `c` on the center `x` of the ball.

For any pseudometric space X, group G acting isometrically on X, and point x in X, the metric balls with radius r centered at x and at the scalar multiplication of x by c in G are equal.


theorem Equiv.Perm.SameCycle.apply_eq_self_iff :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, Equiv.Perm.SameCycle f x y → (f x = x ↔ f y = y) := by sorry

This theorem states that for any type `α`, any permutation `f` on `α`, and any two elements `x` and `y` of `α`, if `x` and `y` are in the same cycle of the permutation `f` (i.e., there exists a integer `i` such that applying the permutation `f` `i` times to `x` yields `y`), then `x` being a fixed point of `f` (meaning `f(x) = x`) is equivalent to `y` being a fixed point of `f` (meaning `f(y) = y`). In other words, either both `x` and `y` are fixed points of `f` or neither of them are.

For any permutation `f` on a type `α` and any elements `x` and `y` in `α`, if `x` and `y` are in the same cycle of `f`, then `x` being a fixed point of `f` if and only if `y` is a fixed point of `f`.


theorem Matrix.one_apply :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α] {i j : n},
      1 i j = if i = j then 1 else 0 :=
  by sorry

The theorem `Matrix.one_apply` states that for any types `n` and `α`, where `n` has decidable equality, `α` has a zero element and a one element, and for any elements `i` and `j` of type `n`, the application of the identity matrix (represented as `1`) at indices `i` and `j` is `1` if `i` and `j` are equal, otherwise it is `0`. Essentially, this theorem formalizes the standard property of identity matrices in mathematics.

For any identity matrix of size `n` over type `α` with decidable equality, the `(i, j)`-entry is `1` if `i = j`, and `0` otherwise.


theorem PSet.mem_wf : WellFounded fun x x_1 => x ∈ x_1 := by sorry

This theorem, `PSet.mem_wf`, states that the relation "is an element of" (`∈`) on the class of all Power Sets (`PSet`) is well-founded. In the context of set theory, a relation is said to be well-founded if there are no infinitely descending chains, which means that we cannot keep finding smaller and smaller elements indefinitely. In this case, we cannot find an infinite descending chain of sets within power sets.

The relation "is an element of" on the class of all power sets is well-founded, meaning there are no infinite descending sets.


theorem Nat.Primrec'.of_prim : ∀ {n : ℕ} {f : Vector ℕ n → ℕ}, Primrec f → Nat.Primrec' f := by sorry

The theorem `Nat.Primrec'.of_prim` states that for any natural number `n` and any function `f` from `Vector ℕ n` (a list of length `n` with elements of type `ℕ`) to `ℕ`, if `f` is primitive recursive (i.e., `Primrec f` holds), then `f` is also primitive recursive in the natural numbers (i.e., `Nat.Primrec' f` holds). In terms of computation theory, this theorem says that any function that can be computed using primitive recursion on arbitrary data types (as long as they can be encoded as natural numbers) can also be computed using primitive recursion directly on natural numbers.

If a function from a vector of natural numbers to natural numbers is primitive recursive, then it is also primitive recursive as a function from natural numbers to natural numbers.


theorem Real.exp_ne_zero : ∀ (x : ℝ), Real.exp x ≠ 0 := by sorry

This theorem states that the real exponential function is never zero. In other words, for all real numbers `x`, the value of the exponential function at `x`, denoted by `Real.exp x`, is not equal to zero. This is a well-known property of the exponential function in mathematics, which can be expressed as $\forall x \in \mathbb{R}, \exp(x) \neq 0$.

For all real numbers x, the exponential function Real.exp x is never zero. Equivalently, ∀x:ℝ, Real.exp x ≠ 0.


theorem intervalIntegral.integral_comp_add_mul :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b c : ℝ} (f : ℝ → E),
      c ≠ 0 → ∀ (d : ℝ), ∫ (x : ℝ) in a..b, f (d + c * x) = c⁻¹ • ∫ (x : ℝ) in d + c * a..d + c * b, f x :=
  by sorry

This theorem states that for any function `f` from real numbers to a normed space `E`, given real numbers `a`, `b`, `c` with `c` not equal to zero, and any real number `d`, we could rewrite the integral of `f` of `d + c * x` over the interval from `a` to `b` as `c⁻¹` times the integral of `f` over the interval from `d + c * a` to `d + c * b`. This theorem essentially establishes a property of a linear change of variables in definite integrals.

For any real-valued function `f` on a normed space `E` and real numbers `a`, `b`, `c` not equal to zero, the integral of `f` over the interval `[a, b]` with respect to the variable `x` is equal to `c⁻¹` times the integral of `f(d + c * x)` over the interval `[d + c * a, d + c * b]`, where `d` is any real number.


Flag.maxChain

theorem Flag.maxChain : ∀ {α : Type u_1} [inst : LE α] (s : Flag α), IsMaxChain (fun x x_1 => x ≤ x_1) ↑s := by sorry

The theorem `Flag.maxChain` states that for any type `α` that has a less than or equal to (`≤`) relation and for any flag `s` of this type, `s` is a maximal chain with respect to the `≤` relation. In other words, `s` is a chain where there is no other chain that strictly includes `s`. If there is a chain `t` that includes `s`, then `t` must be equal to `s`. Here, a chain is a set of elements where any two distinct elements are comparable (one is less than or equal to the other).

For any type `α` with a total order `≤` and any flag `s` of `α`, `s` is a maximal chain with respect to `≤`, meaning there is no strictly larger chain containing `s`.


theorem Commute.zpow_right : ∀ {G : Type w} [inst : Group G] {a b : G}, Commute a b → ∀ (m : ℤ), Commute a (b ^ m) := by
  sorry

This theorem states that for any type `G` that forms a group, given two elements `a` and `b` of `G` that commute with each other (i.e., `a * b = b * a`), and given any integer `m`, the element `a` will also commute with `b` raised to the power of `m` (i.e., `a * (b ^ m) = (b ^ m) * a`).

If `a` and `b` are group elements that commute, then `a` commutes with `b` raised to any power.


theorem Mathlib.Topology.MetricSpace.ThickenedIndicator._auxLemma.2 : (¬False) = True := by sorry

This theorem, titled `Mathlib.Topology.MetricSpace.ThickenedIndicator._auxLemma.2`, states a simple logical equivalence in Boolean logic. Specifically, it asserts the proposition that the negation of `False` (`¬False`) is equal to `True`. This theorem applies in all contexts, and is a fundamental result of Boolean algebra.

The theorem asserts that the negation of False is equivalent to True in Boolean logic.


theorem hasMFDerivAt_id :
    ∀ {𝕜 : 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] [inst_6 : SmoothManifoldWithCorners I M]
      (x : M), HasMFDerivAt I I id x (ContinuousLinearMap.id 𝕜 (TangentSpace I x)) :=
  by sorry

The theorem `hasMFDerivAt_id` states that for any nontrivially normed field 𝕜, any normed additive commutative group E, and any normed space over 𝕜 with base E, if we have a topological space H, a model with corners I associated to 𝕜, E and H, a topological space M, a charted space over M with model H, and a smooth manifold with corners based on I and M, then at any point x in M, the manifold derivative at x of the identity map is the identity map on the tangent space at x. This means that the identity map is differentiable at every point on a smooth manifold, and its derivative at any point is just the identity on the tangent space at that point.

The identity map on a smooth manifold with corners is differentiable at every point and its derivative is the identity on the tangent space at that point.


theorem inf_eq_top_iff :
    ∀ {α : Type u} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {a b : α}, a ⊓ b = ⊤ ↔ a = ⊤ ∧ b = ⊤ := by sorry

The theorem `inf_eq_top_iff` states that for all types `α`, given a semilattice structure (which provides an infimum operation) and an order with top element on `α`, the infimum (greatest lower bound) of two elements `a` and `b` is the top element if and only if both `a` and `b` are the top element. In other words, the largest element that is less than or equal to both `a` and `b` is the top element of the order precisely when `a` and `b` are themselves the top element.

For all types `α` with a semilattice and order structure having a top element, `top`, the infimum of `a` and `b` equals `top` if and only if `a` and `b` both equal `top`.


/-- A geometric series in a normed field is summable iff the norm of the common ratio is less than
one.  -/
theorem summable_geometric_iff_norm_lt_one :
    ∀ {K : Type u_4} [inst : NormedField K] {ξ : K}, (Summable fun n => ξ ^ n) ↔ ‖ξ‖ < 1 := by sorry

The theorem `summable_geometric_iff_norm_lt_one` in Lean 4 states that, for any normed field `K` and any element `ξ` from `K`, the geometric series `ξ ^ n` (for all `n`) is summable if and only if the norm of the common ratio `ξ` is less than one. In other words, the geometric series converges when the norm of the ratio between successive terms is less than one, and diverges otherwise. This is a well-known result in the field of series in analysis.

A geometric series over a normed field converges if and only if the norm of the common ratio is less than one.


Finite.false

theorem Finite.false : ∀ {α : Sort u_1} [inst : Infinite α], Finite α → False := by sorry

This theorem is stating that for any type `α`, if `α` is infinite (as denoted by the `Infinite α` instance), then it cannot also be finite (`Finite α`). In other words, a type can't be both finite and infinite at the same time. If we assume that `α` is both finite and infinite, we arrive at a contradiction, which is the `False` in the theorem statement.

A type cannot be both finite and infinite.


theorem Polynomial.roots_expand_pow :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p n : ℕ} [inst_2 : ExpChar R p] {f : Polynomial R}
      [inst_3 : PerfectRing R p],
      Polynomial.roots ((Polynomial.expand R (p ^ n)) f) =
        p ^ n • Multiset.map (⇑(RingEquiv.symm (iterateFrobeniusEquiv R p n))) (Polynomial.roots f) :=
  by sorry

This theorem states that for any commutative ring `R` that is a domain and has characteristic `p`, and for any polynomial `f` in `R` and natural numbers `p` and `n`, given `R` is a perfect ring with characteristic `p`, the roots of the expanded polynomial `f` by a factor of `p^n` are obtained by mapping the roots of `f` through the inverse of the `n`-times iterated Frobenius automorphism and multiplying it by `p^n`. The Frobenius automorphism is an endomorphism that raises elements to the `p`-th power, and its iteration is an automorphism that raises elements to the `p^n`-th power. This theorem relates the roots of a polynomial and its expanded version in the context of perfect rings.

In a perfect commutative domain `R` of characteristic `p`, the n-th expanded root of a polynomial `f(x)` is given by the n-th iterate of the Frobenius automorphism followed by multiplication by `p^n`.


/-- `A` is in the `r`-th slice of `𝒜` iff it's in `𝒜` and has cardinality `r`.  -/
theorem Finset.mem_slice :
    ∀ {α : Type u_1} {𝒜 : Finset (Finset α)} {A : Finset α} {r : ℕ}, A ∈ Finset.slice 𝒜 r ↔ A ∈ 𝒜 ∧ A.card = r := by
  sorry

The theorem `Finset.mem_slice` states that for any type `α`, any set `𝒜` of finite sets of `α`, any finite set `A` of `α`, and any natural number `r`, `A` belongs to the `r`-th slice of `𝒜` if and only if `A` belongs to `𝒜` and the cardinality of `A` is `r`. Here, the `r`-th slice of a set family is defined as the subset of its elements that have cardinality `r`.

For any type `α` and set `𝒜` of finite sets of `α`, a finite set `A` belongs to the `r`-th slice of `𝒜` if and only if `A` is an element of `𝒜` with cardinality `r`.


theorem CategoryTheory.Limits.cospan_map_inl :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
      (CategoryTheory.Limits.cospan f g).map CategoryTheory.Limits.WalkingCospan.Hom.inl = f :=
  by sorry

The theorem `CategoryTheory.Limits.cospan_map_inl` states that for any given category `C` and objects `X`, `Y`, and `Z` within that category, along with morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the map of the walking cospan functor for the cospan formed by `f` and `g`, when applied to the left arrow of the walking cospan, is equal to the morphism `f`. In simpler terms, it means that if we create a cospan with `f` and `g`, and then map the left arrow of the walking cospan through this cospan, we get back the morphism `f`.

For any category C and morphisms f : X -> Z and g : Y -> Z in C, the map of the walking cospan functor to X from the cospan (Z, f, g) is equal to f.


theorem max_zero_sub_max_neg_zero_eq_self :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α), max a 0 - max (-a) 0 = a :=
  by sorry

This theorem, `max_zero_sub_max_neg_zero_eq_self`, states that for any type `α` that is an additive group and has a linear order and a covariant class, the maximum of a given element `a` and zero, subtracted by the maximum of the negative of `a` and zero, equals `a` itself. In mathematical notations, this can be represented as: max(a, 0) - max(-a, 0) = a. This theorem essentially provides a relationship between an element and its additive inverse in the context of maximum and subtraction operations.

For any additive group with a linear order and a covariant class, max(a, 0) - max(-a, 0) = a.


theorem boole_mul :
    ∀ {α : Type u_1} [inst : MulZeroOneClass α] (P : Prop) [inst_1 : Decidable P] (a : α),
      (if P then 1 else 0) * a = if P then a else 0 :=
  by sorry

This theorem is stating that for any type `α` that belongs to a `MulZeroOneClass` (a class of elements that supports multiplication, zero, and unit), and for any propositional `P`, which is decidable, and any element `a` of type `α`, the product of `a` and either 1 (if `P` is true) or 0 (if `P` is false) is equivalent to `a` if `P` is true, and 0 if `P` is false. In terms of mathematics, if `P` is true, then our multiplication result is `a`, otherwise it's 0.

For any `α` in `MulZeroOneClass` and decidable proposition `P`, `a * (if P then 1 else 0) = a` if `P` is true, and `a * (if P then 1 else 0) = 0` if `P` is false.


theorem Real.Angle.sign_antiperiodic : Function.Antiperiodic Real.Angle.sign ↑Real.pi := by sorry

This theorem states that the sign function for a real angle is antiperiodic with an antiperiod of pi (π). In other words, for any real angle x, the sign of the angle at x + π is the negative of the sign at x. This is consistent with the trigonometric characteristics of sine function, which underlies the definition of the sign of a real angle.

The sign function of a real angle is antiperiodic with an antiperiod of pi, i.e., sign(x + pi) = -sign(x) for all real x.


/-- See https://proofwiki.org/wiki/Fibonacci_Number_in_terms_of_Smaller_Fibonacci_Numbers  -/
theorem Nat.fib_add : ∀ (m n : ℕ), Nat.fib (m + n + 1) = Nat.fib m * Nat.fib n + Nat.fib (m + 1) * Nat.fib (n + 1) := by
  sorry

This theorem states that for any two natural numbers `m` and `n`, the Fibonacci number at the position of `m + n + 1` is equal to the sum of the product of the Fibonacci number at position `m` and the Fibonacci number at position `n`, and the product of the Fibonacci number at position `m + 1` and the Fibonacci number at position `n + 1`. This is a property of the Fibonacci sequence and provides a relationship between the Fibonacci numbers at different positions.

The Fibonacci number at position `m + n + 1` equals the product of the Fibonacci number at position `m` with the Fibonacci number at position `n`, plus the product of the Fibonacci number at position `m + 1` with the Fibonacci number at position `n + 1`.


theorem MeasureTheory.Measure.addHaar_closedBall_eq_addHaar_ball :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
      [inst_3 : BorelSpace E] [inst_4 : FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E)
      [inst_5 : MeasureTheory.Measure.IsAddHaarMeasure μ] [inst_6 : Nontrivial E] (x : E) (r : ℝ),
      ↑↑μ (Metric.closedBall x r) = ↑↑μ (Metric.ball x r) :=
  by sorry

This theorem, named `MeasureTheory.Measure.addHaar_closedBall_eq_addHaar_ball`, states that for any normed additively commutative group `E` that is also a real normed space with a measurable and Borel space structure, and finite-dimensionality over the real numbers, given an additive Haar measure `μ` on this space `E` and a nontrivial element `x` of `E` along with a real number `r`, the measure of the closed ball centered at `x` with radius `r` under `μ` is equal to the measure of the open ball centered at `x` with radius `r` under `μ`. The closed ball is the set of all points whose distance from `x` is less than or equal to `r`, and the open ball is the set of all points whose distance from `x` is strictly less than `r`.

For any finite-dimensional, real normed space `E` with a measurable and Borel structure, and additive Haar measure `μ`, the measure of a closed ball equals the measure of the corresponding open ball.


theorem OneOneReducible.disjoin_left :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : α → Prop} {q : β → Prop},
      p ≤₁ Sum.elim p q :=
  by sorry

The theorem `OneOneReducible.disjoin_left` states that for any types `α` and `β` that have instances of `Primcodable` (i.e., they can be encoded as natural numbers), and for any properties `p` of type `α` and `q` of type `β`, the property `p` is one-one reducible to the function `Sum.elim p q`, which is defined on the sum type of `α` and `β`. The function `Sum.elim p q` applies the property `p` to elements of `α` and the property `q` to elements of `β`. Here, `≤₁` denotes one-one reducibility, meaning that there is an injective (one-to-one) function that transforms instances of `p` into instances of `Sum.elim p q`.

For types `α` and `β` with `Primcodable` instances, and properties `p` of type `α` and `q` of type `β`, `p` is one-one reducible to the function `Sum.elim p q` that applies `p` to elements of `α` and `q` to elements of `β`.


theorem smoothAt_inv₀ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
      [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) {G : Type u_4}
      [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Inv G] [inst_7 : Zero G]
      [inst_8 : SmoothInv₀ I G] {x : G}, x ≠ 0 → SmoothAt I I (fun y => y⁻¹) x :=
  by sorry

This theorem states that for a non-zero point `x` in a topological space `G` that has a smooth inverse operation (`SmoothInv₀ I G`) and is charted with a model `I` (ModelWithCorners) in a normed space `E` over a non-trivially normed field `𝕜`, the function that maps each point `y` to its inverse `y⁻¹` is smooth at `x`. This implies that the inverse function has derivatives of all orders at `x`.

Given a non-zero point `x` in a topological space `G` endowed with a smooth inverse operation and charted in a normed space `E` over a non-trivially normed field `𝕜`, the inverse function is smooth at `x`.


theorem CategoryTheory.Limits.IsInitial.strict_hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasStrictInitialObjects C]
      {I : C}, CategoryTheory.Limits.IsInitial I → ∀ {A : C} (f g : A ⟶ I), f = g :=
  by sorry

This theorem states that for any category `C` that has strict initial objects, if `I` is an initial object in `C`, then for any object `A` in `C` and any two morphisms `f` and `g` from `A` to `I`, `f` must be equal to `g`. This property is characteristic of initial objects in a category, where there is exactly one morphism from any object to the initial object.

In any category with strict initial objects, two morphisms from an arbitrary object to the initial object are equal.


theorem Nat.lcm_dvd_mul : ∀ (m n : ℕ), Nat.lcm m n ∣ m * n := by sorry

This theorem states that for any two natural numbers `m` and `n`, the least common multiple of `m` and `n` divides the product of `m` and `n`. In mathematical terms, if `lcm(m, n)` denotes the least common multiple of `m` and `n`, then there exists a natural number `k`, such that `m * n = k * lcm(m, n)`.

The least common multiple of natural numbers `m` and `n` divides their product. In other words, `lcm(m, n) | (m * n)`.


theorem CompositionSeries.mem_def :
    ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] {x : X} {s : CompositionSeries X},
      x ∈ s ↔ x ∈ Set.range s.series :=
  by sorry

This theorem states that for any type `X` with a lattice structure and a Jordan-Hölder lattice structure, any element `x` of type `X`, and any composition series `s` of type `X`, `x` is an element of the composition series `s` if and only if `x` is in the range of the series function `s.series`. This range is defined as the set of all outputs of the function `s.series`.

For any lattice type `X` with a Jordan-Hölder structure, an element `x` lies in a composition series `s` if and only if `x` is in the image of the series function `s.series`.


theorem Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology._auxLemma.1 :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      (𝒜 : ℕ → Submodule R A) [inst_3 : GradedAlgebra 𝒜] (x : ProjectiveSpectrum 𝒜) (s : Set A),
      (x ∈ ProjectiveSpectrum.zeroLocus 𝒜 s) = (s ⊆ ↑x.asHomogeneousIdeal) :=
  by sorry

The theorem `Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology._auxLemma.1` states that for any commutative semiring `R`, commutative ring `A`, and an algebra structure `A` over `R`, for a graded algebra structure `𝒜` : ℕ → Submodule R A, each point `x` in the Projective Spectrum of `𝒜`, and a set `s` of `A`, the point `x` belongs to the zero locus of `𝒜` over `s` if and only if the set `s` is a subset of the inverse image of `x` under the map to the homogeneous ideal. In other words, the theorem establishes a correspondence between the zero locus of a set in the projective spectrum and the containment of the set in the homogeneous ideal associated with a point in the projective spectrum.

For any commutative semiring `R`, commutative ring `A` with an algebra structure over `R`, graded algebra structure `𝒜` : ℕ → Submodule R A, point `x` in the Projective Spectrum of `𝒜`, and set `s` in `A`, `x` lies in the zero locus of `𝒜` over `s` if and only if `s` is a subset of the inverse image of `x` under the map to the homogeneous ideal.


theorem Multiset.map_single_le_powerset :
    ∀ {α : Type u_1} (s : Multiset α), Multiset.map singleton s ≤ Multiset.powerset s := by sorry

This theorem states that for any given multiset `s` of an arbitrary type `α`, the multiset obtained by applying the function `singleton` to each element of `s` (which is equivalent to mapping each element of `s` to a singleton set containing only that element) is a subset (or is less than or equal) to the power set of `s`. This means that every singleton set created from each element of the original multiset `s` is indeed a member of the power set of `s`.

For any multiset `s` of type `α`, the multiset of singletons formed by applying `singleton` to each element of `s` is a subset of the power set of `s`.


/-- **Alias** of `ENNReal.measurable_of_tendsto'`.

---

A limit (over a general filter) of measurable `ℝ≥0∞` valued functions is measurable.  -/
theorem measurable_of_tendsto_ennreal' :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {ι : Type u_6} {f : ι → α → ENNReal} {g : α → ENNReal} (u : Filter ι)
      [inst_1 : Filter.NeBot u] [inst_2 : Filter.IsCountablyGenerated u],
      (∀ (i : ι), Measurable (f i)) → Filter.Tendsto f u (nhds g) → Measurable g :=
  by sorry

This theorem, referred to as an alias of `ENNReal.measurable_of_tendsto'`, states that if we have a sequence of measurable functions `f : ι → α → [0,∞]` tending to a function `g : α → [0,∞]` as the filter `u` over `ι` tends to a neighborhood of `g`, then `g` itself is a measurable function. Here, measurability of a function is defined as the preimage of every measurable set being measurable, and the notion of tending to a limit is defined in terms of preimages of neighborhoods. The theorem requires that the filter `u` is not bottom (i.e., not the empty filter), and that it is countably generated.

If `f : ι → α → [0,∞]` is a sequence of measurable functions tending to the measurable function `g : α → [0,∞]` as the countably generated filter `u` over `ι` approaches a neighborhood of `g`, then `g` is measurable.


/-- **Alias** of the reverse direction of `linearIndependent_unique_iff`. -/
theorem linearIndependent_unique :
    ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : NoZeroSMulDivisors R M] (v : ι → M) [inst_5 : Unique ι],
      v default ≠ 0 → LinearIndependent R v :=
  by sorry

The theorem `linearIndependent_unique` states that for any types `ι`, `R`, and `M`; given a ring `R` that is nontrivial, an additive commutative group `M`, a module over `R` and `M`, and an assumption that there are no zero scalar multipliers and dividers between `R` and `M`; if `v` is a function from `ι` to `M` where `ι` is unique, and the default of `v` is not zero, then the family of vectors `v` is linearly independent over `R`. In other words, for a unique index type, if the mapped vector is non-zero, then the vector is linearly independent.

Given a nontrivial ring `R`, an additive commutative group `M` with no zero scalar multipliers or dividers, and a function `v : ι -> M` from a unique index type `ι` with non-zero default value, then the family `{v i : M | i ∈ ι}` is linearly independent over `R`.


theorem ConjAct.smul_def :
    ∀ {G : Type u_3} [inst : DivInvMonoid G] (g : ConjAct G) (h : G),
      g • h = ConjAct.ofConjAct g * h * (ConjAct.ofConjAct g)⁻¹ :=
  by sorry

The theorem `ConjAct.smul_def` states that for any group `G` with division and inversion (given by the typeclass `DivInvMonoid G`), and for any elements `g` in `ConjAct G` and `h` in `G`, the action of `g` on `h` (denoted as `g • h`) is equal to the conjugation of `h` by `g`. In this context, conjugation is given by the product of `g`, `h` and the inverse of `g` in that order, i.e., `g * h * g⁻¹`, where `g⁻¹` is the inverse of `g`. This action is referred to as the "conjugation action" of `g` on `h`.

For any group with division and inversion, the action of an element on another element is equal to their conjugation, that is, the product of the element, the second element, and the inverse of the first element.


theorem CategoryTheory.types_comp_apply :
    ∀ {X Y Z : Type u} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X), CategoryTheory.CategoryStruct.comp f g x = g (f x) := by sorry

The theorem `CategoryTheory.types_comp_apply` states that for any three types `X`, `Y`, and `Z` in the same universe `u`, and for any two functions `f` from `X` to `Y` and `g` from `Y` to `Z`, and for any object `x` of type `X`, the composition of `f` and `g`, when applied to `x`, is the same as first applying `f` to `x` and then applying `g` to the result. This is a formal statement of the fundamental concept of function composition in category theory.

For any types X, Y, Z in the same universe u, and functions f : X -> Y and g : Y -> Z, the composition g o f is equal to the function g applied to the result of applying f. In other words, g (f(x)) = (g o f)(x) for all x in X.


theorem UniqueAdd.of_addOpposite :
    ∀ {G : Type u_1} [inst : Add G] {A B : Finset G} {a0 b0 : G},
      UniqueAdd (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } B)
          (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } A) (AddOpposite.op b0) (AddOpposite.op a0) →
        UniqueAdd A B a0 b0 :=
  by sorry

This theorem states that for any type `G` with an addition operation, given two finite subsets `A` and `B` of `G` and two elements `a0` and `b0` from `G`, if the sum of an element from the image finset of `B` under the operation `AddOpposite.op` and an element from the image finset of `A` under the same operation, can be written in at most one way as `AddOpposite.op b0` plus `AddOpposite.op a0`, then it also holds that the sum `a0 + b0` can be written in at most one way as a sum of an element from `A` and an element from `B`. In other words, the uniqueness of addition in the opposite world implies the uniqueness of addition in the original world.

If the sum of an element from the image of a finite set `A` under `AddOpposite.op` and an element from the image of another finite set `B` under `AddOpposite.op` can be written as `AddOpposite.op b0 + AddOpposite.op a0` for at most one pair `(a0, b0)`, then the sum `a0 + b0` can be written as `x + y` with `x ∈ A` and `y ∈ B` for at most one pair `(x, y)`.


Filter.EventuallyLE.isMinFilter

theorem Filter.EventuallyLE.isMinFilter :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
      f ≤ᶠ[l] g → f a = g a → IsMinFilter f l a → IsMinFilter g l a :=
  by sorry

The theorem `Filter.EventuallyLE.isMinFilter` states that for any types `α` and `β`, where `β` has a preorder structure, and any two functions `f` and `g` from `α` to `β`, along with a given filter `l` on `α` and an element `a` of `α`, if `f` is less than or equal to `g` eventually at filter `l` and `f(a)` is equal to `g(a)`, and if `f` has a property of being a minimum filter at `a` (meaning that `f(a)` is less than or equal to `f(x)` for all `x` in some `l`-neighborhood of `a`), then `g` also has the property of being a minimum filter at `a`. In simple terms, under these conditions, if `f` is minimum at `a`, then `g` is also minimum at `a`.

If `f` is a minimum filter at `a`, `f(a) ≤ g(a)`, `g(x) ≤ f(x)` for all `x` in some neighborhood of `a` in `α` (i.e., `x ∈ l`), and `f` is eventually less than or equal to `g` at filter `l`, then `g` is a minimum filter at `a`.


theorem Mathlib.Data.Matroid.Dual._auxLemma.9 :
    ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M﹡.Indep I = (I ⊆ M.E ∧ ∃ B, M.Base B ∧ Disjoint I B) := by sorry

This theorem, from the Matroid theory in the Mathlib library, states that for any type `α`, any Matroid `M` over `α`, and any set `I` of elements of type `α`, the condition that `I` is independent in the dual of `M` is equivalent to the condition that `I` is a subset of the set of loops of `M` and that there exists a set `B` such that `B` is a base of `M` and `I` and `B` are disjoint. In the context of lattice theory, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element of the lattice.

For any matroid M over type α, a set I of elements is independent in the dual of M if and only if I is a subset of the set of loops and there exists a base B of M such that I and B are disjoint in the lattice sense.


theorem Disjoint.closure_left :
    ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], Disjoint s t → IsOpen t → Disjoint (closure s) t := by
  sorry

This theorem states that for any type `X` with a defined `TopologicalSpace`, and for any two sets `s` and `t` of this type, if `s` and `t` are disjoint and `t` is an open set in this topological space, then the closure of `s` is also disjoint from `t`. In other words, in a given topological context, if two sets do not share any common elements and one of them is open, then the smallest closed set that contains one of those sets will still not share any common elements with the other set.

If two disjoint sets in a topological space have one of them open, then their closures are still disjoint.


/-- **Sum of a Geometric Series**  -/
theorem NNReal.hasSum_geometric : ∀ {r : NNReal}, r < 1 → HasSum (fun n => r ^ n) (1 - r)⁻¹ := by sorry

The theorem `NNReal.hasSum_geometric` states that for any non-negative real number `r` that is less than 1, the sum of the geometric series where each term is `r` to the power of `n`, converges to the value `(1 - r)⁻¹`. In other words, the sum of the infinite geometric series $\sum_{n=0}^{\infty} r^n$ is equal to $\frac{1}{1 - r}$, for 0 ≤ `r` < 1.

The theorem asserts that the sum of the infinite geometric series $\sum\_{n=0}^{\infty} r^n$ equals $\frac{1}{1 - r}$ for $0 \leq r < 1$.


theorem Set.surjective_iff_surjOn_univ :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f ↔ Set.SurjOn f Set.univ Set.univ := by sorry

The theorem `Set.surjective_iff_surjOn_univ` states that for any function `f` from type `α` to type `β`, the function `f` is surjective if and only if `f` is surjective on the universal set of `α` to the universal set of `β`. In other words, a function is surjective if every element of type `β` is an image of some element of type `α`, which is equivalent to saying that the image of the entire set of type `α` under function `f` includes all elements of type `β`.

A function between types is surjective if and only if its image under the universal map from the source type to the universe includes the universal map from the target type to the universe.


theorem FirstOrder.Language.Equiv.map_fun :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] (φ : FirstOrder.Language.Equiv L M N) {n : ℕ} (f : L.Functions n)
      (x : Fin n → M), φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure.funMap f (⇑φ ∘ x) :=
  by sorry

The theorem `FirstOrder.Language.Equiv.map_fun` expresses that for any first-order language `L`, types `M` and `N`, given structures of the language `L` over `M` and `N`, and an equivalence `φ` between `M` and `N`, for any `n`-ary function `f` in the language and any function from `Fin n` to `M`, applying the equivalence `φ` after the function map of `f` and `x` in the `M` structure is the same as applying the function map of `f` in the `N` structure to the composition of `φ` and `x`. In simple terms, the theorem states that the process of mapping the function does not depend on which structure, `M` or `N`, the operation is conducted in, as long as we have an equivalence between the two structures.

For any first-order language L, structures M and N, equivalence φ between M and N, n-ary function f in the language, and function g : Fin n → M, the function map of f applied to the composition of φ and g in the M structure is equal to the composition of the function map of f in the N structure and φ, i.e., (M.map_fun f g) φ = φ (N.map_fun f (g)).


theorem Polynomial.not_isUnit_X_sub_C :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] (r : R), ¬IsUnit (Polynomial.X - Polynomial.C r) := by sorry

The theorem `Polynomial.not_isUnit_X_sub_C` states that for any type `R` that is a `Ring` and is `Nontrivial`, and for any real number `r`, the polynomial `X - C r`, where `X` is the polynomial variable and `C r` is the constant polynomial `r`, is not a unit. In other words, the polynomial `X - C r` does not have a two-sided inverse in the ring of polynomials over `R`.

For any nontrivial ring R and real number r, the polynomial X - Cr is not a unit in the ring of polynomials over R.


theorem mul_self_le_mul_self :
    ∀ {α : Type u_1} {a b : α} [inst : MulZeroClass α] [inst_1 : Preorder α] [inst_2 : PosMulMono α]
      [inst_3 : MulPosMono α], 0 ≤ a → a ≤ b → a * a ≤ b * b :=
  by sorry

The theorem `mul_self_le_mul_self` states that for any type `α` equipped with multiplication and zero (`MulZeroClass`), a preorder relation (`Preorder`), and the properties of left and right monotonicity of multiplication by nonnegative elements (`PosMulMono` and `MulPosMono`), if `a` and `b` are two elements of `α` such that `0 ≤ a` and `a ≤ b`, then it must be the case that `a * a ≤ b * b`. This is essentially stating a property of nonnegative real numbers that if `a` is less than or equal to `b` then `a` squared is also less than or equal to `b` squared, generalized to any ordered semiring structure.

If `α` is an ordered semiring with multiplication and zero, and `a`, `b` in `α` satisfy `0 ≤ a ≤ b`, then `a * a ≤ b * b`.


theorem IsOpen.exists_smul_mem :
    ∀ (M : Type u_1) {α : Type u_3} [inst : Monoid M] [inst_1 : TopologicalSpace α] [inst_2 : MulAction M α]
      [inst_3 : MulAction.IsMinimal M α] (x : α) {U : Set α}, IsOpen U → Set.Nonempty U → ∃ c, c • x ∈ U :=
  by sorry

The theorem `IsOpen.exists_smul_mem` states that for any type `M` with a monoid structure, any type `α` with a topological space structure and a multiplication action of `M` on `α`, if the action is minimal, then for any element `x` of type `α` and any open set `U` that is not empty, there exists an element `c` of type `M` such that the multiplication action of `c` on `x` results in an element that belongs to `U`.

For any monoid `M` acting minimally on a topological space `α`, given a non-empty open set `U` in `α`, there exists an element `c` in `M` such that the multiplication action of `c` on any point `x` in `U` results in a point in `U`.


theorem Metric.inseparable_iff :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α}, Inseparable x y ↔ dist x y = 0 := by sorry

This theorem states that for any two points `x` and `y` in a pseudometric space `α`, `x` and `y` are inseparable (meaning that the neighborhoods of `x` and `y` are identical) if and only if the distance between `x` and `y` is zero. This links the topological concept of inseparability with the metric concept of distance, providing a criterion for inseparability in terms of the distance between the two points.

In a pseudometric space, two points are inseparable if and only if their distance is zero.


theorem MeasureTheory.Integrable.add_measure :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] {f : α → β},
      MeasureTheory.Integrable f μ → MeasureTheory.Integrable f ν → MeasureTheory.Integrable f (μ + ν) :=
  by sorry

The theorem `MeasureTheory.Integrable.add_measure` states that for any two measures `μ` and `ν` on a measurable space `α` and any function `f` from `α` to a normed additive commutative group `β`, if `f` is integrable with respect to both `μ` and `ν`, then `f` is also integrable with respect to the measure `μ + ν`, which is the sum of `μ` and `ν`. In other words, the integrability of `f` is preserved under the addition of measures.

If measures `μ` and `ν` on measurable space `α` have integrable function `f` with respect to each, then `f` is integrable with respect to their sum `μ + ν`.


theorem MvPolynomial.degrees_zero : ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.degrees 0 = 0 :=
  by sorry

This theorem states that for any commutative semiring `R` and any type `σ`, the degrees of the zero polynomial (which is a multi-variable polynomial over `R` with variables from `σ`) is zero. In other words, there are no terms in this polynomial, so there are no variables with any associated degree.

For any commutative semiring R and type σ, the zero polynomial over R with variables from σ has degree 0.


theorem Int.le_add_of_nonneg_right : ∀ {a b : ℤ}, 0 ≤ b → a ≤ a + b := by sorry

This theorem states that for any two integers `a` and `b`, if `b` is non-negative (i.e., `b` is greater than or equal to zero), then `a` is less than or equal to the sum of `a` and `b`. Intuitively, adding a non-negative number to `a` will not make `a` smaller; it will either stay the same (if `b` is zero) or become larger.

For all integers `a` and `b`, if `b` is non-negative then `a` is less than or equal to `a + b`.


theorem ProbabilityTheory.kernel.measurable_kernel_prod_mk_left :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      {κ : ↥(ProbabilityTheory.kernel α β)} [inst : ProbabilityTheory.IsSFiniteKernel κ] {t : Set (α × β)},
      MeasurableSet t → Measurable fun a => ↑↑(κ a) (Prod.mk a ⁻¹' t) :=
  by sorry

The theorem `ProbabilityTheory.kernel.measurable_kernel_prod_mk_left` states that for any types `α` and `β`, given the measurable spaces `mα` and `mβ` respectively, a kernel `κ` from `α` to `β`, an instance proving that `κ` is a sigma-finite kernel, and a set `t` of ordered pairs of `α` and `β` that is measurable, the function that maps each element of `α` to the measure of the preimage of `t` under the function that pairs each element of `α` with that element (i.e., the function `(a => ↑↑(κ a) (Prod.mk a ⁻¹' t))`) is a measurable function. In other words, this theorem asserts the measurability of a certain function constructed from a probability kernel and a measurable set in the product space.

Given measurable spaces `mα` and `mβ`, a sigma-finite kernel `κ` from `α` to `β`, and a measurable set `t` in the product space `α × β`, the function mapping each `α` element to the measure of the preimage of `t` under the pairing function is measurable.


theorem Polynomial.leadingCoeff_neg :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R), Polynomial.leadingCoeff (-p) = -Polynomial.leadingCoeff p := by
  sorry

The theorem `Polynomial.leadingCoeff_neg` states that for any given polynomial `p` over a ring `R`, the leading coefficient of the negation of `p` (denoted as `-p`) equals the negation of the leading coefficient of `p`. Here, the leading coefficient of a polynomial is the coefficient of the highest power of `X` in the polynomial.

The leading coefficient of the negation of a polynomial is the negative of the leading coefficient of the original polynomial.