theorem Cardinal.power_def : ∀ (α β : Type u), Cardinal.mk α ^ Cardinal.mk β = Cardinal.mk (β → α) := by sorry

This theorem, `Cardinal.power_def`, states that for any two types `α` and `β`, the cardinality of `α` raised to the power of the cardinality of `β` is equal to the cardinality of the type of functions from `β` to `α`. In mathematical notation, this can be written as |α|^|β| = |β → α|. This corresponds to the standard set-theoretic definition of exponentiation in cardinal numbers, i.e., the size of the set of all functions from a set of size `β` to a set of size `α`.

The cardinality of a type raised to the power of another cardinality is equal to the cardinality of the type of functions from that cardinality to the first type. |α|^|β| = |β → α|.


theorem SchwartzMap.seminormAux_nonneg :
    ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (k n : ℕ) (f : SchwartzMap E F),
      0 ≤ SchwartzMap.seminormAux k n f :=
  by sorry

This theorem states that for any Schwartz map `f` from a real normed space `E` to another real normed space `F` (with `E` and `F` both being normed additive commutative groups), and for any non-negative integers `k` and `n`, the auxiliary seminorm of the Schwartz map `f`, denoted by `SchwartzMap.seminormAux k n f`, is always non-negative. In other words, the auxiliary seminorm of a Schwartz map is always a non-negative real number.

For any Schwartz map from a real normed space to another real normed space, the auxiliary seminorm is non-negative for all non-negative integers.


theorem Multiset.range_subset : ∀ {m n : ℕ}, Multiset.range m ⊆ Multiset.range n ↔ m ≤ n := by sorry

The theorem `Multiset.range_subset` states that for any two natural numbers `m` and `n`, the multiset `range m`, which is the set of natural numbers from `0` to `m-1`, is a subset of the multiset `range n`, which is the set of natural numbers from `0` to `n-1`, if and only if `m` is less than or equal to `n`. Essentially, it's saying that the range of numbers up to `m` can only be contained in the range of numbers up to `n` if `m` is not greater than `n`.

The theorem `Multiset.range_subset` asserts that for all natural numbers `m` and `n`, `range m` is a subset of `range n` if and only if `m <= n`.


theorem Nat.coprime_two_left : ∀ {n : ℕ}, Nat.Coprime 2 n ↔ Odd n := by sorry

The theorem `Nat.coprime_two_left` states that for any natural number `n`, `n` and `2` are coprime (or relatively prime, meaning their greatest common divisor is `1`) if and only if `n` is odd. In other words, a natural number shares no common factor greater than `1` with `2` precisely when it is odd, which is defined as there existing a natural number `k` such that `n = 2*k + 1`.

A natural number `n` is coprime to 2 if and only if `n` is odd.


theorem Filter.HasBasis.lift'_interior :
    ∀ {X : Type u} {ι : Sort w} [inst : TopologicalSpace X] {l : Filter X} {p : ι → Prop} {s : ι → Set X},
      Filter.HasBasis l p s → Filter.HasBasis (Filter.lift' l interior) p fun i => interior (s i) :=
  by sorry

The theorem `Filter.HasBasis.lift'_interior` states that for any type `X`, any type `ι`, and any topological space over `X`, if we have a filter `l` over `X` and two functions `p : ι → Prop` and `s : ι → Set X` such that `l` has a basis defined by the properties `p(i)` and sets `s(i)`, then the filter obtained by lifting `l` via the function `interior` (which assigns to each set its interior) also has a basis defined by the properties `p(i)` and the interiors of the sets `s(i)`. In other words, the interior operation preserves the basis of the filter.

For any type `X`, topological space over `X`, filter `l` on `X`, and functions `p : ι → Prop` and `s : ι → Set X` such that `l` has a basis given by `p(i)` and `s(i)`, the filter obtained by lifting `l` via the `interior` function also has a basis given by `p(i)` and the interiors of `s(i)`.


theorem Polynomial.int_cyclotomic_spec :
    ∀ (n : ℕ),
      Polynomial.map (Int.castRingHom ℂ) (Polynomial.cyclotomic n ℤ) = Polynomial.cyclotomic' n ℂ ∧
        Polynomial.degree (Polynomial.cyclotomic n ℤ) = Polynomial.degree (Polynomial.cyclotomic' n ℂ) ∧
          Polynomial.Monic (Polynomial.cyclotomic n ℤ) :=
  by sorry

The theorem `Polynomial.int_cyclotomic_spec` states that for all natural numbers `n`, three properties hold. First, mapping the `n`-th cyclotomic polynomial with integer coefficients to complex numbers using the integer ring homomorphism is equivalent to the modified `n`-th cyclotomic polynomial with complex coefficients. Second, the degree of the `n`-th cyclotomic polynomial with integer coefficients is equal to the degree of the modified `n`-th cyclotomic polynomial with complex coefficients. Third, the `n`-th cyclotomic polynomial with integer coefficients is a Monic polynomial, meaning its leading coefficient is 1.

The `n`-th cyclotomic polynomial with integer coefficients and its modified complex version have equal degrees, coefficients obtained via ring homomorphism are equal, and both are monic polynomials.


theorem NormedAddGroupHom.NormNoninc.normNoninc_iff_norm_le_one :
    ∀ {V : Type u_1} {W : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
      {f : NormedAddGroupHom V W}, NormedAddGroupHom.NormNoninc f ↔ ‖f‖ ≤ 1 :=
  by sorry

This theorem states that for any two types `V` and `W`, which are semi-normed additive commutative groups, a normed additive group homomorphism `f` from `V` to `W` is norm-nonincreasing (meaning the norm of `f v` is less than or equal to the norm of `v` for all `v` in `V`) if and only if the norm of `f` is less than or equal to one.

A normed additive group homomorphism between two semi-normed additive commutative groups is norm-nonincreasing if and only if its norm is less than or equal to 1.


theorem CategoryTheory.transferNatTransSelf_counit :
    ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C]
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D}
      {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (f : L₂ ⟶ L₁) (X : D),
      CategoryTheory.CategoryStruct.comp (L₂.map (((CategoryTheory.transferNatTransSelf adj₁ adj₂) f).app X))
          (adj₂.counit.app X) =
        CategoryTheory.CategoryStruct.comp (f.app (R₁.obj X)) (adj₁.counit.app X) :=
  by sorry

This theorem, named `CategoryTheory.transferNatTransSelf_counit`, establishes a property of natural transformations in category theory. Given two categories `C` and `D` with respective functors `L₁`, `L₂`, `R₁` and `R₂`, and where `L₁` is left adjoint to `R₁` and `L₂` is left adjoint to `R₂`, the theorem states that for any natural transformation `f` from `L₂` to `L₁` and any object `X` in `D`, the composition of the mapping of the application of the transferred natural transformation at `X` through `L₂` and the application of the counit of the adjunction at `X` in `adj₂` is equal to the composition of the application of `f` at the object `R₁.obj X` and the application of the counit of the adjunction at `X` in `adj₁`. This is a key property of transferred natural transformations between adjunctions in category theory.

For natural transformations `f` from the left adjoint `L₂` to the left adjoint `L₁` of functors `L₁`, `L₂`, `R₁`, and `R₂` between categories `C` and `D`, with adjunctions `adj₁` and `adj₂`, the composition of `L₂.apply f X` and `adj₂.counit X` equals the composition of `f.apply (R₁.obj X)` and `adj₁.counit X`.


theorem norm_pow_le_mul_norm : ∀ {E : Type u_6} [inst : SeminormedCommGroup E] (n : ℕ) (a : E), ‖a ^ n‖ ≤ ↑n * ‖a‖ := by
  sorry

This theorem states that for any seminormed commutative group `E` and any element `a` of `E`, the norm of `a` raised to the power of a natural number `n` is less than or equal to `n` times the norm of `a`. Formally, for all `n` in ℕ and `a` in `E`, `‖a^n‖ ≤ n * ‖a‖`. This theorem holds for any Type `E` that has a seminormed commutative group structure.

For any seminormed commutative group `E` and natural number `n`, the norm of `a` raised to the power of `n` in `E` is bounded above by `n` times the norm of `a`.


theorem USize.size_eq : USize.size = 2 ^ System.Platform.numBits := by sorry

This theorem states that the size of an unsigned machine integer (`USize.size`) is equal to `2` raised to the power of the number of bits in the platform architecture (`System.Platform.numBits`). In other words, the number of distinct values that an unsigned machine integer can represent is exactly the total number of different bit patterns that can be represented with the word size of the platform, which is either 32 or 64 bits.

The size of an unsigned machine integer (`USize`) is equal to 2 raised to the number of bits in the platform architecture (`System.Platform.numBits`). Equivalently, the number of distinct values an unsigned machine integer can represent is 2 raised to the word size of the platform.


theorem Submodule.finrank_lt_finrank_of_lt :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      {s t : Submodule K V} [inst_3 : FiniteDimensional K ↥t],
      s < t → FiniteDimensional.finrank K ↥s < FiniteDimensional.finrank K ↥t :=
  by sorry

This theorem states that for any division ring `K` and an additive commutative group `V` that forms a module over `K`, if `s` and `t` are submodules of `V` such that `t` is of finite dimension and `s` is strictly smaller than `t`, then the rank (or the dimension in the finite case) of `s` is strictly less than the rank of `t`. Here, `<` denotes the proper subset relation between submodules and not a numerical comparison.

If `K` is a division ring, `V` is an additive commutative `K`-module, `s` and `t` are submodules of `V` with `t` finite-dimensional and `s` a proper submodule of `t`, then the dimension of `s` is strictly less than the dimension of `t`.


theorem atTop_le_cocompact :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : NoMaxOrder α]
      [inst_3 : ClosedIciTopology α], Filter.atTop ≤ Filter.cocompact α :=
  by sorry

The theorem `atTop_le_cocompact` states that for any type `α`, which has a linear order, a topological space structure, is without a maximum element (`NoMaxOrder α`), and such that the topology is closed for the set of all elements greater than or equal to a given one (`ClosedIciTopology α`), the filter representing the limit towards positive infinity (`Filter.atTop`) is smaller than or equal to the filter generated by the complements of compact sets (`Filter.cocompact α`) in the order of filters. This essentially means that every neighborhood of infinity (every set that contains all sufficiently large elements) also contains the complement of some compact set.

For any type `α` with a linear order, without a maximum element, and a closed order topology, the filter of elements greater than any given one is contained in the filter generated by the complements of compact sets.


theorem Rat.cast_nonneg : ∀ {K : Type u_5} [inst : LinearOrderedField K] {n : ℚ}, 0 ≤ ↑n ↔ 0 ≤ n := by sorry

This theorem states that for any type `K` which is a linear ordered field, and a given rational number `n`, the non-negative condition (greater or equal to zero) is preserved under the cast from the rational number to `K`. In other words, `n` is non-negative when expressed as a rational number if and only if it is also non-negative when cast to the type `K`.

For any linear ordered field `K` and rational number `n`, `0 ≤ n` if and only if `0 ≤ (n : K)`.


/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero.  -/
theorem Real.tendsto_div_pow_mul_exp_add_atTop :
    ∀ (b c : ℝ) (n : ℕ), 0 ≠ b → Filter.Tendsto (fun x => x ^ n / (b * Real.exp x + c)) Filter.atTop (nhds 0) := by
  sorry

The theorem `Real.tendsto_div_pow_mul_exp_add_atTop` states that for any non-zero real number `b`, any real number `c`, and any natural number `n`, the function `(x ^ n) / (b * exp(x) + c)` tends to `0` as `x` tends to infinity. Here, `x ^ n` represents `x` raised to the power `n`, `exp(x)` is the exponential function, and `/` denotes division. Essentially, this theorem tells us that regardless of the particular values of `b`, `c`, and `n` (as long as `b` is not zero), the value of our function becomes arbitrarily close to `0` for sufficiently large `x`.

For any non-zero real number `b` and real numbers `c` and `n`, the function `x => (x ^ n) / (b * exp(x) + c)` approaches `0` as `x` approaches infinity.


theorem Complex.closure_preimage_im : ∀ (s : Set ℝ), closure (Complex.im ⁻¹' s) = Complex.im ⁻¹' closure s := by sorry

The theorem `Complex.closure_preimage_im` states that for any set `s` of real numbers, the closure of the preimage of `s` under the imaginary part function of complex numbers is equal to the preimage of the closure of `s` under the same function. In other words, closing the set before applying the preimage operation with the imaginary part of complex numbers is the same as applying the preimage operation first and then closing the set. This theorem provides a property of continuity for the imaginary part function in the context of topological spaces.

The closure of the preimage of a real set under the imaginary part function of complex numbers is equal to the preimage of the closure of that set.


theorem Equiv.Perm.IsCycle.support_pow_eq_iff :
    ∀ {α : Type u_2} {f : Equiv.Perm α} [inst : DecidableEq α] [inst_1 : Fintype α],
      Equiv.Perm.IsCycle f → ∀ {n : ℕ}, Equiv.Perm.support (f ^ n) = Equiv.Perm.support f ↔ ¬orderOf f ∣ n :=
  by sorry

This theorem states that for any type `α` and a given permutation `f` on `α`, assuming `α` has decidable equality and is finite, if `f` is a cycle, then for any natural number `n`, the set of non-fixed points of `f^n` (that is, the points that `f^n` moves) is the same as the set of non-fixed points of `f` if and only if the order of `f` does not divide `n`. Here, the order of `f` refers to the smallest `n ≥ 1` such that `f^n` is the identity permutation, or `0` if no such `n` exists. In the context of group theory, this theorem connects the property of a permutation (being a cycle) with its algebraic property (its order).

For any finite type `α` with decidable equality and permutation `f` that is a cycle, the sets of non-fixed points of `f` and `f^n` are equal if and only if the order of `f` does not divide `n`.


theorem Matrix.adjugate_apply :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α)
      (i j : n), Matrix.adjugate A i j = Matrix.det (Matrix.updateRow A j (Pi.single i 1)) :=
  by sorry

This theorem, `Matrix.adjugate_apply`, states that for any square matrix `A` with elements of a commutative ring `α`, and for any pair of indices `(i, j)`, the `(i,j)`-th entry of the adjugate of `A` equals the determinant of the matrix obtained by updating the `j`-th row of `A` with the function supported at `i` with value `1` and `0` elsewhere. In other words, the adjugate of `A` at position `(i, j)` is computed by replacing the `j`-th row of `A` with a row that has `1` at the `i`-th position and `0`'s elsewhere, and calculating the determinant of the resulting matrix.

The `(i, j)`-th entry of the adjugate of a square matrix `A` over a commutative ring is equal to the determinant of the matrix obtained by replacing the `j`-th row of `A` with the `i`-th row and setting all other entries in the replaced row to zero.


theorem Complex.arg_neg_eq_arg_add_pi_of_im_neg : ∀ {x : ℂ}, x.im < 0 → Complex.arg (-x) = Complex.arg x + Real.pi := by
  sorry

The theorem `Complex.arg_neg_eq_arg_add_pi_of_im_neg` states that for any complex number `x` with a negative imaginary part, the argument of the negation of `x` (i.e., `-x`) is equal to the argument of `x` plus π. This is a property that relates the argument of a complex number and its negation, specific to the case where the imaginary part of the original complex number is negative.

For complex numbers `x` with negative imaginary part, the argument of `-x` equals the argument of `x` + π.


theorem Finset.sum_mono_set_of_nonneg :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedAddCommMonoid N] {f : ι → N},
      (∀ (x : ι), 0 ≤ f x) → Monotone fun s => Finset.sum s fun x => f x :=
  by sorry

The theorem `Finset.sum_mono_set_of_nonneg` states that for any type `ι`, any ordered additive commutative monoid `N`, and any function `f` from `ι` to `N`, if `f` maps every element of `ι` to a nonnegative value (i.e., `f(x) ≥ 0` for all `x` in `ι`), then the function that maps a finite set `s` to the sum of `f(x)` for each `x` in `s` is monotone. In other words, if we have two sets `a` and `b` such that `a` is a subset of `b`, the sum of `f` evaluated at each element in `a` is less than or equal to the sum of `f` evaluated at each element in `b`. This is a statement about the preservation of order under summation in the context of nonnegative functions.

For any ordered additive commutative monoid N and function f from a type ι to N with f(x) ≥ 0 for all x in ι, the function summing f over finite sets is monotone, i.e., the sum of f(x) over a subset is less than or equal to the sum over a superset.


theorem AlgHom.coe_range :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : Semiring B] [inst_4 : Algebra R B] (φ : A →ₐ[R] B), ↑(AlgHom.range φ) = Set.range ⇑φ :=
  by sorry

This theorem asserts that for all commutative semirings `R`, semirings `A` and `B`, and algebras `A` and `B` over `R`, the set of elements in the range of any algebra homomorphism `φ` from `A` to `B` over `R` (denoted as `AlgHom.range φ`) is identical to the set of elements obtained by applying the function `φ` to all possible arguments (denoted as `Set.range φ`). In other words, it equates the set of outputs of `φ` considered as an algebra homomorphism, with the set of its outputs considered merely as a function.

For any commutative semirings R, semirings A and B, and algebra homomorphisms φ from A to B over R, the image of φ as an algebra homomorphism equals the image of φ considered as a function, i.e., AlgHom.range φ = Set.range φ.


theorem RingHom.mapMatrix_apply :
    ∀ {m : Type u_2} {α : Type v} {β : Type w} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NonAssocSemiring α]
      [inst_3 : NonAssocSemiring β] (f : α →+* β) (M : Matrix m m α), (RingHom.mapMatrix f) M = Matrix.map M ⇑f :=
  by sorry

The theorem `RingHom.mapMatrix_apply` states that for any type `m`, with finite instances and decidable equality, and for any types `α` and `β`, which are non-associative semirings, if `f` is a ring homomorphism from `α` to `β` and `M` is a square matrix of type `m` with entries from `α`, then applying the function `RingHom.mapMatrix` on `f` and `M` is the same as mapping `f` over each entry of the matrix `M` using the function `Matrix.map`. Here, `⇑f` is the coercion of the ring homomorphism `f` to a function.

For any square matrix M with entries from a non-associative semiring α, and for any ring homomorphism f from α to another semiring β, applying the function RingHom.mapMatrix on f and M is equivalent to mapping f to each entry of M using Matrix.map.


theorem Int.self_le_toNat : ∀ (a : ℤ), a ≤ ↑(Int.toNat a) := by sorry

This theorem states that for any integer `a`, `a` is less than or equal to the natural number that `a` is converted to using the `Int.toNat` function. In terms of mathematical notation, for all integers `a`, `a` ≤ `Int.toNat(a)`. It is important to note that the `Int.toNat` function converts an integer into a natural number with negative numbers becoming `0`. Thus, for negative integers, the theorem verifies that they are always less than or equal to `0`.

For all integers `a`, `a` is less than or equal to the natural number `Int.toNat(a)`.


/-- The `vectorSpan` of a finite set is finite-dimensional.  -/
theorem finiteDimensional_vectorSpan_of_finite :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] {s : Set P},
      Set.Finite s → FiniteDimensional k ↥(vectorSpan k s) :=
  by sorry

The theorem `finiteDimensional_vectorSpan_of_finite` states that for any division ring `k`, additive commutative group `V`, additive torsor `P`, and set `s` of type `P`, if the set `s` is finite, then the vector space spanned by the differences of any pairs of points in `s` (that is, the `vectorSpan` of `s`) is finite-dimensional over `k`. This means that there exists a finite number `n` such that there is a linear equivalence between `vectorSpan k s` and the `n`-dimensional vector space over `k`.

If `k` is a division ring, `V` is an additive commutative group, `P` is an additive torsor over `V`, and `s` is a finite set in `P`, then the vector space spanned by the differences of pairs of points in `s` is finite-dimensional over `k`, with a dimension equal to some natural number.


theorem gcd_zero_right :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α),
      gcd a 0 = normalize a :=
  by sorry

The theorem `gcd_zero_right` states that for any type `α` equipped with a structure of a `CancelCommMonoidWithZero` and a `NormalizedGCDMonoid`, for any element `a` of type `α`, the greatest common divisor of `a` and `0` equals to the normalized version of `a`. In other words, it says that in this mathematical structure, the gcd of any element and zero is just that element, but normalized (multiplied by the associated unit normal for that element). This is a generalization of the concept that the gcd of any number and zero is the absolute value of that number.

For any type `α` with `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` structures, the normalized version of an element `a` is the greatest common divisor of `a` and `0`.


/-- If there exists a addition-preserving equivalence between `G` and `H`,
then the exponent of `G` is equal to the exponent of `H`. -/
theorem AddMonoid.exponent_eq_of_addEquiv :
    ∀ {G : Type u} [inst : AddMonoid G] {H : Type u_1} [inst_1 : AddMonoid H],
      G ≃+ H → AddMonoid.exponent G = AddMonoid.exponent H :=
  by sorry

The theorem states that if there exists an additive equivalence (a bijective function that preserves addition) between two types `G` and `H`, both equipped with an additive monoid structure, then the exponent of `G` is equal to the exponent of `H`. Remember, the exponent of an additive group `G` is the smallest positive integer `n` such that `n • g = 0` for all `g` in `G`, if such an integer exists; otherwise, it is zero by convention. So this theorem is saying that if there's a structure-preserving bijection between two additive groups, their exponents are also the same.

If two additive groups, equipped with bijective additive equivalences between them, have identical additive identities and associative binary operations, then they have equal exponents.


theorem HasStrictFDerivAt.image_mem_toPartialHomeomorph_target :
    ∀ {𝕜 : 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]
      [inst_5 : CompleteSpace E] {f : E → F} {f' : E ≃L[𝕜] F} {a : E} (hf : HasStrictFDerivAt f (↑f') a),
      f a ∈ (HasStrictFDerivAt.toPartialHomeomorph f hf).target :=
  by sorry

This theorem states that for any non-trivial normed field `𝕜`, normed additive commutative groups `E` and `F` equipped with a normed space structure over `𝕜`, where `E` is complete, if a function `f : E → F` has a strict Fréchet derivative at a point `a` in `E`, represented by the linear map `f' : E ≃L[𝕜] F`, then the image of `a` under `f` is within the target set of the partial homeomorphism induced by the strict derivative of `f` at `a`.

If `f : E → F` is a strict differentiable function from a complete normed additive commutative group `E` to a normed space `F` over a non-trivial normed field `𝕜`, with strict derivative `f' : E ≃L[𝕜] F` at a point `a` in `E`, then `f(a)` lies in the image of the partial homeomorphism induced by `f'` at `a`.


Prod.forall

theorem Prod.forall :
    ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) ↔ ∀ (a : α) (b : β), p (a, b) := by sorry

This theorem states that for any two types `α` and `β`, and a property `p` that applies to a pair of elements (one from each type), the statement "for all pairs `(a, b)`, `p (a, b)` holds true" is equivalent to "for all pairs `x`, `p x` holds true". In other words, it says that the property holds for all pairs in the Cartesian product of the two types, regardless of how we express the pair.

For any types `α` and `β` and property `p` on pairs `(α × β) → Prop`, the statements "for all `(a, b)`, `p a b` hold true" and "for all `x`, `p x.fst x.snd` hold true" are equivalent.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.8 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem states that for all types `α` and any two elements `a` and `b` of type `α`, the proposition `a = b` is equivalent to `b = a`. In other words, equality is symmetric: if `a` equals `b`, then `b` equals `a`.

For all types `α` and all elements `a` and `b` of type `α`, the proposition `a = b` is equivalent to `b = a`. (Or more succinctly: Equality is a symmetric relation.)


theorem Mathlib.Data.Sum.Order._auxLemma.14 :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a b : α ⊕ β},
      (toLex a ≤ toLex b) = Sum.Lex (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) a b :=
  by sorry

The theorem `Mathlib.Data.Sum.Order._auxLemma.14` states that for any two elements `a` and `b` of the sum type `α ⊕ β`, where `α` and `β` are types with a less than or equal to (≤) relation, the statement that `a` is less than or equal to `b` under the `toLex` function (which essentially treats `a` and `b` as elements of the lexicographic order type `Lex α`) is equivalent to the statement that `a` is less than or equal to `b` under the sum lexicographic order `Sum.Lex`, where the ordering on both components is the less than or equal to relation of the respective types.

For any `a : α ⊕ β` and `b : α ⊕ β` in a sum type with types `α` and `β` ordered by a relation ≤, `a ≤ b` under the `toLex` function is equivalent to `a ≤ b` under the sum lexicographic order `Sum.Lex` with respect to the ordering ≤ on both components.


theorem MeasureTheory.Integrable.mul_const :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_5} [inst : NormedRing 𝕜]
      {f : α → 𝕜}, MeasureTheory.Integrable f μ → ∀ (c : 𝕜), MeasureTheory.Integrable (fun x => f x * c) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.mul_const` states that for any type `α` with a measurable space structure `m`, any measure `μ` on `α`, any normed ring `𝕜`, and any function `f` from `α` to `𝕜` that is integrable with respect to `μ`, if we multiply `f` by a constant `c` from `𝕜`, the resulting function is also integrable with respect to `μ`. In simple terms, it means that the integrability of a function remains preserved even after multiplying it by a constant.

If `f` is an integrable function from a measurable space `(α, m)` to a normed ring `𝕜`, then the function `c → c * f` is integrable for any constant `c` in `𝕜`.


theorem DFinsupp.coe_neg :
    ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → AddGroup (β i)] (g : Π₀ (i : ι), β i), ⇑(-g) = -⇑g := by sorry

This theorem, `DFinsupp.coe_neg`, states that for any type `ι`, any type function `β` from `ι` to some other type, and any `AddGroup` instance for `β i` (for each `i` in `ι`), the negation of a function `g` from `ι` to `β` (where `g` is a direct-sum function, meaning it is zero for almost all input) can be obtained by applying the negation to the function `g` itself. In simpler terms, applying negation to the function is the same as negating each value of the function independently.

For any type `ι`, any type function `β` from `ι` to an additive group, and any direct-sum function `g : ι → β`, the negation of `g` is equal to the function that maps each `i` in `ι` to the additive negation of `g i`.


theorem CategoryTheory.shift_shiftFunctorCompIsoId_hom_app :
    ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddGroup A]
      [inst_2 : CategoryTheory.HasShift C A] (n m : A) (h : n + m = 0) (X : C),
      (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n m h).hom.app X) =
        (CategoryTheory.shiftFunctorCompIsoId C m n ⋯).hom.app ((CategoryTheory.shiftFunctor C n).obj X) :=
  by sorry

This theorem states that for any objects `C` of type `u`, `A` of type `u_1`, where `C` is a category, `A` is an additive group and a shift operation is defined on `C` with `A`, for any elements `n` and `m` of `A` such that `n + m` equals to zero and any object `X` of `C`, the morphism obtained by applying the map of the shift functor `CategoryTheory.shiftFunctor C n` to the application of the homeomorphism of `CategoryTheory.shiftFunctorCompIsoId C n m` to `X`, is identical to the morphism obtained by applying the homeomorphism of `CategoryTheory.shiftFunctorCompIsoId C m n` to the object obtained from `X` by the object function of the shift functor `CategoryTheory.shiftFunctor C n`.

In simpler terms, in the context of category theory, this theorem shows a specific property of the shift functor, and its interplay with another construct, the shift functor composition isomorphism, when used in a particular order defined by the elements `n` and `m` of the additive group `A`, given that they add up to zero.

For any additive group `A` and category `C`, if `n` and `m` are elements of `A` with `n + m = 0`, then the composition of the shift functor `CategoryTheory.shiftFunctor C n` with the shift functor composition isomorphism `CategoryTheory.shiftFunctorCompIsoId C n m` is equal to the composition of the shift functor composition isomorphism `CategoryTheory.shiftFunctorCompIsoId C m n` with the shift functor `CategoryTheory.shiftFunctor C m`.


theorem MeasureTheory.Measure.restrict_apply_le :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s t : Set α), ↑↑(μ.restrict s) t ≤ ↑↑μ t :=
  by sorry

This theorem states that for any type `α` equipped with a measurable space structure `m0` and any measure `μ` on this space, for any sets `s` and `t` of type `α`, the measure of the restriction of `μ` to `s` calculated on `t` is less than or equal to the measure of `t` itself under `μ`. In other words, restricting a measure to a subset doesn't increase the measure of any other set.

For any measurable spaces `(α, m0)`, measures `μ`, sets `s ⊆ α`, and subsets `t ⊆ α`, we have `μ s t ≤ μ t`.


theorem Polynomial.isRoot_iterate_derivative_of_lt_rootMultiplicity :
    ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {t : R} {n : ℕ},
      n < Polynomial.rootMultiplicity t p → Polynomial.IsRoot ((⇑Polynomial.derivative)^[n] p) t :=
  by sorry

The theorem `Polynomial.isRoot_iterate_derivative_of_lt_rootMultiplicity` states that for any commutative ring `R`, polynomial `p` of `R`, variable `t` of `R`, and natural number `n`, if `n` is less than the root multiplicity of `t` in `p` then `t` is a root of the `n`-th derivative of `p`. In other words, if a number `t` is a root of a polynomial `p` with multiplicity greater than `n`, then `t` is also a root of the `n`-th derivative of `p`.

If the root multiplicity of `t` in polynomial `p` is greater than the degree of the derivative `p.derivative(n)`, then `t` is a root of `p.derivative(n)`.


theorem MeasureTheory.integral_mul_left :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {L : Type u_6} [inst : RCLike L] (r : L)
      (f : α → L), ∫ (a : α), r * f a ∂μ = r * ∫ (a : α), f a ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_mul_left`, states that for any type `α`, measurable space `m` on `α`, measure `μ` on `m`, type `L` that behaves like the real numbers, and a real number `r`, the integral of the function `f` (from `α` to `L`) multiplied by `r` with respect to the measure `μ` is equal to `r` multiplied by the integral of `f` with respect to `μ`. Essentially, this theorem is expressing the property of integrals where the integral of a constant times a function is equal to the constant times the integral of the function, often known as the "linearity" property of integrals.

For any measurable space `(α, m)`, measure `μ` on `m`, type `L` of real numbers, and function `f : α → L` that is integrable with respect to `μ`, the integral of `r * f` with respect to `μ` equals `r * (∫(f)dμ)`.


theorem Real.iSup_of_isEmpty : ∀ {α : Sort u_1} [inst : IsEmpty α] (f : α → ℝ), ⨆ i, f i = 0 := by sorry

This theorem states that for any function `f` from an empty type `α` to the real numbers `ℝ`, the supremum (i.e., the least upper bound) of the image of `f` is zero. In other words, if you have a function mapping from an empty set to the real numbers, the largest value that function can achieve is zero.

For any function from the empty type to the real numbers, the supremum of its image equals 0.


theorem List.get?_range : ∀ {m n : ℕ}, m < n → List.get? (List.range n) m = some m := by sorry

The theorem `List.get?_range` states that for any natural numbers `m` and `n`, if `m` is less than `n`, then when you get the `m`th element from the list of natural numbers from `0` to `n` exclusive (generated by `List.range n`), you will get `m` back. In other words, the position of a natural number `m` in this list is the same as its value when `m` is less than `n`.

For all natural numbers `m` and `n` with `m < n`, the `m`-th element in the list `List.range n` is `m`.


theorem MeasureTheory.Measure.restrict_restrict_of_subset :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
      s ⊆ t → (μ.restrict t).restrict s = μ.restrict s :=
  by sorry

This theorem is about the measure theory in mathematics. It states that for any type `α`, given a measurable space `m0` of this type, a measure `μ` on this measurable space, and two sets `s` and `t` of this type, if set `s` is a subset of set `t`, then restricting the measure `μ` to set `t` and then further restricting it to set `s` is equivalent to directly restricting the measure `μ` to set `s`.
In other words, the restriction of the restriction of a measure is the restriction of the measure itself, provided that the subset relationship holds between the sets.

For any measurable space `(α, m0)` and measure `μ`, if `s ≤ t` are subsets of `α`, then `μ!(t) | s = μ!(s)`.


theorem Relation.reflTransGen_of_transitive_reflexive :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b : α} {r' : α → α → Prop},
      Reflexive r → Transitive r → (∀ (a b : α), r' a b → r a b) → Relation.ReflTransGen r' a b → r a b :=
  by sorry

The theorem `Relation.reflTransGen_of_transitive_reflexive` states that given a type `α` and two binary relations `r` and `r'` over `α`, if `r` is reflexive and transitive, and `r'` implies `r`, then for any elements `a` and `b` of type `α`, if `a` and `b` are related by the reflexive-transitive closure of `r'` (i.e., `a` and `b` are related through a series of steps where each step is either a reflexive application or a `r'`-relation), then `a` is `r`-related to `b`. In other words, the reflexive-transitive closure of a relation `r'` that is a sub-relation of a transitive and reflexive relation `r`, is also a sub-relation of `r`.

If `r` is a reflexive and transitive relation on type `α`, and `r' ⊆ r` is also a relation, then the reflexive-transitive closure of `r'` is a sub-relation of `r`.


Polynomial.Separable.isIntegral

/-- If the minimal polynomial of `x : K` over `F` is separable, then `x` is integral over `F`,
because the minimal polynomial of a non-integral element is `0`, which is not separable.  -/
theorem Polynomial.Separable.isIntegral :
    ∀ {F : Type u_1} {K : Type u_2} [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K] {x : K},
      Polynomial.Separable (minpoly F x) → IsIntegral F x :=
  by sorry

The theorem states that if `x` is an element of a ring `K` over a commutative ring `F`, and the minimal polynomial of `x` over `F` is separable, then `x` is integral over `F`. This is because the minimal polynomial of a non-integral element is `0`, which is not separable. In mathematical terms, a polynomial is considered separable if it is coprime with its derivative, and an element `x` of an algebra `A` over a commutative ring `R` is termed integral if it is a root of some monic polynomial `p : R[X]`.

If `x` is an element of a ring `K` over a commutative ring `F`, and the minimal polynomial of `x` over `F` is separable and non-zero, then `x` is integral over `F`.


theorem IntermediateField.adjoin_simple_toSubalgebra_of_integral :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E},
      IsIntegral F α → F⟮α⟯.toSubalgebra = Algebra.adjoin F {α} :=
  by sorry

The given theorem, `IntermediateField.adjoin_simple_toSubalgebra_of_integral`, states that for any fields `F` and `E` with `F` being an algebra over `E`, and any element `α` from `E` that is integral over `F`, the subalgebra generated by adjoining `α` to `F` corresponds to the minimal subalgebra that includes the set containing `α`. So, when `α` is integral over `F`, there is no difference between adjoining `α` and explicitly constructing the minimal subalgebra that includes `α`.

For any field extension `F` of `E` and any element `α` in `E` integral over `F`, the subalgebra generated by `α` over `F` is equal to the minimal subalgebra containing `α`.


theorem DenseRange.exists_mem_open :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {α : Type u_4} {f : α → X} {s : Set X},
      DenseRange f → IsOpen s → Set.Nonempty s → ∃ a, f a ∈ s :=
  by sorry

The theorem `DenseRange.exists_mem_open` states that for any types `X` and `α` where `X` is equipped with a topological space structure, and for any function `f` from `α` to `X` and any set `s` of `X`, if `f` has a dense range and `s` is an open set in `X` that is not empty, then there exists an element `a` in `α` such that `f(a)` is an element of `s`. In other words, for every nonempty open set in the topological space, there is a point in the dense range of the function that lies within that open set.

For any continuous function `f` from a non-empty open set of a topological space `X` to `X` with a dense range, there exists an element `a` in the domain of `f` such that `f(a)` is in the open set.


theorem CategoryTheory.Limits.PreservesKernel.iso_hom :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
      (G : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.Functor.PreservesZeroMorphisms G] {X Y : C} (f : X ⟶ Y)
      [inst_5 : CategoryTheory.Limits.HasKernel f] [inst_6 : CategoryTheory.Limits.HasKernel (G.map f)]
      [inst_7 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) G],
      (CategoryTheory.Limits.PreservesKernel.iso G f).hom = CategoryTheory.Limits.kernelComparison f G :=
  by sorry

This theorem states that, for any categories `C` and `D` with zero morphisms, a functor `G` from `C` to `D` that preserves zero morphisms, and a morphism `f` from `X` to `Y` in `C` that has a kernel, if `G` preserves the limit of the parallel pair of `f` and `0`, then the morphism defined by the isomorphism between the kernels of `f` and `G.map(f)` is the same as the kernel comparison of `f` and `G`. This means that the process of mapping `f` to `D` and then taking the kernel is equivalent to first taking the kernel in `C` and then mapping to `D` under certain conditions on `G`.

If functor G from categories C and D with zero morphisms preserves limits and zero morphisms, and preserves kernels of morphisms in C, then the kernel of G(f) is isomorphic to the image of the kernel of f under G, for any morphism f in C with a kernel.


theorem liftFun_vecCons :
    ∀ {α : Type u_1} {n : ℕ} (r : α → α → Prop) [inst : IsTrans α r] {f : Fin (n + 1) → α} {a : α},
      ((fun x x_1 => x < x_1) ⇒ r) (Matrix.vecCons a f) (Matrix.vecCons a f) ↔
        r a (f 0) ∧ ((fun x x_1 => x < x_1) ⇒ r) f f :=
  by sorry

This theorem, `liftFun_vecCons`, states that for any type `α`, natural number `n`, a relation `r` on `α` that is transitive, a function `f` from `Fin(n + 1)` to `α` and a value `a` of type `α`, the relation `r` holds between the first elements of two `vecCons` operations and the rest of the elements in them if and only if the relation `r` holds between `a` and `f(0)`, and the relation `r` holds between every pair of elements in `f` where the first element is less than the second.

Here, `vecCons` is a function that prepends an element to a list, `Fin(n + 1)` is a finite set of size `n + 1`, and `r` is a binary relation on `α`. The `<` symbol denotes the natural ordering of these elements. The transitivity of `r` implies that if `r` holds between `a` and `b`, and between `b` and `c`, then `r` also holds between `a` and `c`.

For any type `α`, natural number `n`, transitive relation `r` on `α`, function `f` from `Fin(n + 1)` to `α`, and values `a, x, y` of type `α` with `x` less than `y` in `Fin(n + 1)`, the relation `r` holds between the first elements of `vecCons a (vecCons x (f x))` and `vecCons x (vecCons a f (x + 1))` if and only if `r` holds between `a` and `f(0)` and `r` holds between every pair `(f i, f (i + 1))` for `i` less than `x`.


theorem left_lt_sup : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a < a ⊔ b ↔ ¬b ≤ a := by sorry

This theorem, `left_lt_sup`, states that for any type `α` that forms a semilattice with a supremum operation, and any two elements `a` and `b` of this type, `a` is less than the supremum of `a` and `b` if and only if `b` is not less than or equal to `a`. Here, the symbol "⊔" represents the supremum or least upper bound operation in the semilattice.

For any semilattice with supremum operation ⊔, element a, and element b, the condition a < ⊔(a, b) if and only if b ≥ a holds.


theorem Finset.image_uncurry_product :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] (f : α → β → γ) (s : Finset α) (t : Finset β),
      Finset.image (Function.uncurry f) (s ×ˢ t) = Finset.image₂ f s t :=
  by sorry

The theorem `Finset.image_uncurry_product` asserts that for any types `α`, `β`, and `γ`, where equality in `γ` is decidable, and given a binary function `f : α → β → γ`, and finite sets `s : Finset α` and `t : Finset β`, the image of the uncurried function `Function.uncurry f` over the cartesian product of `s` and `t` is equivalent to the image of the function `f` computed via `Finset.image₂`. In other words, it asserts the equality of two different ways to compute the forward image of a binary function over a pair of finite sets.

For any decidably-equaled types `α`, `β`, `γ`, and finite sets `s : Finset α` and `t : Finset β`, the image of the uncurried function `Function.uncurry (α × β → γ)` over `s × t` equals the image of the original function `α × β → γ` applied to `Finset.image₂ s t`.


theorem MeasureTheory.set_integral_mono_ae :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {f g : X → ℝ} {s : Set X},
      MeasureTheory.IntegrableOn f s μ →
        MeasureTheory.IntegrableOn g s μ →
          f ≤ᶠ[MeasureTheory.Measure.ae μ] g → ∫ (x : X) in s, f x ∂μ ≤ ∫ (x : X) in s, g x ∂μ :=
  by sorry

This theorem states that for any set `s` of a type `X` that is a measurable space, given a measure `μ` on `X` and two real-valued functions `f` and `g` defined on `X`, if both `f` and `g` are integrable over the set `s` with respect to the measure `μ`, and if the function `f` is less than or equal to the function `g` almost everywhere with respect to the measure `μ`, then the integral of `f` over the set `s` with respect to the measure `μ` is less than or equal to the integral of `g` over the same set with respect to the same measure. This is a statement about the monotonicity of the integral in terms of the functions being integrated, under certain conditions.

If `μ` is a measure on the measurable space `(X, Σ)`, `s ∈ Σ` is a set, `f` and `g` are integrable real-valued functions on `s` with `f ≤ g` almost everywhere on `s`, then `∫(f ds) ≤ ∫(g ds)`.


theorem RelIso.rel_symm_apply :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (e : r ≃r s) {x : α} {y : β},
      r x ((RelIso.symm e) y) ↔ s (e x) y :=
  by sorry

The theorem `RelIso.rel_symm_apply` asserts that for any two types `α` and `β`, a relation `r` on `α`, a relation `s` on `β`, and a relation isomorphism `e` from `r` to `s`, for any elements `x` of `α` and `y` of `β`, the statement "x is related to the image under the inverse isomorphism of y" in relation `r` is equivalent to the statement "the image under the isomorphism of x is related to y" in relation `s`. This theorem shows the symmetry property of relation isomorphisms.

For any relation isomorphisms between relations `r` on type `α` and `s` on type `β`, `x` in `α`, and `y` in `β`, `x` related to `y^(-1) . s(y)` in `r` if and only if `s(x)` is related to `y` in `s`.


theorem Mathlib.Data.Set.Lattice._auxLemma.28 : ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s := by sorry

This theorem, named `Mathlib.Data.Set.Lattice._auxLemma.28`, states that for any type `α` and any set `s` of type `α`, the condition `s = ∅` (s is an empty set) is equivalent to the statement that for every element `x` of type `α`, `x` is not an element of `s` (`x ∉ s`). In simpler terms, it says that a set is empty if and only if no element of its base type is in the set.

A set is empty if and only if no element belongs to it.


/-- **Alias** of `Left.add_pos_of_nonneg_of_pos`. -/
theorem add_pos_of_nonneg_of_pos :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α}, 0 ≤ a → 0 < b → 0 < a + b :=
  by sorry

The theorem `add_pos_of_nonneg_of_pos` is essentially an alias of `Left.add_pos_of_nonneg_of_pos`. It states that for any type `α` that has an addition operation (where `0` is the identity element) and a preorder relation (i.e., a binary relation that is reflexive and transitive), and also has a covariant class (essentially meaning that addition preserves the order), if `a` and `b` are elements of `α` such that `a` is non-negative (0 ≤ a) and `b` is positive (0 < b), then the sum of `a` and `b` is also positive (0 < a + b).

If `α` is a type with an addition operation, identity element `0`, a preorder relation that is reflexive, transitive, and covariant, and `0 ≤ a` and `0 < b` hold for elements `a, b ∈ α`, then `0 < a + b`.


theorem MeasureTheory.Measure.neg_neg :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : InvolutiveNeg G] [inst_2 : MeasurableNeg G]
      (μ : MeasureTheory.Measure G), MeasureTheory.Measure.neg (MeasureTheory.Measure.neg μ) = μ :=
  by sorry

This theorem states that for any type `G` which has a measurable space structure, an involutive negation operation, and a measurable negation operation, and for any measure `μ` on `G`, applying the operation `MeasureTheory.Measure.neg` twice to `μ` will yield `μ` back. Here, `MeasureTheory.Measure.neg` is a function mapping a measure `μ` to another measure defined by `μ` evaluated at the pointwise negation of the set `A`. This theorem is essentially stating that the double negation operation is an identity for the `MeasureTheory.Measure.neg` operation.

For any measurable space `(G, Σ)` with a measurable involutive negation operation, if `μ` is a measure on `G`, then `MeasureTheory.Measure.neg (MeasureTheory.Measure.neg μ) = μ`.


theorem Mathlib.Data.Set.Lattice._auxLemma.33 : ∀ {α : Type u} {s t : Set α}, (s = t) = ∀ (x : α), x ∈ s ↔ x ∈ t := by
  sorry

The theorem `Mathlib.Data.Set.Lattice._auxLemma.33` states that for any type `α` and any two sets `s` and `t` of type `α`, the assertion that `s` is equal to `t` is equivalent to the statement that for all elements `x` of type `α`, `x` is an element of set `s` if and only if `x` is an element of set `t`. In other words, two sets are considered equal if and only if they contain exactly the same elements.

Two sets are equal if and only if they have the same elements.


SimplexCategory.Hom.ext

theorem SimplexCategory.Hom.ext :
    ∀ {a b : SimplexCategory} (f g : a ⟶ b),
      SimplexCategory.Hom.toOrderHom f = SimplexCategory.Hom.toOrderHom g → f = g :=
  by sorry

This theorem, `SimplexCategory.Hom.ext`, states that for any two objects `a` and `b` in the simplex category, if we have two morphisms `f` and `g` from `a` to `b`, and if the order-preserving maps corresponding to these morphisms (obtained using `SimplexCategory.Hom.toOrderHom`) are identical, then the original morphisms `f` and `g` themselves must be identical. In other words, different morphisms in the simplex category cannot give rise to the same order-preserving map.

In the simplex category, if two morphisms from one object to another have identical order-preserving maps, then they are equal as morphisms.


theorem CategoryTheory.NatIso.inv_inv_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} (e : F ≅ G) (X : C),
      CategoryTheory.inv (e.inv.app X) = e.hom.app X :=
  by sorry

The theorem `CategoryTheory.NatIso.inv_inv_app` establishes that in any two categories `C` and `D`, for every natural isomorphism `e` between two functors `F` and `G` from `C` to `D`, and for every object `X` in `C`, the inverse of the application of the inverse natural transformation of `e` to `X` is equal to the application of the homomorphism part of `e` to `X`. Essentially, this theorem is stating that the inverse of the inverse of a natural transformation, when applied to an object, gives back the original natural transformation when applied to the same object.

Given any two categories `C` and `D`, and a natural isomorphism `e` between functors `F` and `G` from `C` to `D`, for every object `X` in `C`, the inverse of the application of the inverse natural transformation of `e` to `X` equals the application of `e` to `X`.


theorem Mathlib.Data.Set.Lattice._auxLemma.10 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem states that for any types `α` and `β`, given a function `f : α → β`, a set `s` of type `β`, and an element `a` of type `α`, `a` is in the preimage of `s` under `f` if and only if the image of `a` under `f` is in `s`. In other words, an element maps into a set if and only if it is in the preimage of that set.

For any function `f : α → β` and set `s ∈ β`, an element `a ∈ α` is in the preimage `f⁻¹[s]` of `s` under `f` if and only if `f(a) ∈ s`.


theorem measurable_of_subsingleton_codomain :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : Subsingleton β]
      (f : α → β), Measurable f :=
  by sorry

The theorem `measurable_of_subsingleton_codomain` states that for any two types `α` and `β` with respective measurable spaces, and a function `f` from `α` to `β`, if `β` is a subsingleton (i.e., has at most one element), then `f` is measurable. In other words, a function mapping to a type with at most one element is always measurable. A function is considered measurable if the preimage of every measurable set is measurable.

If `β` is a subsingleton type, then every function from a measurable space to `β` is measurable.


theorem Mathlib.Data.Set.Lattice._auxLemma.16 :
    ∀ {α : Type u_1} {s : Set (Set α)} {t : Set α}, (⋃₀ s ⊆ t) = ∀ t' ∈ s, t' ⊆ t := by sorry

This theorem, `Mathlib.Data.Set.Lattice._auxLemma.16`, states that for any type `α`, any set `s` of sets of `α`, and any set `t` of `α`, the union of all the sets in `s` is a subset of `t` if and only if every set `t'` that belongs to `s` is a subset of `t`. In the context of set theory, the concept of "union" (denoted by `⋃₀ s`) refers to the aggregation of all the elements in the sets in `s`, and "subset" (denoted by `⊆`) means that all elements of the first set are also elements of the second set.

For any type `α`, set `s` of sets of `α`, and set `t` of `α`, `⋃₀ s ⊆ t` if and only if for all `s' ∈ s`, `s' ⊆ t`.


/-- **Alias** of the reverse direction of `dvd_neg`.

---

An element `a` of a semigroup with a distributive negation divides the negation of an element
`b` iff `a` divides `b`.  -/
theorem Dvd.dvd.neg_right :
    ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : HasDistribNeg α] {a b : α}, a ∣ b → a ∣ -b := by sorry

This theorem, named `Dvd.dvd.neg_right`, states that for any type `α` that is a semigroup with a distributive negation, if an element `a` divides another element `b`, then `a` also divides the negative of `b`. In mathematical terms, if `a` divides `b` (denoted as `a ∣ b`), then `a` divides `-b`. This is essentially saying that divisibility is preserved under negation in a semigroup with a distributable negation.

If `a` divides `b` in a semigroup with distributive negation, then `a` divides the negation of `b`.


theorem Submonoid.LocalizationMap.sec_spec :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
      {f : Submonoid.LocalizationMap S N} (z : N),
      z * (Submonoid.LocalizationMap.toMap f) ↑(Submonoid.LocalizationMap.sec f z).2 =
        (Submonoid.LocalizationMap.toMap f) (Submonoid.LocalizationMap.sec f z).1 :=
  by sorry

The theorem `Submonoid.LocalizationMap.sec_spec` states that for any commutative monoid `M`, any submonoid `S` of `M`, any commutative monoid `N`, and any localization map `f` from `S` to `N`, given any element `z` of `N`, the result of multiplying `z` by the image under `f` of the second component of the pair obtained by applying the section function to `z` is equal to the image under `f` of the first component of that pair. This essentially says that each element of the target monoid `N` can be expressed as the product of the image of an element of `M` and the inverse of the image of an element of `S`, which is a central property of the localization at a submonoid.

For any commutative monoids M, N, submonoid S of M, and localization map f from S to N, for all z in N and (x, y) in S, f(y) * f(x) = f(x * y).


theorem Behrend.mem_box : ∀ {n d : ℕ} {x : Fin n → ℕ}, x ∈ Behrend.box n d ↔ ∀ (i : Fin n), x i < d := by sorry

The theorem `Behrend.mem_box` states that for any natural numbers `n` and `d`, and any function `x` from `Fin n` to `ℕ`, `x` is an element of the Behrend box of dimension `n` with side length `d` if and only if for every element `i` in `Fin n`, the value `x(i)` is less than `d`. In other words, every point in the `n`-dimensional box has coordinates strictly less than `d`.

A function from Fin n to ℕ is an element of the Behrend box of dimension n with side length d if and only if its values are strictly less than d for all i in Fin n.


theorem List.dropLast_append_getLast :
    ∀ {α : Type u} {l : List α} (h : l ≠ []), List.dropLast l ++ [List.getLast l h] = l := by sorry

This theorem states that for any non-empty list `l` of elements of an arbitrary type `α`, if you remove the last element of `l` and then append the last element of `l` back, you will get back the original list `l`. In mathematical terms, if $l$ is a non-empty list, then $dropLast(l) ++ [getLast(l)] = l$, where $dropLast$ removes the last element from the list, $getLast$ fetches the last element from the list, and $++$ denotes concatenation of lists.

For any non-empty list `l` of type `α`, the list obtained by removing the last element and the list obtained by appending the last element to the result of removing the last element are equal: `dropLast (l) ++ [getLast (l)] = l`.


theorem CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C}
      (K : CategoryTheory.Limits.Multifork I) (b : I.R),
      K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.ι K (I.fstTo b)) (I.fst b) :=
  by sorry

The theorem `CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst` states that in any category `C`, for any multicospan index `I` and any multifork `K` over `I`, for each object `b` from the right index set `I.R`, the morphism from the apex of the cone `K` to `b` is equal to the composition of the morphism from the apex of the cone to the left object associated to `b` via `I.fstTo`, and the morphism `I.fst b`. In other words, this theorem specifies a property of the diagram chasing in the multifork or multicone structure.

For any category C, given a multicospan index I and a multifork K over I, the morphism from the apex of cone K to any right index object b is equal to the composition of the morphism from the apex to the left object linked to b via I.fstTo, and the morphism I.fst b.


theorem one_le_pow_iff :
    ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : LinearOrder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {x : M} {n : ℕ},
      n ≠ 0 → (1 ≤ x ^ n ↔ 1 ≤ x) :=
  by sorry

This theorem states that for any type `M` with a monoid, linear order, and covariant class structure, and for any element `x` of type `M` and natural number `n`, given that `n` is not zero, `1` is less than or equal to `x` raised to the power of `n` if and only if `1` is less than or equal to `x`. In mathematical terms, for all $x$ in some ordered monoid $M$ and all $n$ in $\mathbb{N}$ with $n \neq 0$, $1 \leq x^n$ if and only if $1 \leq x$.

For any ordered monoid $M$ and $x$ in $M$ with $n$ a non-zero natural number, $1 \leq x^n$ if and only if $1 \leq x$.


theorem imp_iff_or_not : ∀ {b a : Prop}, b → a ↔ a ∨ ¬b := by sorry

This theorem, `imp_iff_or_not`, states that for any two propositions `a` and `b`, the implication `b → a` (if `b` then `a`) is equivalent to `a ∨ ¬b` (either `a` is true, or `b` is not true). This is a logical equivalence principle in propositional logic.

The logical equivalence of `(b → a)` and `(a ∨ ¬b)` holds for all propositions `a` and `b`.


theorem HomologicalComplex.d_comp_d_assoc :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) (i j k : ι)
      {Z : V} (h : C.X k ⟶ Z),
      CategoryTheory.CategoryStruct.comp (C.d i j) (CategoryTheory.CategoryStruct.comp (C.d j k) h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

The theorem `HomologicalComplex.d_comp_d_assoc` states that for any type `ι`, category `V` that has zero morphisms, a complex shape `c`, a homological complex `C` of `V` and `c`, and any three objects `i`, `j`, `k` of type `ι` and an object `Z` of type `V`, the composition of the morphism from `i` to `j` (denoted as `C.d i j`) and the composition of the morphism from `j` to `k` (denoted as `C.d j k`) and `h` (from `k` to `Z`) is the same as the composition of the zero morphism and `h`. In other words, the composition of consecutive differential morphisms in a homological complex is zero, which is a key property in homological algebra.

For any homological complex `C` in a category `V` with zero morphisms, the composition of consecutive differential morphisms is zero: `C.d i j ∘ C.d j k = 0`.


theorem or_not_of_imp : ∀ {a b : Prop}, (a → b) → b ∨ ¬a := by sorry

This theorem, `or_not_of_imp`, states that for any two propositions `a` and `b`, if `a` implies `b`, then either `b` is true or `a` is not true. In the language of logic, this is a demonstration of the principle of the excluded middle in the context of implications. This means that if we have an implication from `a` to `b`, there are no other possibilities outside of `b` being true or `a` being false.

If `a` implies `b`, then `b` or not-`a`.


/-- Pullback a `Nontrivial` instance along a function sending `0` to `0` and `1` to `1`.  -/
theorem pullback_nonzero :
    ∀ {M₀ : Type u_1} {M₀' : Type u_2} [inst : MulZeroOneClass M₀] [inst_1 : Nontrivial M₀] [inst_2 : Zero M₀']
      [inst_3 : One M₀'] (f : M₀' → M₀), f 0 = 0 → f 1 = 1 → Nontrivial M₀' :=
  by sorry

The theorem `pullback_nonzero` states that for any two types `M₀` and `M₀'`, if `M₀` is a MulZeroOneClass and is nontrivial, and `M₀'` is equipped with both zero and one, and there is a function `f` from `M₀'` to `M₀` such that `f` maps `0` to `0` and `1` to `1`, then `M₀'` is nontrivial. In other words, the nontrivial property can be pulled back along a function that preserves `0` and `1`.

If `f` is a function from a nontrivial MulZeroOneClass `M′0` to a nontrivial MulZeroOneClass `M₀` with `f(0) = 0` and `f(1) = 1`, then `M′0` is nontrivial.


theorem SetTheory.PGame.add_lf_add_left :
    ∀ {y z : SetTheory.PGame}, SetTheory.PGame.LF y z → ∀ (x : SetTheory.PGame), SetTheory.PGame.LF (x + y) (x + z) :=
  by sorry

This theorem states that for all pre-games 'y' and 'z', if 'y' is strictly less fuzzy than 'z' (i.e., Left can win 'z' as the first player but not 'y'), then for any pre-game 'x', the pre-game 'x + y' is also strictly less fuzzy than 'x + z'. In other words, adding the same pre-game 'x' to both 'y' and 'z' preserves the less fuzzy relation.

For all pre-games 'x', 'y', and 'z', if 'y' is strictly less fuzzy than 'z', then 'x + y' is strictly less fuzzy than 'x + z'.


theorem AddMonoid.Coprod.lift_comp_swap :
    ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : AddMonoid P] (f : M →+ P) (g : N →+ P),
      AddMonoidHom.comp (AddMonoid.Coprod.lift f g) (AddMonoid.Coprod.swap N M) = AddMonoid.Coprod.lift g f :=
  by sorry

The theorem `AddMonoid.Coprod.lift_comp_swap` states that for any types `M`, `N`, and `P` that have the structure of an additive monoid with zero (`AddZeroClass`), and for any additive monoid morphisms `f` from `M` to `P` and `g` from `N` to `P`, the composition of the `lift` operation from the coproduct of `M` and `N` with the `swap` operation on the coproduct of `N` and `M` is equal to the `lift` operation from the coproduct of `g` and `f`. In mathematical terms, this theorem asserts the commutativity property of the `lift` and `swap` operations in the context of additive monoids and their morphisms.

For any additive monoids `M`, `N`, and `P` with zero, and additive monoid morphisms `f: M → P` and `g: N → P`, the commutativity of `lift` and `swap` operations holds: `lift (coproduct f g) = lift (g ⊕ f)`.


theorem Set.ssubset_singleton_iff : ∀ {α : Type u} {s : Set α} {x : α}, s ⊂ {x} ↔ s = ∅ := by sorry

The theorem `Set.ssubset_singleton_iff` states that for any type `α`, any set `s` of type `α`, and any element `x` of type `α`, the set `s` is a strict subset of the singleton set `{x}` if and only if `s` is the empty set. In other words, a set `s` is strictly contained within a singleton set only if `s` is empty.

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


theorem MeasureTheory.Measure.rnDeriv_pos :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
      [inst : MeasureTheory.Measure.HaveLebesgueDecomposition μ ν],
      MeasureTheory.Measure.AbsolutelyContinuous μ ν → ∀ᵐ (x : α) ∂μ, 0 < μ.rnDeriv ν x :=
  by sorry

This theorem states that for any type `α` and measurable space `m`, given two measures `μ` and `ν` on this space, if `μ` has a Lebesgue decomposition with respect to `ν`, and if `μ` is absolutely continuous with respect to `ν`, then almost everywhere with respect to the measure `μ`, the Radon-Nikodym derivative of `μ` with respect to `ν` is greater than zero.

In other words, this theorem is about the positive nature of the Radon-Nikodym derivative under the condition of absolute continuity. In mathematical terms, if `μ` is absolutely continuous with respect to `ν` (i.e., whenever `ν(A) = 0` it implies `μ(A) = 0` for any subset `A` of the measurable space), then the Radon-Nikodym derivative `μ.rnDeriv ν x` is almost everywhere positive with respect to the measure `μ`.

If `μ` is an absolutely continuous measure with respect to `ν` in a measurable space, then the Radon-Nikodym derivative `μ.rnDeriv ν` is almost everywhere positive with respect to `μ`.


theorem Complex.div_nat_cast : ∀ (z : ℂ) (n : ℕ), z / ↑n = { re := z.re / ↑n, im := z.im / ↑n } := by sorry

This theorem states that for any complex number `z` and natural number `n`, the division of `z` by the real number equivalent of `n` (denoted as `↑n`) equals a complex number whose real part is the division of the real part of `z` by `↑n` and whose imaginary part is the division of the imaginary part of `z` by `↑n`. In other words, it shows that dividing a complex number by a natural number is equivalent to dividing both the real and imaginary parts of the complex number by that natural number.

For any complex number $z$ and natural number $n$, $\frac{z}{n} \equiv \frac{Re(z)} {n} + i \frac{Im(z)} {n}$, where $Re(z)$ and $Im(z)$ denote the real and imaginary parts of $z$, respectively.


ContMDiffMap.smooth

theorem ContMDiffMap.smooth :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
      {H : Type u_4} [inst_5 : TopologicalSpace H] {H' : Type u_5} [inst_6 : TopologicalSpace H']
      {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'} {M : Type u_6} [inst_7 : TopologicalSpace M]
      [inst_8 : ChartedSpace H M] {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      (f : ContMDiffMap I I' M M' ⊤), Smooth I I' ⇑f :=
  by sorry

This theorem states that for a given continuously differentiable mapping `f` from a manifold `M` to a manifold `M'` (both with possible extra structure), the map is also smooth. The smoothness here refers to the infinite differentiability. The theorem holds in the context of normed additive commutative groups `E` and `E'`, normed spaces over a non-trivially normed field `𝕜`, along with topological spaces `H` and `H'` and their corresponding model with corners `I` and `I'`.

A continuously differentiable mapping between manifolds is smooth (infinitely differentiable).


/-- Porting note (#10618): simp can prove this
@[simp]  -/
theorem IsLocalizedModule.mk'_eq_iff :
    ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] {f : M →ₗ[R] M'}
      [inst_5 : IsLocalizedModule S f] {m : M} {s : ↥S} {m' : M'}, IsLocalizedModule.mk' f m s = m' ↔ f m = s • m' :=
  by sorry

This theorem, `IsLocalizedModule.mk'_eq_iff`, states that for any commutative semiring `R`, submonoid `S` of `R`, modules `M` and `M'` over `R`, localization map `f` from `M` to `M'`, element `m` of `M`, element `s` of `S`, and element `m'` of `M'`, the fraction `m/s` with respect to the localization map `f` is equal to `m'` if and only if the result of applying `f` to `m` is equal to the scalar multiplication of `s` and `m'`. In other words, it relates equality in the localized module to equality under the localization map in the original module.

For any commutative semiring `R`, submonoid `S` of `R`, modules `M` and `M'` over `R`, localization map `f` from `M` to `M'`, and elements `m` of `M`, `s` of `S`, and `m'` of `M'`, `m/s ≡ m'` in the localized module if and only if `f(m) = s * m'`.


theorem Polynomial.degree_pos_of_not_isUnit_of_dvd_monic :
    ∀ {R : Type u} [inst : CommSemiring R] {a p : Polynomial R},
      ¬IsUnit a → a ∣ p → Polynomial.Monic p → 0 < Polynomial.degree a :=
  by sorry

This theorem states that for a commutative semiring `R` and two polynomials `a` and `p` over `R`, if `a` is not a unit and `a` divides `p`, and if `p` is a monic polynomial (its leading coefficient is 1), then the degree of `a` is positive. In other words, if a non-unit polynomial `a` divides a monic polynomial `p`, then `a` must be of degree greater than zero.

If `a` is a non-unit polynomial of degree 0 in a commutative semiring `R`, `a` does not divide a monic polynomial `p` in `R`.


theorem Nat.floor_zero : ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α], ⌊0⌋₊ = 0 := by
  sorry

This theorem, `Nat.floor_zero`, states that for all types `α`, if `α` is a linear ordered semiring and a floor semiring, then the floor of zero is zero. In simple mathematical terms, it's saying that the greatest integer less than or equal to zero in any such semiring is indeed zero.

For any linear ordered semiring and floor semiring type `α`, the floor of zero is zero.


theorem MeasureTheory.snorm_mono_nnnorm_ae :
    ∀ {α : Type u_1} {F : Type u_3} {G : Type u_4} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
      (∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) → MeasureTheory.snorm f p μ ≤ MeasureTheory.snorm g p μ :=
  by sorry

The theorem `MeasureTheory.snorm_mono_nnnorm_ae` states that for any two functions `f` and `g` from a set `α` to normed additive commutative groups `F` and `G` respectively, and for a given measure `μ` on `α` and an extended nonnegative real `p`, if almost everywhere in `α` the nonnegative norm of `f(x)` is less than or equal to the nonnegative norm of `g(x)`, then the `ℒp` seminorm of `f` with respect to measure `μ` and `p` is less than or equal to the `ℒp` seminorm of `g` with respect to measure `μ` and `p`. The `ℒp` seminorm is defined as `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞`, `essSup ‖f‖ μ` for `p = ∞`, and `0` for `p=0`.

If two functions from a measure space to normed additive commutative groups have almost everywhere less than or equal nonnegative norms, then the corresponding `ℒp` seminorms with respect to a given measure and `p > 0` satisfy the inequality.


theorem FintypeCat.hom_ext : ∀ {X Y : FintypeCat} (f g : X ⟶ Y), (∀ (x : ↑X), f x = g x) → f = g := by sorry

This theorem states that for any two objects `X` and `Y` in the category of finite types (`FintypeCat`), if two morphisms (functions) `f` and `g` from `X` to `Y` are such that their output is the same for every element of `X` (i.e., `f x = g x` for all `x` in `X`), then `f` and `g` are the same morphism. In other words, in the category of finite types, if two functions have the same effect on all elements of their domain, they are considered identical.

In the category of finite types, two morphisms between objects are equal if and only if they map every element of their domain to the same image.


theorem ConvexOn.average_mem_epigraph :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : CompleteSpace E] {μ : MeasureTheory.Measure α} {s : Set E} {f : α → E} {g : E → ℝ}
      [inst_3 : MeasureTheory.IsFiniteMeasure μ] [inst_4 : NeZero μ],
      ConvexOn ℝ s g →
        ContinuousOn g s →
          IsClosed s →
            (∀ᵐ (x : α) ∂μ, f x ∈ s) →
              MeasureTheory.Integrable f μ →
                MeasureTheory.Integrable (g ∘ f) μ →
                  (⨍ (x : α), f x ∂μ, ⨍ (x : α), g (f x) ∂μ) ∈ {p | p.1 ∈ s ∧ g p.1 ≤ p.2} :=
  by sorry

The theorem `ConvexOn.average_mem_epigraph` states that for any measurable space `α`, a normed additively commutative group `E` which is a complete normed space over the field of real numbers, a measure `μ` on `α`, a set `s` in `E`, and functions `f` from `α` to `E` and `g` from `E` to real numbers (`ℝ`), given that `μ` is a finite measure and non-zero, if `g` is convex on `s` and continuous on `s`, `s` is a closed set, `f(x)` is in `s` for almost every `x` (with respect to the measure `μ`), and both `f` and `g` composed with `f` are integrable (with respect to the measure `μ`), then the `pairwise` integral of `f` and `g` composed with `f` over `μ` is an element of the epigraph of `g` restricted to `s`. The epigraph of a function is the set of points lying above its graph, i.e., it is the set of `pairs (x, y)` such that `y` is greater than or equal to the function value at `x`.

If `μ` is a finite, non-zero measure on measurable space `α`, `E` is a complete normed space over `ℝ`, `s ⊆ E` is a closed set, `f: α → E`, `g: E → ℝ` are measurable functions with `g` convex and continuous on `s`, and `f(x) ∈ s` almost surely with respect to `μ` and `f`, `g ∘ f` and `f` are integrable with respect to `μ`, then `∫ x ∈ α (g (f x)) dμ ∈ Epigraph g (s)`.


theorem Matrix.fromBlocks_toBlocks :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} (M : Matrix (n ⊕ o) (l ⊕ m) α),
      Matrix.fromBlocks (Matrix.toBlocks₁₁ M) (Matrix.toBlocks₁₂ M) (Matrix.toBlocks₂₁ M) (Matrix.toBlocks₂₂ M) = M :=
  by sorry

This theorem states that for any given matrix `M` indexed by the sum types of `n` and `o` for the rows and `l` and `m` for the columns with entries in `α`, the matrix obtained from the "block" operation of `Matrix.fromBlocks`, which flattens four smaller matrices, will be equal to `M` when those four smaller matrices are the "submatrices" of `M` extracted using `Matrix.toBlocks₁₁`, `Matrix.toBlocks₁₂`, `Matrix.toBlocks₂₁`, and `Matrix.toBlocks₂₂` respectively. In essence, this theorem is saying that if we divide a matrix into four submatrices and then recombine those submatrices in the same configuration, we will get back the original matrix.

For any matrix `M` indexed by `n x o x l x m` with entries in `α`, the matrix obtained from `Matrix.fromBlocks [M.toBlocks₁₁, M.toBlocks₁₂, M.toBlocks₂₁, M.toBlocks₂₂]` is equal to `M`.


IsMinFilter.min

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

The theorem `IsMinFilter.min` states that for any given types `α` and `β`, where `β` is a linear order, any two functions `f` and `g` from `α` to `β`, any point `a` of type `α`, and any filter `l` on `α`, if `a` is a minimum of both `f` and `g` under the filter `l`, then `a` is also a minimum of the function that takes `x` to the minimum of `f(x)` and `g(x)` under the same filter `l`. In mathematical terms, if `f(a) ≤ f(x)` for all `x` in a certain `l`-neighborhood of `a`, and `g(a) ≤ g(x)` for all `x` in the same `l`-neighborhood, then the minimum of `f(a)` and `g(a)` is less than or equal to the minimum of `f(x)` and `g(x)` for all `x` in that `l`-neighborhood.

If functions `f` and `g` from type `α` to a linear order `β`, and point `a` in `α` is a minimum of both `f` and `g` under filter `l`, then the point `a` is also a minimum of the function `x ↦ min(f(x), g(x))` under the same filter `l`.


theorem Mathlib.Topology.ContinuousFunction.Bounded._auxLemma.8 :
    ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a : E), ‖a‖ = dist a 0 := by sorry

This theorem, from the Mathlib library on topology in Lean 4, states that for any type `E` which is a seminormed add group, the norm of an element `a` of `E` is equal to the distance from `a` to the zero element in `E`. This theorem essentially establishes that the norm function `‖a‖` and the distance function `dist a 0` are equivalent in this context. The notation `‖a‖` represents the norm of `a`, and `dist a 0` represents the distance from `a` to `0`.

For any seminormed add group `E`, the norm `‖a‖` of an element `a` is equal to the distance `dist a 0` from `a` to the zero element in `E`.


theorem Equiv.Perm.cycleOf.proof_1 :
    ∀ {α : Type u_1} (f : Equiv.Perm α) (x x_1 : α), Equiv.Perm.SameCycle f x x_1 ↔ Equiv.Perm.SameCycle f x (f x_1) :=
  by sorry

This theorem states that for all types `α` and for any permutation `f` of `α`, and any two elements `x` and `x_1` of `α`, the property that `x` and `x_1` are in the same cycle of the permutation `f` is equivalent to the property that `x` and `f(x_1)` are in the same cycle of the permutation `f`. In other words, changing `x_1` by applying the permutation `f` to it does not change whether `x` and `x_1` are in the same cycle of `f`.

For all types `α` and permutations `f` of `α`, and all elements `x` and `x_1` of `α`, `x` and `x_1` are in the same cycle of `f` if and only if `x` and `f(x_1)` are in the same cycle of `f`.


theorem Multiset.sum_map_add :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] {m : Multiset ι} {f g : ι → α},
      Multiset.sum (Multiset.map (fun i => f i + g i) m) =
        Multiset.sum (Multiset.map f m) + Multiset.sum (Multiset.map g m) :=
  by sorry

The theorem `Multiset.sum_map_add` states that for any multiset `m` of a certain type `ι` and any two functions `f` and `g` from `ι` to a type `α` which has an additive commutative monoid structure, the sum of the multiset obtained by mapping each element of `m` to the sum of applying `f` and `g` to it is equal to the sum of adding the sum of the multiset obtained by mapping `f` on `m` and the sum of the multiset obtained by mapping `g` on `m`. Essentially, this theorem asserts the distributive property of addition over the map operation on multisets.

For any additive commutative monoid type `α` and multiset `m` of type `ι`, the sum of the multiset obtained by mapping each element of `m` to the sum of `f` and `g` is equal to the sum of the multiset obtained by mapping `f` and then adding, and the sum of the multiset obtained by mapping `g` and then adding, where `f` and `g` are functions from `ι` to `α`.


/-- An intermediate field contains the image of the smaller field.  -/
theorem IntermediateField.algebraMap_mem :
    ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
      (S : IntermediateField K L) (x : K), (algebraMap K L) x ∈ S :=
  by sorry

This theorem states that for any two fields `K` and `L` where `K` is an algebra over `L`, and for any intermediate field `S` between `K` and `L`, the image of any element `x` of `K` under the algebra map from `K` to `L` is always an element of the intermediate field `S`. In other words, the intermediate field `S` contains the image of the smaller field `K` under the algebra map.

For any fields K being a subalgebra over L, and any intermediate field S between K and L, the image of any element x in K under the algebra map from K to L lies in the intermediate field S.


theorem Mathlib.AlgebraicTopology.SimplexCategory._auxLemma.1 : ∀ {n : ℕ} (a : Fin (n + 1)), (a < 0) = False := by sorry

This theorem, located in the `Mathlib.AlgebraicTopology.SimplexCategory` module and named `_auxLemma.1`, states that for any natural number `n` and any element `a` of the finite set of size `n + 1` (denoted as `Fin (n + 1)`), the condition " `a` is less than zero" is False. In mathematical terms, this asserts that no element of a finite set indexed from 0 to `n` can be less than zero.

For any natural number $n$ and any element $a$ in the finite set $\{0,1,\dots,n\}$, we have $a \not< 0$.


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

The theorem `Set.MapsTo.mono_right` states that for all types `α` and `β`, for all sets `s` of type `α`, and for two sets `t₁` and `t₂` of type `β`, if a function `f` maps elements of set `s` into set `t₁` (denoted as `Set.MapsTo f s t₁`) and all the elements of set `t₁` are also in set `t₂` (denoted as `t₁ ⊆ t₂`), then it follows that the function `f` maps elements of set `s` into set `t₂`. This theorem demonstrates the monotonicity of the mapping with respect to the right-hand (target) set: if the target set expands, the mapping still holds.

If a function maps a set into a subset of another set, then it also maps the set into the larger set.


/-- A function belongs to `piAntidiagonal s n`
iff its support is contained in `s` and the sum of its components is equal to `n`  -/
theorem Finset.mem_piAntidiagonal :
    ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ]
      [inst_2 : Finset.HasAntidiagonal μ] [inst_3 : DecidableEq μ] {s : Finset ι} {n : μ} {f : ι →₀ μ},
      f ∈ Finset.piAntidiagonal s n ↔ f.support ⊆ s ∧ (Finsupp.sum f fun x x => x) = n :=
  by sorry

This theorem states that a function `f` of type `ι →₀ μ` belongs to the antidiagonal set `piAntidiagonal s n` if and only if two conditions are met: Firstly, the support of the function `f` (the set of points where `f` does not vanish) must be a subset of the finite set `s`. Secondly, the sum of the function values of `f` over its support equals `n`. The types `ι` and `μ` are assumed to have decidable equality, with `μ` having an additional structure of a commutative monoid with an antidiagonal.

A function `f` from a decidably-equaled set `ι` to a commutative monoid `μ` with an antidiagonal belongs to the antidiagonal set `piAntidiagonal s n` if and only if its support is a subset of `s` and the sum of its values over its support equals `n`.


theorem AEMeasurable.comp_measurable :
    ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_5} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      [inst_1 : MeasurableSpace δ] {μ : MeasureTheory.Measure α} {f : α → δ} {g : δ → β},
      AEMeasurable g (MeasureTheory.Measure.map f μ) → Measurable f → AEMeasurable (g ∘ f) μ :=
  by sorry

The theorem `AEMeasurable.comp_measurable` states that, given three types `α`, `β`, and `δ` with associated measurable spaces, a measure `μ` on `α`, a function `f` from `α` to `δ`, and a function `g` from `δ` to `β`, if `g` is almost everywhere measurable with respect to the measure `μ` transformed by `f`, and if `f` itself is measurable, then the composition of `g` and `f` (denoted as `g ∘ f`) is also almost everywhere measurable with respect to the measure `μ`.

In other words, the measurability of the composition of two functions is preserved when one of the functions is measurable and the other is almost everywhere measurable.

If a function `g` is almost everywhere measurable with respect to the measure `μ` transformed by a measurable function `f`, then the composition `g ∘ f` is almost everywhere measurable with respect to `μ`.


IsMinFilter.max

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

The theorem `IsMinFilter.max` states that for any types `α` and `β` with `β` having a `LinearOrder` structure, and any functions `f` and `g` from `α` to `β`, if `f` and `g` are both minimizing functions with respect to some filter `l` at a point `a` (i.e., their values at `a` are less than or equal to their values for all points in some `l`-neighborhood of `a`), then the function that takes the maximum of `f` and `g` at each point is also a minimizing function with respect to the same filter `l` at the same point `a`. In other words, if `f(a) ≤ f(x)` for all `x` near `a` and `g(a) ≤ g(x)` for all `x` near `a`, then `max(f(a), g(a)) ≤ max(f(x), g(x))` for all `x` near `a`.

If functions `f` and `g` are both minimizers with respect to filter `l` at point `a`, then the pointwise maximum `\max(f, g)` is also a minimizer with respect to filter `l` at point `a`.


theorem Equiv.Perm.one_lt_of_mem_cycleType :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} {n : ℕ},
      n ∈ Equiv.Perm.cycleType σ → 1 < n :=
  by sorry

The theorem `Equiv.Perm.one_lt_of_mem_cycleType` states that for any given finite type `α` with decidable equality, for any permutation `σ` of `α`, and for any natural number `n`, if `n` is a member of the cycle type of the permutation `σ`, then `n` is greater than 1. In other words, all cycle lengths in the cycle type of a permutation are greater than 1.

For any finite type with decidable equality and any permutation of it, all cycle lengths in its cycle type are greater than 1.


theorem Mathlib.Algebra.GroupWithZero.NonZeroDivisors._auxLemma.2 :
    ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀},
      (x ∈ nonZeroDivisorsRight M₀) = ∀ (y : M₀), x * y = 0 → y = 0 :=
  by sorry

This theorem states that for any `MonoidWithZero` M₀ and for any element `x` of M₀, `x` belongs to the set of non-right-zero-divisors if and only if for every element `y` of M₀, the product of `x` and `y` equalling zero implies `y` equals zero. This theorem essentially defines what it means for an element to not be a right zero divisor in a `MonoidWithZero`. In the language of algebra, it says that in a monoid with zero, an element is a non-right-zero-divisor if it doesn't make any other non-zero element zero by right multiplication.

An element of a `MonoidWithZero` is a non-right-zero-divisor if and only if it does not make any non-zero element zero by right multiplication.


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

This theorem states that for any type `α` and any sort `ι`, and given a set `s` of type `α` and a function `t` mapping `ι` to a set of type `α`, the statement "set `s` is a subset of the intersection of the set `t i` for all `i` belonging to the sort `ι`" is equivalent to "for all `i` in `ι`, set `s` is a subset of the set `t i`". In other words, a set `s` is a subset of the intersection of a family of sets if and only if it is a subset of each set in the family.

For any type `α` and sort `ι`, a set `s` of type `α` is equal to the intersection of sets `{t i | i ∈ ι}`, if and only if `s` is a subset of each `t i`.


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

This theorem states that for any commutative semiring `R`, any index set `σ`, any monomial `m` (which is a function from `σ` to ℕ), and any two multivariate polynomials `p` and `q` (where the polynomials' coefficients are from `R` and their variables are indexed by `σ`), the coefficient of `m` in the polynomial resulting from the addition of `p` and `q` is equal to the sum of the coefficients of `m` in `p` and `q`. This property is analogous to the distributive law in algebra, but applied to the coefficients of multivariate polynomials.

For any commutative semiring `R`, any index set `σ`, and multivariate polynomials `p` and `q` over `R` with coefficients indexed by `σ`, the coefficient of any monomial `m` in the sum of `p` and `q` is the sum of the coefficients of `m` in `p` and `q`.


theorem Cycle.isCycle_formPerm :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (h : Cycle.Nodup s),
      Cycle.Nontrivial s → Equiv.Perm.IsCycle (Cycle.formPerm s h) :=
  by sorry

The theorem `Cycle.isCycle_formPerm` states that for any type `α` with a decidable equality relation, and a cycle `s` of `α` with the property that it has no duplicate elements (`Cycle.Nodup`), if the cycle `s` is nontrivial (meaning it contains at least two unique elements), then the permutation formed by mapping each element in the cycle to the next one (`Cycle.formPerm`) is a non-identity permutation such that any two distinct points in the permutation are related by repeated application of the permutation (`Equiv.Perm.IsCycle`).

For any decidably equated type `α` with a non-duplicative, nontrivial cycle `s`, the permutation formed by mapping each element to the next in `s` is a non-identity cycle relation on distinct elements.


theorem CategoryTheory.Endofunctor.Algebra.Hom.ext :
    ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {F : CategoryTheory.Functor C C}
      {A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} (x y : CategoryTheory.Endofunctor.Algebra.Hom A₀ A₁),
      x.f = y.f → x = y :=
  by sorry

This theorem states that in the context of category theory, given a category `C` and a functor `F` from `C` to itself, for any two 'algebras' `A₀` and `A₁` over this endofunctor `F`, any two morphisms `x` and `y` from `A₀` to `A₁` are equal if and only if their underlying functions `x.f` and `y.f` are equal. This theorem is essentially expressing that the morphism in a category of this specific type of algebra (endofunctor algebra) is fully determined by its function part.

In the category of endofunctor algebras, two morphisms between algebras are equal if and only if their underlying functions are equal.


theorem Set.projIci_coe : ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (x : ↑(Set.Ici a)), Set.projIci a ↑x = x := by
  sorry

This theorem states that for any type `α` equipped with a linear order, and any `a` of type `α`, the projection onto the closed interval `[a, ∞)` of any element `x` in the set `Set.Ici a` (which represents the interval `[a, ∞)`) is equal to `x` itself. In other words, for all members of the interval `[a, ∞)`, projecting them onto the interval `[a, ∞)` doesn't change their value.

For any type `α` with a linear order, and for all `a` in `α` and `x` in the set `Set.Ici a` (the closed interval `[a, ∞)`), the projection of `x` onto the interval `[a, ∞)` equals `x` itself.


theorem NNReal.pi_ne_zero : NNReal.pi ≠ 0 := by sorry

The theorem `NNReal.pi_ne_zero` asserts that π, when considered as a nonnegative real number (`NNReal.pi`), is not equal to zero. In other words, it states that the value of π is nonzero in the domain of nonnegative real numbers.

The theorem `NNReal.pi_ne_zero` asserts that π (as a nonnegative real number) is distinct from zero.


theorem ENNReal.inv_pow : ∀ {a : ENNReal} {n : ℕ}, (a ^ n)⁻¹ = a⁻¹ ^ n := by sorry

This theorem states that for every extended nonnegative real number `a` and for every natural number `n`, the reciprocal (or inverse) of `a` raised to the `n`th power is equal to `n` powers of the reciprocal of `a`. In other words, taking the reciprocal and raising to the `n`th power commute with each other. This can be expressed in mathematical notation by saying that for all $a \in [0, \infty)$ and $n \in \mathbb{N}$, $(a^n)^{-1} = (a^{-1})^n$.

For all $a \in (0, \infty)$ and $n \in \mathbb{N}$, $(a^n)^{-1} = (a^{-1})^n$ (i.e., the reciprocal of a number raised to the power n is equal to n-th power of its reciprocal).


theorem ENNReal.inv_pos : ∀ {a : ENNReal}, 0 < a⁻¹ ↔ a ≠ ⊤ := by sorry

The theorem `ENNReal.inv_pos` states that for every extended nonnegative real number `a`, the inverse of `a` is greater than 0 if and only if `a` is not infinity. Here `ENNReal` represents the set of extended nonnegative real numbers, which comprises all nonnegative real numbers plus the element infinity. The symbol `⁻¹` denotes the multiplicative inverse, `0 < a⁻¹` means that the inverse of `a` is positive, and `a ≠ ⊤` means that `a` is not equal to infinity.

For every extended nonnegative real number `a`, the multiplicative inverse `a⁻¹` is positive if and only if `a` is finite.


theorem StructureGroupoid.LocalInvariantProp.liftProp_id :
    ∀ {H : Type u_1} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] {G : StructureGroupoid H} {Q : (H → H) → Set H → H → Prop},
      StructureGroupoid.LocalInvariantProp G G Q → (∀ (y : H), Q id Set.univ y) → ChartedSpace.LiftProp Q id :=
  by sorry

This theorem states that for any types `H` and `M`, where both have a topological space structure, and `M` has a charted space structure relative to `H`, if `G` is a structure groupoid on `H`, and `Q` is a property that is locally invariant under `G`, then if `Q` holds for the identity function on the universal set of `H`, then `Q` can be lifted to the whole space `M` via the identity function.

In more informal terms, if we have a property `Q` that remains unchanged under certain transformations `G` in a local neighborhood on a space `H`, and this property `Q` holds everywhere in `H` for the identity function, then this property `Q` also holds for the entire space `M` which is modeled on `H`, when considered under the identity function.

If `H` and `M` are topological spaces with `M` charted over `H`, `G` is a groupoid on `H`, `Q` is a locally invariant property under `G`, and `Q(id_H)` holds, then `Q` holds for the identity function on `M`.


theorem MeasureTheory.stoppedValue_upperCrossingTime :
    ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω},
      MeasureTheory.upperCrossingTime a b f N (n + 1) ω ≠ N →
        b ≤ MeasureTheory.stoppedValue f (MeasureTheory.upperCrossingTime a b f N (n + 1)) ω :=
  by sorry

The theorem `MeasureTheory.stoppedValue_upperCrossingTime` states that for any types `Ω`, real numbers `a` and `b`, a function `f` from natural numbers to a function from `Ω` to real numbers, natural numbers `N` and `n`, and an element `ω` of `Ω`, if the upper crossing time of `f` with respect to `a` and `b` at `N` and `n + 1` for `ω` is not equal to `N`, then `b` is less than or equal to the stopped value of `f` with respect to the upper crossing time of `f` with respect to `a` and `b` at `N` and `n + 1` for `ω`. In simpler terms, if `f` crosses the upper limit `b` after time `N`, the stopped value at the crossing time will be at least `b`.

If the upper crossing time of function `f` with respect to `a` and `b` at `N` and `n+1` for `ω` is not equal to `N`, then the stopped value of `f` with respect to `a` and `b` at `N` and `n+1` for `ω` is greater than or equal to `b`.


theorem Nat.add_right_cancel : ∀ {n m k : ℕ}, n + m = k + m → n = k := by sorry

This theorem, `Nat.add_right_cancel`, states that for all natural numbers `n`, `m`, and `k`, if the sum of `n` and `m` equals the sum of `k` and `m`, then `n` must equal `k`. Essentially, it ensures that addition on the right side of a natural number is "cancelable", which is a crucial property of addition in the context of natural numbers.


theorem RatFunc.num_mul_eq_mul_denom_iff :
    ∀ {K : Type u} [inst : Field K] {x : RatFunc K} {p q : Polynomial K},
      q ≠ 0 →
        (RatFunc.num x * q = p * RatFunc.denom x ↔
          x = (algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) :=
  by sorry

This theorem states that for any field `K` and any rational function `x` of type `RatFunc K`, along with any two polynomials `p` and `q` in `K` where `q` is not equal to zero, the equality of the product of the numerator of `x` and `q` with the product of `p` and the denominator of `x` is equivalent to `x` being equal to the division of the algebra map applied to `p` by the algebra map applied to `q`. Here, the algebra map is a function that embeds the ring of polynomials into the field of rational functions.

For any field `K`, rational function `x : RatFunc K`, polynomials `p`, `q ≠ 0` in `K`, the equality `(numerator x) * q = p * (denominator x)` holds if and only if `x = algebraMap K p / algebraMap K q`.


theorem Ordinal.sup_eq_lsub_iff_succ :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u v}),
      Ordinal.sup f = Ordinal.lsub f ↔ ∀ a < Ordinal.lsub f, Order.succ a < Ordinal.lsub f :=
  by sorry

This theorem states that for a given function `f` mapping the type `ι` to ordinals, the supremum of `f` equals the least strict upper bound of `f` if and only if for any ordinal `a` that is less than the least strict upper bound of `f`, the successor of `a` is also less than the least strict upper bound of `f`. In simpler terms, this theorem is essentially asserting a relationship between the supremum and least upper bound of a set of ordinals: they are equivalent if and only if every element less than the least upper bound has its successor also less than the least upper bound.

The supremum of a function from a type to ordinals equals the least strict upper bound if and only if the successor of every ordinal strictly below it is also strictly below the least upper bound.


/-- **First moment method**. A measurable function is greater than its mean on a set of positive
measure.  -/
theorem MeasureTheory.measure_laverage_le_pos :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      μ ≠ 0 → ∫⁻ (a : α), f a ∂μ ≠ ⊤ → 0 < ↑↑μ {x | ⨍⁻ (a : α), f a ∂μ ≤ f x} :=
  by sorry

The theorem, referred to as the "First moment method", states that for any measurable space `α`, any non-zero measure `μ` on this space, and any measurable function `f` from `α` to the extended nonnegative real numbers (which includes [0, ∞]), the function `f` is greater than its mean over a set with a positive measure. More specifically, the measure of the set of points `x` in `α` where the function `f` exceeds its own mean (integrated over the entire space `α` with respect to the measure `μ`) is strictly positive, given that the integral of `f` over `α` is not infinite.

For any measurable space `α`, measurable function `f` from `α` to the extended nonnegative real numbers, and finite measure `μ` on `α`, if the integral of `f` over `α` with respect to `μ` is finite and not equal to zero, then the set of points where `f(x) > int(f) dμ` has positive measure.


theorem Finset.prod_filter_mul_prod_filter_not :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] (s : Finset α) (p : α → Prop) [inst_1 : DecidablePred p]
      [inst_2 : (x : α) → Decidable ¬p x] (f : α → β),
      ((Finset.prod (Finset.filter p s) fun x => f x) * Finset.prod (Finset.filter (fun x => ¬p x) s) fun x => f x) =
        Finset.prod s fun x => f x :=
  by sorry

This theorem states that for any given type `α` and `β` where `β` is a Commutative Monoid, a finite set `s` of type `α`, a predicate `p` on `α` which is decidable, a function `f` from `α` to `β`, and for all elements of `α` the negation of predicate `p` is decidable, the product of `f x` for every `x` in the set of elements of `s` that satisfy `p`, multiplied by the product of `f x` for every `x` in the set of elements of `s` that do not satisfy `p`, is equal to the product of `f x` for every `x` in the set `s`. In other words, it's saying that the product over a set is the same as the product over the partition of the set by a certain decidable predicate.

Given a type `α`, a Commutative Monoid `β`, a finite set `s` of type `α`, a decidable predicate `p` on `α`, and a function `f` from `α` to `β` such that the negation of `p` is also decidable, the product of `f` applied to elements of `s` that satisfy `p` is equal to the product of `f` applied to elements of `s` that satisfy `p` and the product of `f` applied to elements of `s` that do not satisfy `p`.