theorem MeasureTheory.zero_memℒp :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E], MeasureTheory.Memℒp 0 p μ :=
  by sorry

This theorem states that for any type `α` equipped with a measurable space structure `m0`, any extended nonnegative real number `p`, and any measure `μ` on `α`, the zero function (which maps every element of `α` to the zero of a normed additively commutative group `E`) is a member of `ℒp`. In other words, the zero function is almost everywhere strongly measurable and its `p`-th power norm is finite if `p` is less than infinity, or its essential supremum is finite if `p` equals infinity.

The zero function is an element of the Lebesgue space `ℒp(α, m0)` for any measurable space `(α, m0)` and normed additively commutative group `E` with respect to any measure `μ` and any `p ∈ [0, ∞)`.


theorem Finset.inf_cons :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} {f : β → α} {b : β}
      (h : b ∉ s), Finset.inf (Finset.cons b s h) f = f b ⊓ Finset.inf s f :=
  by sorry

The theorem `Finset.inf_cons` states that for any types `α` and `β`, given an instance of the semilattice structure for `α`, an order-top structure for `α`, a finite set `s` of type `β`, a function `f` from `β` to `α`, and an element `b` of type `β` which is not in `s`, the infimum of the union of `{b}` and `s` (i.e., `Finset.cons b s h`) under the function `f` is equal to the infimum of `f` at `b` and the infimum of `s` under `f`. In mathematical terms, this says that $\inf \{f(b)\} \cup \inf \{f(s)\} = f(b) \land \inf \{f(s)\} $, where $\land$ represents the infimum (or greatest lower bound) operation in the semilattice.

For any semilattice and order-topped type `α`, finite set `s` of type `β`, function `f` from `β` to `α`, and `b` not in `s`, the infimum of `f` at `b` and the infimum of `s` under `f` is equal to the infimum of `f` applied to the set `{b} ∪ s`.


theorem CircleDeg1Lift.map_add_one : ∀ (f : CircleDeg1Lift) (x : ℝ), f (x + 1) = f x + 1 := by sorry

This theorem states that for any Circle Degree 1 Lift `f` and any real number `x`, the function `f` applied to `(x + 1)` is equal to `f x + 1`. In other words, adding 1 to the input of the Circle Degree 1 Lift function is equivalent to adding 1 to the output of the function when applied to the original input.

For any Circle Degree 1 Lift function $f$ and real number $x$, we have $f(x+1) = f(x) + 1$.


/-- In a complete lattice, the limsup of a function is the infimum over sets `s` in the filter
of the supremum of the function over `s`  -/
theorem Filter.limsup_eq_iInf_iSup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {u : β → α},
      Filter.limsup u f = ⨅ s ∈ f, ⨆ a ∈ s, u a :=
  by sorry

The theorem `Filter.limsup_eq_inf_sup` states that in a complete lattice, the limit superior (limsup) of a function is equal to the greatest lower bound (infimum) over all sets `s` in the filter of the least upper bound (supremum) of the function over `s`. In other words, for any complete lattice `α`, any filter `f` of `β`, and any function `u` mapping `β` to `α`, the limsup of `u` with respect to `f` is the infimum of the set of all supremums of `u` over all `s` in `f`.

In a complete lattice, the limit superior of a function with respect to a filter is the infimum of the supremums of the function over all sets in the filter.


theorem Real.cos_arctan_pos : ∀ (x : ℝ), 0 < Real.cos (Real.arctan x) := by sorry

The theorem `Real.cos_arctan_pos` states that the cosine of the arctangent of any real number is always positive. In other words, for all real numbers `x`, the value of `cos(arctan(x))` is greater than zero.

For all real numbers x, cos(arctan(x)) > 0.


theorem Submonoid.mem_bot : ∀ {M : Type u_1} [inst : MulOneClass M] {x : M}, x ∈ ⊥ ↔ x = 1 := by sorry

This theorem states that for any type `M` equipped with the structure of a `MulOneClass` (a structure containing multiplication and a multiplicative identity, which is `1`), a certain element `x` belongs to the smallest submonoid (denoted as `⊥`) if and only if `x` is equal to the multiplicative identity (`1`). In other words, the smallest submonoid of a `MulOneClass` is simply the set containing the multiplicative identity.

In a `MulOneClass` type, the smallest submonoid equals the set of multiplicative identities.


/-- The composition of Frobenius and Verschiebung is multiplication by `p`.  -/
theorem WittVector.frobenius_verschiebung :
    ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (x : WittVector p R),
      WittVector.frobenius (WittVector.verschiebung x) = x * ↑p :=
  by sorry

The theorem `WittVector.frobenius_verschiebung` states that for every natural number `p` that is prime, and for any commutative ring `R`, the composition of the Frobenius and Verschiebung operations on any Witt vector `x` from `R` with `p` components, is equivalent to multiplying the Witt vector `x` by `p`. In other words, applying the Frobenius operation to the result of the Verschiebung operation on `x` gives the same result as multiplying `x` by `p`.

For any prime number p and commutative ring R, the composition of the Verschiebung and Frobenius operations on a Witt vector x of length p over R equals x multiplied by p.


/-- In a normed ring, the powers of an element x with `‖x‖ < 1` tend to zero.  -/
theorem tendsto_pow_atTop_nhds_zero_of_norm_lt_one :
    ∀ {R : Type u_4} [inst : NormedRing R] {x : R}, ‖x‖ < 1 → Filter.Tendsto (fun n => x ^ n) Filter.atTop (nhds 0) :=
  by sorry

The theorem `tendsto_pow_atTop_nhds_zero_of_norm_lt_one` states that for any normed ring `R` and any element `x` of `R`, if the norm of `x` is less than 1, then the powers of `x` tend to zero as `n` goes to infinity. In other words, for larger and larger values of `n`, `x^n` gets closer and closer to zero. This is described within the context of filters and neighborhoods, using the `Filter.Tendsto` predicate to express the limit, with `Filter.atTop` representing `n` going to infinity, and `nhds 0` representing the neighborhood of 0.

For any normed ring `R` and element `x` of norm less than 1, the sequence `{x^n : n is nat}` converges to zero as `n` approaches infinity.


/-- See note [partially-applied ext lemmas]  -/
theorem IsLocalization.ringHom_ext :
    ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] ⦃j k : S →+* P⦄,
      RingHom.comp j (algebraMap R S) = RingHom.comp k (algebraMap R S) → j = k :=
  by sorry

The theorem `IsLocalization.ringHom_ext` states that for any commutative semiring `R`, a submonoid `M` of `R`, a commutative semiring `S` that is a localization of `R` at `M`, and any other commutative semiring `P`, if there are two ring homomorphisms `j` and `k` from `S` to `P` such that the composition of `j` or `k` with the algebra map from `R` to `S` are equal, then `j` and `k` have to be equal. In other words, this theorem asserts the uniqueness of a ring homomorphism when extended by a fixed algebra map.

Given commutative semirings R, a submonoid M of R, a localization S of R at M, and commutative semirings P, if two ring homomorphisms j and k from S to P make their compositions with the algebra map from R to S equal, then j = k.


/-- An `affineCombination` with sum of weights 1 is in the
`affineSpan` of an indexed family, if the underlying ring is
nontrivial.  -/
theorem affineCombination_mem_affineSpan :
    ∀ {ι : Type u_1} {k : Type u_2} {V : Type u_3} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] [inst_4 : Nontrivial k] {s : Finset ι} {w : ι → k},
      (Finset.sum s fun i => w i) = 1 →
        ∀ (p : ι → P), (Finset.affineCombination k s p) w ∈ affineSpan k (Set.range p) :=
  by sorry

This theorem states that for any indexed family of points `p : ι → P` in an affine space `P`, with `k` being the underlying nontrivial ring, `V` the associated vector space and `ι` indexing the family, if we consider a finite set `s` of indices and a weight function `w : ι → k` such that the sum of weights over `s` equals 1, then the affine combination `Finset.affineCombination k s p w` lies in the affine span of the range of points `p`. In other words, any affine combination of points from the family where the weights sum to 1 is contained in the smallest affine subspace containing the points in the family.

Given an indexed family of points `p : ι → P` in an affine space `P` over a nontrivial ring `k`, any finite set `s` of indices and a weight function `w : ι → k` with `∑ i in s w i = 1`, the affine combination `Finset.affineCombination k s p w` lies in the affine span of `{p i | i ∈ s}`.


theorem FreeAlgebra.algebraMap_leftInverse :
    ∀ {R : Type u_1} [inst : CommSemiring R] {X : Type u_2},
      Function.LeftInverse ⇑FreeAlgebra.algebraMapInv ⇑(algebraMap R (FreeAlgebra R X)) :=
  by sorry

The theorem `FreeAlgebra.algebraMap_leftInverse` states that for any type `R` with a commutative semiring structure and any type `X`, the function `FreeAlgebra.algebraMapInv` is a left inverse to the function `algebraMap R (FreeAlgebra R X)`. In other words, for any element `x` of type `R`, applying `algebraMap R (FreeAlgebra R X)` to `x` and then applying `FreeAlgebra.algebraMapInv` to the result will return `x`. This is denoted in Lean 4 as `Function.LeftInverse ⇑FreeAlgebra.algebraMapInv ⇑(algebraMap R (FreeAlgebra R X))`.

For any commutative semiring `R` and type `X`, the function `FreeAlgebra.algebraMapInv` is the left inverse of `algebraMap R` on `FreeAlgebra R X`, i.e., `algebraMap R ∘ FreeAlgebra.algebraMapInv = id` on elements of `FreeAlgebra R X`.


theorem RatFunc.algebraMap_ne_zero :
    ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] {x : Polynomial K},
      x ≠ 0 → (algebraMap (Polynomial K) (RatFunc K)) x ≠ 0 :=
  by sorry

The theorem `RatFunc.algebraMap_ne_zero` states that for any commutative ring `K` which is also an integral domain, and any non-zero polynomial `x` with coefficients in `K`, the algebra map from the ring of polynomials over `K` to the field of rational functions over `K`, applied to `x`, is also not zero. Essentially, this means that non-zero polynomials map to non-zero elements in the field of rational functions when using the algebra map.

For any commutative integral domain K and non-zero polynomial x in K[X], the algebra map from K[X] to K(X) maps x to a non-zero rational function.


theorem Rat.cast_div : ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α] (m n : ℚ), ↑(m / n) = ↑m / ↑n :=
  by sorry

This theorem, `Rat.cast_div`, states that for any type `α`, given that `α` has a division ring structure and its characteristic is zero, the division of any two rational numbers `m` and `n` (expressed as `m / n`) when cast to `α` is equal to the division of `m` cast to `α` and `n` cast to `α` (expressed as `↑m / ↑n`). Essentially, this theorem ensures that the division operation in the rational numbers can be correctly translated into the division operation in other numeric types with a division ring structure and zero characteristic.

For any type `α` with a division ring structure and characteristic zero, the operation `m / n` of rational numbers is equal to the operation `↑m / ↑n` of `α`, where `m` and `n` are rational numbers and `↑` denotes the coercion from rational numbers to `α`.


theorem Real.log_lt_log : ∀ {x y : ℝ}, 0 < x → x < y → Real.log x < Real.log y := by sorry

The theorem `Real.log_lt_log` states that for any two real numbers `x` and `y`, if `x` is positive and less than `y`, then the real logarithm of `x` is less than the real logarithm of `y`. This means that the real logarithm is a strictly increasing function on the positive real numbers.

For all real numbers `x` and `y` with `x > 0` and `x < y`, we have `log x < log y` where `log` denotes the real logarithm function.


theorem MeasureTheory.Measure.coe_smul :
    ∀ {α : Type u_1} {R : Type u_6} [inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal]
      {_m : MeasurableSpace α} (c : R) (μ : MeasureTheory.Measure α), ↑↑(c • μ) = c • ↑↑μ :=
  by sorry

This theorem states that for any type `α`, type `R`, and a measurable space `_m` on `α`, given a scalar multiplication operation on `R` and `ENNReal`, and a scalar tower structure established over `R`, `ENNReal`, and `ENNReal`, for any real number `c` and a measure `μ` from the measure theory over `α`, the measure of the scalar multiplication of `c` and `μ` when lifted twice to an extended nonnegative real number (using the `↑↑` notation) equals the scalar multiplication of `c` and the twice lifted measure of `μ`. In other words, the process of lifting the result of scalar multiplication to the extended nonnegative real numbers is consistent with performing scalar multiplication after lifting to the extended nonnegative real numbers. This is an important property that maintains the consistency of operations in measure theory when extended to nonnegative real numbers.

For any measure `μ` on a measurable space `(_,_m)` over type `α`, scalar multiplication `c • μ` and lifting to extended nonnegative reals `↑↑(c • μ)` commute, i.e., `↑↑(c • μ) = c • ↑↑(μ)`.


theorem Finset.gcd_congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α]
      {s₁ s₂ : Finset β} {f g : β → α}, s₁ = s₂ → (∀ a ∈ s₂, f a = g a) → Finset.gcd s₁ f = Finset.gcd s₂ g :=
  by sorry

The theorem `Finset.gcd_congr` states that for any two types `α` and `β` where `α` is a `CancelCommMonoidWithZero` and `NormalizedGCDMonoid`, given two finite sets `s₁` and `s₂` of type `β` and two functions `f` and `g` from `β` to `α`, if `s₁` is equal to `s₂` and, for every element `a` in `s₂`, `f(a)` is equal to `g(a)`, then the greatest common divisor of the set `s₁` under function `f` is equal to the greatest common divisor of the set `s₂` under function `g`. In other words, if two finite sets are the same and the functions applied to their elements yield the same results, then the greatest common divisors of the resulting sets are also equal.

If two finite sets of elements from a `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` type, and two functions mapping these elements to the type yield equal sets with equal images for each element, then the greatest common divisors of the sets under these functions are equal.


theorem Polynomial.mem_roots' :
    ∀ {R : Type u} {a : R} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
      a ∈ Polynomial.roots p ↔ p ≠ 0 ∧ Polynomial.IsRoot p a :=
  by sorry

The theorem `Polynomial.mem_roots'` states that for any type `R`, any instance `a` of type `R`, and any polynomial `p` of type `Polynomial R`, `a` is a root of `p` (i.e., is in the multiset of roots of `p` denoted by `Polynomial.roots p`) if and only if two conditions hold: the polynomial `p` is not the zero polynomial (`p ≠ 0`) and `a` is indeed a root of `p` (denoted by `Polynomial.IsRoot p a` which means the evaluation of `p` at `a` equals zero). Here, `R` is assumed to be a commutative ring and also an integral domain.

For any commutative ring and integral domain R, an element a of R is a root of a non-zero polynomial p in R if and only if a is in the multiset of roots of p.


/-- Cantor's intersection theorem for `iInter`:
the intersection of a directed family of nonempty compact closed sets is nonempty.  -/
theorem IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed :
    ∀ {X : Type u} [inst : TopologicalSpace X] {ι : Type v} [hι : Nonempty ι] (t : ι → Set X),
      Directed (fun x x_1 => x ⊇ x_1) t →
        (∀ (i : ι), Set.Nonempty (t i)) →
          (∀ (i : ι), IsCompact (t i)) → (∀ (i : ι), IsClosed (t i)) → Set.Nonempty (⋂ i, t i) :=
  by sorry

Cantor's Intersection Theorem states that for a given directed family of nonempty, compact, and closed sets in a topological space, the intersection of all these sets is also nonempty.

In more detail, suppose we have a type `X` equipped with a topology, another type `ι` (which is not empty), and a function `t` that maps `ι` to sets of `X`. If the family of sets defined by `t` is directed by the subset relation (meaning that for any pair of sets in the family, there exists another set in the family that contains both), each of these sets is nonempty, each set is compact (meaning any nontrivial filter containing it has a cluster point in it), and each set is closed (in the topological sense), then the intersection over all these sets (represented by `(⋂ i, t i)`) is also nonempty.

Given a nonempty directed family of compact and closed sets in a topological space, their intersection is nonempty.


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

This theorem is a part of category theory in mathematics and it states that for any category `J`, with an instance `inst` of CategoryTheory.Category, and any category `C` with an instance `inst_1` of CategoryTheory.Category, given two functors `F` and `G` from `J` to `C`, a cocone `c` of `F` and `d` of `G`, if `c` is a colimit (`hc` being a proof of this) and a natural transformation `α` from `F` to `G` exists, then for any object `j` of `J` and any morphism `h` from the tip of cocone `d` to an object `Z` in `C`, the composite of the morphism `c.ι.app j` with the composite of the map of the colimit `hc` via `α` to `d` and `h` is equal to the composite of the application of `α` at `j` with the composite of the morphism `d.ι.app j` and `h`. In other words, it's a statement about the commutativity of a certain diagram in the category `C`.

Given functors F and G from category J to category C, a cocone (c, hc) of F and (d, hd) of G, a natural transformation α from F to G, and an object Z in C with a morphism h from d's tip to Z, if c is a colimit and α exists, then the composite of hc ∘ c.ι.app j with h is equal to α.app j ∘ hd.ι.app j for all objects j in J.


theorem hasFDerivAtFilter_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (c : F)
      (x : E) (L : Filter E), HasFDerivAtFilter (fun x => c) 0 x L :=
  by sorry

This theorem states that for any nontrivial normed field `𝕜`, normed add-commutative group `E`, normed space over `𝕜` and `E`, normed add-commutative group `F`, normed space over `𝕜` and `F`, a constant `c` from `F`, a point `x` from `E`, and a filter `L` on `E`, the function that maps any input to `c` has a derivative of zero at point `x` with respect to the filter `L`. In more mathematically precise terms, the constant function `f(x) = c` has a Frechet derivative of 0 at any point `x` in its domain, under any given filter on the domain.

For any nontrivial normed field `𝕜`, normed add-commutative groups `E` and `F`, normed space `E` over `𝕜` and `F`, constant `c` in `F`, point `x` in `E`, and filter `L` on `E`, the constant function `f(x) = c` has a Frechet derivative of 0 at `x` with respect to `L`.


theorem ZNum.cast_zero : ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : Add α] [inst_3 : Neg α], ↑0 = 0 :=
  by sorry

This theorem states that for any type `α` which has defined instances of `Zero`, `One`, `Add`, and `Neg`, the cast of the zero integer `0` to type `α` is equal to the zero element of type `α`. This essentially guarantees that the zero integer in the ZNum number system translates to the zero element in any other number system that has a concept of zero, one, addition, and negation.

For any type `α` with defined instances of `Zero`, `One`, `Add`, and `Neg`, the conversion of the integer zero to type `α` equals the zero element of `α`.


theorem isClosed_discrete :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : DiscreteTopology α] (s : Set α), IsClosed s := by sorry

This theorem states that for any type `α` that has a topology (i.e., it is a topological space) and for which the topology is discrete (i.e., every subset is open), any set `s` of elements of type `α` is a closed set. This means in such a space, it holds true that closure of any set is the set itself. The discrete topology is the finest topology you can put on a set, where every subset is open, and therefore, also closed.

In a discrete topological space, every subset is closed.


theorem RootPairing.coroot_root_two :
    ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
      [inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (i : ι),
      ((LinearMap.flip P.toLin) (P.coroot i)) (P.root i) = 2 :=
  by sorry

This theorem states that for any RootPairing `P` over types `ι`, `R`, `M`, and `N`, with `R` being a commutative ring, `M` and `N` being additive commutative groups and also `R`-modules, if you take the coroot associated with some index `i` from `P`, flip the linear map of `P`, and apply this map to the root associated with the same index `i`, you will always get 2.

For any RootPairing P over commutative rings R, additive commutative groups and R-modules M and N, the coroot at index i flipped and applied to the root at index i equals 2.


/-- A restatement of `Types.Limit.lift_π_apply` that uses `Pi.π` and `Pi.lift`.  -/
theorem CategoryTheory.Limits.Types.pi_lift_π_apply :
    ∀ {β : Type v} [inst : Small.{u, v} β] (f : β → Type u) {P : Type u} (s : (b : β) → P ⟶ f b) (b : β) (x : P),
      CategoryTheory.Limits.Pi.π f b (CategoryTheory.Limits.Pi.lift s x) = s b x :=
  by sorry

This theorem expresses a fundamental property of product objects in category theory, specifically for types. Given a family of types `f : β → Type u`, a type `P : Type u`, and a collection of morphisms `s : (b : β) → P ⟶ f b` (in this context, morphisms are functions from `P` to each `f b`), for any element `x : P` and index `b : β`, applying the morphism `CategoryTheory.Limits.Pi.lift s` to `x` and then projecting onto the `b`-th component (using `CategoryTheory.Limits.Pi.π f b`) is the same as directly applying the `b`-th morphism `s b` to `x`. In other words, lifting `x` into the product type and then projecting it back down to `f b` gives the same result as directly mapping `x` to `f b` using `s b`.

For any family of types `f : β → Type u`, type `P : Type u`, and morphisms `s : (b : β) → P → f b`, the application of `s b` to an element `x : P` is equal to the composition of lifting `x` to the product type `Π (b : β) f b` using `CategoryTheory.Limits.Pi.lift s`, and then projecting it back down to `f b` using `CategoryTheory.Limits.Pi.π`.


theorem Function.minimalPeriod_eq_one_iff_isFixedPt :
    ∀ {α : Type u_1} {f : α → α} {x : α}, Function.minimalPeriod f x = 1 ↔ Function.IsFixedPt f x := by sorry

This theorem states that for any function `f` mapping a type `α` to itself and any element `x` of type `α`, the minimal period of `x` under `f` is 1 if and only if `x` is a fixed point of `f`. In other words, `x` repeats its value every single step under the function `f` if and only if applying `f` to `x` results in `x` itself.

The element `x` of type `α` has minimal period 1 under the function `f:` `α -> α` if and only if `f(x) = x`.


Summable.subtype

theorem Summable.subtype :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [inst_2 : UniformAddGroup α]
      {f : β → α} [inst_3 : CompleteSpace α], Summable f → ∀ (s : Set β), Summable (f ∘ Subtype.val) :=
  by sorry

The theorem `Summable.subtype` states that for any types `α` and `β`, and a function `f` from `β` to `α`, where `α` is an additive commutative group, has a uniform space and is a uniform additive group, and also `α` is a complete space, if `f` is summable then for any set `s` of type `β`, the composition of `f` and the `Subtype.val` function (which retrieves the underlying element from a subtype) is also summable. In other words, if a function `f` has an (infinite) sum, then the function which applies `f` to the elements of any subset of its domain also has an (infinite) sum.

If `f` is a summable function from a set `β` to an additive commutative and complete group `α`, then the composition of `f` with the `Subtype.val` function is also summable.


theorem Mathlib.Order.MinMax._auxLemma.9 : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (min a b = a) = (a ≤ b) :=
  by sorry

This theorem, `Mathlib.Order.MinMax._auxLemma.9`, states that for any type `α` which has a `LinearOrder` instance, and for any two elements `a` and `b` of this type, the condition that the minimum of `a` and `b` is equal to `a` is equivalent to the condition that `a` is less than or equal to `b`. In other words, `min(a, b) = a` if and only if `a ≤ b`.

For any type with a LinearOrder instance, the minimum of two elements is equal to the first element if and only if the first element is less than or equal to the second.


List.IsRotated.refl

theorem List.IsRotated.refl : ∀ {α : Type u} (l : List α), l ~r l := by sorry

This theorem, `List.IsRotated.refl`, states that for any list `l` of elements of an arbitrary type `α`, `l` is rotated version of itself. This is a reflexivity property of the rotation relation for lists: every list is trivially a rotation of itself.

For any list `l` of type `α`, `l` is equivalent to any cyclic rotation of itself. (In Lean, this theorem is named `List.IsRotated.refl`.)


theorem Composition.one_le_blocks : ∀ {n : ℕ} (c : Composition n) {i : ℕ}, i ∈ c.blocks → 1 ≤ i := by sorry

This theorem, `Composition.one_le_blocks`, states that for any natural number `n` and any composition `c` of `n`, if `i` is an element in the list of blocks of `c`, then `i` is greater than or equal to 1. In other words, each block in a composition of a natural number is at least 1.

For any natural number `n` and composition `c` of `n`, every block `i` in `c` satisfies `i ≥ 1`.


theorem Mathlib.Combinatorics.SimpleGraph.Prod._auxLemma.5 :
    ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {H : SimpleGraph β} {x y : α × β},
      (G □ H).Adj x y = (G.Adj x.1 y.1 ∧ x.2 = y.2 ∨ H.Adj x.2 y.2 ∧ x.1 = y.1) :=
  by sorry

This theorem states that for any two vertex tuples `x` and `y` from the Cartesian product of two simple graphs `G` and `H`, `x` and `y` are adjacent in the Cartesian product graph `G □ H` if and only if `x` and `y` satisfy one of two conditions: either the first elements of `x` and `y` are adjacent in `G` and the second elements are equal, or the second elements of `x` and `y` are adjacent in `H` and the first elements are equal.

For two vertex tuples (x, y) from the Cartesian product of simple graphs G and H, they are adjacent in G □ H if and only if either the first components of x and y are adjacent in G or the second components are adjacent in H and their first components are equal.


theorem Hyperreal.ofSeq_surjective : Function.Surjective Hyperreal.ofSeq := by sorry

The theorem `Hyperreal.ofSeq_surjective` asserts that the function `Hyperreal.ofSeq`, which constructs a hyperreal number from a sequence of real numbers, is surjective. In other words, for every hyperreal number, there exists a sequence of real numbers such that the hyperreal number is the image of this sequence under the `Hyperreal.ofSeq` function.

For every hyperreal number, there exists a sequence of real numbers whose `Hyperreal.ofSeq` image equals that hyperreal number.


theorem Filter.tendsto_atBot :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {m : α → β} {f : Filter α},
      Filter.Tendsto m f Filter.atBot ↔ ∀ (b : β), ∀ᶠ (a : α) in f, m a ≤ b :=
  by sorry

The theorem `Filter.tendsto_atBot` states that for any type `α`, type `β` with a preorder structure, a function `m` mapping from `α` to `β`, and a filter `f` on `α`, the function `m` tends to `-∞` along `f` if and only if for every `b` of type `β`, it is eventually true in `f` that `(m a) ≤ b` for all `a` of type `α`. In other words, the function `m` approaches negative infinity at the rate defined by the filter `f` if and only if for any value `b` in `β`, there exists a point in `f` after which all function values `m a` are less than or equal to `b`.

For any preorder type `β`, function `m` from type `α` to `β`, and filter `f` on `α`, `m` tends to negative infinity along `f` if and only if for every `b` in `β`, there exists an element `a` in `f` such that `m a` ≤ `b`.


theorem lipschitzOnWith_iff_restrict :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β}
      {s : Set α}, LipschitzOnWith K f s ↔ LipschitzWith K (Set.restrict s f) :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with pseudo-emetric space structures, a nonnegative real number `K`, a function `f` from `α` to `β`, and a set `s` of `α`, the function `f` is Lipschitz continuous with constant `K` on the set `s` if and only if the function `f`, when restricted to the set `s`, is Lipschitz continuous with constant `K`. In mathematical terms, for all `x, y` in `s`, the extended distance between `f(x)` and `f(y)` is less than or equal to `K` times the extended distance between `x` and `y`. The restriction of the function `f` to the set `s` is the function that maps each element of `s` to its image under `f`.

Given pseudo-metric spaces `α` and `β` with types `α` and `β`, a nonnegative real number `K`, a Lipschitz continuous function `f` from `α` to `β` with constant `K`, and a set `s` of `α`, the restriction of `f` to `s` is Lipschitz continuous with constant `K` on `s`. That is, for all `x, y` in `s`, `d(f(x), f(y)) ≤ K * d(x, y)` where `d` denotes the extended distance.


theorem Int.add_mul_ediv_right : ∀ (a b : ℤ) {c : ℤ}, c ≠ 0 → (a + b * c) / c = a / c + b := by sorry

This theorem states that for any integers `a`, `b`, and `c` (where `c` is not zero), the operation of dividing the sum of `a` and the product of `b` and `c` by `c` is equal to the sum of the division of `a` by `c` and `b`. In mathematical terms, it's expressing the property `(a + b * c) / c = a / c + b` in the ring of integers.

The theorem asserts that for any integers `a`, `b`, and non-zero `c`, the quotient of the sum of `a` and the product of `b` and `c` by `c` equals the sum of the quotient of `a` by `c` and `b`. In other words, `(a + b * c) / c = a / c + b`.


theorem covariant_le_iff_contravariant_lt :
    ∀ (M : Type u_1) (N : Type u_2) (μ : M → N → N) [inst : LinearOrder N],
      (Covariant M N μ fun x x_1 => x ≤ x_1) ↔ Contravariant M N μ fun x x_1 => x < x_1 :=
  by sorry

This theorem, `covariant_le_iff_contravariant_lt`, is a universal statement for any two types `M` and `N`, and a function `μ` from `M` and `N` to `N`. It states that if `N` has a linear order, then the function `μ` is covariant with respect to the less than or equal to relation (i.e., if `n₁ ≤ n₂`, then `μ m n₁ ≤ μ m n₂` for all `m` in `M`) if and only if `μ` is contravariant with respect to the strictly less than relation (i.e., if `μ m n₁ < μ m n₂`, then `n₁ < n₂` for all `m` in `M`). Essentially, this theorem establishes a connection between the covariance of `μ` regarding the "less than or equal to" relation and its contravariance regarding the "strictly less than" relation in the context of a linear order.

For any functions `μ` from type `M` to type `N` over a linearly ordered type `N`, `μ` is covariant with respect to the less than or equal to relation if and only if it is contravariant with respect to the strict less than relation.


/-- Shiftleft on successor with multiple moved to outside.  -/
theorem Nat.shiftLeft_succ : ∀ (m n : ℕ), m <<< (n + 1) = 2 * m <<< n := by sorry

This theorem, `Nat.shiftLeft_succ`, states that for any two natural numbers `m` and `n`, shifting `m` to the left by `n + 1` is equal to twice `m` shifted to the left by `n`. The left shift operation `<<<` can be thought of as multiplication by `2^n`, so this theorem essentially states that `m * 2^(n+1) = 2 * m * 2^n` for all natural numbers `m` and `n`.

For all natural numbers `m` and `n`, `m <<< (n + 1) = 2 * (m <<< n)`.


/-- If `s` is either open, or closed, then `f` is locally integrable on `s` iff it is integrable on
every compact subset contained in `s`.  -/
theorem MeasureTheory.locallyIntegrableOn_iff :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      [inst_2 : NormedAddCommGroup E] {f : X → E} {μ : MeasureTheory.Measure X} {s : Set X}
      [inst_3 : LocallyCompactSpace X] [inst_4 : T2Space X],
      IsClosed s ∨ IsOpen s →
        (MeasureTheory.LocallyIntegrableOn f s μ ↔ ∀ k ⊆ s, IsCompact k → MeasureTheory.IntegrableOn f k μ) :=
  by sorry

The theorem `MeasureTheory.locallyIntegrableOn_iff` states that for a given set `s` in a space `X` that is either open or closed, and a function `f` from `X` to `E`, `f` is locally integrable on `s` if and only if `f` is integrable on every compact subset contained in `s`. The conditions need `X` to be a measurable and locally compact space with a Hausdorff property (T2 space), `E` to be a normed additive commutative group, and `μ` to be a measure on `X`.

A function `f` from a measurable and locally compact T2 space `X` with a Hausdorff measure `μ` to a normed additive commutative group `E` is locally integrable on a set `s` if and only if it is integrable on every compact subset contained in `s`.


/-- In a (weakly) locally compact R₁ space, compact closed neighborhoods of a point `x`
form a basis of neighborhoods of `x`.  -/
theorem isCompact_isClosed_basis_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R1Space X] [inst_2 : WeaklyLocallyCompactSpace X] (x : X),
      Filter.HasBasis (nhds x) (fun K => K ∈ nhds x ∧ IsCompact K ∧ IsClosed K) fun x => x :=
  by sorry

This theorem states that in a weakly locally compact R₁ space, the set of compact closed neighborhoods of a point `x` forms a basis for the neighborhood filter at `x`. In other words, any neighborhood of `x` can be expressed as a union of these compact closed neighborhoods. Here, a space is weakly locally compact if every point has a compact neighborhood, and a space is R₁ if any two distinct points have disjoint neighborhood filters. The compact closed neighborhoods are subsets of the space that are both compact (for any nontrivial filter that contains the subset, there exists a point in the subset where every set of the filter intersects every neighborhood of the point) and closed (their complement is an open set).

In a weakly locally compact and R₁ space, the set of compact closed neighborhoods of a point forms a basis for its neighborhood filter.


theorem Complex.two_sinh : ∀ (x : ℂ), 2 * Complex.sinh x = Complex.exp x - Complex.exp (-x) := by sorry

This theorem states that for any complex number `x`, the value of `2` times the complex hyperbolic sine of `x` is equal to the difference between the complex exponential of `x` and the complex exponential of `-x`. Here, the complex hyperbolic sine and complex exponential functions are defined in terms of their corresponding Taylor series.

The theorem asserts that for any complex number `x`, the equality `2⁝sh(x) = exp(x) - exp(-x)` holds, where `sh` denotes the complex hyperbolic sine and `exp` the complex exponential, both defined using their respective Taylor series.


theorem conj_mul : ∀ {α : Type u} [inst : Group α] {a b c : α}, b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹ := by
  sorry

This theorem states that for any type `α` that has a group structure, given three elements `a`, `b`, and `c` in `α`, the result of multiplying `b` and `a`, inverting `b`, multiplying the result by `b` and `c`, and inverting `b` again, is equal to the result of multiplying `b` by the product of `a` and `c`, and then inverting `b`. In mathematical terms, this means that for any group, the expression `b * a * b⁻¹ * (b * c * b⁻¹)` is equal to `b * (a * c) * b⁻¹`. This is a statement about the "conjugation" operation in group theory.

For any group `α` and elements `a, b, c` in `α`, the conjugation `b * a * b⁻¹` is equivalent to `b * (a * c) * b⁻¹`.


theorem Multiset.le_inter : ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ≤ t → s ≤ u → s ≤ t ∩ u :=
  by sorry

The theorem `Multiset.le_inter` states that for any type `α` which has decidable equality, given three multisets `s`, `t`, and `u` of type `α`, if `s` is a subset of or equal to `t` and `s` is a subset of or equal to `u`, then `s` is also a subset of or equal to the intersection of `t` and `u`. The intersection of two multisets is a multiset which contains all elements that are present in both multisets. Thus, if all elements of `s` are in `t` and `u`, they must also be in the intersection of `t` and `u`.

If `s subseteq/eq s1` and `s subseteq/eq s2`, then `s subseteq/eq s1 inter s2`. (Here, `s`, `s1`, `s2`, and `s1 inter s2` are multisets of type `α` with decidable equality.)


ClosedEmbedding.continuous

theorem ClosedEmbedding.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      ClosedEmbedding f → Continuous f :=
  by sorry

This theorem states that for any two types `X` and `Y`, and a function `f` from `X` to `Y`, given that `X` and `Y` are topological spaces, if `f` is a closed embedding, then `f` is also continuous. In other words, a closed embedding between topological spaces always preserves continuity.

If `f : X → Y` is a closed embedding between topological spaces `X` and `Y`, then `f` is continuous.


theorem Inducing.continuousOn_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace γ] {f : α → β} {g : β → γ},
      Inducing g → ∀ {s : Set α}, ContinuousOn f s ↔ ContinuousOn (g ∘ f) s :=
  by sorry

This theorem states that for all topological spaces `α`, `β`, and `γ`, and for every function `f` from `α` to `β` and `g` from `β` to `γ`, if `g` induces the topology on `γ` from `β`, then `f` is continuous on a subset `s` of `α` if and only if the composition `g ∘ f` is continuous on the same subset `s`. Here, a function being continuous on a subset means that it is continuous at every point within that subset.
In terms of topology, it implies that the continuity of function compositions is preserved when the second function is inducing.

For functions $f: \alpha \to \beta$ and $g: \beta \to \gamma$ with $g$ inducing the topology on $\gamma$ from $\beta$, the subset $s \subseteq \alpha$ is a continuity set for $f$ if and only if $g \circ f$ is a continuity set for $g$ on $s$.


theorem ContinuousMap.norm_coe_le_norm :
    ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
      [inst_2 : NormedAddCommGroup E] (f : C(α, E)) (x : α), ‖f x‖ ≤ ‖f‖ :=
  by sorry

This theorem states that for any continuous function `f` from a compact topological space `α` to a normed additively commutative group `E`, the norm of the function applied to any element `x` in `α` is less than or equal to the norm of the function itself. In mathematical terms, for all `f : C(α, E)` and `x : α`, we have `‖f x‖ ≤ ‖f‖`.

For any continuous function `f` from a compact topological space `α` to a normed additively commutative group `E`, the norm of `f(x)` is less than or equal to the norm of `f` for all `x` in `α`.


theorem CategoryTheory.preimage_map :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [inst_2 : CategoryTheory.Full F]
      [inst_3 : CategoryTheory.Faithful F] {X Y : C} (f : X ⟶ Y), F.preimage (F.map f) = f :=
  by sorry

This theorem states that for any two objects `X` and `Y` in a category `C`, and a functor `F` from `C` to another category `D` that is both full and faithful, the preimage under `F` of the morphism in `D` obtained by applying `F` to a morphism `f` from `X` to `Y` in `C`, is equal to `f` itself. Specifically, this theorem is asserting the property of functors that are both full (every morphism in `D` can be traced back to a morphism in `C`) and faithful (distinct morphisms in `C` are mapped to distinct morphisms in `D`). In simpler terms, if you have a morphism in `C`, map it to `D` using `F`, and then take the preimage under `F`, you'll end up back where you started.

For any functor F from category C to D that is both full and faithful, the preimage under F of a morphism in D obtained from a morphism f in C is equal to f itself.


theorem Complex.contDiff_cosh : ∀ {n : ℕ∞}, ContDiff ℂ n Complex.cosh := by sorry

This theorem states that the complex hyperbolic cosine function, `Complex.cosh`, is continuously differentiable for all natural numbers `n`, including infinity (`ℕ∞`). The function `Complex.cosh` is defined as the average of the exponential function evaluated at a complex number `z` and its negation. The continuous differentiability means that the function has derivatives of all orders up to `n` and that these derivatives vary smoothly.

The complex hyperbolic cosine function `Complex.cosh : ℂ → ℂ`, defined as the average of `exp` and its negation, is continuously differentiable for all natural numbers `n` including infinity.


theorem Units.inv_mul_eq_iff_eq_mul : ∀ {α : Type u} [inst : Monoid α] (a : αˣ) {b c : α}, ↑a⁻¹ * b = c ↔ b = ↑a * c :=
  by sorry

This theorem states that for any type `α` that forms a monoid, and given a unit `a` of type `α` and two elements `b` and `c` of type `α`, the equation `a⁻¹ * b = c` is true if and only if `b = a * c`. Here, `a⁻¹` denotes the inverse of unit `a`. Both `aˣ` and `α` belong to the same monoid and the inverse of a unit is also a unit in the monoid.

For any monoid `α` with unit `a`, `a⁻¹ * b = c` if and only if `b = a * c`.


theorem Mathlib.Data.Set.Prod._auxLemma.12 : ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) := by
  sorry

This theorem, titled `Mathlib.Data.Set.Prod._auxLemma.12`, states that for all types `α`, given an element `x` of this type and two sets `a` and `b` of the same type, the condition of `x` being in the intersection of set `a` and set `b` (denoted as `x ∈ a ∩ b`) is equivalent to `x` being in set `a` and `x` being in set `b` at the same time (denoted as `x ∈ a ∧ x ∈ b`). In other words, the membership of an element in the intersection of two sets is equivalent to the membership of the element in both of the sets separately.

For all types `α` and sets `a` and `b` of type `α`, the element `x` is in the intersection `a ∩ b` if and only if `x` is in `a` and `x` is in `b`.


theorem AddSubmonoid.LocalizationMap.eq_iff_exists :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      (f : AddSubmonoid.LocalizationMap S N) {x y : M},
      (AddSubmonoid.LocalizationMap.toMap f) x = (AddSubmonoid.LocalizationMap.toMap f) y ↔ ∃ c, ↑c + x = ↑c + y :=
  by sorry

The theorem `AddSubmonoid.LocalizationMap.eq_iff_exists` states that for any type `M` which is an instance of the `AddCommMonoid` typeclass, a submonoid `S` of `M`, another type `N` which is also an instance of the `AddCommMonoid` typeclass, and a localization map `f` from `S` to `N`, for any `x` and `y` of type `M`, the localization map applied to `x` equals the localization map applied to `y` if and only if there exists an element `c` from the submonoid such that `c` plus `x` equals `c` plus `y`. This theorem essentially describes a property of the commutativity of addition after the localization map is applied to elements of the original monoid.

For any AddCommMonoid M, submonoid S, AddCommMonoid N, localization map f from S to N, and x, y in M, f(x) = f(y) if and only if there exists c in S such that x + c = y + c.


AffineSubspace.SOppSide.symm

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

This theorem, named `AffineSubspace.SOppSide.symm`, asserts that for a given strict ordered commutative ring `R`, an additive commutative group `V`, a module `R` over `V`, a torsor `P` for `V`, an affine subspace `s` of `R` in `P`, and points `x` and `y` in `P`, if `x` and `y` are strictly on opposite sides of `s` (i.e., `AffineSubspace.SOppSide s x y` holds), then `y` and `x` are also strictly on opposite sides of `s` (i.e., `AffineSubspace.SOppSide s y x` holds). This theorem is actually the symmetric version of the property `AffineSubspace.sOppSide_comm`.

For an affine subspace `s` of a module `P` over a commutative ring `R`, and points `x` and `y` in `P` strictly on opposite sides of `s`, we have that `x` and `y` are also strictly on opposite sides of `s`, i.e., `AffineSubspace.SOppSide s x y` implies `AffineSubspace.SOppSide s y x`.


theorem Mathlib.Data.Finset.PImage._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
      {s : Finset α} {b : β}, (b ∈ Finset.pimage f s) = ∃ a ∈ s, b ∈ f a :=
  by sorry

This theorem states that for any types `α` and `β` with `β` having decidable equality, a partially defined function `f` from `α` to `β`, a finset `s` of `α`, and an element `b` of `β`, `b` belongs to the image of `s` under `f` if and only if there exists an element `a` in `s` such that `b` belongs to `f a`. Here, the image of `s` under `f` is defined as the finset of `β` obtained by applying `f` to each element of `s` and collecting the results into a finset. The existence of `b` in `f a` means that `f` is defined at `a` and `f a` equals `b`.

For any partially defined function `f` from type `α` to decidably equal type `β`, and any finset `s` of `α` and element `b` of `β`, `b` is in the image of `s` under `f` if and only if there exists `a` in `s` such that `f a = b`.


theorem Equiv.Perm.SameCycle.cycleOf_apply :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x y : α},
      Equiv.Perm.SameCycle f x y → (Equiv.Perm.cycleOf f x) y = f y :=
  by sorry

This theorem states that for any type `α` with decidable equality and finite size, and for any permutation `f` of `α` and any two elements `x` and `y` of `α`, if `x` and `y` are in the same cycle of the permutation `f`, then applying the cycle of permutation `f` at `x` to `y` is the same as applying `f` to `y`. In other words, the cycle that `x` belongs to under the permutation `f` acts on `y` just as `f` itself does, if `x` and `y` are in the same cycle of `f`.

For any finite type `α` with decidable equality, permutation `f` of `α`, and elements `x` and `y` in the same cycle of `f`, `f^(cyc x) y` equals `f^(cyc y)`, where `cyc` denotes the cycle containing `x` under `f`.


/-- If `f` is a monomorphism, then `(𝟙 _, 𝟙 _)` is a kernel pair for `f`.  -/
theorem CategoryTheory.IsKernelPair.id_of_mono :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f],
      CategoryTheory.IsKernelPair f (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) :=
  by sorry

The theorem `CategoryTheory.IsKernelPair.id_of_mono` states that if a morphism `f` in a category `C` is a monomorphism (i.e., it has the left cancellation property), then the pair of identity morphisms on the domain object `X` of `f` forms a kernel pair for `f`. In other words, the pair `(𝟙 _, 𝟙 _)` satisfies the property that their compositions with `f` are equal and the square, whose corners are the domain of `f`, the codomain of `f`, and the domain of the identity morphisms, is a pullback square.

If `f` is a monomorphism in a category `C`, then the pair of identity morphisms on the domain of `f` forms a kernel pair for `f`, meaning their compositions with `f` are equal and the square they form with `f` as the diagonal morphism is a pullback square.


IsGδ.biInter

theorem IsGδ.biInter :
    ∀ {X : Type u_1} {ι : Type u_3} [inst : TopologicalSpace X] {s : Set ι},
      Set.Countable s →
        ∀ {t : (i : ι) → i ∈ s → Set X}, (∀ (i : ι) (hi : i ∈ s), IsGδ (t i hi)) → IsGδ (⋂ i, ⋂ (h : i ∈ s), t i h) :=
  by sorry

The theorem `IsGδ.biInter` states that for any set `s` of type `ι` which is countable, if for every element `i` in `s` we have a corresponding G-delta set `t i hi` (where `hi` is proof that `i` is in `s`), then the intersection of all these G-delta sets is also a G-delta set. Here, a G-delta set in a topological space `X` is defined as a countable intersection of open sets in `X`. This theorem hence establishes the closure of G-delta sets under countable intersections. The set `s` indexes over the G-delta sets, and the theorem applies even when `s` is infinite, as long as it is countable.

Given a countable set `s` of indices and for each `i` in `s`, a G-delta set `ti` in a topological space `X`, the intersection of all `ti` is also a G-delta set in `X`.


theorem Nat.count_monotone : ∀ (p : ℕ → Prop) [inst : DecidablePred p], Monotone (Nat.count p) := by sorry

The theorem `Nat.count_monotone` states that for any decidable predicate `p` on natural numbers, the function `Nat.count p` is monotone. In other words, if `m` and `n` are natural numbers and `m ≤ n`, then the number of natural numbers less than `m` that satisfy `p` is less than or equal to the number of natural numbers less than `n` that satisfy `p`. This property is known as monotonicity.

For any decidable predicate `p` on natural numbers, the function `Nat.count p` is monotone, that is, `Nat.count p x ≤ Nat.count p y` whenever `x ≤ y`.


theorem Mathlib.Algebra.Star.Pointwise._auxLemma.2 :
    ∀ {α : Type u_1} {s : Set α} {a : α} [inst : Star α], (a ∈ star s) = (star a ∈ s) := by sorry

The theorem `Mathlib.Algebra.Star.Pointwise._auxLemma.2` states that for any type `α`, any set `s` of `α`, and any element `a` of `α`, given that `Star` is defined for `α`, the property of `a` being in the star closure of `s` is equivalent to the star of `a` being in the set `s`. Here, the star operation typically means taking the adjoint in the context of star algebras.

For any type `α`, set `s` of `α`, and element `a` of `α` in a star algebra, `a` is in the star closure of `s` if and only if the star of `a` is in `s`.


theorem Equiv.Perm.cycleType_one :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], Equiv.Perm.cycleType 1 = 0 := by sorry

The theorem `Equiv.Perm.cycleType_one` states that for any finite type `α` with decidable equality, the cycle type of the identity permutation is zero. In other words, the number of cycles of each length in the decomposition of the identity permutation into disjoint cycles, which is represented as a multiset of natural numbers, is zero for any given finite type with decidable equality.

The identity permutation on a finite type with decidable equality has no cycles.


theorem Cardinal.sum_le_iSup_lift :
    ∀ {ι : Type u} (f : ι → Cardinal.{max u v}), Cardinal.sum f ≤ Cardinal.lift.{v, u} (Cardinal.mk ι) * iSup f := by
  sorry

This theorem states that for any type `ι` and a function `f` from `ι` to a cardinal number, the indexed sum of cardinal numbers (which is the cardinality of the indexed disjoint union), denoted by `Cardinal.sum f`, is less than or equal to the product of the universe lift of the cardinal number of `ι` and the indexed supremum of `f`. In other words, for any type and a function mapping the type to cardinal numbers, the total cardinality of the disjoint union indexed by the type is at most the product of the cardinality of the type and the supremum of the cardinalities that the function maps to.

For any type `ι` and function `f` from `ι` to cardinal numbers, the cardinality of the indexed sum of `ι` is less than or equal to the product of the cardinality of `ι` and the supremum of `f`.


theorem YoungDiagram.transpose_transpose :
    ∀ (μ : YoungDiagram), YoungDiagram.transpose (YoungDiagram.transpose μ) = μ := by sorry

This theorem states that for any given Young diagram `μ`, the transpose of the transpose of `μ` is equal to `μ` itself. In other words, performing the transpose operation twice on a Young diagram returns the original Young diagram. Here, the transpose operation on a Young diagram involves swapping the coordinates (i's with j's), which corresponds to reflecting the diagram along its main diagonal.

The transpose of a Young diagram is equal to its own transpose. In other words, (μ^T)^T = μ for any Young diagram μ.


theorem abs_coe_circle : ∀ (z : ↥circle), Complex.abs ↑z = 1 := by sorry

This theorem states that for any complex number `z` that is a member of the unit circle in the complex plane (also known as `circle`), the absolute value of `z` is equal to 1. In other words, the absolute value of any point on the unit circle in the complex plane is always 1. In mathematical terms, if `z` is a complex number such that it belongs to the unit circle, i.e., |z| = 1, then the theorem `abs_coe_circle` asserts this fact.

The theorem asserts that the absolute value of any complex number in the unit circle is equal to 1.


theorem Int.neg_mul_eq_mul_neg : ∀ (a b : ℤ), -(a * b) = a * -b := by sorry

This theorem states that for any two integers `a` and `b`, the negative of their product is equal to the product of `a` and the negative of `b`. In other words, if you multiply two numbers and then take the negative of the result, it's the same as if you had multiplied the first number by the negative of the second number. This theorem encapsulates a fundamental property of integer multiplication.

For all integers a and b, (-1) * (a * b) = a * (-b).


theorem Part.bind_assoc :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_4} (f : Part α) (g : α → Part β) (k : β → Part γ),
      Part.bind (Part.bind f g) k = Part.bind f fun x => Part.bind (g x) k :=
  by sorry

The theorem `Part.bind_assoc` states that for any types `α`, `β`, and `γ`, and any partial functions `f : Part α`, `g : α → Part β`, and `k : β → Part γ`, the operation `Part.bind` is associative. In other words, first binding `f` and `g`, and then binding the result with `k`, is the same as first binding `f` with the result of binding `g` and `k`. This mirrors the associative property in algebra where the way in which operations are grouped does not change the result (i.e., `(a * b) * c = a * (b * c)`).

For any partial functions `f : Part α → Part β`, `g : α → Part β`, and `k : Part β → Part γ` in Lean 4, the composition `(Part.bind _ _) (f _) (Part.bind _ _ g)` is equal to `(Part.bind _ _ (Part.bind _ _ g)) f`.


theorem Polynomial.natDegree_lt_natDegree_iff :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      p ≠ 0 → (Polynomial.natDegree p < Polynomial.natDegree q ↔ Polynomial.degree p < Polynomial.degree q) :=
  by sorry

This theorem states that, for any type `R` that is a semiring and any two polynomials `p` and `q` over `R`, if `p` is not the zero polynomial, then the natural degree of `p` is less than the natural degree of `q` if and only if the degree of `p` is less than the degree of `q`. The natural degree of a polynomial is the highest power of `X` that appears in the polynomial, with the natural degree of the zero polynomial defined as 0. The degree of a polynomial is similar to the natural degree, but it is allowed to be bottom (⊥), which is the case for the zero polynomial.

For any semiring type `R`, if non-zero polynomials `p` and `q` over `R` have different degrees, then their natural degrees are strictly less than or equal to their respective degrees.


/-- Group homomorphisms preserve division.  -/
theorem MonoidHom.map_div :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : DivisionMonoid β] (f : α →* β) (g h : α),
      f (g / h) = f g / f h :=
  by sorry

This theorem states that group homomorphisms preserve division. Specifically, for any two elements `g` and `h` from a group `α` and a homomorphism `f` from `α` to a division monoid `β`, the image of the division of `g` and `h` under `f` is the same as the division of the images of `g` and `h` under `f`. In mathematical terms, this can be written as `f(g / h) = f(g) / f(h)`.

Given a group homomorphism `f` from group `α` to a division monoid `β`, `f(g / h) = f(g) / f(h)` for all `g, h` in `α`.


theorem Submodule.smul_le_right :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Ideal R}
      {N : Submodule R M}, I • N ≤ N :=
  by sorry

This theorem states that for any commutative semiring `R`, any additive commutative monoid `M`, and any `R`-module structure on `M`, if `I` is an ideal in `R` and `N` is a submodule of `M`, then the scalar multiplication of `I` and `N` (denoted as `I • N`) is a substructure of `N`. In other words, any element resulting from multiplying elements of the ideal `I` with elements from the submodule `N` is still contained within `N`.

For any commutative semiring `R`, additive commutative monoid `M`, and `R`-module structure on `M`, if `I` is an ideal in `R` and `N` is a submodule of `M`, then `I • N` (the scalar multiplication of `I` and `N`) is a submodule of `N`.


theorem MeasureTheory.ae_eq_trans :
    ∀ {α : Type u_1} {δ : Type u_4} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {f g h : α → δ},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → g =ᶠ[MeasureTheory.Measure.ae μ] h → f =ᶠ[MeasureTheory.Measure.ae μ] h :=
  by sorry

The theorem `MeasureTheory.ae_eq_trans` states that for any measure space `α`, any type `δ`, and any measure `μ` on `α`, if two functions `f` and `g` from `α` to `δ` are equal almost everywhere with respect to `μ`, and `g` and another function `h` are also equal almost everywhere with respect to `μ`, then `f` and `h` are equal almost everywhere with respect to `μ`. This is the transitive property for the equivalence relation of being equal almost everywhere.

If functions `f` and `g`, and `g` and `h` are equal almost everywhere with respect to measure `μ` on measure space `α`, then `f` and `h` are equal almost everywhere with respect to `μ`.


theorem Submodule.comap_equiv_eq_map_symm :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {τ₂₁ : R₂ →+* R} [inst_6 : RingHomInvPair τ₁₂ τ₂₁] [inst_7 : RingHomInvPair τ₂₁ τ₁₂]
      (e : M ≃ₛₗ[τ₁₂] M₂) (K : Submodule R₂ M₂), Submodule.comap (↑e) K = Submodule.map (↑(LinearEquiv.symm e)) K :=
  by sorry

This theorem states that for any two semirings `R` and `R₂`, commutative additive monoids `M` and `M₂`, modules over `R` and `R₂` respectively, a pair of inverse ring homomorphisms `τ₁₂` and `τ₂₁` between `R` and `R₂`, a linear equivalence `e` between `M` and `M₂`, and a submodule `K` of `M₂`, the comap of the linear equivalence `e` over the submodule `K` is equal to the map of the inverse of the linear equivalence `e` over the submodule `K`.

In simpler terms, this is about a transformation between two algebraic structures (`M` and `M₂`), preserving the submodule `K` under the mapping and inverse mapping of a linear equivalence.

 For any commutative semirings R and R₂, modules M over R and M₂ over R₂, ring homomorphisms τ₁₂: R -> R₂ and τ₂₁: R₂ -> R, linear equivalences e: M -> M₂, and submodule K of M₂, the following diagram commutes:

```
M �� injects e ��jet K
|___|   |___|
|   |   |   |
| e |---| e^{-1} |
|   |   |   |
|___|   |___|
M/K �� incl ��jet M₂/K
```

Here "injects" denotes the inclusion of M into its quotient M/K, and "�� jet" represents the respective quotient maps. In other words, e(m + K) = e(m) + K for all m ∈ M. Similarly, e^{-1}(m₂ + K) = e^{-1}(m₂) + K for all m₂ ∈ M₂.


theorem Irrational.of_inv : ∀ {x : ℝ}, Irrational x⁻¹ → Irrational x := by sorry

The theorem `Irrational.of_inv` states that for any real number `x`, if its reciprocal `x⁻¹` (1/x) is irrational, then `x` itself is also irrational. In other words, the irrationality is preserved under the operation of taking the reciprocal.

If the reciprocal of a real number is irrational, then the number itself is irrational.


theorem Asymptotics.IsEquivalent.tendsto_nhds :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α} {c : β},
      Asymptotics.IsEquivalent l u v → Filter.Tendsto u l (nhds c) → Filter.Tendsto v l (nhds c) :=
  by sorry

The theorem `Asymptotics.IsEquivalent.tendsto_nhds` states that given any two functions `u` and `v` from a type `α` to a normed add commutative group `β` that are asymptotically equivalent along a filter `l` on `α`, and a value `c` in `β`, if the function `u` converges to `c` along `l` (in the sense that for every neighborhood of `c`, the preimage under `u` of that neighborhood is an `l`-neighborhood), then the function `v` also converges to `c` along `l`. In mathematical terms, if `u` and `v` are asymptotically equivalent and `u` tends to `c`, then `v` also tends to `c`.

If functions `u` and `v` from type `α` to a normed add commutative group `β` are asymptotically equivalent along filter `l` on `α`, and `u` converges to a value `c` in `β` along `l`, then `v` also converges to `c` along `l`.


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

This theorem, `CategoryTheory.ShortComplex.rightHomologyι_naturality'`, asserts that for any two short complexes `S₁` and `S₂` in a category `C` that has zero morphisms, and a morphism `φ` from `S₁` to `S₂`, the composition of the right homology map of `φ` and embedding map `h₂.ι` is equal to the composition of the embedding map `h₁.ι` and the map of chain complexes of `φ`. More formally, if `h₁` and `h₂` are the right homology data for `S₁` and `S₂` respectively, then the composition `(CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂) ≫ h₂.ι` is equal to `h₁.ι ≫ (CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂)`. This asserts the naturality of the embedding map in the context of short complexes in category theory.

Given short complexes $S\_1$, $S\_2$ in a category with zero morphisms, a morphism $\varphi$ from $S\_1$ to $S\_2$, and their respective right homology data $h\_1$ and $h\_2$, the composition of the right homology map of $\varphi$ with $h\_2.\ι$ equals the composition of $h\_1.\ι$ with the map of chain complexes of $\varphi$. In other words, $(h\_2.\ι \circ \text{rightHomologyMap'} \_\varphi \_ {h\_1} \_ {h\_2}) = (h\_1.\ι \circ \text{opcyclesMap'} \_\varphi \_ {h\_1} \_ {h\_2})$.


List.Chain'.tail

theorem List.Chain'.tail :
    ∀ {α : Type u} {R : α → α → Prop} {l : List α}, List.Chain' R l → List.Chain' R (List.tail l) := by sorry

This theorem states that, for any type `α` and any binary relation `R` on `α`, if a list `l` of type `α` satisfies the property `List.Chain' R`, meaning that the relation `R` holds between every pair of adjacent elements in `l`, then the tail of the list `l` (which is `l` without its first element) also satisfies the property `List.Chain' R`. In other words, if `R` holds between each pair of consecutive elements in a list, it also holds between each pair of consecutive elements in the tail of that list.

If `R` is a binary relation on type `α` and `l` is a list of `α` with property `List.Chain' R`, then the tail of `l` also satisfies property `List.Chain' R`.


theorem Multiset.pmap_eq_map :
    ∀ {α : Type u_1} {β : Type v} (p : α → Prop) (f : α → β) (s : Multiset α) (H : ∀ a ∈ s, p a),
      Multiset.pmap (fun a x => f a) s H = Multiset.map f s :=
  by sorry

This theorem states that for any type `α` and `β`, a predicate `p` on `α`, a function `f` from `α` to `β`, and a multiset `s` of type `α` such that all elements `a` in `s` satisfy the predicate `p`, the operation `Multiset.pmap` using the function `f` (ignoring the proof of the predicate) on `s` is equivalent to the `Multiset.map` of function `f` on `s`. Simply put, if we have a function that applies to all elements of a multiset, partial mapping and full mapping of that function produce the same result.

For any type `α`, `β`, predicate `p` on `α`, function `f` from `α` to `β`, and multiset `s` of type `α` where all elements satisfy `p`, `Multiset.pmap f s = Multiset.map f s`.


theorem Filter.frequently_of_forall :
    ∀ {α : Type u} {f : Filter α} [inst : Filter.NeBot f] {p : α → Prop}, (∀ (x : α), p x) → ∃ᶠ (x : α) in f, p x := by
  sorry

This theorem states that for any type `α`, any filter `f` on `α` that is not the bottom filter, and any predicate `p` on `α`, if the predicate `p` holds for all elements `x` of the type `α`, then there exists a subset of elements from `f` for which `p` holds frequently. In other words, if a property is true for all elements, then there are many places in the filter where it's true.

If `f` is a non-bottom filter on type `α` and `p` is a predicate on `α` such that `∀x ∈ α, p x`, then there exists a non-empty `X ∈ f` such that `#{x ∈ X | p x} / #X ≥ ε` for some constant `ε > 0`.


theorem MeasureTheory.lowerCrossingTime_le :
    ∀ {Ω : Type u_1} {ι : Type u_2} [inst : ConditionallyCompleteLinearOrderBot ι] {a b : ℝ} {f : ι → Ω → ℝ} {N : ι}
      {n : ℕ} {ω : Ω}, MeasureTheory.lowerCrossingTime a b f N n ω ≤ N :=
  by sorry

The theorem `MeasureTheory.lowerCrossingTime_le` states that, for any given sets Ω and ι (with ι having a conditionally complete linear order with a least element), real numbers `a` and `b`, function `f` mapping from Ω×ι to real numbers, a specific element `N` from ι, a natural number `n`, and an element `ω` from Ω, the "lower crossing time" of `f` (the first time before `N` that `f` reaches below `a` after reaching above `b` for the `n`-th time) is always less than or equal to `N`. In simpler terms, the time when the function dips below a certain level after reaching above another level a specific number of times will never exceed a prescribed time limit.

For any sets Ω and ι, real numbers a ≤ b, function f : Ω × ι → ℝ, element N ∈ ι, natural number n, and ω ∈ Ω, the lower crossing time of f at (ω, N), defined as the infimum time t < N such that f(ω, t) < a after reaching above b for the n-th time, is less than or equal to N.


theorem Complex.UnitDisc.coe_injective : Function.Injective Subtype.val := by sorry

The theorem `Complex.UnitDisc.coe_injective` states that the function `Subtype.val`, when it operates on the subtype corresponding to the complex unit disc, is injective. This implies that for any two elements in the complex unit disc, if they have the same image under `Subtype.val`, then they must be identical. In other words, no two distinct elements of the complex unit disc map to the same point in the codomain.

The function `Subtype.val` maps distinct elements in the complex unit disc to distinct values.


Asymptotics.IsEquivalent.isLittleO

theorem Asymptotics.IsEquivalent.isLittleO :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l u v → (u - v) =o[l] v :=
  by sorry

The theorem `Asymptotics.IsEquivalent.isLittleO` states that for any types `α` and `β`, where `β` is a `NormedAddCommGroup`, if two functions `u` and `v` (both from `α` to `β`) are asymptotically equivalent along a filter `l`, then the difference between `u` and `v` is little-o of `v` along that filter. In other words, if `u` and `v` have the same asymptotic behaviour as `x` approaches along the filter `l` (i.e., `(u - v) = o(v)`), then `u - v` is an infinitesimally small quantity compared to `v` as `x` converges along `l`.

If functions `u` and `v` are asymptotically equivalent to each other along filter `l` on types `α` and `β` (where `β` is a normed additive commutative group), then the difference `u - v` is little-o of `v` along `l`.


theorem ZNum.add_one : ∀ (n : ZNum), n + 1 = ZNum.succ n := by sorry

This theorem states that for any given integer number `n` represented as `ZNum` in Lean 4, incrementing `n` by `1` is equivalent to the successor of `n` (`ZNum.succ n`). The successor operation in this context is defined such that the successor of zero is 1, the successor of a positive number is the next positive number, and the successor of a negative number is the previous negative number.

For any integer `n` in Lean 4, `ZNum.succ n` is equal to the integer obtained by adding 1 to `n`.


theorem Filter.HasBasis.totallyBounded_iff :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {ι : Sort u_1} {p : ι → Prop} {U : ι → Set (α × α)},
      Filter.HasBasis (uniformity α) p U →
        ∀ {s : Set α}, TotallyBounded s ↔ ∀ (i : ι), p i → ∃ t, Set.Finite t ∧ s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ U i} :=
  by sorry

This theorem states that for a given type `α` with an associated uniform space and a given filter basis on `α × α` determined by a property `p` and a set function `U`, a set `s` of type `α` is totally bounded if and only if for every `i` where `p(i)` is true, there exists a finite set `t` such that every element in `s` is close, with closeness defined by `U(i)`, to at least one element in `t`. In other words, no matter which condition `i` from the filter basis we use to define closeness, we can always find a finite set of reference points such that all points in our set are close to at least one reference point.

A set `s` in a uniform space `α` is totally bounded with respect to a filter basis determined by property `p` and set function `U` if and only if for each `i` where `p(i)` holds, there exists a finite set `t` such that every element in `s` is close to some element in `t` using the closeness relation defined by `U(i)`.


theorem Finsupp.filter_eq_indicator :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (p : α → Prop) [inst_1 : DecidablePred p] (f : α →₀ M),
      ⇑(Finsupp.filter p f) = Set.indicator {x | p x} ⇑f :=
  by sorry

This theorem states that for any type `α`, an additional type `M` that has a zero element, a decidable predicate `p` on `α`, and a finitely supported function `f` from `α` to `M`, the function obtained by applying the `Finsupp.filter` operation on `f` with predicate `p` is equivalent to applying the `Set.indicator` on `f` with the set of elements of `α` satisfying the predicate `p`. In other words, both operations produce the same function that takes an element of `α` and returns the corresponding value of `f` if the element satisfies the predicate `p`, and zero otherwise.

For any type `α`, decidable predicate `p` on `α`, and a finitely supported function `f` from `α` to a type `M` with a zero element, `Finsupp.filter p f` equals `Set.indicator {x : α | p x} f`.


Monotone.compRel

theorem Monotone.compRel :
    ∀ {α : Type ua} {β : Type ub} [inst : Preorder β] {f g : β → Set (α × α)},
      Monotone f → Monotone g → Monotone fun x => compRel (f x) (g x) :=
  by sorry

This theorem states that for any type `α` and any preordered type `β`, if we have two functions `f` and `g` from `β` to the set of ordered pairs of `α`, then if both `f` and `g` are monotone functions, the function that maps `x` to the composition of the relations `f(x)` and `g(x)` is also monotone. In other words, the monotonicity is preserved under the composition of relations.

If `f` and `g` are monotone functions from a preordered type `β` to the ordered pairs of a type `α`, then their composition `f ∘ g` is also a monotone function.


multiplicity.mul

theorem multiplicity.mul :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {p a b : α},
      Prime p → multiplicity p (a * b) = multiplicity p a + multiplicity p b :=
  by sorry

This theorem states that for any type `α` which has a structure of a `CancelCommMonoidWithZero` (a commutative monoid with zero where multiplication has the cancellation property), and a decidable relation which determines if one element divides another, if `p` is a prime element in `α`, then the multiplicity of `p` in the product of `a` and `b` is equal to the sum of the multiplicity of `p` in `a` and the multiplicity of `p` in `b`. In other words, the number of times a prime `p` divides into a product `a * b` is the sum of the number of times `p` divides into `a` and the number of times `p` divides into `b`.

For any commutative monoid with zero and cancellation property, and a decidable division relation, if `p` is a prime element, then the multiplicity of `p` in the product of `a` and `b` equals the sum of the multiplicities of `p` in `a` and `b`.


AntivaryOn.symm

theorem AntivaryOn.symm :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : LinearOrder β] {f : ι → α} {g : ι → β}
      {s : Set ι}, AntivaryOn f g s → AntivaryOn g f s :=
  by sorry

The theorem `AntivaryOn.symm` states that for any types `ι`, `α`, and `β`, with `α` and `β` equipped with a Preorder structure and `β` additionally having a LinearOrder structure, any two functions `f: ι → α` and `g: ι → β`, and any set `s` of type `ι`, if `f` antivaries with `g` on `s`, then `g` also antivaries with `f` on `s`. Here, a function `f` is said to antivary with a function `g` on a set `s` if for all elements `i` and `j` in `s`, a smaller value of `g` (i.e., `g i < g j`) implies a larger or equal value of `f` (i.e., `f j ≤ f i`).

If functions $f: ι → α$ and $g: ι → β$ have $f(j) ≤ f(i)$ for all $i, j \in s$ whenever $g(i) < g(j)$, then $g(j) ≤ g(i)$ implies $f(i) ≤ f(j)$ for all $i, j \in s$.


theorem closedEmbedding_smul_left :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜]
      [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : T2Space E] [inst_5 : TopologicalAddGroup E]
      [inst_6 : Module 𝕜 E] [inst_7 : ContinuousSMul 𝕜 E] {c : E}, c ≠ 0 → ClosedEmbedding fun x => x • c :=
  by sorry

This theorem states that for any non-zero element `c` in a certain type `E`, the function that multiplies `c` by a scalar `x` is a closed embedding. Here, `𝕜` is a nontrivially normed field that is also complete, `E` is an additive group with a topological structure satisfying the T2 property and is also a topological additive group. Additionally, `E` is a module over `𝕜` and the scalar multiplication in this module is continuous. A closed embedding in this context implies that the function is both injective and continuous, and its image is a closed set in the codomain.

For any non-zero `c` in the topological module `E` over a complete, nontrivially normed field `𝕜`, the scalar multiplication function `x mapsto c * x` is a continuous, injective and closed embedding.


theorem sq_eq_one_iff :
    ∀ {R : Type u_1} [inst : Ring R] {a : R} [inst_1 : NoZeroDivisors R], a ^ 2 = 1 ↔ a = 1 ∨ a = -1 := by sorry

This theorem states that for any element 'a' in a ring 'R' that does not contain zero divisors (NoZeroDivisors R), the square of 'a' is equal to 1 if and only if 'a' is either 1 or -1. Here, '^' is the exponentiation operation, and '∨' represents the logical OR operation. This means that if 'a' squared is 1, then 'a' must be 1 or -1, and if 'a' is either 1 or -1, its square will be 1.

For any element 'a' in a ring without zero divisors, 'a'^2 = 1 if and only if 'a' = 1 or 'a' = -1.


theorem NormedSpace.isVonNBounded_ball :
    ∀ (𝕜 : Type u_1) (E : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] (r : ℝ), Bornology.IsVonNBounded 𝕜 (Metric.ball 0 r) :=
  by sorry

The theorem `NormedSpace.isVonNBounded_ball` states that for any nontrivially normed field `𝕜`, any seminormed additive commutative group `E`, and any given normed space over `𝕜` and `E`, the metric ball centered at zero with radius `r` (which is the set of all points whose distance from zero is less than `r`) is von Neumann bounded. In other words, every neighborhood of zero in the topological space `E` can absorb the metric ball. This absorption suggests that any element of the metric ball can be scaled by a factor from the field `𝕜` such that it lies within any given neighborhood of zero.

For any nontrivially normed field `𝕜`, any seminormed additive commutative group `E` made into a normed space over `𝕜`, and any `r` in `𝕜` such that the metric ball in `E` centered at zero with radius `r` is nonempty, it holds that this ball is von Neumann bounded, meaning for any neighborhood of zero `U` in `E`, there exists `s` in `𝕜` such that the ball with radius `sr` is contained in `U`.


theorem isAtom_top :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [inst_2 : IsSimpleOrder α], IsAtom ⊤ := by sorry

The theorem `isAtom_top` states that for any type `α` which has a `PartialOrder`, is a `BoundedOrder`, and is a `SimpleOrder`, the top element `⊤` is an atom. In the context of order theory, an atom is defined as an element which has no other elements between it and the bottom element `⊥`, and it is not the bottom element itself. Thus, in these particular kinds of orders, the top element is such a minimal element above the bottom.

In any type endowed with a SimpleOrder that is both Bounded and Partial, the top element is an atom.


theorem Mathlib.Order.Filter.Basic._auxLemma.17 : ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x := by
  sorry

This theorem states that, for any type `α` and any predicate `p` on `α`, the assertion that it is not the case that `p` holds for all `x` of type `α` is equivalent to there existing an `x` of type `α` for which `p` does not hold. In other words, if there exists a member of type `α` that does not satisfy the predicate `p`, then it is not true that `p` is satisfied by all members of `α`, and conversely, if it is not true that `p` is satisfied by all members of `α`, then there exists a member of `α` that does not satisfy `p`.

For any type `α` and predicate `p` on `α`, the negation of "∀x ∈ α, p(x)" is equivalent to the existence of an `x ∈ α` such that not `p(x)`.


WellFounded.induction

theorem WellFounded.induction :
    ∀ {α : Sort u} {r : α → α → Prop},
      WellFounded r → ∀ {C : α → Prop} (a : α), (∀ (x : α), (∀ (y : α), r y x → C y) → C x) → C a :=
  by sorry

This theorem states that for any type `α` and a relation `r` on `α`, if `r` is well-founded, then for any predicate `C` on `α` and an element `a` of `α`, if every `x` in `α` satisfies `C` whenever all `y` related to `x` by `r` satisfy `C`, then `a` satisfies `C`. In other words, this is the principle of well-founded induction: if a property holds for all elements that are "smaller" according to a well-founded relation, then it holds for all elements.

If `r` is a well-founded relation on type `α` and for all `a` in `α`, if every `x` related to `a` by `r` satisfies predicate `C(x)`, then `C(a)` holds.


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

The theorem `IsMax.succ_eq` states that for any type `α` equipped with a partial order and a successor order, if an element `a` of `α` is maximal (meaning that no other element in `α` is strictly greater than `a`), then the successor of `a` is `a` itself. In other words, if `a` is a maximal element, then there's no element strictly greater than `a`, hence the successor of `a` is `a`. This theorem is an alias of the reverse direction of `Order.succ_eq_iff_isMax`.

If `α` is a type equipped with partial and successor orders, then for all `a` in `α`, if `a` is maximal, then `a = succ a`.


theorem zero_ceilDiv :
    ∀ {α : Type u_2} {β : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : OrderedAddCommMonoid β]
      [inst_2 : SMulZeroClass α β] [inst_3 : CeilDiv α β] (a : α), 0 ⌈/⌉ a = 0 :=
  by sorry

The theorem `zero_ceilDiv` states that for all types `α` and `β`, given that these types have an ordered additive commutative monoid structure, can be scaled by zero, and have a 'ceiling division' operation, the ceiling division of zero by any instance `a` of type `α` always equals zero. In mathematical terms, for any `a` in an ordered additive commutative monoid, `0 ⌈/⌉ a = 0`. This signifies that dividing zero by any number and rounding up to the nearest integer is always zero.

For any ordered additive commutative monoid type `α` with a ceiling division operation, `0 ⌈/⌉ a = 0` for all `a` in `α`.


theorem Cardinal.inductionOn₃ :
    ∀ {p : Cardinal.{u_1} → Cardinal.{u_2} → Cardinal.{u_3} → Prop} (c₁ : Cardinal.{u_1}) (c₂ : Cardinal.{u_2})
      (c₃ : Cardinal.{u_3}),
      (∀ (α : Type u_1) (β : Type u_2) (γ : Type u_3), p (Cardinal.mk α) (Cardinal.mk β) (Cardinal.mk γ)) →
        p c₁ c₂ c₃ :=
  by sorry

The theorem `Cardinal.inductionOn₃` states that for all properties `p` about three cardinal numbers `c₁`, `c₂`, and `c₃`, if the property `p` is true for the cardinalities of any three types `α`, `β`, and `γ`, then the property `p` is also true for the cardinal numbers `c₁`, `c₂`, and `c₃`. In this context, a property about cardinal numbers is a logical statement that can either be true or false for given cardinal numbers. The theorem is a form of induction principle for cardinal numbers, but instead of a single cardinal number, it deals with three cardinal numbers at a time.

If a property holds for the cardinalities of any types α, β, and γ, then it holds for the cardinal numbers c₁, c₂, and c₃.


theorem ProbabilityTheory.kernel.indep_iSup_of_directed_le :
    ∀ {α : Type u_1} {ι : Type u_3} {_mα : MeasurableSpace α} {Ω : Type u_4} {m : ι → MeasurableSpace Ω}
      {m' m0 : MeasurableSpace Ω} {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α}
      [inst : ProbabilityTheory.IsMarkovKernel κ],
      (∀ (i : ι), ProbabilityTheory.kernel.Indep (m i) m' κ μ) →
        (∀ (i : ι), m i ≤ m0) →
          m' ≤ m0 → Directed (fun x x_1 => x ≤ x_1) m → ProbabilityTheory.kernel.Indep (⨆ i, m i) m' κ μ :=
  by sorry

This theorem states that in a probability theory context, given a set `α` and an index set `ι`, along with measurable spaces over a set `Ω` defined by a function `m` indexed by `ι` and two other measurable spaces `m'` and `m0`. If we have a Markov kernel `κ` from `α` to `Ω` and a measure `μ` over `α`, we can show the following: If every `m i` is independent from `m'` with respect to `κ` and `μ`, if every `m i` is a sub-measurable space of `m0`, and if `m'` is a sub-measurable space of `m0`, and if the `m i`'s form a directed set with respect to the subset relation, then the supremum of the `m i`'s is also independent from `m'` with respect to `κ` and `μ`. In other words, the independence property is preserved when moving from any index `i` to the supremum over all indices in the context of directed sets and Markov kernels.

Given a measurable space `(Ω, Σ)`, a set `α`, an index set `ι`, measurable spaces `(α, Σα)` and `(Ω, Σ′)` over `Ω`, a Markov kernel `κ : α -> Ω`, and a measure `μ` over `α`, if for all `i ∈ ι`, `m i` is a sub-measurable, independent sub-σ-algebra of `m0 = Σ′` with respect to `κ` and `μ`, then the supremum of the `m i`'s is also independent from `m' = Σ` with respect to `κ` and `μ`.


theorem MeasureTheory.ae_imp_of_ae_restrict :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {p : α → Prop},
      (∀ᵐ (x : α) ∂μ.restrict s, p x) → ∀ᵐ (x : α) ∂μ, x ∈ s → p x :=
  by sorry

This theorem, `MeasureTheory.ae_imp_of_ae_restrict`, states that for any type `α`, any `MeasurableSpace` on `α`, any `MeasureTheory.Measure` on `α`, any set `s` of `α`, and any property `p` defined on `α`, if almost everywhere in the measure restricted to set `s`, the property `p` holds, then almost everywhere in the original measure, if an element `x` is in the set `s`, the property `p` holds for `x`. In other words, if a property is almost universally true on a measure-restricted set, then it will also be almost universally true on the whole set, provided the elements are in the restricted set.

If a property holds almost everywhere in the measure restriction of a set, then it holds almost everywhere in the original measure for elements in that set.


theorem CategoryTheory.Iso.symm_hom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y), α.symm.hom = α.inv := by sorry

This theorem states that in any category `C`, for all objects `X` and `Y` in `C`, if there exists an isomorphism `α` between `X` and `Y`, then the morphism from `Y` to `X` in the inverse of `α` (denoted as `α.symm.hom`) is equal to the inverse of `α` (denoted as `α.inv`). In simpler terms, it asserts that the morphism of the inverse of an isomorphism is the inverse of the original isomorphism itself, in the context of category theory.

In any category, the inverse of an isomorphism is equal to its symmetric morphism (i.e., the morphism induced by composing the isomorphism with its inverse).


/-- Post-composition by a uniformly continuous function is uniformly continuous on `α →ᵤ β`.

More precisely, if `f : γ → β` is uniformly continuous, then `(fun g ↦ f ∘ g) : (α →ᵤ γ) → (α →ᵤ β)`
is uniformly continuous.  -/
theorem UniformFun.postcomp_uniformContinuous :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] [inst_1 : UniformSpace γ] {f : γ → β},
      UniformContinuous f → UniformContinuous (⇑UniformFun.ofFun ∘ (fun x => f ∘ x) ∘ ⇑UniformFun.toFun) :=
  by sorry

The theorem `UniformFun.postcomp_uniformContinuous` states that if a function `f` from some type γ to another type β is uniformly continuous, then the function that post composes any function from type α to γ with `f` is also uniformly continuous. More formally, given a uniformly continuous function `f : γ → β`, the function `(fun g ↦ f ∘ g) : (α →ᵤ γ) → (α →ᵤ β)` is uniformly continuous. This means no matter where the inputs to `f` and `g` are located in their domains, as the inputs get arbitrarily close to each other, the outputs of the composed function `(f ∘ g)` also get arbitrarily close to each other.

If `f` is a uniformly continuous function from type γ to type β, then the function `(f ∘ g)` obtained bypost composing any uniformly continuous function `g` from type α to type γ with `f` is also uniformly continuous from type α to type β.


theorem Mathlib.Order.Filter.Basic._auxLemma.79 :
    ∀ {α : Type u} {p : α → Prop}, (∀ᶠ (x : α) in ⊤, p x) = ∀ (x : α), p x := by sorry

This theorem states that for any type `α` and a property `p` that applies to elements of `α`, the statement "for almost every `x` of type `α` in the top filter, `p x` holds" is equivalent to "for every `x` of type `α`, `p x` holds". Here, the top filter (represented by `⊤`) is a filter that contains all subsets of `α`. Thus, the theorem establishes that in such a universal context, the concepts of "almost every" and "every" coincide.

For any type `α` and property `p` on `α`, "p holds for almost every x in α if and only if p holds for all x in α" (equivalently, "p holds for almost all x in the top filter on α if and only if p holds universally on α").


theorem Mathlib.Order.Filter.Basic._auxLemma.20 : ∀ {α : Type u} {f : Filter α}, (¬Filter.NeBot f) = (f = ⊥) := by sorry

This theorem, `Mathlib.Order.Filter.Basic._auxLemma.20`, states that for any type `α` and any filter `f` on `α`, the negation of the statement "filter `f` is not the bottom element" is equivalent to saying "filter `f` is the bottom element". In other words, if `f` is not a non-empty filter (not NeBot), then `f` is the bottom filter, denoted by `⊥`. The bottom filter `⊥` is a special filter that contains all sets.

The statement `Mathlib.Order.Filter.Basic._auxLemma.20` in Lean 4 asserts that for any filter `f` on type `α`, `~(f ≠ ⊥)` is equivalent to `f = ⊥`.


theorem Stream'.cons_append_stream :
    ∀ {α : Type u} (a : α) (l : List α) (s : Stream' α), a :: l ++ₛ s = Stream'.cons a (l ++ₛ s) := by sorry

This theorem, `Stream'.cons_append_stream`, states that for any type `α`, any element `a` of type `α`, any list `l` of elements of type `α`, and any Stream `s` of elements of type `α`, prepending `a` to the concatenation of `l` and `s` (`a :: l ++ₛ s`) is equivalent to creating a new Stream where `a` is the first element and the concatenation of `l` and `s` forms the rest of the Stream (`Stream'.cons a (l ++ₛ s)`).

For any type α, the stream obtained by consing an element a to the concatenation of a list l and a stream s is equal to the stream obtained by consing a to the stream formed by the concatenation of l and s. In Lean notation: ∀α, a :: l ++ₛ s = Stream.cons a (l ++ₛ s).


theorem AkraBazziRecurrence.growsPolynomially_id : AkraBazziRecurrence.GrowsPolynomially fun x => x := by sorry

The theorem `AkraBazziRecurrence.growsPolynomially_id` states that the identity function `x` satisfies the Akra-Bazzi growth condition. In other words, for any constant `b` in the open interval `(0,1)`, there exist positive constants `c₁` and `c₂` such that for all sufficiently large `x`, for any `u` between `b*x` and `x`, `u` lies in the closed interval `[c₁*x, c₂*x]`. The identity function thus grows polynomially in accordance with the Akra-Bazzi theorem's requirement.

For the identity function, there exist constants `c₁, c₂` such that for all sufficiently large `x`, any number `u` between `b*x` and `x` satisfies `c₁*x ≤ u ≤ c₂*x` for `0<b<1`.


theorem Finsupp.toMultiset_add :
    ∀ {α : Type u_1} (m n : α →₀ ℕ), Finsupp.toMultiset (m + n) = Finsupp.toMultiset m + Finsupp.toMultiset n := by
  sorry

The theorem `Finsupp.toMultiset_add` states that for all types `α` and for any two functions `m` and `n` mapping from `α` to the natural numbers, converting the sum of `m` and `n` (under the function addition operation) to a multiset using `Finsupp.toMultiset` is equivalent to converting `m` and `n` separately to multisets and then adding the resulting multisets. In other words, the `Finsupp.toMultiset` function preserves the addition operation.

For all types α and functions m, n from α to ℕ, Finsupp.toMultiset (m + n) = Finsupp.toMultiset m ⊕ Finsupp.toMultiset n.


theorem IsDedekindDomain.HeightOneSpectrum.mem_adicCompletionIntegers :
    ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
      [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
      {x : IsDedekindDomain.HeightOneSpectrum.adicCompletion K v},
      x ∈ IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v ↔ Valued.v x ≤ 1 :=
  by sorry

The theorem `IsDedekindDomain.HeightOneSpectrum.mem_adicCompletionIntegers` states that for any commutative ring `R` which is a Dedekind domain, a field `K` which is a fraction field of `R`, and a height one prime `v` of `R`, an element `x` of the `v`-adic completion of `K` is in the ring of integers of this `v`-adic completion if and only if its valuation is less than or equal to 1. The `v`-adic completion of `K` is a completion of `K` with respect to its `v`-adic valuation. The ring of integers of this `v`-adic completion is a subring of the `v`-adic completion. A valuation of `x` maps `x` to an element in a linearly ordered commutative group with zero.

For a commutative Dedekind domain R with fraction field K and height one prime v, an element x of the v-adic completion of K belongs to the subring of integers if and only if its valuation is less than or equal to 1.


theorem CategoryTheory.Faithful.of_comp_eq :
    ∀ {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} {H : CategoryTheory.Functor C E}
      [ℋ : CategoryTheory.Faithful H], CategoryTheory.Functor.comp F G = H → CategoryTheory.Faithful F :=
  by sorry

This theorem states that in the context of category theory, given categories C, D, and E, and functors F: C → D, G: D → E, and H: C → E, if H is a faithful functor (meaning it injects morphisms) and the composition of F and G equals H, then F is also a faithful functor.

If functors F: C → D, G: D → E, and H: C → E are such that H is faithful, and F = G ∘ H, then F is faithful.


theorem Mathlib.CategoryTheory.Monoidal.Functor._auxLemma.2 :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X : C) {Y₁ Y₂ : C}
      (f : Y₁ ⟶ Y₂),
      CategoryTheory.MonoidalCategory.whiskerLeft X f =
        CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id X) f :=
  by sorry

This theorem in the field of category theory states that for any category `C` which is also a monoidal category, and for any objects `X`, `Y₁`, `Y₂` in `C`, and a morphism `f` from `Y₁` to `Y₂`, the left whiskering of `f` with `X` (which is the act of pre-composing each morphism in the functor category with `f`) is equal to the tensor product of the identity morphism on `X` and the morphism `f`. This theorem thus provides a relation between the concepts of left whiskering and tensor product in the context of a monoidal category.

In a monoidal category, for any object X and morphism f, the left whiskering of f with X is equal to the tensor product of the identity morphism on X and f.


theorem Mathlib.CategoryTheory.Monoidal.Functor._auxLemma.1 :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X₁ X₂ : C}
      (f : X₁ ⟶ X₂) (Y : C),
      CategoryTheory.MonoidalCategory.whiskerRight f Y =
        CategoryTheory.MonoidalCategory.tensorHom f (CategoryTheory.CategoryStruct.id Y) :=
  by sorry

This theorem, named `Mathlib.CategoryTheory.Monoidal.Functor._auxLemma.1`, is a statement about Monoidal Categories in Category Theory. For any type `C` that forms a category `𝒞` and a Monoidal Category `inst`, and for any two objects `X₁` and `X₂` in `C` with a morphism `f` from `X₁` to `X₂`, and any object `Y` in `C`, the result of whiskering on the right by `f` on `Y` is equal to the tensor product of the morphism `f` and the identity morphism on `Y`. The equality here is in terms of morphisms in the Monoidal Category `C`. This theorem asserts that these two ways of manipulating morphisms and objects in a monoidal category are equivalent.

For any Monoidal Category `C` with type `𝒞`, object `X₁`, object `X₂`, morphism `f : X₁ → X₂`, and object `Y` in `C`, the right whiskering of `f` on `Y` is equal to the tensor product of `f` and the identity morphism on `Y`.


/-- A polynomial splits if and only if it has as many roots as its degree.  -/
theorem Polynomial.splits_iff_card_roots :
    ∀ {K : Type v} [inst : Field K] {p : Polynomial K},
      Polynomial.Splits (RingHom.id K) p ↔ Multiset.card (Polynomial.roots p) = Polynomial.natDegree p :=
  by sorry

This theorem states that a polynomial over a field splits if and only if the number of its roots, including their multiplicities, is equal to its degree. Here, a polynomial is said to split if it is either zero or all of its irreducible factors have degree 1. The roots of the polynomial are computed non-computationally, giving a multiset that includes all the roots along with their multiplicities. The degree of the polynomial is forced to a natural number, with the degree of the zero polynomial defined as 0. The identity mapping of the field is used in the definition of a splitting polynomial.

A polynomial over a field is splitting if and only if it has exactly degree-many roots, counted with multiplicity.


theorem Real.rpow_sub' : ∀ {x : ℝ}, 0 ≤ x → ∀ {y z : ℝ}, y - z ≠ 0 → x ^ (y - z) = x ^ y / x ^ z := by sorry

This theorem states that for any real number `x` that is greater than or equal to zero, and for any real numbers `y` and `z` such that their difference is not zero, the power of `x` raised to the difference of `y` and `z` is equal to the ratio of the power of `x` raised to `y` and the power of `x` raised to `z`. In mathematical notation, this would be represented as: for all $x$, $y$, $z$ in $\mathbb{R}$ with $x \geq 0$ and $y - z \neq 0$, $x^{y-z} = \frac{x^y}{x^z}$.

For any real numbers $x \ge 0$, $y$, and $z$ with $y \neq z$, $x^{y-z} = \frac{x^y}{x^z}$.


theorem Inducing.prod_map :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : X → Y} {g : Z → W},
      Inducing f → Inducing g → Inducing (Prod.map f g) :=
  by sorry

The theorem `Inducing.prod_map` states that for any four types `X`, `Y`, `Z`, and `W`, equipped with topological spaces, given two functions `f : X → Y` and `g : Z → W`, if `f` is an inducing function and `g` is also an inducing function, then the function `Prod.map f g`, which is defined on the Cartesian product of `X` and `Z` and maps each pair `(x, z)` to `(f(x), g(z))`, is also an inducing function. Here, an inducing function is one that induces (pulls back) the topology of its codomain to its domain.

If functions `f : X → Y` and `g : Z → W` are inducing functions on topological spaces `X × Z`, then their composition `Prod.map f g : X × Z → Y × W` is also an inducing function.