theorem SetTheory.PGame.lf_congr :
    ∀ {x₁ y₁ x₂ y₂ : SetTheory.PGame}, x₁ ≈ x₂ → y₁ ≈ y₂ → (SetTheory.PGame.LF x₁ y₁ ↔ SetTheory.PGame.LF x₂ y₂) := by
  sorry

This theorem states that for any four pre-games `x₁`, `y₁`, `x₂`, and `y₂`, if `x₁` is equivalent to `x₂` and `y₁` is equivalent to `y₂`, then the 'less or fuzzy' relation (`SetTheory.PGame.LF`) holds between `x₁` and `y₁` if and only if it holds between `x₂` and `y₂`. In other words, the 'less or fuzzy' relationship is preserved under equivalence of pre-games. 'Less or fuzzy' relation, denoted as `SetTheory.PGame.LF x y`, implies that Left can win the game `y` as the first player if `0` is not less or equal to `x`.

Given any pre-games x₁, y₁, x₂, and y₂, if x₁ is equivalent to x₂ and y₁ is equivalent to y₂, then the 'less or fuzzy' relation (SetTheory.PGame.LF) between x₁ and y₁ holds if and only if it holds between x₂ and y₂.


theorem norm_indicator_eq_indicator_norm :
    ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedAddCommGroup E] {s : Set α} (f : α → E) (a : α),
      ‖Set.indicator s f a‖ = Set.indicator s (fun a => ‖f a‖) a :=
  by sorry

The theorem `norm_indicator_eq_indicator_norm` states that for any type `α`, any seminormed additive commutative group `E`, any set `s` of type `α` and any function `f` from `α` to `E`, and for any element `a` of type `α`, the norm of the indicator function of `s` applied to the function `f` at `a` is equal to the indicator function of `s` applied to the function that maps `a` to the norm of `f` at `a`. In mathematical terms, this states that ‖1[s](f(a))‖ = 1[s](‖f(a)‖), where 1[s] denotes the indicator function of the set `s`.

For any seminormed additive commutative group E, set s, and function f, the norm of the indicator function of set s applied to function f at an element a equals the indicator function of set s applied to the norm function of f at element a. In other words, ‖1[s](f(a))‖ = 1[s](‖f(a)‖).


theorem min_assoc : ∀ {α : Type u} [inst : LinearOrder α] (a b c : α), min (min a b) c = min a (min b c) := by sorry

This theorem, `min_assoc`, states that for any type `α` that has a linear order, the function `min` is associative. In other words, for any three elements `a`, `b`, and `c` of this type, computing the minimum of `a` and `b` first and then the minimum of the result with `c` yields the same result as computing the minimum of `b` and `c` first and then the minimum of `a` with the result. This is similar to the mathematical property that, for real numbers, `(a⊕b)⊕c = a⊕(b⊕c)`, where `⊕` represents the min operation.

For any type `α` with a linear order, the function `min` is associative: `min a (min b c) = min (min a b) c`.


theorem Submodule.quotientRel_r_def :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
      {x y : M}, Setoid.r x y ↔ x - y ∈ p :=
  by sorry

This theorem states that for any ring `R`, any additive commutative group `M`, any `R`-module structure on `M`, and any submodule `p` of `M`, the relation `Setoid.r` between two elements `x` and `y` of `M` is equivalent to the assertion that the difference `x - y` is an element of the submodule `p`. In other words, two elements `x` and `y` in the module `M` are related by the equivalence relation defined by the setoid if and only if their difference is in the given submodule `p`.

For any ring `R`, additive commutative group `M`, `R`-module structure on `M`, and submodule `p` of `M`, the equivalence relation defined by the setoid `Setoid.r` on `M` is equivalent to the submodule membership relation for the differences of elements in `M` with respect to `p`.


theorem Nat.succ_lt_succ_iff : ∀ {a b : ℕ}, Nat.succ a < Nat.succ b ↔ a < b := by sorry

This theorem states that for any two natural numbers 'a' and 'b', the successor of 'a' (i.e., 'a+1') is less than the successor of 'b' (i.e., 'b+1') if and only if 'a' is less than 'b'. It essentially asserts that adding 1 to both sides of an inequality between natural numbers doesn't change the validity of the inequality.

For all natural numbers a and b, a < b if and only if a + 1 < b + 1.


theorem Submodule.Quotient.mk_smul :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
      {S : Type u_3} [inst_3 : SMul S R] [inst_4 : SMul S M] [inst_5 : IsScalarTower S R M] (r : S) (x : M),
      Submodule.Quotient.mk (r • x) = r • Submodule.Quotient.mk x :=
  by sorry

The theorem `Submodule.Quotient.mk_smul` states that for any ring `R`, any additive commutative group `M` which is also a `R`-module, a submodule `p` of `M`, a type `S` such that `S` can be multiplied by `R` and `M` (denoted by `SMul S R` and `SMul S M` respectively), and such that multiplication of `S` over `R` over `M` is associative (denoted by `IsScalarTower S R M`), and any element `r` of type `S` and `x` of type `M`, scalar multiplication of `r` and `x` followed by the quotient mapping equals to the quotient of `x` followed by scalar multiplication by `r`. In essence, it shows that the map of moving an element of `M` to the quotient group `M/p` commutes with scalar multiplication from `S`.

For any ring `R`, additive commutative group `M` that is an `R`-module, submodule `p` of `M`, type `S` with associative scalar multiplication on `M`, and any `r` in `S` and `x` in `M`, we have `(r • x + p) = r • (x + p)` in `M/p`, where `•` denotes scalar multiplication.


/-- A linear isometric equivalence preserves the inner product.  -/
theorem LinearIsometryEquiv.inner_map_map :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {E' : Type u_7} [inst_3 : NormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] (f : E ≃ₗᵢ[𝕜] E') (x y : E),
      ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜 :=
  by sorry

This theorem states that for any type 𝕜, any normed additive commutative group E with an inner product space over 𝕜, and another such group E', if there is a linear isometric equivalence 'f' from E to E', then the inner product of f(x) and f(y) (where x and y are elements of E) is equal to the inner product of x and y. In other words, a linear isometric equivalence preserves the inner product.

A linear isometric map between two inner product spaces preserves the inner product.


theorem Equiv.Perm.mem_cycleFactorsFinset_iff :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f p : Equiv.Perm α},
      p ∈ Equiv.Perm.cycleFactorsFinset f ↔ Equiv.Perm.IsCycle p ∧ ∀ a ∈ Equiv.Perm.support p, p a = f a :=
  by sorry

This theorem states that for any type `α` with decidable equality and being finite, and for any permutations `f` and `p` of `α`, `p` is a member of the cycle factors of `f` if and only if `p` is a cycle and for all elements `a` in the support of `p` (the set of nonfixed points of a permutation), `p` applied to `a` equals `f` applied to `a`. It essentially describes a condition for a permutation to be considered as one of the cyclic factors of another permutation.

A permutation `p` is a cycle factor of `f` if and only if `p` is a cycle and for all elements `a` in the support of `p`, `p(a) = f(a)`.


/-- Convex **Jensen's inequality**, `Finset.sum` version.  -/
theorem ConvexOn.map_sum_le :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} {ι : Type u_5} [inst : LinearOrderedField 𝕜]
      [inst_1 : AddCommGroup E] [inst_2 : OrderedAddCommGroup β] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 β]
      [inst_5 : OrderedSMul 𝕜 β] {s : Set E} {f : E → β} {t : Finset ι} {w : ι → 𝕜} {p : ι → E},
      ConvexOn 𝕜 s f →
        (∀ i ∈ t, 0 ≤ w i) →
          (Finset.sum t fun i => w i) = 1 →
            (∀ i ∈ t, p i ∈ s) → f (Finset.sum t fun i => w i • p i) ≤ Finset.sum t fun i => w i • f (p i) :=
  by sorry

This theorem states the **Convex Jensen's Inequality** in the context of finite sets. The inequality applies to a function `f` defined on a set `s` over which `f` is convex. Given a finite set `t`, weights `w` (where each weight is non-negative and the sum of all weights equals 1), and points `p` in set `s`, the value of the function `f` at the weighted sum of the points `p` is less than or equal to the weighted sum of the values of function `f` at each point `p`. In mathematical terms, the theorem states that if `f` is convex on `s`, then `f (∑_{i∈t} w_i * p_i) ≤ ∑_{i∈t} w_i * f(p_i)`.

If `f` is a convex function over a finite set `s`, then for any finite subset `t` of `s`, weights `w` summing to 1, and points `p` in `s`, we have `f (∑ₙₙₙₕₖ wₕ pₖ) ≤ ∑ₙₙₙₕₖ wₕ f(pₖ)`.


theorem Mathlib.Order.Filter.Basic._auxLemma.134 : ∀ {α : Type u} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any set `s` of type `α`, the singleton set containing `a` is a subset of `s` if and only if `a` is an element of `s`. In other words, a singleton set `{a}` is included in another set `s` precisely when the element `a` is in `s`.

For any type `α`, set `s` of type `α`, and element `a` of type `α`, the singleton set `{a}` is a subset of `s` if and only if `a` is an element of `s`. (Equivalently, `a` belongs to `s` if and only if the singleton set `{a}` is a subset of `s`.)


theorem MeasureTheory.integral_eq_zero_iff_of_nonneg_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae μ] f →
        MeasureTheory.Integrable f μ → (∫ (x : α), f x ∂μ = 0 ↔ f =ᶠ[MeasureTheory.Measure.ae μ] 0) :=
  by sorry

This theorem states that for a given measurable space `α` and a measure `μ` on that space, if a function `f : α → ℝ` is nonnegative almost everywhere (with respect to `μ`) and is integrable with respect to `μ`, then the integral of `f` with respect to `μ` is equal to zero if and only if `f` is zero almost everywhere (with respect to `μ`). In other words, under these conditions, the integral being zero is equivalent to the function being zero almost everywhere.

For a measurable space `(α, Σ, μ)` and a nonnegative, integrable function `f : α → ℝ` with respect to `μ`, the equality of their integrals, `∫(α, Σ, μ, f) = 0`, holds if and only if `f` is almost everywhere equal to zero.


/-- Series divergence test: if `f` is unconditionally summable, then `f x` tends to zero
along `cofinite`. -/
theorem Summable.tendsto_cofinite_zero :
    ∀ {α : Type u_1} {G : Type u_5} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G]
      [inst_2 : TopologicalAddGroup G] {f : α → G}, Summable f → Filter.Tendsto f Filter.cofinite (nhds 0) :=
  by sorry

This theorem, known as the "Series divergence test", states that if a function `f` is unconditionally summable (that is, the infinite sum of its values exists), then the values of `f(x)` tends to zero in the cofinite filter. The cofinite filter is defined as the collection of subsets whose complements are finite, so essentially, `f(x)` tends to zero when considered over all but a finite number of points. This is a fundamental result in analysis related to the behavior of sum of infinite series. The theorem applies to any function `f` from a type `α` to a topological add group `G`.

If a function `f` from a type `α` to a topological add group `G` is unconditionally summable, then `f(x)` converges to zero in the cofinite filter.


IsConj.refl

theorem IsConj.refl : ∀ {α : Type u} [inst : Monoid α] (a : α), IsConj a a := by sorry

This theorem states that, for any type `α` that has a monoid structure, any element `a` of that type is conjugate to itself. In other words, for every monoid element `a`, there exists a unit `c` such that `c * a * c⁻¹ = a`. Essentially, this is reflecting that each element in a monoid is conjugate to itself under the relation of conjugacy.

For any monoid `α` and its element `a`, there exists a unit `c` in `α` such that `c * a * c⁻¹ = a`.


/-- Addition in an `AddLocalization` is defined as `⟨a, b⟩ + ⟨c, d⟩ = ⟨a + c, b + d⟩`.
Should not be confused with the ring localization counterpart `Localization.add`, which maps
`⟨a, b⟩ + ⟨c, d⟩` to `⟨d * a + b * c, b * d⟩`. -/
theorem AddLocalization.add_def :
    ∀ {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M), AddLocalization.add S = Add.add := by sorry

The theorem `AddLocalization.add_def` states that for any type `M` that forms an additive commutative monoid and any additive submonoid `S` of `M`, the addition operation defined on the localization of `M` at `S` is identical to the regular addition operation. Remember that the addition in `AddLocalization` is defined such that the sum of two elements `⟨a, b⟩` and `⟨c, d⟩` is `⟨a + c, b + d⟩`. This should not be confused with the counterpart in ring localization, which gives a different result.

For any additive commutative monoid M and its additive submonoid S, the addition operation in the localization of M at S is equivalent to the regular addition operation on M.


Finset.SupIndep.pairwiseDisjoint

theorem Finset.SupIndep.pairwiseDisjoint :
    ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α},
      Finset.SupIndep s f → Set.PairwiseDisjoint (↑s) f :=
  by sorry

The theorem `Finset.SupIndep.pairwiseDisjoint` states that for any set `s` of elements of type `ι` and any function `f` from `ι` to `α`, where `α` is a lattice and an ordered bot (it contains a least element), if `s` enjoys the supremum independence property under `f`, then the set `s` (viewed as a set instead of a finset) is pairwise disjoint under `f`. In other words, the images of any two distinct elements of `s` under `f` are disjoint. Supremum independence implies that for any subset `t` of `s` and any element `i` in `s` but not in `t`, `f(i)` is disjoint from the supremum of `f` over `t`.

If a set `s` of elements from a lattice `α` with a least element has the supremum independence property under a function `f` from `s` to `α`, then the images of distinct elements of `s` under `f` are disjoint.


theorem map_inv_nat_cast_smul :
    ∀ {M : Type u_5} {M₂ : Type u_6} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂] {F : Type u_9}
      [inst_2 : FunLike F M M₂] [inst_3 : AddMonoidHomClass F M M₂] (f : F) (R : Type u_10) (S : Type u_11)
      [inst_4 : DivisionSemiring R] [inst_5 : DivisionSemiring S] [inst_6 : Module R M] [inst_7 : Module S M₂] (n : ℕ)
      (x : M), f ((↑n)⁻¹ • x) = (↑n)⁻¹ • f x :=
  by sorry

This theorem states that for any two types `M` and `M₂` that are additive commutative monoids, a type `F` that is a function from `M` to `M₂` with certain homomorphism properties, two types `R` and `S` that are division semirings, and `n` a natural number and `x` in `M`, if `M` and `M₂` are modules over `R` and `S` respectively, then the function `f` applied to the result of scaling `x` by the inverse of the cast of `n` is equal to the result of scaling `f x` by the inverse of the cast of `n`. This theorem is essentially asserting that this function `f` commutes with the operation of scaling by the inverse of a natural number cast.

For functions `F` between additive commutative monoids `M` and `M₂` that are homomorphisms, if `M`, `M₂`, `R`, and `S` are modules over division semirings `R` and `S` respectively, then for all natural numbers `n`, `x ∈ M`, `f(nx⁻¹ ×x) = n⁻¹ ×(Fx)`.


theorem Polynomial.natDegree_map :
    ∀ {R : Type u} {S : Type v} [inst : DivisionRing R] {p : Polynomial R} [inst_1 : Semiring S] [inst_2 : Nontrivial S]
      (f : R →+* S), Polynomial.natDegree (Polynomial.map f p) = Polynomial.natDegree p :=
  by sorry

The theorem `Polynomial.natDegree_map` states that for any division ring `R`, any polynomial `p` over `R`, any semiring `S` that is nontrivial, and any ring homomorphism `f` from `R` to `S`, the natural degree of the polynomial obtained by mapping `p` across `f` is equal to the natural degree of `p`. In other words, mapping a polynomial across a ring homomorphism does not change its natural degree. This can be mathematically represented as $\text{{natDegree}}(\text{{map}}(f, p)) = \text{{natDegree}}(p)$.

The natural degree of a polynomial mapped across a ring homomorphism remains unchanged.


Algebra.FinitePresentation.equiv

/-- If `e : A ≃ₐ[R] B` and `A` is finitely presented, then so is `B`.  -/
theorem Algebra.FinitePresentation.equiv :
    ∀ {R : Type w₁} {A : Type w₂} {B : Type w₃} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      [inst_3 : CommRing B] [inst_4 : Algebra R B],
      Algebra.FinitePresentation R A → (A ≃ₐ[R] B) → Algebra.FinitePresentation R B :=
  by sorry

The theorem `Algebra.FinitePresentation.equiv` states that for all types `R`, `A`, and `B`, where `R` is a commutative ring, `A` and `B` are rings and `A` and `B` are algebras over `R`, if `A` is a finitely presented algebra, then `B` is also a finitely presented algebra, given there exists an algebra isomorphism from `A` to `B`. In other words, if we have an algebra that is the quotient of a polynomial ring in `n` variables by a finitely generated ideal (i.e., it's finitely presented), and if we have an isomorphism (equivalence) between this algebra and another, then the second algebra is also finitely presented.

If `R` is a commutative ring, `A` and `B` are `R`-algebras with `A` finitely presented and there exists an algebra isomorphism from `A` to `B`, then `B` is also finitely presented.


theorem List.nodup_dedup : ∀ {α : Type u} [inst : DecidableEq α] (l : List α), List.Nodup (List.dedup l) := by sorry

The theorem `List.nodup_dedup` states that for any type `α` which has decidable equality, given any list `l` of type `α`, the list obtained by removing duplicates from `l` using the `List.dedup` function has no duplicates. In other words, for every list, it's guaranteed that the deduplicated version of that list won't contain any repeated elements.

Given any list `l` of type `α` with decidable equality, the list `List.dedup l` has no repeated elements.


theorem inf_iSup_eq :
    ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] (a : α) (f : ι → α), a ⊓ ⨆ i, f i = ⨆ i, a ⊓ f i := by sorry

This theorem states that for any given type `α` equipped with a frame structure (a type of order theoretic structure), a constant `a` of type `α`, and a function `f` from an arbitrary type `ι` to `α`, the infimum (greatest lower bound) of `a` and the supremum (least upper bound) over all `i` of `f i` is equal to the supremum over all `i` of the infimum of `a` and `f i`. In other words, it exchanges the order of the infimum and supremum operations. This property is often found in mathematical structures that involve order and lattice operations, and is known as the "inf-sup distributive law".

For any frame-structured type `α`, any element `a` of `α`, and any function `f` from an arbitrary type to `α`, the infimum of `a` and the supremum of the infima of `a` and `f i` over all `i` are equal.


theorem Mathlib.Algebra.GroupWithZero.Units.Basic._auxLemma.1 :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Nontrivial M₀] (u : M₀ˣ), (↑u = 0) = False := by sorry

This theorem, `Mathlib.Algebra.GroupWithZero.Units.Basic._auxLemma.1`, states that for any nontrivial `MonoidWithZero` (a mathematical structure that is both a monoid and has an element defined as zero), every unit (non-zero element that has a multiplicative inverse) is not equal to zero. In other words, the equality of the unit converted to the monoid type and zero is always false.

In any nontrivial MonoidWithZero, a unit is distinct from the zero element.


theorem ContinuousAddMonoidHom.inducing_toContinuousMap :
    ∀ (A : Type u_2) (B : Type u_3) [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
      [inst_3 : TopologicalSpace B], Inducing ContinuousAddMonoidHom.toContinuousMap :=
  by sorry

The theorem `ContinuousAddMonoidHom.inducing_toContinuousMap` states that for any types `A` and `B`, given instances of `A` and `B` as additive monoids and also as topological spaces, the function `ContinuousAddMonoidHom.toContinuousMap` that reinterprets a `ContinuousAddMonoidHom` as a `ContinuousMap`, is an inducing function. In other words, the topology on `B` is the coarsest that makes this function continuous, meaning that the function's continuity is preserved under the mapping from `A` to `B`.

Given types `A` and `B` with instances of additive monoid and topological spaces structures, the function `ContinuousAddMonoidHom.toContinuousMap` from `ContinuousAddMonoidHom` to `ContinuousMap` is the greatest continuous function between the structures, preserving the additive monoid homomorphism property.


theorem MeasureTheory.Measure.addHaarMeasure_self :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G]
      [inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] {K₀ : TopologicalSpace.PositiveCompacts G},
      ↑↑(MeasureTheory.Measure.addHaarMeasure K₀) ↑K₀ = 1 :=
  by sorry

This theorem states that for any given additive group `G`, which also has the structures of a topological space, a topological additive group, a measurable space, and a Borel space, and given `K₀`, a positive compact subset of `G`, the Haar measure associated with `K₀` applied to `K₀` itself is 1. In other words, it asserts that the Haar measure of a positive compact set in the context of an additive topological group is normalized to 1.

For any additive topological group endowed with a translation-invariant Borel measure, the Haar measure of any positive compact subset equals 1.


Nat.Primrec.pred

theorem Nat.Primrec.pred : Nat.Primrec Nat.pred := by sorry

This theorem states that the predecessor function on natural numbers, as defined by `Nat.pred`, is primitive recursive. In the context of number theory, a function is said to be primitive recursive if it can be constructed from certain basic functions using composition and primitive recursion. Hence, this theorem is essentially a statement about the computability of the predecessor function in the natural number system.

The predecessor function on natural numbers, defined as `Nat.pred`, is a primitive recursive function.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.9 : ∀ {r : ℝ}, (ENNReal.ofReal r = ⊤) = False := by sorry

The theorem `Mathlib.Data.ENNReal.Basic._auxLemma.9` states that for any real number `r`, the result of the function `ENNReal.ofReal r` can never be infinity (or `⊤` in Lean 4 notation). In other words, when a real number is converted to an extended nonnegative real number using the `ofReal` function, the result is never infinity.

For any real number r, the result of the function `ENNReal.ofReal r` is finite.


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

This theorem is about the relationship between a specific set and the union of a collection of sets. For any type `α`, an index type `ι`, a second index type `κ` dependent on `ι`, and a function `s` that, for each `i` of type `ι` and `j` of type `κ i`, assigns a set of type `α`, the theorem asserts that the set `s i j` is a subset of the union of all sets `s i' j'`, where `i'` ranges over `ι` and `j'` ranges over `κ i'`. In simpler terms, any individual set within a collection of sets is a subset of the union of the entire collection.

For any function `s` that assigns to each pair `(i, j)` of indices a set `s i j`, the set `s i j` is a subset of the union of all sets `s i' j'` over all indices `i'` and `j'`.


ONote.NF.snd'

theorem ONote.NF.snd' :
    ∀ {e : ONote} {n : ℕ+} {a : ONote}, ONote.NF (ONote.oadd e n a) → ONote.NFBelow a (ONote.repr e) := by sorry

The theorem `ONote.NF.snd'` states that for any ordinal notation `e`, positive natural number `n`, and ordinal notation `a`, if the ordinal notation constructed from `e`, `n`, and `a` (in the form `ONote.oadd e n a`) is in normal form (`ONote.NF`), then the ordinal notation `a` is below the ordinal representation of `e` (`ONote.repr e`) in terms of normal form (`ONote.NFBelow`). Here, "normal form" indicates a specific format for expressing ordinal notations, and "below" means that `a` is less than or equal to `e` in the ordering defined by this normal form.

For any ordinal notations `e`, `n`, and `a` in normal form, if `ONote.oadd e n a` is equal to `ONote.NF (ONote.oadd e n a)`, then `a` is below `e` in the normal form ordering.


theorem MeasureTheory.snorm_mono_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_ae` states that in a measurable space, given two normed additive commutative groups (`F` and `G`), a measure and an extended non-negative real number `p`, if almost everywhere in the measurable space the norm of a function `f` from the space to `F` is less than or equal to the norm of a function `g` from the space to `G`, then the `ℒp` seminorm of `f` is less than or equal to the `ℒp` seminorm of `g`.

In the `ℒp` seminorm, `p` is equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.

If two measurable functions from a measurable space to normed additive commutative groups have almost everywhere less than or equal norms, then the `ℒp` seminorm of the first function is less than or equal to that of the second function for any `0 ≤ p <= ∞`.


theorem CategoryTheory.Limits.biproduct.ι_desc_assoc :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {f : J → C} [inst_2 : CategoryTheory.Limits.HasBiproduct f]
      {P : C} (p : (b : J) → f b ⟶ P) (j : J) {Z : C} (h : P ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.desc p) h) =
        CategoryTheory.CategoryStruct.comp (p j) h :=
  by sorry

The theorem `CategoryTheory.Limits.biproduct.ι_desc_assoc` establishes a property of product structures in a category with zero morphisms. It says that for any type `J`, category `C` with zero morphisms, a function `f` from `J` to `C`, a biproduct of `f`, a morphism `p` from type `J` to `C`, and any objects `P`, `Z` in `C`, the composition of the inclusion into a summand of a biproduct `(CategoryTheory.Limits.biproduct.ι f j)` and the composition of the morphism that maps each factor to a fixed target object `(CategoryTheory.Limits.biproduct.desc p)` with a morphism `h`, is the same as the composition of the morphism `p` at `j` with the morphism `h`. In more mathematical terms, this theorem is stating the associativity condition `(ι j) ≫ ((desc p) ≫ h) = (p j) ≫ h` in the context of a category with a biproduct.

In a category with zero morphisms, for any function `f` from a type `J` to `C`, biproduct `(ι f)`, morphism `p` from `J` to `C`, and object `Z` in `C`, the composition `(ι j) ≫ (desc p ≫ h)` equals `(p j) ≫ h` for all `j` in `J`.


theorem Denumerable.sigma_ofNat_val :
    ∀ {α : Type u_1} [inst : Denumerable α] {γ : α → Type u_3} [inst_1 : (a : α) → Denumerable (γ a)] (n : ℕ),
      Denumerable.ofNat (Sigma γ) n =
        { fst := Denumerable.ofNat α (Nat.unpair n).1,
          snd := Denumerable.ofNat (γ (Denumerable.ofNat α (Nat.unpair n).1)) (Nat.unpair n).2 } :=
  by sorry

The theorem `Denumerable.sigma_ofNat_val` states that for any denumerable type `α`, a function `γ` from `α` to another type, and a natural number `n`, the `n`-th element of the sigma type `Sigma γ` (which represents dependent pairs of an element of `α` and an element of the type determined by `γ` applied to the element of `α`) is a pair whose first component is the `n`-th denumerable element of `α`, and whose second component is the `n`-th denumerable element of the type determined by `γ` applied to the `n`-th denumerable element of `α`. This is done by using `Nat.unpair` function to split the natural number `n` into two numbers, one for indexing the first component and the other for indexing the second component.

For any denumerable type `α` and function `γ` from `α` to another type, the `n`-th element of the sigma type `Σγ` is the pair with the `n`-th element of `α` as the first component and the `n`-th element of the image of `γ` on the `n`-th element of `α` as the second component.


theorem QuaternionAlgebra.coe_add : ∀ {R : Type u_3} [inst : CommRing R] {c₁ c₂ : R} (x y : R), ↑(x + y) = ↑x + ↑y := by
  sorry

This theorem states that for any commutative ring `R` and any two elements `c₁` and `c₂` of `R`, the addition operation in `R` is preserved under the quaternion algebra embedding. Specifically, if `x` and `y` are two elements of `R`, then the quaternion algebra embedding of their sum `x + y` is equal to the sum of their quaternion algebra embeddings `↑x + ↑y`.

For any commutative ring `R` and elements `c₁, c₂` of `R`, the quaternion algebra embedding maps the sum `c₁ + c₂` to the sum of their embeddings, i.e., `↑(c₁ + c₂) = ↑c₁ + ↑c₂`.


theorem List.maximum_cons :
    ∀ {α : Type u_1} [inst : LinearOrder α] (a : α) (l : List α), List.maximum (a :: l) = max (↑a) (List.maximum l) :=
  by sorry

The theorem `List.maximum_cons` states that for any type `α` that has a `LinearOrder` structure, any element `a` of type `α`, and any list `l` of elements of type `α`, the maximum element of the list that results from prepending `a` to `l` is the maximum of `a` and the maximum element of `l`. The maximum of `a` and the maximum element of `l` is computed using the `max` function, and the maximum element of the list is computed using the function `List.maximum`. If `l` is an empty list, the maximum of `a` and `List.maximum l` is simply `a`.

For any type `α` with a `LinearOrder` structure and any list `l` of `α` elements, `max (a :: l) = max a (List.maximum l)`.


theorem mul_mem_cancel_left :
    ∀ {G : Type u_1} [inst : Group G] {S : Type u_6} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G]
      {x y : G}, x ∈ H → (x * y ∈ H ↔ y ∈ H) :=
  by sorry

This theorem, `mul_mem_cancel_left`, states that for any given type `G` that forms a group, a type `S`, an instance `H` of `S`, where `S` behaves like a set for `G` and `S` is a subgroup class of `G`, given any two elements `x` and `y` of the group `G`, if `x` is an element of `H`, then `x * y` is an element of `H` if and only if `y` is an element of `H`. In simpler terms, in the context of a given subgroup `H` of a group `G`, if we multiply an element of the subgroup by another element from the group, the result is in the subgroup if and only if the second element was already in the subgroup.

If `H` is a subgroup of a group `G`, then for all `x in H` and `y in G`, `x * y` is in `H` if and only if `y` is in `H`.


theorem StieltjesFunction.measure_Ioc :
    ∀ (f : StieltjesFunction) (a b : ℝ), ↑↑(StieltjesFunction.measure f) (Set.Ioc a b) = ENNReal.ofReal (↑f b - ↑f a) :=
  by sorry

This theorem states that for any Stieltjes function `f` and any two real numbers `a` and `b`, the measure of the interval `(a, b]` under this function is equal to the nonnegative real part of the difference `f(b) - f(a)`. In other words, it is associating a measure to the interval `(a, b]` that corresponds to the difference in the values of `f` at `b` and `a`, with the measure being `0` if this difference is negative. The function `f` essentially maps an interval of real numbers to a measure, and this theorem gives the rule for how it does this.

For any Stieltjes function `f` and real numbers `a` and `b` with `b > a`, the measure of the interval `(a, b]` under `f` equals the nonnegative real part of `(f(b) - f(a))`.


theorem List.length_finRange : ∀ (n : ℕ), List.length (List.finRange n) = n := by sorry

The theorem `List.length_finRange` states that for any natural number `n`, the length of the list of all elements of `Fin n` (generated using the `List.finRange` function) is equal to `n`. Essentially, it means that the list created by `List.finRange` contains `n` elements, where each element is a finite ordinal less than `n`. These finite ordinals range from `0` to `n-1`.

The length of the list produced by `List.finRange` over a finite type `Fin n` is equal to `n`.


theorem ENNReal.rpow_ne_top_of_nonneg : ∀ {x : ENNReal} {y : ℝ}, 0 ≤ y → x ≠ ⊤ → x ^ y ≠ ⊤ := by sorry

The theorem `ENNReal.rpow_ne_top_of_nonneg` states that for any extended nonnegative real numbers `x` and any real number `y`, if `y` is nonnegative and `x` is not equal to positive infinity, then `x` raised to the power `y` (represented as `x ^ y`) will never be equal to positive infinity. This theorem is commonly used in measure theory, where the extended nonnegative real numbers often serve as the codomain of a measure.

For all extended nonnegative real numbers `x` that are not positive infinity and all nonnegative real numbers `y`, `x^y` is finite.


theorem IsometryEquiv.symm_symm :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β),
      IsometryEquiv.symm (IsometryEquiv.symm h) = h :=
  by sorry

This theorem states that for any two types `α` and `β` which have `PseudoEMetricSpace` structures, and given an isometric isomorphism `h` from `α` to `β`, applying the operation `IsometryEquiv.symm` twice (i.e., taking the inverse of the inverse) returns the original isometric isomorphism `h`. In other words, the `IsometryEquiv.symm` operation is its own inverse when applied twice.

For any isometric isomorphism `h` between PseudoMetricSpaces `α` and `β`, `h` is equal to its own inverse, i.e., `h = IsometryEquiv.symm (IsometryEquiv.symm h)`.


theorem MeasureTheory.exists_measurable_superset_of_null :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
      ↑↑μ s = 0 → ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = 0 :=
  by sorry

This theorem, `MeasureTheory.exists_measurable_superset_of_null`, states that for any type `α`, measurable space `α`, measure `μ` on `α`, and set `s` of `α`, if the measure of set `s` is zero, then there exists a measurable superset `t` of `s` such that the measure of `t` is also zero. In mathematical terms, for all sets `s` with `μ(s) = 0`, there exists a set `t` such that `s` is a subset of `t`, `t` is a measurable set, and `μ(t) = 0`.

For any measurable space `(α, μ)` and measurable set `s` with `μ(s) = 0`, there exists a measurable set `t` containing `s` such that `μ(t) = 0`.


theorem Nat.shiftRight_eq_div_pow : ∀ (m n : ℕ), m >>> n = m / 2 ^ n := by sorry

This theorem states that for any two natural numbers `m` and `n`, the operation of right bitwise shift of `m` by `n` places is equal to the operation of integer division of `m` by `2` to the power of `n`. Bitwise shift to the right effectively divides the number by 2 for each shift, hence the equivalence to dividing by `2^n`.

For all natural numbers m and n, m >> n = m / (2^n), where >> denotes right bitwise shift and / denotes integer division.


theorem Real.hasDerivAt_cosh : ∀ (x : ℝ), HasDerivAt Real.cosh (Real.sinh x) x := by sorry

The theorem `Real.hasDerivAt_cosh` states that for any real number `x`, the derivative of the hyperbolic cosine function (`Real.cosh`) at the point `x` is equal to the value of the hyperbolic sine function (`Real.sinh`) at that same point `x`. In other words, if we differentiate the hyperbolic cosine function at any real number, we will get the hyperbolic sine function evaluated at that number. This corresponds to the mathematical statement $\frac{d}{dx}\cosh(x) = \sinh(x)$ in calculus.

The derivative of the hyperbolic cosine function equals the hyperbolic sine function. In Lean: `Real.hasDerivAt_cosh : ∀ x : ℝ, (derivative (Real.cosh) x) = Real.sinh x`.


Hyperreal.IsSt.unique

theorem Hyperreal.IsSt.unique : ∀ {x : ℝ*} {r s : ℝ}, Hyperreal.IsSt x r → Hyperreal.IsSt x s → r = s := by sorry

The theorem `Hyperreal.IsSt.unique` states that for any hyperreal number `x` and any two real numbers `r` and `s`, if `r` and `s` both satisfy the condition of being the standard part (the real part) of `x`, then `r` and `s` must be equal. In other words, the standard part of a hyperreal number is unique.

The standard part of a hyperreal number is unique. That is, for all hyperreal numbers x and real numbers r and s, if r and s are the standard parts of x, then r = s.


CategoryTheory.IsReflexivePair.mk'

theorem CategoryTheory.IsReflexivePair.mk' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B} (s : B ⟶ A),
      CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B →
        CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B →
          CategoryTheory.IsReflexivePair f g :=
  by sorry

This theorem states that for any Category 'C', and any objects 'A' and 'B' in 'C', if there exist morphisms 'f' and 'g' from 'A' to 'B' and a morphism 's' from 'B' to 'A', such that the composition of 's' and 'f' equals the identity of 'B', and the composition of 's' and 'g' also equals the identity of 'B', then 'f' and 'g' form a reflexive pair in category theory. Here, the reflexivity refers to the existence of a morphism from 'B' to 'A' that, when composed with 'f' or 'g', yields the identity on 'B'.

In any category 'C', if there exist morphisms 'f' and 'g' from object 'A' to 'B' and morphism 's' from 'B' to 'A' such that the compositions 's * f' and 's * g' equal the identity of 'B', then 'f' and 'g' form a reflexive pair.


theorem Fintype.piFinset_image₂ :
    ∀ {ι : Type u_14} {α : ι → Type u_15} {β : ι → Type u_16} {γ : ι → Type u_17} [inst : DecidableEq ι]
      [inst_1 : Fintype ι] [inst_2 : (i : ι) → DecidableEq (γ i)] (f : (i : ι) → α i → β i → γ i)
      (s : (i : ι) → Finset (α i)) (t : (i : ι) → Finset (β i)),
      (Fintype.piFinset fun i => Finset.image₂ (f i) (s i) (t i)) =
        Finset.image₂ (fun a b i => f i (a i) (b i)) (Fintype.piFinset s) (Fintype.piFinset t) :=
  by sorry

This theorem states that for any types `ι`, `α`, `β`, and `γ` (all indexed by `ι`), given decidable equality on `ι` and on each `γ i`, and the finiteness of `ι`, a function `f` that maps elements of `α i` and `β i` to `γ i`, and two finsets `s` and `t` (indexed by `ι`) of `α i` and `β i` respectively, the image of the binary function `f i` over the cartesian product of `s i` and `t i` for all `i` in `ι` (obtained via `Fintype.piFinset`) is the same as the image of a function that takes a pair of functions `a` and `b` (which are `i` indexed elements of `α i` and `β i` respectively) and an index `i` and applies `f i` to `a i` and `b i`, over the cartesian product of `Fintype.piFinset s` and `Fintype.piFinset t`. In simpler terms, it establishes the equality of two ways of applying a binary function over pairs of elements from finsets, either individually for each index or collectively for all indices.

For any types `ι`, `α`, `β`, and `γ`, given decidable equality on `ι` and each `γ ι`, the image of a binary function `f` on the cartesian product of two finsets `s` and `t` (indexed by `ι`) of `α ι` and `β ι`, respectively, is equal to the image of a function that applies `f ι` to pairs of elements from `α ι` and `β ι` over the cartesian product of `s` and `t`.


theorem Polynomial.splits_X_sub_C :
    ∀ {K : Type v} {L : Type w} [inst : CommRing K] [inst_1 : Field L] (i : K →+* L) {x : K},
      Polynomial.Splits i (Polynomial.X - Polynomial.C x) :=
  by sorry

The theorem `Polynomial.splits_X_sub_C` states that for any commutative ring `K`, any field `L`, and any ring homomorphism `i` from `K` to `L`, the polynomial `X - C x` (where `X` represents the polynomial variable and `C x` is the constant polynomial `x`) splits over field `L`. In other words, the polynomial `X - C x` is either zero or all of its irreducible factors have degree 1 in the field `L`.

For any commutative ring K, field L, and ring homomorphism i from K to L, the polynomial X - i(C) in L[X] splits completely into linear factors.


theorem ENNReal.ofReal_lt_ofReal_iff : ∀ {p q : ℝ}, 0 < q → (ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q) := by sorry

This theorem states that for any two real numbers `p` and `q`, given that `q` is greater than zero, the function `ENNReal.ofReal` applied to `p` is less than the function applied to `q` if and only if `p` is less than `q`. In other words, the comparison of the two real numbers remains the same after going through the `ENNReal.ofReal` operation as long as `q` is positive.

For all real numbers `p` and `q` with `q > 0`, `ENNReal.ofReal p < ENNReal.ofReal q` if and only if `p < q`.


theorem Set.biUnion_insert :
    ∀ {α : Type u_1} {β : Type u_2} (a : α) (s : Set α) (t : α → Set β), ⋃ x ∈ insert a s, t x = t a ∪ ⋃ x ∈ s, t x :=
  by sorry

The theorem `Set.biUnion_insert` states that for all types `α` and `β`, for any element `a` of type `α`, set `s` which is a collection of elements of type `α`, and a function `t` that maps elements of type `α` to sets of type `β`, the big union of `t x` where `x` belongs to the insertion of `a` into `s`, is equal to the union of `t a` and the big union of `t x` where `x` belongs to `s`. In other words, for any specific element and a set, the big union over the set including that specific element is the same as the union of the specific element and the big union over the rest of the set.

For any type `α`, set `s` of `α`, element `a` of `α`, and function `t` mapping `α` to sets of `β`, we have `(⋃ x in s.insert a) t x = t a ∪ (⋃ x in s) t x`.


HasLineDerivAt.lineDifferentiableAt

theorem HasLineDerivAt.lineDifferentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
      {x v : E}, HasLineDerivAt 𝕜 f f' x v → LineDifferentiableAt 𝕜 f x v :=
  by sorry

This theorem states that for any nontrivially normed field 𝕜, normed additive commutative group F, and additive commutative group E which is a 𝕜 module, a function `f` from E to F is "line differentiable" at a point `x` in the direction `v` if there exists a derivative `f'` such that the function `f` has a line derivative at `x` in the direction `v`. Here, "line differentiable" refers to the existence of a derivative `f'` such that the function `f (x + t v) = f x + t • f' + o (t)` as `t` tends to `0`.

For any nontrivially normed field 𝕜, normed additive commutative group F, and additive commutative group E which is a 𝕜 module, a function `f` from E to F is line differentiable at a point `x` in the direction `v` if there exists a derivative `f'` such that `f (x + tv) = f x + t•f' + o(t)` as `t` approaches 0.


theorem eventually_le_of_tendsto_lt :
    ∀ {α : Type u} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α]
      {l : Filter γ} {f : γ → α} {u v : α}, v < u → Filter.Tendsto f l (nhds v) → ∀ᶠ (a : γ) in l, f a ≤ u :=
  by sorry

This theorem, `eventually_le_of_tendsto_lt`, states that for any types `α` and `γ`, given a topological space and a linear order on `α`, a filter `l` on `γ`, a function `f` from `γ` to `α`, and two elements `u` and `v` of `α` such that `v` is less than `u`, if `f` tends to the neighborhood filter at `v` as the filter `l` varies, then for almost all `a` in `l`, the value `f(a)` is less than or equal to `u`. In mathematical terms, it says that if $f$ converges to $v$ under the filter $l$, and $v < u$, then $f(a) \leq u$ for almost all $a$ in the filter $l$.

If a function $f: \gamma \to \alpha$ converges to $v$ in $\alpha$ with respect to a filter $l$ on $\gamma$, and $v < u$ in $\alpha$, then $f(a) \leq u$ for almost all $a$ in $l$.


padicValNat.zero

/-- `padicValNat p 0` is `0` for any `p`.  -/
theorem padicValNat.zero : ∀ {p : ℕ}, padicValNat p 0 = 0 := by sorry

The theorem `padicValNat.zero` states that for any natural number `p`, the `p`-adic valuation of `0` is `0`. This is consistent with the definition of `p`-adic valuation, which specifies that the `p`-adic valuation of `0` defaults to `0` regardless of the value of `p`.

The `p`-adic valuation of the natural number 0 is 0.


theorem Mathlib.Combinatorics.SetFamily.Compression.Down._auxLemma.1 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
      (s ∈ Finset.nonMemberSubfamily a 𝒜) = (s ∈ 𝒜 ∧ a ∉ s) :=
  by sorry

This theorem states that for any type `α` with decidable equality, any finite set `𝒜` of finite sets of `α`, and any finite set `s` of `α` and element `a` of `α`, the set `s` is in the subfamily of `𝒜` that does not contain `a` (i.e., `Finset.nonMemberSubfamily a 𝒜`) if and only if `s` is in `𝒜` and `a` is not in `s`. In mathematical terms, this theorem is asserting that membership in the subfamily of sets not containing a particular element is equivalent to membership in the original set family and non-membership of the specified element.

For any decidably equated type `α` and finite sets `𝒜` of finite sets of `α`, and `s ∈ 𝒜` and `a ∈ α`, `Finset.nonMemberSubfamily a 𝒜` holds if and only if `s ∈ 𝒜` and `a ∉ s`.


theorem isOpen_induced_iff :
    ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {s : Set α} {f : α → β},
      IsOpen s ↔ ∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = s :=
  by sorry

The theorem `isOpen_induced_iff` states that for any types `α` and `β`, a topological space `t` on `β`, a set `s` of type `α`, and a function `f` from `α` to `β`, the set `s` is open if and only if there exists a set `t_1` such that `t_1` is open and the preimage of `t_1` under the function `f` is equal to `s`. This characterizes an open set in the induced topology, where the open sets are the preimages of open sets in the original space.

A set in the induced topology is open if and only if it is the preimage of some open set under a continuous function.


theorem WithTop.zero_lt_top : ∀ {α : Type u} [inst : OrderedAddCommMonoid α], 0 < ⊤ := by sorry

This theorem, `WithTop.zero_lt_top`, states that for any ordered additive commutative monoid `α`, zero is less than infinity. An ordered additive commutative monoid is a mathematical structure that combines the properties of an ordered set (i.e., it has a notion of "less than"), a commutative monoid (it has an operation that is associative and commutative, and also has an identity element), and the operation also respects the order. The symbol `⊤` represents infinity in this context.

In any ordered additive commutative monoid, zero is less than the infinite element.


theorem CategoryTheory.IsIso.of_isIso_comp_right :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.IsIso g] [inst_2 : CategoryTheory.IsIso (CategoryTheory.CategoryStruct.comp f g)],
      CategoryTheory.IsIso f :=
  by sorry

The theorem `CategoryTheory.IsIso.of_isIso_comp_right` states that for any category `C`, and any three objects `X`, `Y`, and `Z` in `C`, if there exists a morphism `f` from `X` to `Y` and a morphism `g` from `Y` to `Z`, such that `g` is an isomorphism and the composition of `f` and `g` is also an isomorphism, then `f` itself must be an isomorphism. In other words, if `g` and `f ≫ g` are isomorphisms, then `f` is an isomorphism as well.

If `f: X ⟶ Y` and `g: Y ⟶ Z` are morphisms in a category `C` with `g` an isomorphism and `f ∘ g` also an isomorphism, then `f` is an isomorphism.


MeasurableSet.disjointed

theorem MeasurableSet.disjointed :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {f : ℕ → Set α},
      (∀ (i : ℕ), MeasurableSet (f i)) → ∀ (n : ℕ), MeasurableSet (disjointed f n) :=
  by sorry

This theorem states that for any type `α` and any measure space `m` on `α`, if we have a sequence `f` of sets of `α` (which can be interpreted as a sequence of measurable events) such that every set in this sequence is a measurable set, then the `n`-th set in the sequence derived from `f` by the `disjointed` function is also a measurable set. In other words, if you take a sequence of measurable sets and subtract each set from the ones following it, resulting in a new sequence of sets where each set is disjoint from the previous ones, each set in this new sequence is also measurable.

Given a type `α` and a measure space `m` on `α`, if `f` is a sequence of measurable sets, then the sequence `disjointed f` of pairwise disjoint sets obtained from `f` is also a sequence of measurable sets.


theorem inv_lt_zero : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, a⁻¹ < 0 ↔ a < 0 := by sorry

The theorem `inv_lt_zero` states that for any type `α` which is a LinearOrderedSemifield, a type of field with a linear order, a element `a` from `α` has its inverse less than zero if and only if `a` itself is less than zero. In terms of mathematics, this theorem says: given a linear ordered semifield, the inverse of a number is less than zero if and only if the number itself is less than zero.

For any linear ordered semifield type `α`, if `a` is an element of `α` with `a < 0`, then `0 < -a`. Conversely, if `-a < 0`, then `a < 0`.


SimpleGraph.Coloring.colorable

theorem SimpleGraph.Coloring.colorable :
    ∀ {V : Type u} {G : SimpleGraph V} {α : Type u_1} [inst : Fintype α],
      SimpleGraph.Coloring G α → SimpleGraph.Colorable G (Fintype.card α) :=
  by sorry

The theorem `SimpleGraph.Coloring.colorable` states that for any given type `V`, a simple graph `G` of type `V`, and another type `α`, if `α` is a finite type, then if there exists a coloring of graph `G` with elements of `α`, it implies that the graph `G` is colorable with at most as many colors as there are elements in `α`. In terms of graph theory, it says that if you can properly color a graph using certain colors from a finite set, then the graph is considered colorable with a maximum color count equal to the size of that set.

If a simple graph of finite type `V` admits a coloring using at most `α.size` colors, then it is colorable.


theorem Cardinal.lift_continuum : Cardinal.lift.{v, u_1} Cardinal.continuum = Cardinal.continuum := by sorry

This theorem, `Cardinal.lift_continuum`, asserts that the cardinality of the continuum (often denoted as $2^{\aleph_0}$ in set theory, and represented in Lean 4 as `Cardinal.continuum`) does not change when lifted from the universe `v` to the universe `u_1` using the universe lift operation (`Cardinal.lift`). In other words, the cardinality of the real numbers remains the same even when viewed in a larger universe of sets.

The cardinality of the continuum is invariant under universe lifting, i.e., `Cardinal.continuum = Cardinal.lift Cardinal.continuum`.


theorem Continuous.image_connectedComponent_subset :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
      Continuous f → ∀ (a : α), f '' connectedComponent a ⊆ connectedComponent (f a) :=
  by sorry

This theorem states that for any continuous function `f` from one topological space `α` to another topological space `β`, the image under `f` of the connected component of any point `a` in `α` is a subset of the connected component of the image of the point `f(a)` in `β`. In other words, continuous functions map connected components to subsets of connected components.

For any continuous function between topological spaces and any point in the domain, the image of the connected component of that point is contained in the connected component of the image under the function.


theorem Ordinal.le_div : ∀ {a b c : Ordinal.{u_4}}, c ≠ 0 → (a ≤ b / c ↔ c * a ≤ b) := by sorry

This theorem, `Ordinal.le_div`, states that for any three ordinals `a`, `b`, and `c` in a certain type, if `c` is not zero, then `a` is less than or equal to the quotient of `b` by `c` if and only if `c` multiplied by `a` is less than or equal to `b`. In other words, it establishes an equivalence between the "divided" comparison (`a ≤ b / c`) and the "multiplied" comparison (`c * a ≤ b`) within the context of ordinal numbers, provided that the divisor `c` is non-zero.

For ordinal numbers `a`, `b`, and `c` (with `c` non-zero), `a ≤ b / c` if and only if `c * a ≤ b`.


theorem lt_of_mul_lt_mul_left' :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LT α]
      [inst_2 : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b c : α},
      a * b < a * c → b < c :=
  by sorry

This theorem, `lt_of_mul_lt_mul_left'`, asserts that for any type `α` equipped with a multiplication operation, a less-than relation, and a contravariant property between the multiplication and the less-than relation, if the product of `a` and `b` is less than the product of `a` and `c`, then `b` must be less than `c`. In other words, it allows us to infer inequality between two elements `b` and `c` from the inequality of their products with a common factor `a`, under certain algebraic assumptions. This theorem is a generalization of the familiar property from elementary algebra that if `a` is positive and `a * b < a * c`, then `b < c`.

Given a type `α` with multiplication `*`, less-than relation `<`, and a contravariant property between multiplication and less-than, if `a * b < a * c`, then `b < c`.


theorem Homeomorph.symm_comp_self :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      ⇑(Homeomorph.symm h) ∘ ⇑h = id :=
  by sorry

This theorem states that for every homeomorphism `h` from a topological space `X` to another topological space `Y`, the composition of `h` and its inverse (denoted by `Homeomorph.symm h`) is the identity function. In other words, applying the homeomorphism `h` and then its inverse always brings us back to where we started, as it should for a well-defined inverse. This is a fundamental property of homeomorphisms, reflecting their role as isomorphisms in the category of topological spaces.

For every homeomorphism `h` between topological spaces `X` and `Y`, `h` and its inverse `Homeomorph.symm h` are mutually inverse functions, i.e., `h ∘ Homeomorph.symm h = idX` and `Homeomorph.symm h ∘ h = idY`, where `idX` and `idY` are the identity functions on `X` and `Y`, respectively.


InfClosed.image

theorem InfClosed.image :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {s : Set α}
      [inst_2 : FunLike F α β] [inst_3 : InfHomClass F α β], InfClosed s → ∀ (f : F), InfClosed (⇑f '' s) :=
  by sorry

This theorem states that if a set `s` of elements in a semilattice `α` is inf-closed (that is, the infimum of any two elements in `s` is also in `s`) and there is a function `f` of type `F` that behaves like a homomorphism preserving infimum operations (an `InfHomClass`) from `α` to another semilattice `β`, then the image of `s` under `f` is also inf-closed in `β`. In simple terms, applying an infimum-preserving function to an inf-closed set results in an inf-closed set.

If `s` is an inf-closed set in a semilattice `α` and `f` is a function from `α` to another semilattice `β` that preserves infima, then the image of `s` under `f` is an inf-closed set in `β`.


theorem CategoryTheory.Sieve.functor_galoisConnection :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C),
      GaloisConnection (CategoryTheory.Sieve.functorPushforward F) (CategoryTheory.Sieve.functorPullback F) :=
  by sorry

This theorem states that for any two categories `C` and `D` and a functor `F` from `C` to `D`, the functions `functorPushforward` and `functorPullback` form a Galois connection. This Galois connection is a relationship between two order-preserving functions such that for all sieves `R` in `C` and `S` in `D`, the sieve `R` is a subset of the pullback of `S` if and only if the pushforward of `R` is a subset of `S`. In mathematical terms, this means that for all sieves `R` and `S`, `R ≤ F^*(S)` if and only if `F_*(R) ≤ S`, where `F^*` is the pullback functor and `F_*` is the pushforward functor.

For any functor F from category C to category D, the pullback and pushforward functions of F form a Galois connection, i.e., for all sieves R in C and S in D, R ≤ F^*(S) if and only if F_(R) ≤ S.


theorem Real.hasDerivAt_tan : ∀ {x : ℝ}, Real.cos x ≠ 0 → HasDerivAt Real.tan (1 / Real.cos x ^ 2) x := by sorry

The theorem `Real.hasDerivAt_tan` states that for every real number `x`, if the cosine of `x` is not equal to 0, then the tangent function has a derivative at `x`, and the value of the derivative is `1 / (cos(x))^2`. In mathematical terms, this is demonstrating that wherever the cosine function doesn't equal zero, the derivative of the tangent function is equal to the secant squared function.

For every real number `x` with `cos(x) ≠ 0`, the derivative of the tangent function at `x` is equal to `1 / (cos(x))^2`.


theorem Computation.exists_of_mem_bind :
    ∀ {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {b : β},
      b ∈ Computation.bind s f → ∃ a ∈ s, b ∈ f a :=
  by sorry

This theorem, `Computation.exists_of_mem_bind`, states that for any types `α` and `β`, a computation `s` of type `α`, a function `f` from `α` to a computation of type `β`, and an element `b` of type `β`, if `b` is an element of the computation that results from binding `s` with `f` (using the `Computation.bind` operation), then there exists an element `a` in the computation `s` such that `b` is an element of the computation `f(a)`. In other words, if `b` is produced by the combined computation, it must have been produced by applying `f` to some element of the original computation `s`.

If `b` is an element of the computation `Computation.bind (s) f`, then there exists an element `a` in `s` such that `b` is an element of `f(a)`.


theorem Set.EqOn.image_eq :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β}, Set.EqOn f₁ f₂ s → f₁ '' s = f₂ '' s := by sorry

The theorem `Set.EqOn.image_eq` states that for any set `s` of elements from a type `α`, and any two functions `f₁` and `f₂` from `α` to another type `β`, if `f₁` and `f₂` are equal on `s` (meaning `f₁ x = f₂ x` for all `x` in `s`), then the images of `s` under `f₁` and `f₂` are equal. In other words, applying either `f₁` or `f₂` to every element of `s` produces the same set of results.

If two functions from a set to another type are equal on that set, then their images are equal.


theorem List.toFinset_cons :
    ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, List.toFinset (a :: l) = insert a (List.toFinset l) :=
  by sorry

This theorem states that for any type `α` with decidable equality (denoted by `DecidableEq α`), for any list `l` of elements of type `α`, and for any element `a` of the same type, converting a list that starts with element `a` and is followed by list `l` into a finite set (using the `List.toFinset` function) is the same as inserting element `a` into the finite set version of list `l`. In other words, if you have a list starting with an element and then convert it to a set, it's the same as first converting the list to a set and then adding the element to the set.

For any type `α` with decidable equality, the function `List.toFinset` that maps a list `a :: l : list α` to the set `{x : α | x ∈ l} ∪ {a}` is equal to the function that first maps `l` to the set `{x : α | x ∈ l}`, and then maps the resulting set to the set `{x : α | x ∈ l ∪ {a}}`.


theorem constantCoeff_wittStructureInt :
    ∀ (p : ℕ) {idx : Type u_2} [hp : Fact (Nat.Prime p)] (Φ : MvPolynomial idx ℤ),
      MvPolynomial.constantCoeff Φ = 0 → ∀ (n : ℕ), MvPolynomial.constantCoeff (wittStructureInt p Φ n) = 0 :=
  by sorry

The `constantCoeff_wittStructureInt` theorem states that for any prime number `p` and any multivariate polynomial `Φ` with integer coefficients indexed by `idx`, if the constant coefficient of `Φ` is zero, then the constant coefficient of the `n`-th Witt structure of `Φ` is also zero, for all natural numbers `n`. Here, the Witt structure is a transformation that modifies the polynomial in a way depending upon the prime `p`.

For any prime number p and multivariate polynomial Φ with integer coefficients, if the constant coefficient of Φ is zero then the constant coefficient of its n-th Witt structure modulo p is also zero for all natural numbers n.


theorem Function.support_comp_eq_preimage :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (g : β → M) (f : α → β),
      Function.support (g ∘ f) = f ⁻¹' Function.support g :=
  by sorry

The theorem `Function.support_comp_eq_preimage` states that for any types `α`, `β`, and `M` with `M` having a zero element, and for any functions `g : β → M` and `f : α → β`, the support of the composition function `(g ∘ f)` is equal to the preimage of the support of `g` under `f`. In other words, the set of `α` points at which `(g ∘ f)` is non-zero is exactly the set of `α` points whose `f` image is a point where `g` is non-zero.

The support of the composition of functions `g ∘ f` from `α` to `M` equals the preimage of the support of `g` under `f`.


/-- The rank of a free module `M` over `R` is the cardinality of `ChooseBasisIndex R M`.  -/
theorem Module.Free.rank_eq_card_chooseBasisIndex :
    ∀ (R : Type u) (M : Type v) [inst : Ring R] [inst_1 : StrongRankCondition R] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : Module.Free R M],
      Module.rank R M = Cardinal.mk (Module.Free.ChooseBasisIndex R M) :=
  by sorry

The theorem `Module.Free.rank_eq_card_chooseBasisIndex` states that for any ring `R` and any free module `M` over `R`, given that `R` satisfies the strong rank condition and `M` is an additive commutative group and a module over `R`, the rank of the module `M` is equal to the cardinality of the set `ChooseBasisIndex R M`. In other words, the rank of a free module is the cardinality of the type that indexes its basis.

For any free module M over a ring R satisfying the strong rank condition, the rank of M equals the cardinality of a basis for M.


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

The theorem `Finset.sup_induction` is a principle of mathematical induction for the supremum of a finite set in the context of semilattice and ordered bottom structure. Given a type `α` with a semilattice supremum structure and an ordered bottom structure, a finite set `s` of type `β`, a function `f` mapping `β` to `α`, and a property `p` holding over `α`, it states that if the property `p` holds for the least element `⊥` of `α`, and if `p` holds for any supremum `a₁ ⊔ a₂` whenever it holds for `a₁` and `a₂`, and finally, if `p` holds for each element of `s` under the function `f`, then `p` must also hold for the supremum of the set `s` under `f`.

Given a semilattice and ordered bottom structure on type `α`, if a property `p(x)` holds for the least element `⊥`, the supremum `a ⊔ b` of any two elements `a` and `b` satisfying `p(a)` and `p(b)`, and each element `x ∈ s` under the function `f`, then `p(∨x in s.f : f(x))` holds, where `∨` denotes the supremum of the set `{f(x) | x ∈ s}`.


ContinuousOn.restrict

/-- **Alias** of the forward direction of `continuousOn_iff_continuous_restrict`. -/
theorem ContinuousOn.restrict :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
      ContinuousOn f s → Continuous (Set.restrict s f) :=
  by sorry

This theorem states that for any two types `α` and `β`, given that `α` and `β` are both topological spaces, if a function `f : α → β` is continuous on a subset `s` of `α` (i.e., it is continuous at every point in `s`), then the function `f` remains continuous when its domain is restricted to the set `s`. In other words, if a function is continuous over a specific set in its domain, then the restriction of that function to that set is also continuous.

If a function between topological spaces is continuous on a subset, then its restriction to that subset is also continuous.


theorem Set.image_smul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {t : Set β} {a : α}, (fun x => a • x) '' t = a • t := by sorry

The theorem `Set.image_smul` states that for any types `α` and `β` with a scalar multiplication operation defined on them (`SMul α β`), any set `t` of type `β`, and any element `a` of type `α`, the image of set `t` under the function that multiplies each element by `a` (expressed as `(fun x => a • x) '' t`) is equal to the scalar multiplication of `a` and the entire set `t` (expressed as `a • t`). Essentially, this theorem formalizes the distribution of scalar multiplication over a set in the context of image of a set under a function.

For any type `α` and `β` with scalar multiplication, and for any set `t` of type `β` and element `a` of type `α`, `(fun x => a • x) '' t = a • t`.


theorem Prod.mk.inj_left : ∀ {α : Type u_5} {β : Type u_6} (a : α), Function.Injective (Prod.mk a) := by sorry

The theorem `Prod.mk.inj_left` states that for any type `α` and `β` and for any given element `a` of type `α`, the function `Prod.mk a` is injective. In other words, if we fix an element `a : α` and consider the function that takes an element `b : β` to the pair `(a, b)`, then different inputs `b` will always produce different pairs `(a, b)`. This function, `Prod.mk a`, is thus injective.

For any type `α` and element `a` of type `α`, the function mapping `β` to the pair `(a, β)` is an injection.


theorem Set.subset_set_smul_iff₀ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ {A B : Set β}, A ⊆ a • B ↔ a⁻¹ • A ⊆ B :=
  by sorry

This theorem, `Set.subset_set_smul_iff₀`, is a statement about the interaction of sets and scalar multiplication in the context of a group with zero. Specifically, given two types `α` and `β` where `α` is a group with zero and `β` supports multiplication action by `α`, and given two sets `A` and `B` of type `β`, the theorem states that for any nonzero element `a` of `α`, the set `A` is a subset of the set resulting from scalar multiplication of `B` by `a` if and only if the set resulting from scalar multiplication of `A` by the inverse of `a` is a subset of `B`. In other words, it provides a condition for the scalar multiplication of a set to be subset of another set. This theorem characterizes the "subset" relation in terms of scalar multiplication in the setting of a group with zero.

For sets `A` and `B` of a group `α` with zero, and a nonzero element `a` in `α`, `A ⊆ {b ∈ β | ∃ x ∈ A, b = ax}` if and only if `{b ∈ β | ∃ x ∈ A, b = x/a} ⊆ B`.


theorem IsAtom.le_iff :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a x : α}, IsAtom a → (x ≤ a ↔ x = ⊥ ∨ x = a) := by
  sorry

The theorem `IsAtom.le_iff` states that for all types `α` equipped with a partial ordering and a least element denoted by `⊥`, and for all elements `a` and `x` in `α`, if `a` is an atom (meaning `a` is not the least element and there are no elements between `a` and `⊥`), then `x` is less than or equal to `a` if, and only if, `x` is either `⊥` or `a`. In other words, in an ordered set with a least element, if `a` is an atom, then any element `x` that's not greater than `a` must be either the least element, `⊥`, or `a` itself.

For all types `α` with a partial ordering and least element `⊥`, if `a` is an atom in `α`, then `x ≤ a` if and only if `x = ⊥` or `x = a`.


theorem List.perm_replicate :
    ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, List.Perm l (List.replicate n a) ↔ l = List.replicate n a := by sorry

The theorem `List.perm_replicate` states that for any type `α`, natural number `n`, element `a` of type `α`, and list `l` of type `α`, the list `l` is a permutation of `n` copies of `a` (i.e., the list created by `List.replicate n a`) if and only if `l` is equal to the list of `n` copies of `a`. This means that the only way that `l` can be a permutation of `n` copies of `a` is when `l` itself is `n` copies of `a`.

For any type `α`, natural number `n`, element `a` of type `α`, and list `l` of type `List α`, `l` is a permutation of `n` copies of `a` if and only if `l` equals `List.replicate n a`.


theorem Ordinal.one_add_omega : 1 + Ordinal.omega = Ordinal.omega := by sorry

The theorem `Ordinal.one_add_omega` states that if we add 1 to the first infinite ordinal, which we denote as `Ordinal.omega` and is defined as the order type of the natural numbers ℕ, the result is still `Ordinal.omega`. This captures the essence of infinity in ordinal arithmetic: adding a finite number (in this case 1) to an infinite ordinal does not change the infinite ordinal.

The first infinite ordinal `Ordinal.omega` equals the sum of itself and one, `Ordinal.omega + 1`.


theorem Decidable.eq_or_lt_of_le :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : DecidableRel fun x x_1 => x ≤ x_1] {a b : α},
      a ≤ b → a = b ∨ a < b :=
  by sorry

This theorem, `Decidable.eq_or_lt_of_le`, asserts that for any type `α` that has a partial order and a decidable relation for the "less than or equal to" (`≤`) operation, given two elements `a` and `b` of the type `α`, if `a` is less than or equal to `b`, then either `a` is equal to `b` or `a` is strictly less than `b`. The theorem essentially states the trichotomy property for ordered types with a decidability predicate, specifically for the case when one element is less than or equal to another.

For any type `α` with a decidable partial order `≤`, if `a ≤ b` then `a = b` or `a < b`.


theorem Set.image2_comm :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {g : β → α → γ},
      (∀ (a : α) (b : β), f a b = g b a) → Set.image2 f s t = Set.image2 g t s :=
  by sorry

The `Set.image2_comm` theorem states that for any types `α`, `β`, and `γ`, any binary function `f` from `α` and `β` to `γ`, any set `s` of type `α`, any set `t` of type `β`, and any binary function `g` from `β` and `α` to `γ`, if for all `a` in `α` and `b` in `β` the result of `f` applied to `a` and `b` is equal to the result of `g` applied to `b` and `a`, then the image of `s` and `t` under `f` is equal to the image of `t` and `s` under `g`. In other words, if `f` and `g` are commutative with respect to their arguments, then the image of the sets under these functions are equal when the input sets are swapped.

If functions `f : α × β → γ` and `g : β × α → γ` satisfy `f a b = g b a` for all `a : α` and `b : β`, then `Set.image2 f s t = Set.image2 g t s`.


theorem MeasureTheory.Measure.mutuallySingular_singularPart :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α),
      MeasureTheory.Measure.MutuallySingular (μ.singularPart ν) ν :=
  by sorry

This theorem states that for any measurable space `α` and any two measures `μ` and `ν` on this space, the singular part of `μ` with respect to `ν` is mutually singular with `ν`. In other words, there exists a measurable set `s` such that the singular part of `μ` with respect to `ν` gives zero measure to the set `s`, and `ν` gives zero measure to the complement of `s`.

For any measurable spaces `α` and measurable sets `A` on `α`, the singular part of measures `μ` and `ν` on `α` are mutually singular, i.e., there exists a measurable set `s` such that both `μ(s) = 0` and `ν(α \ s) = 0`.


theorem AffineSubspace.map_direction :
    ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂) (s : AffineSubspace k P₁),
      AffineSubspace.direction (AffineSubspace.map f s) = Submodule.map f.linear (AffineSubspace.direction s) :=
  by sorry

The theorem `AffineSubspace.map_direction` states that for any ring `k`, additively commutative group `V₁` and `V₂`, module `V₁` and `V₂` over `k`, affine torsors `P₁` over `V₁` and `P₂` over `V₂`, and an affine map `f` from `P₁` to `P₂`, when an affine subspace `s` of `P₁` is mapped to `P₂` using `f`, the direction of the resulting subspace is equal to the image of the direction of the original subspace `s` under the linear part of the affine map `f`. In other words, if you take an affine subspace, map it via an affine map, the direction of the new subspace is just the direction of the original subspace transformed by the linear part of the affine map.

Given an affine map between affine torsors, the image of an affine subspace under the map has direction equal to the linear part of the map times the direction of the original subspace.


theorem Vector.get_ofFn : ∀ {α : Type u_1} {n : ℕ} (f : Fin n → α) (i : Fin n), Vector.get (Vector.ofFn f) i = f i := by
  sorry

The theorem `Vector.get_ofFn` states that for every type `α`, natural number `n`, function `f` mapping from `Fin n` to `α`, and `i` of type `Fin n`, when we get the `i`-th element from a vector created by applying `f` to every element of `Fin n` (through the function `Vector.ofFn`), it is equivalent to directly applying `f` to `i`. In other words, when we first construct a vector by applying a function to each element in a finite set, and then retrieve an element from the vector, it's the same as if we applied the function directly to the element.

For every type `α`, natural number `n`, function `f` from `Fin n` to `α`, and `i` in `Fin n`, `Vector.get i (Vector.ofFn n f) = f i`.


theorem Mathlib.Order.Hom.Basic._auxLemma.1 :
    ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} [inst : LE α] [inst_1 : LE β] [inst_2 : EquivLike F α β]
      [self : OrderIsoClass F α β] (f : F) {a b : α}, (f a ≤ f b) = (a ≤ b) :=
  by sorry

This theorem, named `_auxLemma.1` from `Mathlib.Order.Hom.Basic`, states that for any types `F`, `α`, and `β`, with `α` and `β` being types with less-than-or-equal-to (`≤`) relations, and `F` being a type that behaves like an equivalence between `α` and `β`, the following holds: If `F` also represents an order-isomorphism class (denoted by `OrderIsoClass F α β`), then for any function `f` of type `F` and any two elements `a` and `b` of type `α`, the statement "`f a` is less than or equal to `f b`" is equivalent to the statement "`a` is less than or equal to `b`". In other words, the order-isomorphism preserves the order of elements.

For any type `F` behaving like an equivalence between types `α` and `β` with less-than-or-equal-to relations, if `F` is an order isomorphism, then `x ≤ y` in `α` if and only if `F x ≤ F y` in `β`.


theorem MeasureTheory.Measure.measurable_map :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (f : α → β),
      Measurable f → Measurable fun μ => MeasureTheory.Measure.map f μ :=
  by sorry

The theorem `MeasureTheory.Measure.measurable_map` states that for any two types `α` and `β` that each have a measurable space structure, and for any function `f` from `α` to `β`, if `f` is a measurable function then the function which maps each measure on `α` to its pushforward measure on `β` via `f` is also measurable. This means that for every measurable set in the target space of measures, the preimage of this set under the measure pushforward function is also measurable.

If `f: α → β` is a measurable function between measurable spaces `(α, Σα)` and `(β, Σβ)`, then the function that maps each measure `μ ∈ Σα` to its pushforward `f_#(μ) ∈ Σβ` is also a measurable function from `(Σα, ℬ(Σα))` to `(Σβ, ℬ(Σβ))`.


theorem ENNReal.hasSum_coe : ∀ {α : Type u_1} {f : α → NNReal} {r : NNReal}, HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r :=
  by sorry

This theorem states that for any type `α`, any function `f` that maps from `α` to nonnegative real numbers (`NNReal`), and any nonnegative real number `r`, the property of `f` having a sum equal to `r` (denoted by `HasSum f r`) is equivalent to the property that the function obtained by applying the embedding from `NNReal` to `Real` to `f` has a sum equal to the embedding of `r` (denoted by `HasSum (fun a => ↑(f a)) ↑r`). In other words, summing the function values in the real number domain is the same as summing the function values in the nonnegative real number domain and then embedding the sum into the real number domain.

For any function `f: α → NNReal` and real number `r`, the property `HasSum f r` is equivalent to `HasSum (fun a => ↑(f a)) ↑r`.


theorem Set.diff_subset_diff : ∀ {α : Type u} {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ s₂ → t₂ ⊆ t₁ → s₁ \ t₁ ⊆ s₂ \ t₂ := by sorry

This theorem states that for any type `α` and for any four sets `s₁`, `s₂`, `t₁`, `t₂` of this type, if `s₁` is a subset of `s₂` and `t₂` is a subset of `t₁`, then the difference of `s₁` and `t₁` is a subset of the difference of `s₂` and `t₂`. Here, the difference of two sets `A` and `B`, denoted `A \ B`, comprises all elements that are in `A` but not in `B`.

For any type `α` and sets `s₁`, `s₂`, `t₁`, `t₂` of type `α`, if `s₁ ⊆ s₂` and `t₂ ⊆ t₁`, then `(s₁ \ t₁) ⊆ (s₂ \ t₂)`.


theorem dist_mul_right :
    ∀ {M : Type u} [inst : Mul M] [inst_1 : PseudoMetricSpace M] [inst_2 : IsometricSMul Mᵐᵒᵖ M] (a b c : M),
      dist (a * c) (b * c) = dist a b :=
  by sorry

This theorem states that for any type `M` that supports multiplication (`Mul`), is a pseudo metric space (`PseudoMetricSpace`), and has an isometric scalar multiplication (`IsometricSMul`) with its opposite (`Mᵐᵒᵖ`), the distance (`dist`) between the product of `a` and `c` and the product of `b` and `c` is equal to the distance between `a` and `b`. This essentially means that multiplication by a constant `c` doesn't affect the distance between two elements `a` and `b` in this space.

For any type `M` with multiplication, being a pseudo metric space with isometric scalar multiplication by its opposite, the distance between the product of `a` and `c` and the product of `b` and `c` equals the distance between `a` and `b`.


/-- Symmetric statement to `Set.image_image2_right_comm`.  -/
theorem Set.image_image2_distrib_right :
    ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {f : α → β → γ} {s : Set α}
      {t : Set β} {g : γ → δ} {f' : α → β' → δ} {g' : β → β'},
      (∀ (a : α) (b : β), g (f a b) = f' a (g' b)) → g '' Set.image2 f s t = Set.image2 f' s (g' '' t) :=
  by sorry

The theorem `Set.image_image2_distrib_right` states that for all types `α`, `β`, `β'`, `γ`, and `δ`, and for all functions `f : α → β → γ`, `g : γ → δ`, `f' : α → β' → δ`, `g' : β → β'`, and sets `s : Set α` and `t : Set β`, if for every `a` in `α` and `b` in `β` the equation `g (f a b) = f' a (g' b)` holds, then the image of the function `g` on the image of the binary function `f` on the sets `s` and `t` is equal to the image of the binary function `f'` on the set `s` and the image of the function `g'` on the set `t`. In other words, this theorem is a statement about the distributivity of the image of a function over the image of a binary function.

For functions `f : α → β → γ`, `g : γ → δ`, `f' : α → β' → δ`, and `g' : β → β'`, sets `s : Set α` and `t : Set β`, if `g (f a b) = f' a (g' b)` for all `a ∈ α` and `b ∈ β`, then `image g (image f s t) = image (f' o g') (s × t)`.


/-- **Alias** of `mul_div_cancel_right`. -/
theorem mul_div_cancel'' : ∀ {G : Type u_3} [inst : Group G] (a b : G), a * b / b = a := by sorry

This theorem, referred to as an alias of `mul_div_cancel_right`, deals with the concepts of multiplication and division in the area of group theory. In the context of any group `G`, for any elements `a` and `b` of `G`, the theorem states that if you multiply `a` and `b` together and then divide the result by `b`, you get back `a`. This reflects the property of groups where division undoes multiplication.

In any group, for all elements a and b, a * b / b = a.


theorem Set.image_swap_eq_preimage_swap :
    ∀ {α : Type u_1} {β : Type u_2}, Set.image Prod.swap = Set.preimage Prod.swap := by sorry

This theorem states that for any two types `α` and `β`, the image of a set under the function `Prod.swap` is equal to the preimage under the same function `Prod.swap`. In other words, swapping the elements of ordered pairs in a set is equivalent to looking at the set of elements that, when swapped, would fall in the original set. This establishes a relationship between the `Set.image` and `Set.preimage` functions when the `Prod.swap` function is applied.

For any set `S` in the product type `α × β`, the sets `Set.image (Prod.swap) S` and `Set.preimage (Prod.swap) S` are equal.


theorem Cardinal.lt_aleph0_iff_finite : ∀ {α : Type u}, Cardinal.mk α < Cardinal.aleph0 ↔ Finite α := by sorry

This theorem states that for any type `α`, the cardinality of `α` is less than `aleph0` (the smallest infinite cardinal number, often used to represent the cardinality of the set of natural numbers) if and only if `α` is a finite set. In other words, it establishes a correspondence between the finiteness of a set in terms of set theory, and its cardinality being less than the first infinite cardinal number, `aleph0`.

A set `α` is finite if and only if the cardinality of `α` is less than the first infinite cardinal number `aleph0`.


theorem Polynomial.degree_sum_le :
    ∀ {R : Type u} [inst : Semiring R] {ι : Type u_1} (s : Finset ι) (f : ι → Polynomial R),
      Polynomial.degree (Finset.sum s fun i => f i) ≤ Finset.sup s fun b => Polynomial.degree (f b) :=
  by sorry

The theorem `Polynomial.degree_sum_le` states that for any semiring `R`, any finite set `s` of type `ι`, and any function `f` that maps elements of `ι` to polynomials in `R`, the degree of the sum of polynomials (which is obtained by summing the polynomials that result from applying `f` to each element in `s`) is less than or equal to the supremum of the degrees of the polynomials for each element in `s`. In other words, the degree of the sum of these polynomials is not larger than the highest degree of these polynomials.

For any semiring R, finite set ι, and function f from ι to polynomials over R, the degree of the sum of the polynomials in the image of f is less than or equal to the supremum of the degrees of the polynomials in the image of f.


theorem gcd_eq_normalize :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {a b c : α},
      gcd a b ∣ c → c ∣ gcd a b → gcd a b = normalize c :=
  by sorry

The theorem `gcd_eq_normalize` asserts that for any type `α` that forms a cancel commutative monoid with zero and is also a normalized gcd monoid, and for any three elements `a`, `b`, and `c` of `α`, if the greatest common divisor (gcd) of `a` and `b` divides `c` and `c` also divides the gcd of `a` and `b`, then the gcd of `a` and `b` is equal to the normalized value of `c`. Here, the normalization of `c` is achieved by multiplying `c` by the unit-normal of `c`, which essentially "chooses" an element from each associate class.

If `α` is a cancel commutative monoid with zero and a normalized gcd monoid, then the gcd of `a` and `b` equals the normalized value of `c`, where `c` is the greatest common divisor of `a` and `b` that divides both `a` and `b`.


theorem norm_eq_sqrt_real_inner :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x : F), ‖x‖ = Real.sqrt ⟪x, x⟫_ℝ :=
  by sorry

This theorem states that for any type `F` that is a normed add commutative group and has a real inner product space structure, the norm of an element `x` of type `F` is equal to the square root of the real inner product of `x` with itself. In mathematical notation, this is saying that for any vector `x` in such a space `F`, the equation `‖x‖ = sqrt(<x, x>)` holds.

For any normed add commutative group `F` with a real inner product space structure, the norm of an element `x` equals the square root of the inner product of `x` with itself: `‖x‖ = sqrt(<x, x>)`.


theorem tendsto_iff_dist_tendsto_zero :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α} {x : Filter β} {a : α},
      Filter.Tendsto f x (nhds a) ↔ Filter.Tendsto (fun b => dist (f b) a) x (nhds 0) :=
  by sorry

The theorem `tendsto_iff_dist_tendsto_zero` states that for any function `f` from a type `β` to a type `α` where `α` has a pseudometric space structure, a filter `x` on `β` and a point `a` in `α`, the function `f` tends to `a` with respect to the filter `x` if and only if the distance between `f` and `a` tends to zero with respect to the same filter `x`. This is essentially saying that the limit of a function at a point in a pseudometric space is equivalent to the distance from the function to the point converging to zero.

A function from a pseudometric space to itself tends to a point if and only if the distance between the function and the point converges to zero with respect to the given filter.


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

The theorem `FirstOrder.Language.Hom.map_fun` states that for any first-order language `L`, types `M` and `N`, and language structures on `M` and `N`, if `φ` is a homomorphism from `M` to `N`, then for any `n`-ary function `f` in `L` and any map `x` from a `n`-dimensional finite set to `M`, applying `φ` to the result of mapping `f` via `x` is equal to first applying `φ` to the result of `x` and then mapping `f`. In other words, the function mapping operation of the language structure is compatible with the homomorphism `φ`.

For any first-order language L, types M and N, language structures on M and N, homomorphism φ from M to N, n-ary function f in L, and map x from a n-dimensional finite set to M, we have φ(f^M(x)) = f^N(φ(x)).


HahnSeries.SummableFamily.ext

theorem HahnSeries.SummableFamily.ext :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R] {α : Type u_3}
      {s t : HahnSeries.SummableFamily Γ R α}, (∀ (a : α), s a = t a) → s = t :=
  by sorry

This theorem states that for any type `Γ` with a partial order, any type `R` with an additive commutative monoid structure, and any additional type `α`, if we have two summable families of Hahn series `s` and `t` indexed by `α`, then `s` and `t` are equal if and only if they are equal at every index `a` in `α`. Essentially, it says that two summable families of Hahn series are equal if they produce the same series for each index in the family.

Given types `Γ` with a partial order, `R` with an additive commutative monoid structure, and `α`, if `s` and `t` are two summable families of Hahn series indexed by `α` over `Γ` and `R`, then `s = t` if and only if `s a = t a` for all `a ∈ α`.


theorem Nat.mem_divisorsAntidiagonal : ∀ {n : ℕ} {x : ℕ × ℕ}, x ∈ Nat.divisorsAntidiagonal n ↔ x.1 * x.2 = n ∧ n ≠ 0 :=
  by sorry

This theorem states that for any natural numbers `n` and `x` (which is a pair of natural numbers), `x` belongs to `n`'s divisor antidiagonal if and only if the product of the elements of the pair `x` equals `n` and `n` is not equal to zero. In other words, a pair of natural numbers is in the set of pairs whose product equals `n` (the so-called divisor antidiagonal of `n`) exactly when this product is indeed `n` and `n` is not zero.

The pair of natural numbers `(x, y)` is in the divisor antidiagonal of `n` if and only if `x * y = n` and `n` is non-zero.


theorem Nat.size_zero : Nat.size 0 = 0 := by sorry

The theorem `Nat.size_zero` asserts that the size of the natural number 0, in terms of its binary representation, is 0. In other words, the binary length of the number 0 is zero, which is intuitively true as 0 does not have any binary digits.

The theorem `Nat.size_zero` asserts that the size of the natural number 0, in Lean's binary representation, is 0.


theorem Submodule.ker_subtype :
    ∀ {R : Type u_1} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), LinearMap.ker (Submodule.subtype p) = ⊥ :=
  by sorry

The theorem `Submodule.ker_subtype` states that for any ring `R`, additive commutative monoid `M`, and any submodule `p` of `M` over `R`, the kernel of the embedding of the submodule `p` into the ambient space `M` is the trivial module (denoted by `⊥`). In other words, no non-zero element of the submodule `p` gets mapped to the zero element under the embedding operation.

The theorem asserts that the kernel of the embedding of a submodule in a commutative additive monoid is the trivial submodule, containing only the additive identity.


theorem bit0_zero : ∀ {M : Type u} [inst : AddMonoid M], bit0 0 = 0 := by sorry

The theorem `bit0_zero` states that for any type `M` that forms an additive monoid, the `bit0` of zero is equal to zero. In other words, if you add zero to itself in the context of the `bit0` function, you will always get zero. In mathematical terms, this can be expressed as `0 + 0 = 0`.

For any additive monoid type M, `bit0 (0 : M) = 0`.


theorem Mathlib.Topology.FiberBundle.Basic._auxLemma.3 : ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True := by sorry

This theorem states that for any type `α` and any element `x` of that type, `x` belongs to the universal set of `α`. In other words, every element of a type is always a member of the universal set of that type. This is consistent with the definition of the universal set, which contains all elements of a given type.

For any type `α` and any of its elements `x`, `x` is an element of the universal set of `α`.


theorem Multiset.Nodup.of_map :
    ∀ {α : Type u_1} {β : Type u_2} {s : Multiset α} (f : α → β),
      Multiset.Nodup (Multiset.map f s) → Multiset.Nodup s :=
  by sorry

The theorem `Multiset.Nodup.of_map` states that for any types `α` and `β`, any multiset `s` of type `α`, and any function `f` mapping from `α` to `β`, if the multiset resulting from mapping the function `f` over `s` has no duplicates (i.e., `Multiset.Nodup (Multiset.map f s)`), then the original multiset `s` must also have no duplicates (i.e., `Multiset.Nodup s`). In simpler terms, if applying a function to each element of a multiset results in a set with no duplicate values, then the original set also had no duplicates.

If `s` is a multiset with no duplicates and `f` is a function such that `Multiset.map f s` has no duplicates, then `α = β` and `s = {x | ∃! y, f x = y}`. (This statement assumes that the function `f` is injective, i.e., distinct inputs map to distinct outputs.)


Dilation.lipschitz

theorem Dilation.lipschitz :
    ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f : F), LipschitzWith (Dilation.ratio f) ⇑f :=
  by sorry

This theorem states that for any types `α`, `β`, and `F`, where `α` and `β` are equipped with a pseudo-emetric space structure, and `F` is a function-like type from `α` to `β` that also has a dilation structure, any function `f` of type `F` is Lipschitz continuous with the dilation ratio of `f` as the Lipschitz constant. In other words, the extended distance between the images of any two points under `f` is less than or equal to the dilation ratio of `f` times the extended distance between the two points themselves.

Given types `α` and `β` with pseudo-metric spaces structures, and a function-like type `F` from `α` to `β` with a dilation structure, any `F`-function `f` is Lipschitz continuous with Lipschitz constant equal to the dilation ratio of `f`.


theorem Filter.map_eq_comap_of_inverse :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {n : β → α},
      m ∘ n = id → n ∘ m = id → Filter.map m f = Filter.comap n f :=
  by sorry

The theorem `Filter.map_eq_comap_of_inverse` states that for any types `α` and `β`, any filter `f` on `α`, and any functions `m` from `α` to `β` and `n` from `β` to `α`, if `m` composed with `n` equals the identity function and `n` composed with `m` also equals the identity function, then the forward map of `f` through `m` is equal to the co-filter of `f` through `n`. Essentially, this theorem is about the symmetry between forward mapping and co-filtering in the context of filters when there exist inverse functions between the types.

Given filters `f` on type `α`, functions `m: α → β` and `n: β → α` such that `m ∘ n = id_β` and `n ∘ m = id_α`, then `Filter.map f m = Filter.comap f n`.


theorem CovBy.Ioo_eq : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⋖ b → Set.Ioo a b = ∅ := by sorry

The theorem `CovBy.Ioo_eq` states that for any type `α` that has a preorder structure, and for any two elements `a` and `b` of type `α`, if `a` is strictly covered by `b` (`a ⋖ b`), then the left-open right-open interval between `a` and `b` (`Set.Ioo a b`) is equal to the empty set. In other words, if `a` is strictly covered by `b`, there are no elements of type `α` that are strictly greater than `a` and strictly less than `b`.

For any preordered type `α` and elements `a` and `b` such that `a` is strictly covered by `b`, the interval `(a, b)` is empty.


theorem MeasurableEquiv.symm_comp_self :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
      ⇑e.symm ∘ ⇑e = id :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with a measurable space structure, given a measurable equivalence `e` from `α` to `β`, the composition of the inverse of `e` with `e` itself is the identity function. In other words, applying `e`, and then its inverse, to any element of `α` will yield the original element, which is the definition of an inverse in the context of functions. This is a fundamental property of all bijective (one-to-one and onto) functions, and it holds for measurable functions as well.

For any measurable equivalences `e : α ≡ β` between types `α` and `β` equipped with measurable space structures, `e ∘ e⁻¹ = id α`, where `id α` is the identity function on `α`.


theorem Mathlib.Order.Lattice._auxLemma.5 : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a ⊔ b = a) = (b ≤ a) :=
  by sorry

This theorem, `Mathlib.Order.Lattice._auxLemma.5`, states that for any type `α` that is a semilattice with respect to an operation "sup" (denoted as `⊔`), and for any two elements `a` and `b` of this type, `a ⊔ b` being equal to `a` is equivalent to `b` being less than or equal to `a`. In other words, using the semilattice's sup operation, if the sup of `a` and `b` is equal to `a`, then `b` must be less than or equal to `a`.

For any semilattice `α` with operation `⊔`, if `a ⊔ b = a`, then `b ≤ a`.


theorem Mathlib.Combinatorics.Young.YoungDiagram._auxLemma.15 :
    ∀ {μ : YoungDiagram} {c : ℕ × ℕ}, (c ∈ YoungDiagram.transpose μ) = (Prod.swap c ∈ μ) := by sorry

This theorem states that for any Young diagram `μ` and any pair of natural numbers `c`, the pair `c` is in the transpose of the Young diagram `μ` if and only if the swapped pair `c` is in `μ`. The transpose of a Young diagram is obtained by swapping each pair of numbers (i.e., swapping the x and y coordinates of each cell), and `Prod.swap` is a function that swaps the elements in a given pair.

For any Young diagram `μ` and pair of natural numbers `c`, `c` is in the transpose of `μ` if and only if the swapped pair `(fst c, snd (swap c))` is in `μ`, where `swap` is the function swapping the elements of a pair.


theorem mul_div_right_comm : ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a * b / c = a / c * b := by
  sorry

This theorem states that for any type `α` that is a Division Commutative Monoid, given three elements `a`, `b`, and `c` of this type, the product of `a` and `b` divided by `c` is equal to `a` divided by `c` multiplied by `b`. In other words, multiplication and division operations are commutative, so we can rearrange the order of these operations without changing the result. It's represented mathematically as: `a * b / c = a / c * b`.

For any division commutative monoid type `α`, the law of dividing by the same element is commutative, that is, `a * b / c = a / c * b`.


theorem NNReal.coe_rpow : ∀ (x : NNReal) (y : ℝ), ↑(x ^ y) = ↑x ^ y := by sorry

This theorem states that for all nonnegative real numbers `x` and any real number `y`, the real number representation of `x` raised to the power `y` is equal to the nonnegative real number `x` itself raised to the power `y`. In mathematical notation, this would be expressed as ∀x ∈ NNReal, ∀y ∈ ℝ, (x^y) = x^y, where ^ denotes exponentiation. The theorem involves the type coercion (↑) from `NNReal` to `ℝ`, which does not affect the value of exponentiation.

For all non-negative real numbers x and real numbers y, x raised to the power y, with x coerced to a real number, equals x raised to the power y. (i.e., (↑x)^y = x^y)


Bornology.IsVonNBounded.subset

/-- Subsets of bounded sets are bounded.  -/
theorem Bornology.IsVonNBounded.subset :
    ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : Zero E]
      [inst_3 : TopologicalSpace E] {s₁ s₂ : Set E},
      s₁ ⊆ s₂ → Bornology.IsVonNBounded 𝕜 s₂ → Bornology.IsVonNBounded 𝕜 s₁ :=
  by sorry

The theorem `Bornology.IsVonNBounded.subset` states that, given any seminormed ring `𝕜` and any set `E` that is a smul (scalar multiplication), a zero, and a topological space, if we have two subsets `s₁` and `s₂` of `E`, and `s₁` is a subset of `s₂`, then if `s₂` is von Neumann bounded (meaning that every neighborhood of zero absorbs `s₂`), `s₁` is also von Neumann bounded. In other words, the subset of a bounded set is also bounded.

If `s₁` is a subset of von Neumann bounded `s₂` in a seminormed ring `𝕜` and `E` with `E` being a smul, a zero, and a topological space, then `s₁` is von Neumann bounded.


theorem Ordering.Compares.eq_lt :
    ∀ {α : Type u_1} [inst : Preorder α] {o : Ordering} {a b : α},
      Ordering.Compares o a b → (o = Ordering.lt ↔ a < b) :=
  by sorry

The theorem `Ordering.Compares.eq_lt` states that for any given type `α` equipped with a preorder, an `Ordering` `o`, and elements `a` and `b` of type `α`, if `a` and `b` have the ordering relation `o` between them (as defined by `Ordering.Compares`), then `o` is equal to `Ordering.lt` if and only if `a` is less than `b`. In other words, the relation `a < b` is true exactly when the ordering `o` that compares `a` and `b` is `Ordering.lt`.

If `α` is a type with preorder `o`, and `a` and `b` are elements of `α` with `a o b`, then `o = Ordering.lt` if and only if `a` is less than `b` (i.e., `a < b`).