AddCommGroupCat.hasColimitsOfSize

theorem AddCommGroupCat.hasColimitsOfSize :
    CategoryTheory.Limits.HasColimitsOfSize.{v, u, max (max u v) w, max (max (u + 1) (v + 1)) (w + 1)}
      AddCommGroupCat :=
  by sorry

The theorem `AddCommGroupCat.hasColimitsOfSize` states that the category of additive commutative groups (`AddCommGroupCat`), which consists of the objects as additive commutative groups and the morphisms as group homomorphisms, has colimits of a certain size. In category theory, a colimit is a way to glue objects together; they could be thought of as the "most efficient" way to map from a diagram (a functor from an index category to another category) into another object. The size of the colimits here is determined by the universe levels `v`, `u`, and `w`.

The category of additive commutative groups has colimits of size `v × u × w`.


Succ.rec

/-- Induction principle on a type with a `SuccOrder` for all elements above a given element `m`.  -/
theorem Succ.rec :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [inst_2 : IsSuccArchimedean α] {P : α → Prop} {m : α},
      P m → (∀ (n : α), m ≤ n → P n → P (Order.succ n)) → ∀ ⦃n : α⦄, m ≤ n → P n :=
  by sorry

The theorem `Succ.rec` is an induction principle for a type with a `SuccOrder`, namely, an order with a successor function. It applies to all elements above a given element `m` in a type `α` which is equipped with a Preorder and a SuccOrder, and also satisfies the `IsSuccArchimedean` property. The theorem asserts that if property `P` holds for `m`, and for any `n` greater than or equal to `m`, if `P` holds for `n` then it also holds for the successor of `n`, then `P` actually holds for all elements `n` that are greater than or equal to `m`.

If `P` is a property that satisfies the hypotheses of `Succ.rec` in a type `α` with a `SuccOrder`, then `P` holds for all elements greater than or equal to `m` if it holds for `m` and for the successor of any element greater than or equal to `m`.


theorem ENNReal.ofReal_coe_nat : ∀ (n : ℕ), ENNReal.ofReal ↑n = ↑n := by sorry

This theorem states that for any natural number 'n', the function 'ENNReal.ofReal' applied to the real number representation of 'n' is equal to the co-domain representation of 'n'. In simpler terms, when you convert a natural number to a real number and apply the 'ENNReal.ofReal' function, it behaves the same as if you directly converted the natural number to the co-domain.

For any natural number n, ENNReal.ofReal (realNumberRepresentationOf n) = coDomainRepresentationOf n.


theorem MeasureTheory.integrableOn_congr_fun :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f g : α → E} {s : Set α}
      {μ : MeasureTheory.Measure α},
      Set.EqOn f g s → MeasurableSet s → (MeasureTheory.IntegrableOn f s μ ↔ MeasureTheory.IntegrableOn g s μ) :=
  by sorry

The theorem `MeasureTheory.integrableOn_congr_fun` states that for any type `α` with a measurable space structure and any normed add commutative group `E`, given two functions `f` and `g` from `α` to `E`, a set `s` of type `α`, and a measure `μ` on `α`, if `f` and `g` are equal on set `s` and `s` is a measurable set, then `f` is integrable on set `s` with respect to measure `μ` if and only if `g` is also integrable on the same set with respect to the same measure. In other words, the integrability of two functions that are equal on a measurable set is equivalent.

If `s` is a measurable subset of a measurable space `(α, Σ, μ)` and `f = g` almost everywhere on `s`, then `f` and `g` are integrable on `s` with respect to `μ` if and only if they are both integrable.


/-- A field extension `E / F` of exponential characteristic `q` is purely inseparable
if and only if for every element `x` of `E`, there exists a natural number `n` such that
`x ^ (q ^ n)` is contained in `F`.  -/
theorem isPurelyInseparable_iff_pow_mem :
    ∀ (F : Type u) {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (q : ℕ)
      [inst_3 : ExpChar F q], IsPurelyInseparable F E ↔ ∀ (x : E), ∃ n, x ^ q ^ n ∈ RingHom.range (algebraMap F E) :=
  by sorry

The theorem `isPurelyInseparable_iff_pow_mem` states that for any field `F` and field extension `E` endowed with an `Algebra` structure from `F` to `E`, and a given exponential characteristic `q`, the extension `E / F` is purely inseparable if and only if for every element `x` in `E`, there exists a natural number `n` such that the `q^n`-th power of `x` belongs to the range of the ring homomorphism induced by the `Algebra` structure from `F` to `E`. In other words, an element `x` of `E` raised to the power of `q` to the `n`th is in the image of the map from `F` to `E`. Here, `q` is a natural number representing the exponential characteristic of the field `F`.

For a field extension endowed with an algebra structure, an extension is purely inseparable if and only if every element in the extension raises to a power in its image under the induced homomorphism for some natural number, equivalent to the exponential characteristic of the base field.


/-- Cancellation subtracting the results of two subtractions.  -/
theorem vsub_sub_vsub_cancel_left :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddCommGroup G] [inst_1 : AddTorsor G P] (p₁ p₂ p₃ : P),
      p₃ -ᵥ p₂ - (p₃ -ᵥ p₁) = p₁ -ᵥ p₂ :=
  by sorry

This theorem states that for any three points `p₁`, `p₂`, and `p₃` in an additive torsor `P` over an additive commutative group `G`, the result of subtracting the subtraction of `p₃` and `p₂` from the subtraction of `p₃` and `p₁` equals the subtraction of `p₁` and `p₂`. In other words, it establishes a cancellation property of subtraction function `-ᵥ` in the context of an additive torsor.

For any additive torsor P over an additive commutative group G and any points p₁, p₂, p₃ in P, we have p₁ − (p₃ − p₂) = p₁ − p₃ + p₂.


theorem IsAdjoinRoot.aeval_eq :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
      (h : IsAdjoinRoot S f) (p : Polynomial R), (Polynomial.aeval (IsAdjoinRoot.root h)) p = h.map p :=
  by sorry

This theorem states that for any types `R` and `S` where `R` is a commutative ring and `S` is a ring, and `f` is a polynomial with coefficients in `R`, given the conditions that `S` is an `R`-algebra and `h` is an indication that a root can be adjoined to `S` to generate a root of `f`, for any polynomial `p` in `R`, the result of applying the algebraic evaluation map `Polynomial.aeval` (which maps `p` to `S`) at the root adjoined to `S` (`IsAdjoinRoot.root h`) is equal to the result of mapping `p` through `h`. In mathematical terms, for any polynomial `p`, we have `aeval(root(h))(p) = h(p)`, where `aeval` is the algebraic evaluation map and `root(h)` is the root associated with `h`.

For any commutative ring R, ring S, polynomial f over R with root h, and element p in R, we have Polynomial.aeval (IsAdjoinRoot.root h) (p) = h (p).


theorem Subgroup.normalizer_eq_top :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, Subgroup.normalizer H = ⊤ ↔ Subgroup.Normal H := by sorry

This theorem states that, for any type `G` with a group structure and any subgroup `H` of `G`, the normalizer of `H` equals the top element (indicating the whole group `G`) if and only if `H` is a normal subgroup of `G`. In mathematical terms, $H$ is normal in $G$ if and only if every element of $G$ commutes with $H$ (i.e., for all $g$ in $G$ and $n$ in $H$, $g * n * g^{-1}$ is in $H$).

A subgroup `H` of a group `G` is normal if and only if the normalizer of `H` equals `G`. That is, `norm_group G H = G` if and only if `H` is a normal subgroup of `G`.


HolderWith.holderOnWith

theorem HolderWith.holderOnWith :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal}
      {f : X → Y}, HolderWith C r f → ∀ (s : Set X), HolderOnWith C r f s :=
  by sorry

The theorem `HolderWith.holderOnWith` states that for all spaces `X` and `Y` that are pseudo emetric spaces, for any nonnegative real numbers `C` and `r`, and any function `f` from `X` to `Y`, if `f` is Hölder continuous with constant `C` and exponent `r`, then for any set `s` within `X`, `f` is also Hölder continuous with constant `C` and exponent `r` on the set `s`. In other words, if a function is Hölder continuous in the whole space, it is also Hölder continuous when restricted to any subset of that space.

If `f` is a Hölder continuous function from a pseudo metric space `X` to another pseudo metric space `Y` with constant `C` and exponent `r`, then `f` restricted to any subset `s` of `X` is also Hölder continuous with constant `C` and exponent `r`.


theorem Finset.inf_image :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeInf α] [inst_1 : OrderTop α]
      [inst_2 : DecidableEq β] (s : Finset γ) (f : γ → β) (g : β → α),
      Finset.inf (Finset.image f s) g = Finset.inf s (g ∘ f) :=
  by sorry

This theorem states that for any set `s` of type `γ`, functions `f : γ → β` and `g : β → α`, and under the conditions that `α` has a semilattice structure and a top element, and `β` has decidable equality, the infimum of the image of `s` under `f` with respect to `g` is equal to the infimum of `s` with respect to the composition of `g` and `f`. In mathematical terms, if we denote the infimum of a set `X` with respect to a function `h` by `inf(X, h)`, the theorem can be written as `inf(f(S), g) = inf(S, g ∘ f)`, where `S` is a finite set, `f` is a function mapping elements of `S` to another set, and `g` is a function mapping the image of `S` under `f` to a semilattice.

For any finite set `S` and functions `f : S → β` and `g : β → α` where `α` is a semilattice with top element and `β` has decidable equality, `inf(f(S), g) = inf(S, g ∘ f)`.


theorem pow_dvd_pow_of_dvd : ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, a ∣ b → ∀ (n : ℕ), a ^ n ∣ b ^ n := by
  sorry

This theorem states that for any commutative monoid `α` and any elements `a` and `b` of this monoid, if `a` divides `b`, then `a` raised to any natural number power `n` also divides `b` raised to the same power `n`. This theorem essentially generalizes the property of divisibility under exponentiation in the context of a commutative monoid.

For any commutative monoid `α` and elements `a, b` of `α`, if `a` divides `b`, then `a^n` divides `b^n` for all natural numbers `n`.


theorem CategoryTheory.ShortComplex.RightHomologyData.homologyIso_rightHomologyData :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasHomology S],
      CategoryTheory.ShortComplex.RightHomologyData.homologyIso (CategoryTheory.ShortComplex.rightHomologyData S) =
        (CategoryTheory.ShortComplex.rightHomologyIso S).symm :=
  by sorry

This theorem in category theory states that for any short complex 'S' of a category 'C', assuming 'C' has zero morphisms and 'S' has right homology, the homology isomorphism given by the chosen right homology data of the short complex 'S' equals the inverse of the right homology isomorphism of the short complex 'S'. This ties the explicit construction of a right homology object to the abstract definition by the universal property.

For any short complex S in a zero-object category C with right homology, the right homology isomorphism of S is the inverse of the right homology isomorphism given by its chosen data.


theorem Finset.image_union :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : DecidableEq α] {f : α → β} (s₁ s₂ : Finset α),
      Finset.image f (s₁ ∪ s₂) = Finset.image f s₁ ∪ Finset.image f s₂ :=
  by sorry

The `Finset.image_union` theorem states that for all types `α` and `β`, given the condition that `β` has decidable equality and `α` has decidable equality, and given a function `f` from `α` to `β` and two finite sets `s₁` and `s₂` of type `α`, the forward image under `f` of the union of `s₁` and `s₂` is equal to the union of the forward images of `s₁` and `s₂` under `f`. This theorem basically asserts the preservation of set union under the image of a function, which is a fundamental property in set theory.

For functions between type `α` and `β` with decidable equality, the image under `f` of the union of two finite sets `s₁` and `s₂` in `α` equals the union of the images of `s₁` and `s₂` under `f`.


theorem Mathlib.Data.Complex.Basic._auxLemma.4 : ∀ (r s : ℝ), ↑r + ↑s = ↑(r + s) := by sorry

This theorem, `Mathlib.Data.Complex.Basic._auxLemma.4`, states that for all real numbers `r` and `s`, the sum of their complex equivalents is equal to the complex equivalent of their sum. In mathematical notation, this is saying that for any real numbers `r` and `s`, the operation `↑r + ↑s = ↑(r + s)`, where `↑` denotes the conversion from real to complex numbers.

For all real numbers r and s, converting their sum to complex numbers is equal to the sum of their individual complex conversions: ↑(r + s) = ↑r + ↑s.


theorem CategoryTheory.Limits.kernel.lift_ι_assoc :
    ∀ {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.HasKernel f] {W : C} (k : W ⟶ X)
      (h : CategoryTheory.CategoryStruct.comp k f = 0) {Z : C} (h_1 : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.lift f k h)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) h_1) =
        CategoryTheory.CategoryStruct.comp k h_1 :=
  by sorry

The theorem `CategoryTheory.Limits.kernel.lift_ι_assoc` states that in a category `C` with zero morphisms, for any objects `X`, `Y`, `W`, and `Z`, and for any morphism `f` from `X` to `Y` which has a kernel, there is a morphism `k` from `W` to `X` such that the composition of `k` and `f` is zero. Then for any morphism `h_1` from `X` to `Z`, the composition of `k` and `h_1` is equal to the composition of the lift of `f` with respect to `k` and the composition of the kernel of `f` and `h_1`. This theorem captures the property of kernels in the context of category theory, which reflects the abstract structure of mathematical concepts.

For any morphism `f: X -> Y` with kernel in a category `C` with zero morphisms, the composition of the kernel of `f` with any morphism `h_1: X -> Z` equals the composition of the lift of `f` with respect to `h_1` and `k`, where `k` is the morphism from `W` to `X` such that `f ∘ k = 0`.


theorem HomologicalComplex.liftCycles_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) {i : ι}
      [inst_2 : HomologicalComplex.HasHomology K i] {A : C} (k : A ⟶ K.X i) (j : ι) (hj : ComplexShape.next c i = j)
      (hk : CategoryTheory.CategoryStruct.comp k (K.d i j) = 0),
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.liftCycles K k j hj hk) (HomologicalComplex.iCycles K i) =
        k :=
  by sorry

The theorem `HomologicalComplex.liftCycles_i` states that for any homological complex `K` of a category `C` (where `C` is a category with zero morphisms), given an index `i` such that `K` has homology at `i`, a morphism `k` from some object `A` to `K.X i`, and another index `j` such that `j` is the next index after `i` in the complex shape `c`, if the composition of `k` and the differential `K.d i j` is the zero morphism, then the composition of `HomologicalComplex.liftCycles K k j hj hk` and the inclusion of cycles `HomologicalComplex.iCycles K i` equals `k`.

In other words, this theorem demonstrates that we can lift cycles in a homological complex such that they are mapped correctly by the inclusion of cycles, aligning with the expected behavior in homology theory.

Given a homological complex `K` in a category `C` with zero morphisms, a morphism `k` from an object `A` to `K.X i`, and indices `i` and `j` such that `i` has homology, `j` is the next index, and `k ∘ K.d i j` is the zero morphism, the cycle lifting map `HomologicalComplex.liftCycles K k j hj hk` equals `k` when composed with the inclusion of cycles `HomologicalComplex.iCycles K i`.


Set.SurjOn.mono

theorem Set.SurjOn.mono :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
      s₁ ⊆ s₂ → t₁ ⊆ t₂ → Set.SurjOn f s₁ t₂ → Set.SurjOn f s₂ t₁ :=
  by sorry

This theorem states that for any two types `α` and `β`, given two sets `s₁` and `s₂` of type `α`, two sets `t₁` and `t₂` of type `β`, and a function `f` from `α` to `β`, if `s₁` is a subset of `s₂` and `t₁` is a subset of `t₂`, and if `f` is surjective from `s₁` onto `t₂`, then `f` is also surjective from `s₂` onto `t₁`. In other words, if the function `f` maps all elements of `s₁` onto elements in `t₂`, then it also maps all elements of the larger set `s₂` onto elements in the smaller set `t₁`.

If `f` is a surjective function from subset `s₁` of type `α` to subset `t₂` of type `β`, and `s₁` is a subset of `s₂`, then `f` is surjective from `s₂` to `t₁`.


theorem MvPolynomial.eval_add :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p q : MvPolynomial σ R} {f : σ → R},
      (MvPolynomial.eval f) (p + q) = (MvPolynomial.eval f) p + (MvPolynomial.eval f) q :=
  by sorry

The theorem `MvPolynomial.eval_add` states that for any commutative semiring `R`, any type `σ`, any two multivariate polynomials `p` and `q` over `R` with variables indexed by `σ`, and any function `f` from `σ` to `R`, the evaluation of the sum of `p` and `q` using `f` is equal to the sum of the evaluations of `p` and `q` using `f`. In other words, it affirms the distributivity of polynomial evaluation over polynomial addition.

For any commutative semiring R, type σ, multivariate polynomials p and q over R with variables indexed by σ, and function f from σ to R, the evaluation of p + q using f is equal to the sum of the evaluations of p and q using f.


theorem Set.ncard_le_ncard :
    ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → autoParam (Set.Finite t) _auto✝ → Set.ncard s ≤ Set.ncard t := by sorry

The theorem `Set.ncard_le_ncard` states that for any type `α`, and any two sets `s` and `t` of type `α`, if `s` is a subset of `t`, and `t` is finite (inferred automatically), then the cardinality of `s` (denoted as `Set.ncard s`) is less than or equal to the cardinality of `t` (denoted as `Set.ncard t`). This is a generalization of the intuitive concept that a subset of a finite set cannot have more elements than the set itself.

If `α` is a type, `s` and `t` are sets of type `α`, and `s` is a subset of `t` with `t` finite, then `Set.ncard s ≤ Set.ncard t`.


theorem MvPolynomial.eval_pow :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {f : σ → R} (n : ℕ),
      (MvPolynomial.eval f) (p ^ n) = (MvPolynomial.eval f) p ^ n :=
  by sorry

This theorem states that for any commutative semiring `R`, any multivariate polynomial `p` over the set of variables `σ` and the ring `R`, any function `f` that maps each variable in `σ` to a value in `R`, and any natural number `n`, evaluating the polynomial `p` raised to the power `n` (with respect to the valuation `f`) is the same as evaluating the polynomial `p` (with respect to the valuation `f`) and then raising the result to the power `n`. In other words, the evaluation function `MvPolynomial.eval` commutes with the power operation.

For any commutative semiring `R`, any multivariate polynomial `p` over `R` and variables `σ`, and any function `f: σ -> R`, the evaluation of `p` at `f` raised to the power `n` equals the power of the evaluation of `p` at `f` by `n`.


/-- If a family is affinely independent, so is any subfamily given by
composition of an embedding into index type with the original
family.  -/
theorem AffineIndependent.comp_embedding :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {ι : Type u_4} {ι2 : Type u_5} (f : ι2 ↪ ι) {p : ι → P},
      AffineIndependent k p → AffineIndependent k (p ∘ ⇑f) :=
  by sorry

The theorem `AffineIndependent.comp_embedding` states that, for any given set of types `k`, `V`, `P`, `ι`, and `ι2` where `k` is a ring, `V` is an additive commutative group, `V` is a module over `k`, and `P` is an affine torsor over `V`; if we have a family `p` indexed by `ι` that is affinely independent, and an embedding `f` from `ι2` into `ι`, then the subfamily resulting from the composition of `p` with `f` (i.e., `p ∘ ⇑f`) is also affinely independent. In other words, any subfamily of an affinely independent family, derived via an embedding into the index type, preserves the property of affine independence.

Given a ring `k`, an additive commutative group `V` that is a `k`-module, an affine torsor `P` over `V`, an affinely independent family `p:` `ι` → `P`, and an embedding `f:` `ι2` → `ι`, the subfamily `p ∘ ⇑f` of `P` indexed by `ι2` is also affinely independent.


Set.Infinite.ncard

theorem Set.Infinite.ncard : ∀ {α : Type u_1} {s : Set α}, Set.Infinite s → Set.ncard s = 0 := by sorry

This theorem states that for any type `α` and any set `s` of type `α`, if the set `s` is infinite, then the cardinality of `s` as given by the function `Set.ncard` is equal to `0`. In other words, the cardinality function `Set.ncard` returns the value `0` for any infinite set.

For any type `α` and any infinite set `s` of type `α`, the cardinality of `s` as given by `Set.ncard` is equal to 0.


theorem Multiset.mem_map_of_mem :
    ∀ {α : Type u_1} {β : Type v} (f : α → β) {a : α} {s : Multiset α}, a ∈ s → f a ∈ Multiset.map f s := by sorry

The theorem `Multiset.mem_map_of_mem` states that for any types `α` and `β`, a function `f` from `α` to `β`, and a multiset `s` of type `α`, if an element `a` of type `α` is in the multiset `s`, then the result of applying the function `f` to `a` is in the multiset obtained by applying `f` to each element of `s`. In other words, if an element is in the original multiset, its transformed version through the function `f` will be in the transformed multiset.

If `a` is an element of multiset `s` over type `α`, then the image `f(a)` is in the multiset `map f s` over type `β`.


theorem MvPolynomial.finSuccEquiv_apply :
    ∀ (R : Type u) [inst : CommSemiring R] (n : ℕ) (p : MvPolynomial (Fin (n + 1)) R),
      (MvPolynomial.finSuccEquiv R n) p =
        (MvPolynomial.eval₂Hom (RingHom.comp Polynomial.C MvPolynomial.C) fun i =>
            Fin.cases Polynomial.X (fun k => Polynomial.C (MvPolynomial.X k)) i)
          p :=
  by sorry

The theorem `MvPolynomial.finSuccEquiv_apply` states that for any commutative semiring `R` and any natural number `n`, the application of the algebra isomorphism `finSuccEquiv`, which converts multivariable polynomials in `Fin (n + 1)` to polynomials over multivariable polynomials in `Fin n`, to any multivariable polynomial `p` in `Fin (n + 1)` is equal to the result of evaluating `p` with a specific ring homomorphism and a function.

This specific ring homomorphism is the composition of the polynomial constant `Polynomial.C` and the multivariable polynomial constant `MvPolynomial.C`. The function takes a natural number `i` and, if `i` is zero, it returns the polynomial variable `Polynomial.X`. Otherwise, for `i` equal to the successor of `k`, it returns the constant polynomial with value equal to the degree `1` monomial `MvPolynomial.X k`.

For any commutative semiring R and natural number n, the application of `finSuccEquiv` to a multivariable polynomial p in Fin (n + 1) is equivalent to evaluating p under the homomorphism Polynomial.C ∘ MvPolynomial.C and the function that maps i to the degree 1 monomial X i if i ≠ 0, or X if i = 0.


NonUnitalSubring.ext

/-- Two non-unital subrings are equal if they have the same elements.  -/
theorem NonUnitalSubring.ext :
    ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {S T : NonUnitalSubring R}, (∀ (x : R), x ∈ S ↔ x ∈ T) → S = T := by
  sorry

This theorem, `NonUnitalSubring.ext`, asserts that given two non-unital subrings `S` and `T` of a non-unital, non-associative ring `R`, if every element `x` from the ring `R` belongs to `S` if and only if it belongs to `T`, then the subrings `S` and `T` are equal. In other words, two non-unital subrings are considered the same if they contain exactly the same elements.

If two non-unital subrings of a ring contain the same elements, then they are equal.


theorem Set.disjoint_sdiff_left : ∀ {α : Type u} {s t : Set α}, Disjoint (t \ s) s := by sorry

The theorem `Set.disjoint_sdiff_left` states that for any type `α` and any two sets `s` and `t` of type `α`, the set difference `t \ s` is disjoint from set `s`. In other words, there is no element in `t` that is not in `s` which also belongs to `s`. This is defined in the context of a lattice, where the infimum of the two sets is considered to be the bottom element, symbolized by `⊥`.

For any type `α` and sets `s` and `t` of type `α`, the set difference `t \ s` is a subset of the complement of `s`. In other words, `t \ s` and `s` have no elements in common.


theorem Asymptotics.isBigOWith_neg_right :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {c : ℝ}
      {f : α → E} {g' : α → F'} {l : Filter α},
      (Asymptotics.IsBigOWith c l f fun x => -g' x) ↔ Asymptotics.IsBigOWith c l f g' :=
  by sorry

The theorem `Asymptotics.isBigOWith_neg_right` states that for all types `α`, `E`, and `F'`, and for any real number `c`, functions `f : α → E` and `g' : α → F'`, and a filter `l` on `α`, the property that `f` is Big O of `-g'` (in the sense that the norm of `f` is eventually bounded by `c` times the norm of `-g'` at the limit points of the filter `l`) is equivalent to the property that `f` is Big O of `g'`. This means that negating the second function does not change the Big O relationship.

The theorem `Asymptotics.isBigOWith_neg_right` asserts that for all types `α`, functions `f : α -> E`, `g' : α -> F'`, real number `c`, and filter `l` on `α`, `f` is Big O of `g'` if and only if `f` is Big O of `-g'`.


theorem Matrix.zero_empty : ∀ {α : Type u} [inst : Zero α], 0 = ![] := by sorry

This theorem states that for any type `α` that has a zero element (as specified by the `Zero α` typeclass), the zero matrix is represented as an empty list. Essentially, it denotes that an empty matrix is equivalent to the zero matrix in the context of a type that supports a zero element.

For any type `α` with a zero element, the zero matrix is represented as an empty list. Equivalently, an empty matrix is the matrix representation of the additive identity for type `α`.


theorem Mathlib.Data.Finset.Basic._auxLemma.46 :
    ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) := by sorry

This theorem states that for any type `α` and any two predicates `p` and `q` on `α`, the assertion that for every element of `α` both `p` and `q` hold is equivalent to the assertion that for every element of `α`, `p` holds and for every element of `α`, `q` holds. In other words, it shows the equivalence between the global conjunction of two properties and the conjunction of their global truth.

For any type `α` and predicates `p` and `q` on `α`, the assertion that for all `x : α`, `p x` and `q x` hold is equivalent to the assertion that for all `x : α`, `p x` holds and for all `x : α`, `q x` holds.


theorem CategoryTheory.ShortComplex.rightHomologyMap'_comp :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃)
      (h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁) (h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂)
      (h₃ : CategoryTheory.ShortComplex.RightHomologyData S₃),
      CategoryTheory.ShortComplex.rightHomologyMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap' φ₁ h₁ h₂)
          (CategoryTheory.ShortComplex.rightHomologyMap' φ₂ h₂ h₃) :=
  by sorry

This theorem is about the composition of morphisms in category theory, specifically within the context of short complexes. It states that for any category `C` that has zero morphisms, and for any three short complexes `S₁`, `S₂`, and `S₃` within `C`, if we have morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, along with right homology data `h₁`, `h₂`, and `h₃` for `S₁`, `S₂`, and `S₃` respectively, then the right homology map of the composition of `φ₁` and `φ₂` from `S₁` to `S₃` is equal to the composition of the right homology map of `φ₁` from `S₁` to `S₂` and the right homology map of `φ₂` from `S₂` to `S₃`. In essence, this theorem is expressing a property of functoriality of the right homology in the category of short complexes.

Given any category `C` with zero morphisms and three short complexes `S₁`, `S₂`, `S₃`, along with morphisms `φ₁ : S₁ ⟶ S₂` and `φ₂ : S₂ ⟶ S₃`, and right homology data `h₁`, `h₂`, and `h₃`, the right homology map of the composition `φ₁ ∘ φ₂` from `S₁` to `S₃` equals the composition of `h₁` and `h₂`.


IsOpenMap.comp

theorem IsOpenMap.comp :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z], IsOpenMap g → IsOpenMap f → IsOpenMap (g ∘ f) :=
  by sorry

The theorem `IsOpenMap.comp` states that for any three types `X`, `Y` and `Z` with respective topological spaces, if `f` is a function from `X` to `Y` and `g` is a function from `Y` to `Z`, then the composition of `g` and `f` is also an open map if `f` and `g` are both open maps. In mathematical terms, if the image of any open set `U` under `f` or `g` is open, then the image of `U` under the composition of `f` and `g` (i.e., `g ∘ f`) is also open.

If `f: X ⟹ Y` and `g: Y ⟹ Z` are open maps, then their composition `g ∘ f: X ⟹ Z` is also an open map.


theorem Finset.inter_eq_left : ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ∩ t = s ↔ s ⊆ t := by sorry

This theorem states that for any type `α` that has decidable equality, and for any two finite sets `s` and `t` of type `α`, the intersection of `s` and `t` is equal to `s` if and only if `s` is a subset of `t`. In other words, it asserts that for any two finite sets, the intersection being equal to one of the sets implies that this set is contained within the other set, and conversely if one set is contained within the other, then their intersection is the set that is contained.

For any finite sets `s` and `t` of type `α` with decidable equality, `s` is a subset of `t` if and only if `s` is equal to their intersection.


theorem Mathlib.Analysis.Asymptotics.Asymptotics._auxLemma.20 :
    ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
      {g' : α → F'} {l : Filter α}, (f =O[l] fun x => ‖g' x‖) = f =O[l] g' :=
  by sorry

This theorem states that, for every types `α`, `E`, and `F'`, with `E` as a normed space and `F'` as a seminormed additive commutative group, and for every functions `f` from `α` to `E` and `g'` from `α` to `F'`, and a filter `l` on `α`, the function `f` is of the same order (big O notation) as the function that maps `x` to the norm of `g' x` under filter `l` if and only if `f` is of the same order as `g'` under filter `l`. In mathematical terms, $f=O(g'(x))$ if and only if $f=O(‖g'(x)‖)$, where $O$ is the big O notation used in Asymptotic analysis.

For functions $f : \alpha \to E$ and $g' : \alpha \to F'$ between a type, a normed space, and a seminormed additive commutative group respectively, with $E$ being normed, the functions $f$ and $g'$ are of the same order under filter $l$ if and only if $f$ is of the same order as the norm of $g'$ under filter $l$. In symbols, $f = O(g'(x))$ if and only if $f = O(\|\,g'(x)\,\|)$.


theorem Mathlib.Analysis.Asymptotics.Asymptotics._auxLemma.26 :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {f' : α → E'} {l : Filter α}, (fun x => ‖f' x‖) =O[l] g = f' =O[l] g :=
  by sorry

This theorem states that for any types `α`, `F`, and `E'`, with `F` having a norm and `E'` being a seminormed addititive commutative group, and given a function `g` from `α` to `F` and another function `f'` from `α` to `E'`, and a filter `l` on `α`, the big O notation of the norm of `f'` with respect to `g` at the filter `l` is equal to the big O notation of `f'` with respect to `g` at the same filter `l`. In other words, when considering asymptotic behavior, taking the norm of the function `f'` does not change the order of growth when compared to `g`.

For functions `g : α → F` with `F` having a norm, `f' : α → E'` with `(E', ±)|.|)` a seminormed additive commutative group, and filter `l` on `α`, the big O notation of `|f'|` with respect to `g` at `l` equals the big O notation of `f'` with respect to `g` at `l`.


theorem Filter.union_mem_sup : ∀ {α : Type u} {f g : Filter α} {s t : Set α}, s ∈ f → t ∈ g → s ∪ t ∈ f ⊔ g := by sorry

The theorem `Filter.union_mem_sup` states that for any two filters `f` and `g` of a certain type `α`, and any two sets `s` and `t` of the same type, if set `s` is in filter `f` and set `t` is in filter `g`, then the union of sets `s` and `t` is in the supremum of filters `f` and `g`. In other words, this theorem asserts that the union of elements from two different filters resides within the filter formed by the supremum of these two filters.

If filters `f` and `g` over set `α` have `s ∈ f` and `t ∈ g` for some sets `s` and `t` of type `α`, then `s ∪ t ∈ sup (f) ∧ g`.


theorem List.mem_dedup : ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α}, a ∈ List.dedup l ↔ a ∈ l := by
  sorry

The theorem `List.mem_dedup` states that for any type `α` that has decidable equality and for any element `a` of type `α` and list `l` of type `α`, `a` is a member of the deduplicated list `l` if and only if `a` is a member of the original list `l`. In other words, deduplicating a list using the `List.dedup` function does not change the membership of any element in the list.

For any type `α` with decidable equality and any list `l` of elements `α`, the deduplicated list `List.dedup l` contains an element `a` if and only if `l` contains `a`.


theorem Nat.Coprime.coprime_dvd_left : ∀ {m k n : ℕ}, m ∣ k → Nat.Coprime k n → Nat.Coprime m n := by sorry

The theorem `Nat.Coprime.coprime_dvd_left` states that for any three natural numbers `m`, `k`, and `n`, if `m` divides `k` and `k` and `n` are coprime (meaning their greatest common divisor is 1), then `m` and `n` are also coprime. In other words, the property of being coprime is preserved under division. In the language of number theory, this theorem implies that if `m` is a factor of a number `k` that is coprime with another number `n`, then `m` must also be coprime with `n`.

If natural numbers `m`, `k`, and `n` satisfy `m` divides `k` and `gcd(k, n) = 1`, then `gcd(m, n) = 1`.


AddSemiconjBy.eq

/-- Equality behind `AddSemiconjBy a x y`; useful for rewriting. -/
theorem AddSemiconjBy.eq : ∀ {S : Type u_1} [inst : Add S] {a x y : S}, AddSemiconjBy a x y → a + x = y + a := by sorry

The theorem `AddSemiconjBy.eq` states that for any type `S` with addition (`Add`), given elements `a`, `x`, and `y` of `S`, if `x` is additive semiconjugate to `y` by `a` (i.e., `AddSemiconjBy a x y` holds true), then the sum of `a` and `x` equals the sum of `y` and `a`. This theorem is useful for rewriting expressions in Lean 4.

For any type `S` with addition, if `x` is additive semiconjugate to `y` by `a` (i.e., `x = a + y`), then `a + x = y + a`.


theorem CategoryTheory.Discrete.eqToIso.proof_1 :
    ∀ {α : Type u_1} {X Y : CategoryTheory.Discrete α}, X.as = Y.as → X = Y := by sorry

This theorem states that for any type `α` and for any two objects `X` and `Y` in the Discrete category of `α`, if the `as` (identity) of `X` is equal to the `as` (identity) of `Y`, then `X` and `Y` are indeed the same object. Simply put, in a Discrete category, two objects are the same if and only if their identities are the same.

In the Discrete category, two objects are equal if and only if their identities are equal.


theorem Real.Angle.sign_ne_zero_iff : ∀ {θ : Real.Angle}, Real.Angle.sign θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑Real.pi := by sorry

This theorem states that the sign of an angle θ in the real plane (represented as a `Real.Angle`) is non-zero if and only if the angle θ is not equal to 0 and θ is not equal to π (represented as `Real.pi`). This is based on the earlier definition where the sign of an angle is 0 if the angle is either 0 or π, and non-zero otherwise.

The sign of a real angle θ is non-zero if and only if θ ≠ 0 and θ ≠ π.


theorem MeasureTheory.Measure.map_prod_map :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : MeasurableSpace γ] {δ : Type u_7} [inst_3 : MeasurableSpace δ] {f : α → β} {g : γ → δ}
      (μa : MeasureTheory.Measure α) (μc : MeasureTheory.Measure γ) [inst_4 : MeasureTheory.SFinite μa]
      [inst_5 : MeasureTheory.SFinite μc],
      Measurable f →
        Measurable g →
          MeasureTheory.Measure.prod (MeasureTheory.Measure.map f μa) (MeasureTheory.Measure.map g μc) =
            MeasureTheory.Measure.map (Prod.map f g) (MeasureTheory.Measure.prod μa μc) :=
  by sorry

The theorem `MeasureTheory.Measure.map_prod_map` states that for any measurable spaces α, β, γ, δ, any measurable functions `f` from α to β and `g` from γ to δ, and any σ-finite measures `μa` on α and `μc` on γ, the measure of the product of the spaces resulting from mapping `f` and `g` under `μa` and `μc` respectively, is equal to the measure resulting from mapping the product function `Prod.map f g` under the product measure of `μa` and `μc`. Essentially, it states that the pushing forward measures with a pair of functions then taking the product measure is the same as taking the product measure then pushing forward with the product function.

For measurable spaces α, β, γ, δ, measurable functions f : α → β and g : γ → δ, and σ-finite measures μa on α and μc on γ, the measure of the product of the spaces α × γ under the measures μa ⊤μc and μa ⊤ (Prod.map f g) μc is equal.


theorem MvPolynomial.eval_mul :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p q : MvPolynomial σ R} {f : σ → R},
      (MvPolynomial.eval f) (p * q) = (MvPolynomial.eval f) p * (MvPolynomial.eval f) q :=
  by sorry

This theorem, `MvPolynomial.eval_mul`, states that for any commutative semiring `R`, any type `σ`, any two multivariate polynomials `p` and `q` over `σ` with coefficients in `R`, and any evaluation function `f` from `σ` into `R`, the evaluation of the product of `p` and `q` at `f` is equal to the product of the evaluations of `p` and `q` at `f`. In other words, the polynomial evaluation function preserves multiplication. This mirrors the well-known property of function evaluations: $(p*q)(f) = p(f) * q(f)$ for multivariate polynomials $p$ and $q$ and a function evaluation $f$.

For any commutative semiring R, type σ, multivariate polynomials p and q over σ with coefficients in R, and evaluation function f from σ into R, the product of the evaluations of p and q at f equals the evaluation of the product of p and q at f.


theorem CategoryTheory.Functor.map_sub :
    ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
      [inst_1 : CategoryTheory.Category.{u_5, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
      [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
      [inst_4 : CategoryTheory.Functor.Additive F] {X Y : C} {f g : X ⟶ Y}, F.map (f - g) = F.map f - F.map g :=
  by sorry

This theorem states that for any two morphisms `f` and `g` from `X` to `Y` in a preadditive category `C`, and any additive functor `F` from `C` to another preadditive category `D`, the functor `F` preserves the subtraction of morphisms. That is, applying `F` to the subtraction of `f` and `g` (`f - g`) gives the same result as subtracting the images of `f` and `g` under `F` (`F.map f - F.map g`).

For any preadditive functor F between preadditive categories, and morphisms f, g in C, F(f - g) = F(f) - F(g).


theorem Continuous.div_const :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [inst_2 : ContinuousMul G₀]
      {f : α → G₀} [inst_3 : TopologicalSpace α], Continuous f → ∀ (y : G₀), Continuous fun x => f x / y :=
  by sorry

This theorem states that for any type `α`, any type `G₀` that is a divisional inverse monoid (a kind of algebraic structure) with a topology (a concept from topology, the study of space) and a continuous multiplication operation, and any function `f` from `α` to `G₀`, if `f` is a continuous function (a concept from calculus), then the function that maps every element `x` of type `α` to `f(x) / y` is also continuous for any `y` in `G₀`. This is a theorem about the continuity of functions under division by a constant in topological division inverse monoids.

Given a topological divisional inverse monoid `G₀` and a continuous function `f` from type `α` to `G₀`, the function `x ↦ f(x) / y` is continuous for any fixed `y` in `G₀`.


theorem Complex.sin_pi : Complex.sin ↑Real.pi = 0 := by sorry

This theorem states that the sine of pi in the complex plane is zero. To be more precise, when the real number pi, represented as `Real.pi` in Lean, is considered as a complex number (by the coercion `↑Real.pi`), the application of the complex sine function to it (`Complex.sin ↑Real.pi`) results in zero. It utilizes the mathematical concept that the sine of pi is zero in both the real number system and the complex number system.

The complex sine function evaluates to zero at the real number pi. (`Complex.sin ↑Real.pi = 0`)


theorem Nat.bits_append_bit : ∀ (n : ℕ) (b : Bool), (n = 0 → b = true) → Nat.bits (Nat.bit b n) = b :: Nat.bits n := by
  sorry

The theorem `Nat.bits_append_bit` states that for any natural number `n` and any boolean `b`, if `n` is zero implies `b` is true, then the binary representation of the natural number obtained by appending `b` to `n` (using the `Nat.bit` function) is equal to the list that has `b` as the head followed by the binary representation of `n` (using the `Nat.bits` function). In other words, it asserts that the `Nat.bits` function correctly reflects the addition of a binary digit to a natural number using the `Nat.bit` function, assuming that when the natural number is zero, the added digit is one.

For any natural number `n` and boolean `b`, if `n = 0` implies `b = true`, then `Nat.bit (Nat.succ n) b` equals the cons of `b` with the list `Nat.bits n`.


theorem List.map_singleton : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (a : α), List.map f [a] = [f a] := by sorry

The theorem `List.map_singleton` states that for all types `α` and `β`, and for any function `f` from `α` to `β` and any element `a` of type `α`, applying the `List.map` function with `f` to a list containing just `a` returns a new list containing `f(a)`. In other words, mapping a function over a singleton list results in a new singleton list where the function has been applied to the sole element of the original list. This theorem describes an elementary behavior of the `List.map` function in Lean 4.

For any type `α`, type `β`, function `f : α → β`, and element `a : α`, `List.map f [a] = [f a]`.


theorem Function.nmem_mulSupport :
    ∀ {α : Type u_1} {M : Type u_5} [inst : One M] {f : α → M} {x : α}, x ∉ Function.mulSupport f ↔ f x = 1 := by sorry

The theorem `Function.nmem_mulSupport` states that for any types `α` and `M`, given a function `f` of type `α` to `M`, and an element `x` of type `α`, `x` is not in the `mulSupport` of `f` if and only if the function `f` applied to `x` equals `1`. In other words, a point `x` does not belong to the set of points where `f(x)` is not equal to `1` (the `mulSupport` of `f`) if and only if `f(x) = 1`.

For any function `f` from type `α` to `M`, `x` is not in the support of the multiplication action of `f` if and only if `f(x) = 1`.


theorem supClosed_supClosure : ∀ {α : Type u_2} [inst : SemilatticeSup α] {s : Set α}, SupClosed (supClosure s) := by
  sorry

The theorem `supClosed_supClosure` states that for every type `α` that forms a join-semilattice (denoted as `SemilatticeSup α`), and for every set `s` of this type `α`, the closure under join operation (`supClosure`) of the set `s` is supremum-closed (`SupClosed`). In other words, for any two elements `a` and `b` in the closure of the set, their supremum (join) also belongs to the closure. This is a property of join-semilattices, where every subset generates a sub-structure that is also a join-semilattice.

For every join-semilattice type `α` and set `s` of elements in `α`, the supremum of any two elements in the supremum-closure of `s` lies in the supremum-closure of `s`.


Dist.ext

theorem Dist.ext : ∀ {α : Type u_3} (x y : Dist α), dist = dist → x = y := by sorry

This theorem, `Dist.ext`, states that for all types `α` and any two distributions `x` and `y` of type `α`, if their distance functions are equal, then the two distributions `x` and `y` are also equal. Here, `dist` refers to a function that calculates the distance between two points. This theorem is fundamental in the context of probability distributions or any other mathematical constructs where a notion of distance is defined.

If for all types `α` and distributions `x` and `y` of type `α` in Lean 4, `dist x y` equals a constant `c`, then `x` equals `y`.


theorem ite_eq_left_iff :
    ∀ {α : Sort u_1} {a b : α} {P : Prop} [inst : Decidable P], (if P then a else b) = a ↔ ¬P → b = a := by sorry

This theorem, `ite_eq_left_iff`, states that for any type `α`, any two values `a` and `b` of that type, and any proposition `P`, given that `P` is decidable, `(if P then a else b) = a` if and only if `¬P` implies that `b = a`. In simpler terms, it's stating that if deciding `P` results in `a`, then it's equivalent to saying that if `P` is not true, then `b` must be equal to `a`.

For any type `α`, proposition `P` decidable over it, values `a, b : α`, if and only if `(if P then a else b) = a` is equivalent to `¬P → b = a`.


theorem map_mem_closure :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set X}
      {x : X} {t : Set Y}, Continuous f → x ∈ closure s → Set.MapsTo f s t → f x ∈ closure t :=
  by sorry

This theorem states that for any types `X` and `Y` with respective topological spaces, any function `f` from `X` to `Y`, any set `s` of type `X`, any element `x` of type `X`, and any set `t` of type `Y`; if `f` is continuous, `x` is in the closure of `s`, and `f` maps elements of `s` to `t`, then `f(x)` is in the closure of `t`. In other words, the image under a continuous function of a point in the closure of a set is in the closure of the image of that set. This is a property linking continuity, closure of sets, and the mapping of sets under functions in topological spaces.

If a continuous function maps a point in the closure of a set to a set, then the image of that point is in the closure of the image of the set.


theorem CategoryTheory.Faithful.of_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E)
      [inst_3 : CategoryTheory.Faithful (CategoryTheory.Functor.comp F G)], CategoryTheory.Faithful F :=
  by sorry

The theorem `CategoryTheory.Faithful.of_comp` states that in the context of category theory, given any three categories `C`, `D`, and `E`, and two functors `F` from `C` to `D` and `G` from `D` to `E`, if the composition of the functors `F` and `G` is faithful (which means that it reflects monomorphisms), then the functor `F` is also faithful.

If functors `F: C -> D` and `G: D -> E` have faithful composition `F ∘ G`, then `F` is faithful.


theorem Polynomial.natDegree_X_pow_sub_C :
    ∀ {R : Type u} [inst : Ring R] [inst_1 : Nontrivial R] {n : ℕ} {r : R},
      Polynomial.natDegree (Polynomial.X ^ n - Polynomial.C r) = n :=
  by sorry

The theorem `Polynomial.natDegree_X_pow_sub_C` states that for any ring `R` which is nontrivial, and for any natural number `n` and any element `r` of `R`, the degree of the polynomial (when forced to ℕ) resulting from the subtraction of the constant polynomial `r` from the polynomial `X^n` (which is the variable polynomial `X` raised to the power `n`) equals `n`. This essentially means that the degree of the polynomial `X^n - r` is `n`.

For any nontrivial ring R and natural number n, the degree of X^n - r is n.


theorem Filter.exists_mem_subset_iff : ∀ {α : Type u} {f : Filter α} {s : Set α}, (∃ t ∈ f, t ⊆ s) ↔ s ∈ f := by sorry

The theorem `Filter.exists_mem_subset_iff` states that for any type `α`, any filter `f` on `α`, and any set `s` of elements of type `α`, there exists a set `t` that is a member of the filter `f` and is a subset of `s` if and only if `s` is a member of the filter `f`. In other words, this theorem is describing a condition that a set `s` is in a filter `f` if and only if there's another set `t` in `f` that is contained within `s`.

A set belongs to a filter if and only if there exists a subset of it that is in the filter.


theorem Finset.card_attach : ∀ {α : Type u_1} {s : Finset α}, (Finset.attach s).card = s.card := by sorry

The theorem `Finset.card_attach` asserts that, for any finite set `s` of a certain type `α`, the cardinality (or size) of the set that results from attaching `s` (which consists of the elements of `s` as an element of the subtype `{x // x ∈ s}`), is equal to the cardinality of `s` itself. In other words, attaching a finite set to its elements doesn't change its size.

For any finite set `s` of type `α`, the cardinality of the set `{x // x ∈ s}` is equal to the cardinality of `s`.


theorem Primrec.nat_double : Primrec fun n => 2 * n := by sorry

The theorem `Primrec.nat_double` states that the function which doubles a natural number is primitive recursive. In other words, if you take a natural number and multiply it by 2, the resulting function is guaranteed to be primitive recursive, meaning there is an algorithm that can compute it using a finite number of simple operations. The "Primrec" in the theorem's name refers to the property of being primitive recursive.

The function that doubles a natural number is a primitive recursive function.


theorem Subgroup.coe_mul : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (x y : ↥H), ↑(x * y) = ↑x * ↑y := by sorry

This theorem is stating that, for any type `G` that has an instance of a group structure, and for any subgroup `H` of `G`, the multiplication of two elements `x` and `y` in `H` (viewed as elements of the larger group `G` through the injection `↑`) is the same as their multiplication within the subgroup. In other words, the process of lifting the subgroup elements to the larger group does not affect the result of the multiplication.

For any group `G` and subgroup `H`, and all `x, y ∈ H`, the multiplication `x * y` in `G` agrees with the multiplication `x * y` within `H`.


theorem Set.mul_singleton : ∀ {α : Type u_2} [inst : Mul α] {s : Set α} {b : α}, s * {b} = (fun x => x * b) '' s := by
  sorry

The theorem `Set.mul_singleton` states that for any type `α` equipped with a multiplication operation, and for any set `s` of elements of type `α` and an element `b` of type `α`, the multiplication of the set `s` and the singleton set `{b}` results in a set that contains the product of each element of `s` with `b`. Here `s * {b}` denotes the set that contains the product of each element of `s` with `b`, and `(fun x => x * b) '' s` is the image of the set `s` under the function that multiplies each element by `b`.

For any type `α` with multiplication and any set `s �ябряα` and element `b ∈ α`, `s * {b} = {x * b | x ∈ s}`.


theorem CategoryTheory.Limits.coprod.inl_map_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z) {Z_1 : C} (h : Y ⨿ Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.map f g) h) =
        CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl h) :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.inl_map_assoc` states that for any category `C`, given objects `W`, `X`, `Y`, `Z` and `Z_1` in `C` and morphisms `f: W ⟶ Y`, `g: X ⟶ Z`, and `h: Y ⨿ Z ⟶ Z_1` where `⨿` denotes the coproduct and provided that the binary coproducts `W ⨿ X` and `Y ⨿ Z` exist, the composition of morphisms `CategoryTheory.Limits.coprod.inl` and `(CategoryTheory.Limits.coprod.map f g) ≫ h` is equal to the composition of `f` and `CategoryTheory.Limits.coprod.inl ≫ h`. In simpler terms, it asserts a specific associativity property of the morphism composition in the context of category theory, specifically involving the inclusion map from the first component of the coproduct and the map from the binary coproduct.

For any objects `W`, `X`, `Y`, `Z`, and `Z_1` in a category `C` with binary coproducts `W ⨿ X` and `Y ⨿ Z`, and given morphisms `f: W ⟶ Y`, `g: X ⟶ Z`, and `h: Y ⨿ Z ⟶ Z_1`, the composition of `f`, `CategoryTheory.Limits.coprod.inl`, and `h` equals the composition of `CategoryTheory.Limits.coprod.inl`, `g`, and `h`.


theorem local_compact_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : LocallyCompactSpace X] {x : X} {n : Set X},
      n ∈ nhds x → ∃ s ∈ nhds x, s ⊆ n ∧ IsCompact s :=
  by sorry

The theorem `local_compact_nhds` states that for any given topological space `X` which is locally compact, any point `x` in `X`, and any set `n` that is a neighborhood of `x`, there exists a set `s` which is also a neighborhood of `x`, such that `s` is a subset of `n` and `s` is compact. In other words, in a locally compact topological space, for every neighborhood of every point, we can find a compact neighborhood contained within it.

In a locally compact topological space, every neighborhood of a point contains a compact neighborhood of that point.


theorem Cardinal.mk_toNat_eq_card :
    ∀ {α : Type u} [inst : Fintype α], Cardinal.toNat (Cardinal.mk α) = Fintype.card α := by sorry

This theorem states that for any finite type `α` (i.e., a type `α` with a `Fintype` instance), the function `Cardinal.toNat` applied to the cardinality of `α` (i.e., `Cardinal.mk α`) is equal to the cardinality of `α` as computed by the `Fintype.card` function. In other words, when dealing with finite types, the function `Cardinal.toNat` when composed with `Cardinal.mk` gives the same result as `Fintype.card`. This ensures the coherence between two different methods of computing the cardinality of a finite type.

For any finite type `α`, the cardinalities computed by `Cardinal.mk α` and `Fintype.card α` are equal, i.e., `Cardinal.toNat (Cardinal.mk α) = Fintype.card α`.


theorem CategoryTheory.Limits.biprod.inl_desc_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) {Z : C} (h : W ⟶ Z),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.desc f g) h) =
        CategoryTheory.CategoryStruct.comp f h :=
  by sorry

This theorem states that, in any category `C` with zero morphisms and binary biproducts, for any objects `W`, `X`, `Y`, and `Z` in `C`, and for any morphisms `f : X ⟶ W`, `g : Y ⟶ W`, and `h : W ⟶ Z`, the composition of the inclusion of `X` into the first summand of the binary biproduct `X ⊞ Y` with the composition of the morphism described by `f` and `g` and `h` is the same as the composition of `f` and `h`. In more mathematical language, it states that `(inl ∘ (desc(f, g) ∘ h)) = (f ∘ h)`, where `inl` is the inclusion into the first summand of a binary biproduct, `desc` is a morphism described by `f` and `g`, and `∘` denotes the composition of morphisms.

In any category with zero morphisms and binary biproducts, the inclusion of an object into the first summand of the biproduct and the composition of morphisms from it to the target object through a common intermediate object is equal to the direct composition of these morphisms.


/-- `MulAction.period m a` is definitionally equal to `Function.minimalPeriod (m • ·) a`.  -/
theorem MulAction.period_eq_minimalPeriod :
    ∀ {α : Type v} {M : Type u} [inst : Monoid M] [inst_1 : MulAction M α] {m : M} {a : α},
      MulAction.period m a = Function.minimalPeriod (fun x => m • x) a :=
  by sorry

The theorem `MulAction.period_eq_minimalPeriod` states that for any type `α`, any type `M` with a monoid structure, any action of `M` on `α`, and any elements `m` of type `M` and `a` of type `α`, the period of the multiplicative action of `m` on `a` is exactly the same as the minimal period of `a` under the endomorphism defined by the action of `m`. In other words, the period of the action of `m` on `a` is the smallest number of times you need to apply the action of `m` to `a` to get back to `a` itself, and this number is the same as the minimal period of `a` under the action of `m`.

For any monoid action on type `α`, the period of an element `a` under the multiplicative action of an element `m` equals the minimal period of `a` under the endomorphism defined by `m`.


theorem Int.even_iff_not_odd : ∀ {n : ℤ}, Even n ↔ ¬Odd n := by sorry

The theorem `Int.even_iff_not_odd` states that for every integer `n`, `n` is even if and only if `n` is not odd. Here, an integer `n` is defined as "even" if it can be expressed as the sum of two identical integers, and "odd" if it can be written in the form `2*k + 1` for some integer `k`. This theorem formalizes a basic property of integers in the mathematical field of number theory.

An integer is even if and only if it is not odd, where an integer is even if it can be expressed as the sum of two identical integers, and odd if it can be written in the form 2*k + 1 for some integer k.


theorem Polynomial.coeff_reflect :
    ∀ {R : Type u_1} [inst : Semiring R] (N : ℕ) (f : Polynomial R) (i : ℕ),
      Polynomial.coeff (Polynomial.reflect N f) i = Polynomial.coeff f ((Polynomial.revAt N) i) :=
  by sorry

This theorem states that for any semiring `R`, any natural number `N`, any polynomial `f` of type `R`, and any natural number `i`, the coefficient of `X^i` in the reflection of `f` about `N` is equal to the coefficient of `X^((N-i) or i)` in `f`. The reflection of `f` about `N` is a new polynomial where the terms of `f` with exponent `[0, ..., N]` now have exponent `[N, ..., 0]`. The function `revAt` returns `N-i` if `i ≤ N`, otherwise it returns `i`.

For any semiring `R`, polynomial `f` of type `R`, natural numbers `N` and `i`, the coefficient of `X^(i)` in `f` is equal to the coefficient of `X^(N \|^ i \|^)` in the reflected polynomial `f` about `N`.


theorem Traversable.traverse_map :
    ∀ {t : Type u → Type u} [inst : Traversable t] [inst_1 : LawfulTraversable t] {F : Type u → Type u}
      [inst_2 : Applicative F] [inst_3 : LawfulApplicative F] {α β γ : Type u} (f : β → F γ) (g : α → β) (x : t α),
      traverse f (g <$> x) = traverse (f ∘ g) x :=
  by sorry

The theorem `Traversable.traverse_map` states that for any type `t` that is `Traversable` and obeys the laws of a `LawfulTraversable`, for any `Applicative` functor `F` that obeys the laws of a `LawfulApplicative`, and for any three types `α`, `β`, and `γ`, if you have a function `f` from `β` to `F γ` and a function `g` from `α` to `β`, then traversing over the result of mapping `g` over `x` (where `x` is of type `t α`) with function `f` is equivalent to traversing over `x` with the composite function `f ∘ g`. This is a property of traversable functors in functional programming and is closely related to the "map" operation of functors and the "traverse" operation of traversable functors.

For any `Traversable t` and `LawfulTraversable t`, `LawfulApplicative F`, functions `f : β -> F γ` and `g : α -> β`, the traversal of `f . map g` over `t x` equals the traversal of `x` with `f . (.) g`.


theorem Complex.sinh_neg : ∀ (x : ℂ), Complex.sinh (-x) = -Complex.sinh x := by sorry

This theorem states that the complex hyperbolic sine function, `Complex.sinh`, satisfies the property of oddness. Specifically, for any complex number `x`, the value of `Complex.sinh` at `-x` is equal to the negation of the value of `Complex.sinh` at `x`. In mathematical language, this can be written as sinh(-x) = -sinh(x) for all complex numbers x.

The complex hyperbolic sine function satisfies the property of oddness, that is, sinh(-x) = -sinh(x) for all complex numbers x.


theorem AkraBazziRecurrence.differentiableAt_smoothingFn :
    ∀ {x : ℝ}, 1 < x → DifferentiableAt ℝ AkraBazziRecurrence.smoothingFn x := by sorry

The theorem `AkraBazziRecurrence.differentiableAt_smoothingFn` states that for all real numbers `x` where `x` is greater than 1, the function `smoothingFn` from the Akra-Bazzi recurrence, defined as `1 / log(n)`, is differentiable at `x`. Differentiability means that at the point `x`, the function has a derivative, which can possibly be non-unique. In practical terms, the function smoothly changes at these points without any sharp turns or breaks.

For `x` being a real number greater than 1, the function `1 / log(x)` from the Akra-Bazzi recurrence is differentiable at `x`.


Finset.Colex.toColex.injEq

theorem Finset.Colex.toColex.injEq :
    ∀ {α : Type u_3} (ofColex ofColex_1 : Finset α),
      ({ ofColex := ofColex } = { ofColex := ofColex_1 }) = (ofColex = ofColex_1) :=
  by sorry

This theorem states that for any type `α` and any two finite sets `ofColex` and `ofColex_1` of this type, the equality of the two single-field structures `{ ofColex := ofColex }` and `{ ofColex := ofColex_1 }` is equivalent to the equality of `ofColex` and `ofColex_1` themselves. In other words, two such structures are equal if and only if their single field `ofColex` are equal.

For any type `α` and finite sets `ofColex` and `ofColex_1` of type `α`, the single-field structures `{ ofColex := ofColex }` and `{ ofColex := ofColex_1 }` are equal if and only if `ofColex` and `ofColex_1` are equal.


theorem Set.mem_insert_iff : ∀ {α : Type u} {x a : α} {s : Set α}, x ∈ insert a s ↔ x = a ∨ x ∈ s := by sorry

This theorem, `Set.mem_insert_iff`, states that for any type `α` and any elements `x` and `a` of type `α`, and any set `s` of type `α`, the proposition `x` is in the set formed by inserting `a` into `s` if and only if `x` is equal to `a` or `x` is in `s`. In other words, it explains the condition for an element to be in a set to which a new element has been added.

For any set `s` of type `α` and any `x, a` in `α`, `x ∈ insert a s` if and only if `x = a` or `x ∈ s`.


theorem CategoryTheory.Idempotents.Karoubi.p_comm :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      (f : CategoryTheory.Idempotents.Karoubi.Hom P Q),
      CategoryTheory.CategoryStruct.comp P.p f.f = CategoryTheory.CategoryStruct.comp f.f Q.p :=
  by sorry

The theorem `CategoryTheory.Idempotents.Karoubi.p_comm` states that for any category `C` and any two objects `P` and `Q` in the Karoubi envelope (which is a category formed from `C` by adding new morphisms) of `C`, and for any morphism `f` from `P` to `Q` in this Karoubi envelope, the composition of the projection morphism of `P` and `f` is equal to the composition of `f` and the projection morphism of `Q`. In other words, the projection morphisms commute with any morphism in the Karoubi envelope of the category.

For any category C and objects P, Q in its Karoubi envelope, and any morphism f from P to Q in the Karoubi envelope, the composition of the projection of P with f equals the composition of f with the projection of Q.


Asymptotics.IsBigOWith.add

theorem Asymptotics.IsBigOWith.add :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c₁ c₂ : ℝ}
      {g : α → F} {l : Filter α} {f₁ f₂ : α → E'},
      Asymptotics.IsBigOWith c₁ l f₁ g →
        Asymptotics.IsBigOWith c₂ l f₂ g → Asymptotics.IsBigOWith (c₁ + c₂) l (fun x => f₁ x + f₂ x) g :=
  by sorry

The theorem `Asymptotics.IsBigOWith.add` states that for any two functions `f₁` and `f₂` from a type `α` to a semi-normed add commutative group `E'`, and a function `g` from `α` into a normed type `F`, if `f₁` is "Big O" of `g` with constant `c₁` and `f₂` is "Big O" of `g` with constant `c₂` at a filter `l` on `α`, then the function `f₁ + f₂` is "Big O" of `g` at the same filter `l` with constant `c₁ + c₂`. Here, "Big O" is defined in the sense of Landau's notation, that is, `f` is "Big O" of `g` if the norm of `f` is eventually (for `l`) bounded by the product of a constant and the norm of `g`.

If functions `f₁` and `f₂` are Big O of a function `g` with constants `c₁` and `c₂`, respectively, at a filter `l` on `α` over a semi-normed add commutative group `E'`, then their sum `f₁ + f₂` is Big O of `g` with constant `c₁ + c₂` at the same filter `l`.


theorem Nat.bit1_ne_zero : ∀ (n : ℕ), bit1 n ≠ 0 := by sorry

The theorem `Nat.bit1_ne_zero` states that for every natural number `n`, the binary representation `bit1 n` is not equal to zero. In other words, the binary representation with an odd number of 1's `bit1 n` (which equates to `2n + 1` in natural numbers) will never be zero for any natural number `n`.

For all natural numbers n, the first binary digit of n, represented as `bit1 n` in Lean, is non-zero. Equivalently, the binary representation of a natural number has an odd number of 1's.


theorem Uniform.tendsto_nhds_right :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {f : Filter β} {u : β → α} {a : α},
      Filter.Tendsto u f (nhds a) ↔ Filter.Tendsto (fun x => (a, u x)) f (uniformity α) :=
  by sorry

This theorem, `Uniform.tendsto_nhds_right`, states that for any types `α` and `β` with `α` being a uniform space, any filter `f` on `β`, any function `u` from `β` to `α`, and any element `a` of `α`, the function `u` converges to `a` under the filter `f` (denoted as `Filter.Tendsto u f (nhds a)`) if and only if the function that maps each element of `β` to the pair `(a, u x)` tends towards the uniformity on `α` under the filter `f` (denoted as `Filter.Tendsto (fun x => (a, u x)) f (uniformity α)`). In other words, the convergence of `u` to `a` in the topological sense (using neighborhoods of `a`) is equivalent to the convergence in the uniform space sense (using the uniformity filter on `α`).

For a uniform space `α` and a filter `f` on `β`, a function `u` from `β` to `α` converges to an element `a` in `α` under filter `f` if and only if the function that maps each element `x` in `β` to the pair `(a, u x)` tends towards the uniformity on `α` under filter `f`.


OrderAddMonoidHom.ext

theorem OrderAddMonoidHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
      [inst_3 : AddZeroClass β] {f g : α →+o β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem, titled `OrderAddMonoidHom.ext`, states that for any two order-preserving additive monoid homomorphisms `f` and `g` from a preordered additive monoid `α` to another preordered additive monoid `β`, if for every element 'a' in `α`, the result of applying `f` to 'a' is equal to the result of applying `g` to 'a', then `f` and `g` are the same homomorphism. This is essentially a uniqueness property, asserting that two such homomorphisms are uniquely determined by their action on elements of `α`.

If two order-preserving additive homomorphisms from a preordered additive monoid to another with the same action on elements agree on all elements, then they are equal.


/-- Union of an indexed family of sets `s : ι → Set α` is equal to the union of the unions
of finite subfamilies. This version assumes `ι : Type*`. See also `iUnion_eq_iUnion_finset'` for
a version that works for `ι : Sort*`.  -/
theorem Set.iUnion_eq_iUnion_finset : ∀ {α : Type u_2} {ι : Type u_5} (s : ι → Set α), ⋃ i, s i = ⋃ t, ⋃ i ∈ t, s i :=
  by sorry

The theorem `Set.iUnion_eq_iUnion_finset` states that for any type `α` and any index type `ι`, the union of an indexed family of sets `s : ι → Set α` is equivalent to the union of the unions of finite subfamilies of `ι`. In other words, it states that taking the union over all sets indexed by `ι` is the same as taking the union over all finite subsets of `ι`, and then taking the union over all sets indexed by elements in these subsets. This version of the theorem assumes `ι : Type*`. There is a similar version of this theorem, `iUnion_eq_iUnion_finset'`, that works for `ι : Sort*`.

For any type `α` and index type `ι:*`, the indexed union of sets `s : ι → Set α` equals the union of unions of finite subsets of `ι` over their elements.


theorem CategoryTheory.whiskerRight_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      {G H K : CategoryTheory.Functor C D} (α : G ⟶ H) (β : H ⟶ K) (F : CategoryTheory.Functor D E),
      CategoryTheory.whiskerRight (CategoryTheory.CategoryStruct.comp α β) F =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight α F) (CategoryTheory.whiskerRight β F) :=
  by sorry

The theorem `CategoryTheory.whiskerRight_comp` in Lean 4 states that for any three categories `C`, `D`, and `E`, and any three functors `G`, `H`, and `K` from `C` to `D` (with corresponding morphisms `α : G ⟶ H` and `β : H ⟶ K`), and any functor `F` from `D` to `E`, the operation of "whiskering on the right" by `F` preserves the composition of morphisms. This means that whiskering the composition of `α` and `β` is the same as the composition of the whiskerings of `α` and `β`. In mathematical notation, we have `(α ≫ β) ⊗ F = (α ⊗ F) ≫ (β ⊗ F)`, where `≫` denotes composition and `⊗` denotes whiskering on the right.

For any functors G, H, K from category C to categories D and E, and functor F from D to E, the right whiskering of the composition of G and H with F is equal to the composition of the right whiskerings of G and H with F. In other words, (G ⊗ F) ≫ (H ⊗ F) = (G ≫ H) ⊗ F.


theorem Denumerable.ofEquiv_ofNat :
    ∀ (α : Type u_3) {β : Type u_4} [inst : Denumerable α] (e : β ≃ α) (n : ℕ),
      Denumerable.ofNat β n = e.symm (Denumerable.ofNat α n) :=
  by sorry

The theorem `Denumerable.ofEquiv_ofNat` states that for any type `α` and a type `β` equivalent to `α` (denoted as `β ≃ α`), and for any natural number `n`, the `n`-th element of `β` as indexed by the denumerable decoding is equal to the inverse of the equivalent mapping applied to the `n`-th element of `α`. In other words, applying the bijective function `e` to map elements from `α` to `β` doesn't affect the `n`-th element of the denumerable decoding.

For any denumerable types `α` and `β` equivalent to `α`, and any bijective function `e : α ≃ β`, the `n`-th element of `β` as indexed by the denumerable decoding equals the inverse of `e` applied to the `n`-th element of `α`.


theorem Function.Periodic.nat_mul_sub_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c x : α} [inst : Ring α],
      Function.Periodic f c → ∀ (n : ℕ), f (↑n * c - x) = f (-x) :=
  by sorry

The theorem `Function.Periodic.nat_mul_sub_eq` states that for any type `α` and `β`, any function `f` from `α` to `β`, any elements `c` and `x` of type `α`, and any natural number `n`, if `α` is a ring and `f` is a periodic function with period `c`, then `f` applied to the difference of the product of `n` and `c` and `x` is equal to `f` applied to the negation of `x`. In mathematical terms, it says that if `f` is a periodic function with period `c`, then for every natural number `n`, we have `f(n*c - x) = f(-x)`.

If `f` is a periodic function on a ring with period `c`, then `f(nc - x) = f(-x)` for all natural numbers `n` and elements `x`.


BoundedContinuousFunction.bounded

theorem BoundedContinuousFunction.bounded :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      (f : BoundedContinuousFunction α β), ∃ C, ∀ (x y : α), dist (f x) (f y) ≤ C :=
  by sorry

This theorem states that for every bounded continuous function `f` from a topological space `α` to a pseudo metric space `β`, there exists a real number `C` such that the distance between `f(x)` and `f(y)` for any `x` and `y` in `α` is less than or equal to `C`. In other words, the distances between all pairs of values of a bounded continuous function are bounded by some constant.

Every bounded continuous function from a topological space to a pseudo metric space has a uniform bound on its values.


theorem SimpleGraph.Colorable.chromaticNumber_eq_sInf :
    ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ},
      SimpleGraph.Colorable G n → SimpleGraph.chromaticNumber G = ↑(sInf {n' | SimpleGraph.Colorable G n'}) :=
  by sorry

The theorem `SimpleGraph.Colorable.chromaticNumber_eq_sInf` states that for any type `V`, any simple graph `G` of type `V`, and any natural number `n`, if the graph `G` can be colored with at most `n` colors i.e., `G` is `n`-colorable, then the chromatic number of the graph `G` is equal to the infimum of the set of all natural numbers `n'` such that `G` is `n'`-colorable. In other words, the chromatic number of a simple graph is the smallest number of colors needed to color the graph, in terms of the least element of the set of all natural numbers that color the graph.

The chromatic number of a simple graph is the smallest natural number sufficient for its coloring.


IsBoundedBilinearMap.contDiff

/-- Bilinear functions are `C^∞`.
 -/
theorem IsBoundedBilinearMap.contDiff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {b : E × F → G} {n : ℕ∞},
      IsBoundedBilinearMap 𝕜 b → ContDiff 𝕜 n b :=
  by sorry

This theorem states that for any non-trivial normed field 𝕜, if `b` is a bounded bilinear map from a product of two normed spaces (E, F) over 𝕜 to another normed space G over 𝕜, then `b` is continuously differentiable of any order `n`. In simpler terms, the theorem asserts that all bounded bilinear maps are infinitely differentiable.

For any non-trivial normed field 𝕜, every bounded bilinear map from the product of two normed spaces over 𝕜 to another normed space over 𝕜 is infinitely differentiable.


theorem Nat.mul_left_comm : ∀ (n m k : ℕ), n * (m * k) = m * (n * k) := by sorry

This theorem states that for any three natural numbers `n`, `m`, and `k`, the operation of multiplication is left-commutative. In mathematical terms, this means that multiplying `n` with the product of `m` and `k` (`n * (m * k)`) is equal to multiplying `m` with the product of `n` and `k` (`m * (n * k)`).

For all natural numbers n, m, and k, n * (m * k) = m * (n * k).


Nat.Coprime.mul

theorem Nat.Coprime.mul : ∀ {m k n : ℕ}, Nat.Coprime m k → Nat.Coprime n k → Nat.Coprime (m * n) k := by sorry

The theorem `Nat.Coprime.mul` states that for any natural numbers `m`, `k`, and `n`, if `m` and `k` are coprime (i.e., their greatest common divisor (gcd) is 1), and `n` and `k` are also coprime, then `m * n` and `k` are coprime. In other words, the product of two numbers each of which is coprime to a third number, is itself coprime to that third number.

If `m` and `k`, as well as `n` and `k`, are pairwise coprime, then `m * n` and `k` are coprime.


theorem CategoryTheory.BraidedCategory.braiding_tensor_right :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      [inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : C),
      (β_ X (CategoryTheory.MonoidalCategory.tensorObj Y Z)).hom =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (β_ X Y).hom Z)
            (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator Y X Z).hom
              (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Y (β_ X Z).hom)
                (CategoryTheory.MonoidalCategory.associator Y Z X).inv))) :=
  by sorry

The theorem `CategoryTheory.BraidedCategory.braiding_tensor_right` states that for any type `C` which has a category structure, a monoidal category structure, and a braided category structure, and for any three objects `X`, `Y`, and `Z` in `C`, the braiding of `X` with the tensor product of `Y` and `Z` is equal to a specific composition of morphisms that involve associators, whiskering, and other braiding operations. This composition involves first inverting the associator of `X`, `Y`, and `Z`, then whisking the braiding of `X` and `Y` on the right with `Z`, then applying the associator of `Y`, `X`, and `Z`, then whisking the braiding of `X` and `Z` on the left with `Y`, and finally inverting the associator of `Y`, `Z`, and `X`. This theorem is a part of the mathematical structure known as "braided monoidal categories" which play a key role in many areas of mathematics and theoretical physics, including knot theory and quantum field theory.

In a braided monoidal category, the braiding of objects X, Y, and Z is equal to the composition of whiskering the braiding of X and Y on the right with Z, associators, and whiskering the braiding of X and Z on the left with Y, inverted associators.


/-- The measurable space structures generated by independent pi-systems are independent.  -/
theorem ProbabilityTheory.kernel.IndepSets.indep :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {m1 m2 m : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {p1 p2 : Set (Set Ω)},
      m1 ≤ m →
        m2 ≤ m →
          IsPiSystem p1 →
            IsPiSystem p2 →
              m1 = MeasurableSpace.generateFrom p1 →
                m2 = MeasurableSpace.generateFrom p2 →
                  ProbabilityTheory.kernel.IndepSets p1 p2 κ μ → ProbabilityTheory.kernel.Indep m1 m2 κ μ :=
  by sorry

This theorem states that if we have two subsets (`p1` and `p2`) of the power set of a set `Ω` that are π-systems (i.e., for any two sets in the collection, their non-empty intersection is also in the collection) and independent with respect to a Markov kernel `κ` and a measure `μ`, then the measurable space structures generated by these π-systems are also independent with respect to the same kernel and measure.

In other words, if `p1` and `p2` define independent structures under the Markov kernel `κ` and the measure `μ`, then the measurable spaces created from `p1` and `p2` also maintain this independence under the same kernel and measure. Here, independence of two sets of sets means that for any sets selected from each set of sets, the kernel of their intersection equals the product of their individual kernels almost everywhere with respect to the measure `μ`.

If two π-systems `p1` and `p2` of a measurable space `(Ω, Σ, μ)` are independent with respect to a Markov kernel `κ`, then the σ-algebras they generate are independent under `κ` and `μ`.


theorem Polynomial.map_ne_zero_iff :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] {f : R →+* S},
      Function.Injective ⇑f → (Polynomial.map f p ≠ 0 ↔ p ≠ 0) :=
  by sorry

The theorem `Polynomial.map_ne_zero_iff` states that, for any types `R` and `S` with `R` and `S` being semirings, any polynomial `p` of type `R`, and any ring homomorphism `f` from `R` to `S`, if the ring homomorphism `f` is injective (meaning that if `f` maps two different elements to the same element, then those two elements must have been the same), then the polynomial `p` is not the zero polynomial if and only if the polynomial obtained by mapping `p` across the ring homomorphism `f` is not the zero polynomial. In other words, a polynomial `p` is nonzero if and only if its image under an injective ring homomorphism `f` is nonzero.

For any injective ring homomorphism between semirings `f` and polynomial `p` over ring `R`, `p` is not the zero polynomial if and only if the image of `p` under `f` is not the zero polynomial in `S`.


theorem Associated.mul_left :
    ∀ {α : Type u_1} [inst : Monoid α] (a : α) {b c : α}, Associated b c → Associated (a * b) (a * c) := by sorry

The `Associated.mul_left` theorem states that for any type `α` that forms a `Monoid`, given an element `a` of the `Monoid` and two other elements `b` and `c` such that `b` and `c` are `Associated`, the product of `a` and `b` is `Associated` with the product of `a` and `c`. In other words, in a `Monoid`, if two elements are `Associated`, meaning that one can be obtained by multiplying the other by a unit, then premultiplying both elements by the same factor preserves this `Associated` relationship.

If `a` is a unit in a monoid `α`, and `b` and `c` are associated elements, then `a * b` is associated with `a * c`.


theorem Primrec.vector_ofFn :
    ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] {n : ℕ} {f : Fin n → α → σ},
      (∀ (i : Fin n), Primrec (f i)) → Primrec fun a => Vector.ofFn fun i => f i a :=
  by sorry

The theorem `Primrec.vector_ofFn` states that for any types `α` and `σ` that have a primitive encoding (denoted by `Primcodable α` and `Primcodable σ`), for any natural number `n`, and for any function `f` that takes a finite ordinal (an element of `Fin n`) and an element of type `α` and returns an element of type `σ`, if each function `f i` (for each finite ordinal `i`) is primitive recursive, then the function that takes an element of type `α` and returns a vector of length `n` (each element of the vector is the result of applying `f i` to the element of `α`) is also primitive recursive.

If `α` and `σ` are types with primitive encodings, `n` is a natural number, and `f` is a primitive recursive function that takes a finite ordinal and an element of `α` to produce an element of `σ`, then the function that maps an element of `α` to the vector of length `n` where the `i`-th component is `f (i x)` is also primitive recursive.


theorem ENNReal.div_le_div : ∀ {a b c d : ENNReal}, a ≤ b → d ≤ c → a / c ≤ b / d := by sorry

This theorem states that for any four extended nonnegative real numbers `a`, `b`, `c`, and `d`, if `a` is less than or equal to `b` and `d` is less than or equal to `c`, then the division of `a` by `c` is less than or equal to the division of `b` by `d`. In mathematical notation, this is equivalent to saying that if $a \leq b$ and $d \leq c$, then $\frac{a}{c} \leq \frac{b}{d}$.

If $a \leq b$ and $c > 0$ with $d > 0$, then $\frac{a}{c} \leq \frac{b}{d}$.


theorem Polynomial.toFinsupp_add :
    ∀ {R : Type u} [inst : Semiring R] (a b : Polynomial R), (a + b).toFinsupp = a.toFinsupp + b.toFinsupp := by sorry

This theorem states that for any semiring `R` and any two polynomials `a` and `b` over `R`, the 'toFinsupp' representation of the sum of `a` and `b` is equal to the sum of the 'toFinsupp' representations of `a` and `b` individually. Here, 'toFinsupp' refers to a conversion of a polynomial to a certain type of representation called a finite support function. Essentially, it's saying that converting a sum of polynomials to this representation behaves the same way as summing the individual converted polynomials.

For any semiring `R` and polynomials `a` and `b` over `R`, the conversion of their sum to finite support representations equals the sum of the individual finite support representations.


theorem left_comm : ∀ {α : Type u} (f : α → α → α), Commutative f → Associative f → LeftCommutative f := by sorry

The theorem `left_comm` states that for any type `α` and any binary function `f` on this type, if `f` is commutative and associative, then `f` is left commutative. In other words, for any two elements `a₁` and `a₂` of type `α` and any element `b` of some type `β`, the result of applying `f` to `a₁` and then applying `f` to the result and `a₂` is the same as applying `f` to `a₂` and then applying `f` to `a₁` and the result. This encapsulates the property that `f` can be rearranged or swapped in its arguments without changing the result when nested to the left.

If a binary function `f` on type `α` is commutative and associative, then for all `a₁, a₂ : α` and `b : β`, `f a₁ (f a₂ b) = f a₂ (f a₁ b)`.


Matroid.Base.indep

theorem Matroid.Base.indep : ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M.Base B → M.Indep B := by sorry

This theorem states that for any type `α`, any Matroid `M` defined on this type, and any set `B` of elements of type `α`, if `B` is a base of the Matroid `M` (`M.Base B`), then `B` is also an independent set in `M` (`M.Indep B`). In other words, every base of a Matroid is also an independent set in the Matroid.

For any Matroid M over type α, if B is a base of M then B is an independent set in M.


theorem CategoryTheory.Limits.Types.FilteredColimit.eqvGen_quot_rel_of_rel :
    ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
      (x y : (j : J) × F.obj j),
      CategoryTheory.Limits.Types.FilteredColimit.Rel F x y → EqvGen (CategoryTheory.Limits.Types.Quot.Rel F) x y :=
  by sorry

The theorem `CategoryTheory.Limits.Types.FilteredColimit.eqvGen_quot_rel_of_rel` states that for any category 'J' and a functor 'F' from 'J' to Type 'u', and for any two objects 'x' and 'y' in the product of 'J' and the object of 'F', if 'x' and 'y' are related by `CategoryTheory.Limits.Types.FilteredColimit.Rel` of 'F', then 'x' and 'y' are also related by the equivalence generated by `CategoryTheory.Limits.Types.Quot.Rel` of 'F'. In simpler terms, this theorem is a part of the construction of colimits in a category of types, stating that any pair of objects that are related in the filtered colimit are also related in the quotient type that implements the colimit.

For any category 'J' and functor 'F' from 'J' to Type 'u', if two objects in the product of 'J' and 'F' are related by the filtered colimit relation of 'F', then they are related by the equivalence relation generated by the quotient relation of 'F'.


theorem Int.neg_add_cancel_left : ∀ (a b : ℤ), -a + (a + b) = b := by sorry

This theorem, `Int.neg_add_cancel_left`, states that for all integers `a` and `b`, the sum of the negation of `a` and the sum of `a` and `b` is equal to `b`. In mathematical terms, it's saying that for all integers $a$ and $b$, $-a + (a + b) = b$. This aligns with the principle that adding a number and its negation results in zero, effectively canceling each other out.

For all integers `a` and `b`, the negation of `a` plus the sum of `a` and `b` equals `b`. In mathematical notation, $-a + (a + b) = b$.


theorem IsPGroup.iff_card :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fintype G],
      IsPGroup p G ↔ ∃ n, Fintype.card G = p ^ n :=
  by sorry

The theorem `IsPGroup.iff_card` states that for any natural number `p` and any type `G` with a group structure, where `p` is a prime number and `G` is finite, `G` is a p-group (i.e., every element of the group has an order that is a power of `p`) if and only if there exists a natural number `n` such that the cardinality of `G` (i.e., the number of elements in `G`) is equal to `p` raised to the power of `n`. In mathematical terms, a group is a p-group if and only if its order is a power of a prime `p`.

A finite group of prime order `p` is a `p`-group if and only if its cardinality equals `p^n` for some natural number `n`.


Ultrafilter.unique

theorem Ultrafilter.unique :
    ∀ {α : Type u} (f : Ultrafilter α) {g : Filter α}, g ≤ ↑f → autoParam (Filter.NeBot g) _auto✝ → g = ↑f := by sorry

The theorem `Ultrafilter.unique` states that for any type `α`, given an ultrafilter `f` of type `α`, and any other filter `g` on `α` that is less than or equal to `f` and is not the bottom filter (as mandated by the `autoParam` gadget), then `g` has to be equal to `f`. In other words, this theorem is about the uniqueness of ultrafilters: if there is a filter that is not the bottom filter and is included in an ultrafilter, then they have to be the same.

For any type `α` and ultrafilter `f` on `α`, if there exists a filter `g` on `α` that is strictly below `f` and not the bottom filter, then `g = f`.


theorem neg_surjective : ∀ {G : Type u_3} [inst : InvolutiveNeg G], Function.Surjective Neg.neg := by sorry

This theorem, named `neg_surjective`, states that for any type `G` with an `InvolutiveNeg` structure (meaning negation on `G` is an involution, i.e., applying it twice gives back the original element), the negation function `Neg.neg` is surjective. In other words, every element of type `G` can be expressed as the negation of some other element in `G`. This is typically true in structures like groups, rings, and fields where each element has an additive inverse.

For any type `G` equipped with an InvolutiveNeg structure, the negation function `Neg.neg` is a surjection.


theorem isLUB_singleton : ∀ {α : Type u} [inst : Preorder α] {a : α}, IsLUB {a} a := by sorry

The theorem `isLUB_singleton` asserts that for any type `α` equipped with a preorder, and any element `a` of type `α`, `a` is a least upper bound of the singleton set `{a}`. In other words, `a` is the smallest element that is greater than or equal to every element in the set `{a}`, which in this case, only contains `a` itself.

For any preordered type `α` and element `a` in `α`, `a` is the least upper bound of the singleton set `{a}`.


theorem ContinuousMultilinearMap.opNorm_nonneg :
    ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
      [inst_4 : SeminormedAddCommGroup G] [inst_5 : NormedSpace 𝕜 G] (f : ContinuousMultilinearMap 𝕜 E G), 0 ≤ ‖f‖ :=
  by sorry

This theorem states that for any continuous multilinear map `f` from a nontrivially normed field `𝕜` and semi-normed additive commutative group `E i` to another semi-normed additive commutative group `G` with `E i` and `G` being normed spaces over `𝕜`, the operator norm of `f` is always nonnegative, i.e., `0 ≤ ‖f‖`. This is a property of norms in general, which are always nonnegative.

For any continuous multilinear map from a nontrivially normed field into two semi-normed additive commutative groups, where these spaces are normed over the field, the operator norm is nonnegative.


theorem List.eraseP_cons_of_neg :
    ∀ {α : Type u_1} {a : α} {l : List α} (p : α → Bool), ¬p a = true → List.eraseP p (a :: l) = a :: List.eraseP p l :=
  by sorry

The theorem `List.eraseP_cons_of_neg` states that for any type `α`, an element `a` of type `α`, a list `l` of elements of type `α`, and a predicate `p` that takes an input of type `α` and outputs a Boolean, if `p a` is not true, then the result of applying the `eraseP` function to the list that results from consing `a` onto `l` (i.e., `a :: l`) is equal to `a` consed onto the result of applying `eraseP` to `l` itself. In other words, if the predicate does not hold for the head of the list, we can move it outside of the `eraseP` operation.

If `p(a)` is false, then `List.eraseP (a :: l) = a :: List.eraseP l`.


theorem MeasureTheory.measure_compl :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasurableSet s → ↑↑μ s ≠ ⊤ → ↑↑μ sᶜ = ↑↑μ Set.univ - ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.measure_compl` states that for any type `α`, any measurable space `m` on `α`, any measure `μ` in that measurable space, and any set `s` of type `α` that is measurable in the aforementioned measurable space, as long as the measure of the set `s` is not infinite, then the measure of the complement of the set `s` equals the measure of the universal set subtracted by the measure of the set `s`. In mathematical terms, this is stated as: if `s` is a measurable subset of a measurable space and μ(s) ≠ ∞, then μ(sᶜ) = μ(U) - μ(s), where U is the universal set, sᶜ is the complement of `s`, and μ() denotes the measure of a set.

For any measurable set `s` in a measurable space with finite measure `μ`, the measure of its complement is equal to the measure of the universal set minus the measure of `s`.


theorem compl_iSup :
    ∀ {α : Type u} {ι : Sort w} [inst : CompleteBooleanAlgebra α] {f : ι → α}, (iSup f)ᶜ = ⨅ i, (f i)ᶜ := by sorry

The theorem `compl_iSup` states that for any type `α` that forms a complete Boolean algebra, and a function `f` from an arbitrary type `ι` to `α`, the complement of the indexed supremum of `f` is equal to the infimum of the complements of the values of `f`. In other words, the theorem expresses the property that the negation of the supremum of a set equals to the infimum of the negations of the elements in that set, in the context of a complete Boolean algebra.

In a complete Boolean algebra, the complement of the supremum of a function is equal to the infimum of the complements of its values.


theorem Metric.closedBall_zero : ∀ {γ : Type w} [inst : MetricSpace γ] {x : γ}, Metric.closedBall x 0 = {x} := by sorry

The theorem `Metric.closedBall_zero` states that for any type `γ` equipped with a metric space structure and any element `x` of `γ`, the closed ball of radius 0 around `x` is exactly the set containing `x` alone. In other words, in any metric space, the set of all points at a distance less than or equal to 0 from a given point `x` is just the set `{x}` itself.

In any metric space, the closed ball with radius 0 around a point is equal to the singleton set containing that point.


/-- **Alias** of the reverse direction of `Order.lt_succ_iff_not_isMax`. -/
theorem Order.lt_succ_of_not_isMax :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, ¬IsMax a → a < Order.succ a := by sorry

This theorem states that for any type `α` that has a preorder and successor order structure, if an element `a` of type `α` is not a maximal element (as defined by `IsMax`), then `a` is strictly less than the successor of `a` (as defined by `Order.succ`). In other words, if `a` is not the greatest element in its set, then the next element in the order is strictly greater than `a`.

If `α` is a type with a preorder and successor structure, and `a` is an element of `α` that is not maximal, then `Order.succ a > a`.


theorem MeasureTheory.AEStronglyMeasurable.restrict :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β},
      MeasureTheory.AEStronglyMeasurable f μ → ∀ {s : Set α}, MeasureTheory.AEStronglyMeasurable f (μ.restrict s) :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.restrict` states that for any types `α` and `β`, any measurable space `m` on `α`, any measure `μ` on `α`, any topological space structure on `β`, any function `f` from `α` to `β`, and any set `s` of `α`, if `f` is almost everywhere strongly measurable with respect to the measure `μ`, then `f` is also almost everywhere strongly measurable with respect to the measure `μ` restricted to the set `s`. In other words, the property of being almost everywhere strongly measurable is preserved under the restriction of the measure to a subset of the domain.

If `f` is almost everywhere strongly measurable with respect to measure `μ` on type `α`, then `f` is almost everywhere strongly measurable with respect to the restriction of `μ` to any subset `s` of `α`.


theorem Rack.left_cancel :
    ∀ {R : Type u_1} [inst : Rack R] (x : R) {y y' : R}, Shelf.act x y = Shelf.act x y' ↔ y = y' := by sorry

This theorem, `Rack.left_cancel`, states that for any type `R` with a `Rack` structure, and for any elements `x`, `y`, and `y'` of `R`, the action of `x` on `y` being equal to the action of `x` on `y'` is equivalent to `y` being equal to `y'`. In other words, it asserts the left-cancellative property of the operation `Shelf.act` in a rack: if `x * y = x * y'`, then `y = y'`.

For any rack `R` and elements `x`, `y`, `y'` in `R`, `x * y = x * y'` implies `y = y'`.


theorem List.append_cancel_left : ∀ {α : Type u_1} {as bs cs : List α}, as ++ bs = as ++ cs → bs = cs := by sorry

This theorem states that for any type `α` and any three lists of that type (`as`, `bs`, and `cs`), if the result of appending `bs` to `as` equals the result of appending `cs` to `as`, then `bs` must equal `cs`. In other words, if we have two equal lists that were formed by appending different lists to the same list, then those different lists must have been equal. This is a property of the list append operation in Lean.

If for any type `α`, `as : list α`, `bs, cs : list α`, `as ++ bs = as ++ cs` implies `bs = cs`, then `append` is commutative over lists of type `α`.


theorem IsUnit.mul_right_inj : ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, IsUnit a → (a * b = a * c ↔ b = c) := by
  sorry

The theorem `IsUnit.mul_right_inj` states that for any monoid `M`, and any elements `a`, `b`, and `c` of `M`, if `a` is a unit (i.e., it has a two-sided inverse), then the equality `a * b = a * c` implies `b = c`. In other words, for a unit `a` in a monoid, multiplication by `a` is injective on the right.

If `a` is a unit in a monoid `M`, then `a * b = a * c` implies `b = c`.


theorem Stream'.WSeq.destruct_nil : ∀ {α : Type u}, Stream'.WSeq.destruct Stream'.WSeq.nil = Computation.pure none := by
  sorry

The theorem `Stream'.WSeq.destruct_nil` states that for all types `α`, destructing an empty weak sequence (`Stream'.WSeq.nil`) results in a computation that immediately terminates with the result `none`. This is regardless of the particular type `α` of the elements that the sequence could potentially hold. Essentially, the theorem connects the concept of destructing an empty sequence in the weak sequence space with the concept of a computation that yields `none` instantaneously.

For all types `α`, destructing an empty weak sequence `Stream'.WSeq.nil` in Lean 4 yields an immediate computation of `none`.