ZFSet.inductionOn

/-- Induction on the `∈` relation.  -/
theorem ZFSet.inductionOn : ∀ {p : ZFSet → Prop} (x : ZFSet), (∀ (x : ZFSet), (∀ y ∈ x, p y) → p x) → p x := by sorry

This theorem deals with the principle of induction on the membership (`∈`) relation in the Zermelo-Fraenkel (ZF) universe of sets. It states that for any property `p` and any set `x` in the ZF universe, if we assume that the property `p` holds for every member `y` of `x`, then property `p` must also hold for `x` itself. This is an essential principle for proving properties of sets in the ZF universe, similar to structural induction in other mathematical contexts.

If `p(x)` is a property and for all `y ∈ x`, `p(y)` holds, then `p(x)` also holds. (Principle of Induction on membership in ZF)


/-- Non-zero elements of an integral domain are regular.  -/
theorem isRegular_of_ne_zero : ∀ {R : Type u_1} [inst : CancelMonoidWithZero R] {a : R}, a ≠ 0 → IsRegular a := by sorry

This theorem states that in any integral domain, all non-zero elements are regular. More specifically, for any type `R` equipped with a `CancelMonoidWithZero` structure (which is a mathematical structure combining properties of a monoid and a total order where cancellation laws hold and an element 0 has special properties) and any element `a` of type `R`, if `a` is not equal to 0, then `a` is a regular element. Here, a regular element of a ring is one where multiplication by that element, on either side, is injective.

In any integral domain, every non-zero element is a regular multiplicative element.


theorem Complex.sinh_two_mul : ∀ (x : ℂ), Complex.sinh (2 * x) = 2 * Complex.sinh x * Complex.cosh x := by sorry

The theorem `Complex.sinh_two_mul` states that for all complex numbers `x`, the hyperbolic sine of twice `x` is equal to twice the product of the hyperbolic sine of `x` and the hyperbolic cosine of `x`. In mathematical notation, it expresses the identity $\sinh(2x) = 2 \sinh(x) \cosh(x)$ for all complex numbers $x$.

For all complex numbers x, $\sinh(2x) = 2\cdot\sinh(x)\cdot\cosh(x)$.


theorem MeasureTheory.lintegral_trim :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) {f : α → ENNReal},
      Measurable f → ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ :=
  by sorry

The theorem `MeasureTheory.lintegral_trim` states that for any type `α`, any two measurable spaces `m` and `m0` over `α`, any measure `μ` over `α`, and any measurable function `f` from `α` to the extended nonnegative real numbers, if `m` is a subspace of `m0` and the function `f` is measurable, then the Lebesgue integral (or `lintegral`) of `f` with respect to the trimmed measure `μ.trim hm` is equal to the `lintegral` of `f` with respect to the original measure `μ`. So, essentially, trimming the measure does not change the value of the `lintegral`.

For measurable spaces `m` and `m0` over type `α`, measure `μ` over `α`, measurable function `f` from `α` to the extended nonnegative real numbers, if `m` is a subspace of `m0` and `f` is measurable, then `lintegral (f) (μ.trim hm) = lintegral (f) μ`.


theorem AddSubmonoid.map_sup :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (S T : AddSubmonoid M) (f : F),
      AddSubmonoid.map f (S ⊔ T) = AddSubmonoid.map f S ⊔ AddSubmonoid.map f T :=
  by sorry

The theorem `AddSubmonoid.map_sup` states that for any types `M` and `N`, which are assumed to be additive monoids (as indicated by `[inst : AddZeroClass M]` and `[inst_1 : AddZeroClass N]`), for any type `F` that behaves like a function from `M` to `N` (expressed by `[inst_2 : FunLike F M N]`) and is a homomorphism between additive monoids (`[mc : AddMonoidHomClass F M N]`), for any additive submonoids `S` and `T` of `M`, and for any function `f` of type `F`, the image of the supremum (join) of `S` and `T` under `f` is the same as the supremum of the image of `S` under `f` and the image of `T` under `f`. In simpler terms, mapping the join of two submonoids is the same as joining the maps of the two submonoids.

For additive monoids M and N, homomorphism F : M -> N, and additive submonoids S and T of M, the image of the join (supremum) of S and T under F is equal to the join of the images of S and T under F.


theorem Cardinal.mk_uLift : ∀ (α : Type u), Cardinal.mk (ULift.{v, u} α) = Cardinal.lift.{v, u} (Cardinal.mk α) := by
  sorry

The theorem `Cardinal.mk_uLift` states that for any type `α` in universe `u`, the cardinality of the lifted type `ULift.{v, u} α` is equal to the lifted cardinality `Cardinal.lift.{v, u} (Cardinal.mk α)`. In other words, taking a type and lifting it to a higher universe, then computing its cardinality is the same as computing the cardinality in the original universe and then lifting the cardinality to the higher universe. Here, cardinality refers to the size of a set or type, and universe refers to a hierarchical level in Lean's type theory where types and sets can exist.

The cardinality of `ULift.{v, u} α` is equal to the lifted cardinality `Cardinal.lift.{v, u} (Cardinal.mk α)` for any type `α` in universe `u`.


theorem finprod_eq_prod :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) (hf : Set.Finite (Function.mulSupport f)),
      (finprod fun i => f i) = Finset.prod (Set.Finite.toFinset hf) fun i => f i :=
  by sorry

The theorem `finprod_eq_prod` states that for any type `α`, a type `M` that is a commutative monoid, and a function `f` from `α` to `M`, given the finite set condition `hf` which states that the set of elements `x` such that `f(x)` is not equal to 1 is finite (`Set.Finite (Function.mulSupport f)`), the product of `f(x)` as `x` ranges over the elements of the multiplicative support of `f` (`finprod fun i => f i`) equals the product of `f(x)` as `x` ranges over the elements of the finite set (`Finset.prod (Set.Finite.toFinset hf) fun i => f i`). In other words, when the multiplicative support of the function `f` is finite, the unrestricted product over the whole domain `α` is equal to the finite product over the finite set of points where `f` is not equal to 1.

Given a commutative monoid M, a type α, and a function f from α to M with finite multiplicative support, the product of f(x) over the finite set of elements x where f(x) is not equal to 1 is equal to the product of f(x) over the entire domain α.


theorem CategoryTheory.MonoidalCategory.leftUnitor_inv_whiskerRight :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
      CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.leftUnitor X).inv Y =
        CategoryTheory.CategoryStruct.comp
          (CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).inv
          (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).inv :=
  by sorry

This theorem states that for any objects `X` and `Y` in a monoidal category `C`, the whisker right operation of the inverse of the left unitor of `X` with `Y` is the same as the composition of the inverse of the left unitor of the tensor product of `X` and `Y` and the inverse of the associator of the identity object with `X` and `Y`. In mathematical terms, this can be written as

\[
\eta_{X}^{-1} \circ Y = (\eta_{X \otimes Y}^{-1} \circ (1_{C} \otimes X \otimes Y)^{-1})
\]

Where `\eta_{X}` is the left unitor of `X`, `1_{C}` is the identity of `C`, and `\otimes` represents the tensor product operation.

The inverse of the whisker right application of the left unitor of object `X` with `Y` equals the composition of the inverse of the left unitor of the tensor product of `X` and `Y`, and the inverse of the associator of the identity object with `X` and `Y`.


ContinuousLinearEquiv.surjective

theorem ContinuousLinearEquiv.surjective :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
      [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
      [inst_5 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
      [inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂), Function.Surjective ⇑e :=
  by sorry

The theorem `ContinuousLinearEquiv.surjective` states that for any two types `R₁` and `R₂` with semiring structures, given two ring homomorphisms `σ₁₂ : R₁ →+* R₂` and `σ₂₁ : R₂ →+* R₁` that form a ring homomorphism inverse pair, and any two types `M₁` and `M₂` with topological space and additive commutative monoid structures, and modules over `R₁` and `R₂` respectively, then for every continuous linear equivalence `e : M₁ ≃SL[σ₁₂] M₂`, the function `e` is surjective. In other words, for every element in `M₂`, there exists an element in `M₁` such that applying `e` to this element of `M₁` yields the element in `M₂`.

Given continuous linear equivalences between topological additive commutative monoids and modules over commutative semirings with invertible ring homomorphisms, the equivalence is surjective.


theorem Bornology.isVonNBounded_empty :
    ∀ (𝕜 : Type u_1) (E : Type u_3) [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : Zero E]
      [inst_3 : TopologicalSpace E], Bornology.IsVonNBounded 𝕜 ∅ :=
  by sorry

This theorem states that for any type `𝕜` which is a semi-normed ring, and any type `E` which is a zero element, a topological space, and allows scalar multiplication by `𝕜`, the empty set is von Neumann bounded. In other words, for all neighborhoods `V` of zero in the vector space `E`, `V` absorbs the empty set. This means that there exists a scalar in `𝕜` such that scaling `V` by this scalar contains the empty set, which is trivially true.

For any semi-normed ring `𝕜` and topological vector space `E` over `𝕜` with zero element, the empty set is von Neumann bounded, i.e., there exists a scalar `r` in `𝕜` such that `{x ∈ E | r * x = ∅}` (the scalar multiplication of `r` with the empty set).


theorem Primrec.option_map :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α → Option β} {g : α → β → σ},
      Primrec f → Primrec₂ g → Primrec fun a => Option.map (g a) (f a) :=
  by sorry

The theorem `Primrec.option_map` states that for any types `α`, `β`, and `σ` that are primitive encodable, and any two functions `f : α → Option β` and `g : α → β → σ` that are primitive recursive, the composition of `f` and `Option.map (g a)` as `(a => Option.map (g a) (f a))` is also primitive recursive. This means that if we have a primitive recursive function `f` that maps an element of type `α` to an optional value of type `β`, and another binary primitive recursive function `g` that maps an element of type `α` and an element of type `β` to a value of type `σ`, then mapping `(g a)` over the possible values `f(a)` is primitive recursive, where `a` is from type `α`.

Given primitive encodable types α, β, and σ, and primitive recursive functions f : α → Option β and g : α → β → σ, the function x => Option.map (g x) (f x) is primitive recursive.


theorem Mathlib.Topology.Separation._auxLemma.8 :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, SeparatedNhds s t = Disjoint (nhdsSet s) (nhdsSet t) :=
  by sorry

This theorem states that for any topological space 'X' and any two subsets 's' and 't' of 'X', the two subsets are SeparatedNhds (i.e., they can be separated by two disjoint open sets in the topological space) if and only if the filters of neighborhoods of the two subsets are Disjoint (i.e., their meet is the bottom element of the lattice of filters). Thus, it gives a condition for the separation of two sets in terms of the disjointness of their neighborhood filters in the topological space.

Two subsets of a topological space are separated if and only if their filters of neighborhoods are disjoint.


theorem iff_iff_implies_and_implies : ∀ (a b : Prop), (a ↔ b) ↔ (a → b) ∧ (b → a) := by sorry

This theorem states that for any two propositional variables `a` and `b`, the biconditional statement `a ↔ b` (which reads "a if and only if b") is equivalent to the conjunction of two implications: `a → b` and `b → a` (which reads "a implies b and b implies a"). Essentially, it is asserting that the "if and only if" relationship between two propositions can be expressed as a pair of mutual implications.

For any propositional variables `a` and `b`, the biconditional `a ↔ b` is logically equivalent to the conjunction of `a → b` and `b → a`.


theorem Finset.iSup_union :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] [inst_1 : DecidableEq α] {f : α → β} {s t : Finset α},
      ⨆ x ∈ s ∪ t, f x = (⨆ x ∈ s, f x) ⊔ ⨆ x ∈ t, f x :=
  by sorry

The theorem `Finset.iSup_union` states that for all types `α` and `β` where `β` is a Complete Lattice and `α` has decidable equality, for any function `f` from `α` to `β` and any finite sets `s` and `t` of type `α`, the supremum of `f(x)` for `x` in the union of `s` and `t` is equal to the join (supremum in the lattice structure) of the supremum of `f(x)` for `x` in `s` and the supremum of `f(x)` for `x` in `t`. This theorem essentially says that the supremum operation distributes over the union of sets in this context.

For any Complete Lattice β and type α with decidable equality, the supremum of a function from α to β over the union of two finite sets is equal to the join of the supremums over each set.


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

The theorem `Part.map_bind` is about the interaction between the `map` and `bind` operations on `Part` types in Lean 4. It states that for all types `α`, `β`, `γ`, for any function `f` from `α` to `Part β`, a `Part` of `α` named `x`, and a function `g` from `β` to `γ`, mapping `g` over the result of binding `x` with `f` (i.e., `Part.map g (Part.bind x f)`) is equal to binding `x` with the function that maps `g` over `f` of `y` (i.e., `Part.bind x (λ y, Part.map g (f y))`). In essence, this theorem ensures that the `map` and `bind` operations on `Part` types are compatible in a way that mirrors the monadic laws.

For any types α, β, γ, functions f from α to Part β and g from β to γ, Part.map g (Part.bind x f) equals Part.bind x (λ y, Part.map g (f y)).


theorem Subgroup.map_commutator :
    ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (H₁ H₂ : Subgroup G) (f : G →* G'),
      Subgroup.map f ⁅H₁, H₂⁆ = ⁅Subgroup.map f H₁, Subgroup.map f H₂⁆ :=
  by sorry

The theorem `Subgroup.map_commutator` states that for any two subgroups `H₁` and `H₂` of a group `G`, and any group homomorphism `f` from `G` to another group `G'`, the image of the commutator subgroup of `H₁` and `H₂` under `f` is equal to the commutator subgroup of the images of `H₁` and `H₂` under `f`. In other words, map operation commutes with the commutator operation in the context of subgroups and group homomorphisms.

For any group homomorphism $f$ and subgroups $H\_1$ and $H\_2$ of a group $G$, we have $[[H\_1, H\_2]] = [f(H\_1), f(H\_2)]$, where $[[.,.]]$ denotes the commutator subgroup.


CategoryTheory.IsCoseparating.mono

theorem CategoryTheory.IsCoseparating.mono :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {𝒢 : Set C},
      CategoryTheory.IsCoseparating 𝒢 → ∀ {ℋ : Set C}, 𝒢 ⊆ ℋ → CategoryTheory.IsCoseparating ℋ :=
  by sorry

This theorem states that for any category 'C', and a given set '𝒢' that is a coseparating set in the category, any other set 'ℋ' that contains the set '𝒢' (in the sense that '𝒢' is a subset of 'ℋ') is also a coseparating set in the category. In other words, if every functor `C(-, G)` for `G ∈ 𝒢` is collectively faithful, then every functor `C(-, H)` for `H ∈ ℋ` is also collectively faithful, provided that '𝒢' is a subset of 'ℋ'. This theorem is essentially about the preservation of the coseparating property under the operation of taking subsets.

If a subset '𝒢' of a category 'C' is a coseparating set and is contained in another set 'ℋ', then 'ℋ' is also a coseparating set in 'C'.


theorem OrderIso.upperBounds_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set α},
      upperBounds (⇑f '' s) = ⇑f '' upperBounds s :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with a preorder structure, and given an order isomorphism `f` from `α` to `β`, the image under `f` of the set of upper bounds of a set `s` in `α` is equal to the set of upper bounds of the image of `s` under `f` in `β`. In simpler terms, this theorem asserts that the order isomorphism `f` preserves the property of being an upper bound of a set when applied to both the elements of the set and its upper bounds.

Given types `α` and `β` with preorders, an order isomorphism `f` from `α` to `β`, and a set `s` in `α`, the image of the set of upper bounds of `s` under `f` equals the set of upper bounds of `f(s)` in `β`.


theorem CategoryTheory.Preadditive.mono_of_kernel_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
      {f : X ⟶ Y} [inst_2 : CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelPair f 0)],
      CategoryTheory.Limits.kernel.ι f = 0 → CategoryTheory.Mono f :=
  by sorry

This theorem, `CategoryTheory.Preadditive.mono_of_kernel_zero`, states that in any category `C` of type `u`, where `C` is equipped with both a category structure and a preadditive structure, for any objects `X` and `Y` in `C` and any morphism `f` from `X` to `Y`, if `C` has a limit of the parallel pair `f` and `0`, and if the kernel of `f` is `0`, then `f` is a monomorphism.

In terms of category theory, this is asserting that if the kernel of a morphism in a preadditive category is zero, then that morphism is a monomorphism, which is a generalization of a property from the category of abelian groups.

In a preadditive category, if the kernel of a morphism is the zero object, then the morphism is a monomorphism.


Set.Finite.isWF

theorem Set.Finite.isWF : ∀ {α : Type u_2} [inst : Preorder α] {s : Set α}, Set.Finite s → Set.IsWF s := by sorry

This theorem states that for any type `α` with a Preorder structure, if a set `s` of type `α` is finite, then the relation `<` is well-founded when restricted to this set `s`. In other words, for every set of elements of a type which has a preorder (a relation that is reflexive and transitive), if the set is finite, there are no infinite descending `<` chains in the set.

For any finite subset of a preordered type, the preorder relation is well-founded.


theorem CofiniteTopology.nhds_eq : ∀ {X : Type u} (x : CofiniteTopology X), nhds x = pure x ⊔ Filter.cofinite := by
  sorry

This theorem states that for any type `X` and an element `x` of type `X` equipped with the cofinite topology, the neighborhood filter at `x` is equal to the join of the pure filter of `x` and the cofinite filter. In other words, a set is a neighborhood of `x` in the cofinite topology if and only if it contains `x` and its complement is finite.

In the cofinite topology on any type `X` and element `x` of `X`, the neighborhood filter of `x` equals the join of the pure filter of `x` and the cofinite filter. (Equivalently, a set is a neighborhood of `x` if and only if it contains `x` and has finite complement.)


theorem Mathlib.GroupTheory.QuotientGroup._auxLemma.5 :
    ∀ {G : Type u} [inst : AddGroup G] {N : AddSubgroup G} [nN : AddSubgroup.Normal N] (x : G), (↑x = 0) = (x ∈ N) := by
  sorry

This theorem from the group theory module in Mathlib states that for any type `G` with an addition group structure, and any normal addition subgroup `N` of `G`, a particular element `x` from `G` is in `N` if and only if the additive quotient of `x` is zero. Essentially, it establishes a relationship between the membership of an element in a subgroup and the quotient of that element being zero.

For any additive group `G` and normal subgroup `N`, an element `x` in `G` belongs to `N` if and only if `x` has additive quotient `0` in `G/N`.


theorem WithLp.prod_lipschitzWith_equiv_aux :
    ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [hp : Fact (1 ≤ p)] [inst : PseudoEMetricSpace α]
      [inst_1 : PseudoEMetricSpace β], LipschitzWith 1 ⇑(WithLp.equiv p (α × β)) :=
  by sorry

This theorem states that for any extended nonnegative real number `p`, any types `α` and `β`, given that `p` is greater than or equal to 1 and both `α` and `β` have a PseudoEMetricSpace instance, the function obtained by applying (or "lifting") the canonical equivalence between `WithLp p (α × β)` and `(α × β)` is Lipschitz continuous with a Lipschitz constant of `1`. In mathematical terms, for all `x, y` in `α × β`, the distance between the images of `x` and `y` under this function is less than or equal to the distance between `x` and `y` itself.

For any extended nonnegative real number `p` greater than or equal to 1, the function lifting the canonical equivalence between `WithLp p (α × β)` and `(α × β)` is Lipschitz continuous with a Lipschitz constant of 1.


theorem MeasureTheory.Measure.eq_zero_of_isEmpty :
    ∀ {α : Type u_1} [inst : IsEmpty α] {_m : MeasurableSpace α} (μ : MeasureTheory.Measure α), μ = 0 := by sorry

This theorem states that for any type `α` that is empty (in other words, there are no values of this type), and any measurable space derived from this type `α`, any measure `μ` on that space is equal to zero. In simpler terms, if there are no elements in the set we're measuring, then the measure of that set is necessarily zero.

For any empty type `α` and measurable space derived from it, the measure of every set is zero.


theorem tsum_le_of_sum_range_le :
    ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : AddCommMonoid α] [inst_2 : TopologicalSpace α]
      [inst_3 : OrderClosedTopology α] [inst_4 : T2Space α] {f : ℕ → α} {c : α},
      Summable f → (∀ (n : ℕ), (Finset.sum (Finset.range n) fun i => f i) ≤ c) → ∑' (n : ℕ), f n ≤ c :=
  by sorry

This theorem states that for any function `f` from natural numbers to a type `α` which has a preorder, an addition operation, a topology, an ordering compatible with its topology, and is Hausdorff, if `f` is summable and the sum of `f` for all natural numbers less than any given natural number `n` is less than or equal to a constant `c`, then the infinite series sum of `f` over all natural numbers is also less than or equal to `c`. This essentially shows that if all partial sums of a summable series are bounded by some constant `c`, then the total sum of the series is also bounded by `c`.

If `f` is a summable function from natural numbers to a type `α` with a preorder, addition operation, topology, ordering compatible with its topology, and is Hausdorff, such that the sum of `f` for all natural numbers less than any given natural number is bounded by a constant `c`, then the infinite series sum of `f` is also bounded by `c`.


theorem Multiset.finite_toSet : ∀ {α : Type u} (s : Multiset α), Set.Finite {x | x ∈ s} := by sorry

The theorem `Multiset.finite_toSet` states that, for any multiset `s` of type `α`, the set of elements `{x | x ∈ s}` that are in `s` is finite. In other words, it asserts that if we take a multiset and construct a set by considering all of its elements, the resulting set will always be finite. This is essentially a property linking multisets to finite sets.

The theorem `Multiset.finite_toSet` asserts that the set of elements in a multiset is finite.


theorem PartialHomeomorph.isOpen_extend_source :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H),
      IsOpen (PartialHomeomorph.extend f I).source :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, normed space `E` over `𝕜`, and topological spaces `H` and `M`, given a partial homeomorphism `f` from `M` to `H` and a model with corners `I` on `𝕜`, `E`, and `H`, the source set of the extension of the partial homeomorphism `f` by the model with corners `I` is an open set in the ambient topological space on `M`.

For any non-trivially normed field `𝕜`, normed additive commutative group `E`, and topological spaces `H` and `M`, given a partial homeomorphism `f` from `M` to `H`, and a model with corners `I` on `𝕜`, `E`, and `H`, the source set of the extension of `f` by `I` is open in `M`.


theorem Finite.card_le_of_injective :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Finite β] (f : α → β), Function.Injective f → Nat.card α ≤ Nat.card β := by
  sorry

The theorem `Finite.card_le_of_injective` states that for any two types `α` and `β`, where `β` is finite, and a function `f` from `α` to `β`, if the function `f` is injective, then the cardinality of `α` as a natural number, represented by `Nat.card α`, is less than or equal to the cardinality of `β`, represented by `Nat.card β`. In other words, the size of the domain of an injective function cannot exceed the size of the codomain, when the codomain is finite.

If `α` is a type, `β` is finite, and `f : α → β` is injective, then `Nat.card α ≤ Nat.card β`.


theorem le_iInf_iSup :
    ∀ {α : Type u} {ι : Sort w} {κ : ι → Sort w'} [inst : CompleteLattice α] {f : (a : ι) → κ a → α},
      ⨆ g, ⨅ a, f a (g a) ≤ ⨅ a, ⨆ b, f a b :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice, and for any function `f` from a pair of indices `(a, g(a))` to `α`, the supremum of the infimums of `f(a, g(a))` over all `g` is less than or equal to the infimum of the supremums of `f(a, b)` over all `b` for each `a`. Here, the infimum and supremum are the greatest lower bound and least upper bound in the complete lattice `α` respectively. This theorem is a formal statement of the generalized distributive law for complete lattices.

For any complete lattice `α` and function `f` from a pair of indices to `α`, the supremum of the infima of `f(a, g(a))` over all `g` is less than or equal to the infimum of the supremas of `f(a, b)` over all `b`, for each `a`.


/-- The cdf tends to 0 at -∞.  -/
theorem ProbabilityTheory.tendsto_cdf_atBot :
    ∀ (μ : MeasureTheory.Measure ℝ), Filter.Tendsto (↑(ProbabilityTheory.cdf μ)) Filter.atBot (nhds 0) := by sorry

This theorem states that the cumulative distribution function (CDF) of any real measure tends to 0 as its argument tends to negative infinity. In other words, for any probability measure `μ`, as we consider increasingly negative values, the CDF of `μ` approaches 0. This is a common property of CDFs in probability theory, reflecting that the probability of the random variable being less than any given value approaches 0 as that value goes to negative infinity.

For any real measure `μ`, the limit as `x` approaches negative infinity of its cumulative distribution function is 0.


theorem Mathlib.ModelTheory.Semantics._auxLemma.1 : ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (α → b) = b := by
  sorry

This theorem, `Mathlib.ModelTheory.Semantics._auxLemma.1`, states that for any proposition `b` and any type or sort `α` that is nonempty (i.e., there exists at least one element of type `α`), the type of functions from `α` to `b` is equivalent to `b` itself. This theorem is a facet of mathematical logic and model theory.

For any nonempty type or sort `α`, the type of functions from `α` to a proposition `b` is equivalent to `b`.


theorem Mathlib.ModelTheory.Semantics._auxLemma.9 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {φ ψ : FirstOrder.Language.BoundedFormula L α l} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.imp φ ψ) v xs =
        (FirstOrder.Language.BoundedFormula.Realize φ v xs → FirstOrder.Language.BoundedFormula.Realize ψ v xs) :=
  by sorry

This theorem is part of Model Theory in the field of mathematical logic and is about the semantics of logical formulas. It states that for any first-order language `L`, any model `M` of that language, any type `α`, any natural number `l`, any two bounded formulas `φ` and `ψ` in `L` of the same quantifier depth `l`, and any variable assignment `v` from `α` to `M` and `xs` from `Fin l` to `M`, realizing the implication `φ -> ψ` is equivalent to the logical implication: if `φ` is realized then `ψ` is also realized. Here, "realizing a formula" refers to the formula being true under the given variable assignment in the model.

For any first-order language L, model M, type α, natural number l, bounded formulas φ and ψ of depth l in L, variable assignment v from α to M, and xs from Fin l to M, realizing implication φ -> ψ (in the sense of being true under v in M for all xs) is equivalent to the logical implication (φ implies ψ).


theorem ContDiffAt.norm_sq :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst : InnerProductSpace 𝕜 E]
      [inst : NormedSpace ℝ E] {G : Type u_4} [inst_2 : NormedAddCommGroup G] [inst_3 : NormedSpace ℝ G] {f : G → E}
      {x : G} {n : ℕ∞}, ContDiffAt ℝ n f x → ContDiffAt ℝ n (fun x => ‖f x‖ ^ 2) x :=
  by sorry

The theorem `ContDiffAt.norm_sq` states that for any given normed-additive commutative group `E` with an inner product space over a ring `𝕜` that behaves like real numbers (`RCLike 𝕜`) and is a normed space over real numbers, and another normed-additive commutative group `G` which is also a normed space over real numbers, if a function `f` mapping from `G` to `E` is continuously differentiable at a point `x` in `G` to any degree `n` (which can be a natural number or infinity), then the function that maps `x` to the squared norm of `f(x)` is also continuously differentiable at `x` to the same degree `n`.

If `f:` `G` -> `E` is `n`-times continuously differentiable at `x` in the normed spaces `G` over `𝕜` and `E` over real numbers, then the function `x` -> `∥f(x)∥²` is also `n`-times continuously differentiable at `x`.


HasDerivAt.unique

theorem HasDerivAt.unique :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f₀' f₁' : F} {x : 𝕜},
      HasDerivAt f f₀' x → HasDerivAt f f₁' x → f₀' = f₁' :=
  by sorry

The theorem `HasDerivAt.unique` states that if a function `f` has derivatives `f₀'` and `f₁'` at a particular point `x` in a non-trivially normed field `𝕜` with normed additive commutative group structure `F` and normed space structure over `𝕜`, then `f₀'` and `f₁'` must be equal. This essentially asserts the uniqueness of the derivative at a given point. If there are two derivatives at the same point, they cannot be different; they have to be the same.

If a function `f` has two derivatives `f′0` and `f′1` at a point `x` in a normed field `ℝ` with corresponding normed additive commutative group structure and normed space structure, then `f′0 = f′1`.


theorem antitone_mul_right :
    ∀ {α : Type u} [inst : OrderedSemiring α] [inst_1 : ExistsAddOfLE α]
      [inst_2 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α},
      a ≤ 0 → Antitone fun x => x * a :=
  by sorry

The theorem `antitone_mul_right` states that for any ordered semiring `α`, assuming an additive identity for any element less than or equal to another, and having a contravariant class with respect to the swapped addition operation and the standard less than or equal operation, for any `a` in `α`, if `a` is less than or equal to zero then multiplication by `a` is an antitone function. In other words, if `a` is less than or equal to zero in an ordered semiring, then for any two elements `x` and `y` in `α`, if `x` is less than or equal to `y` then `y * a` is less than or equal to `x * a`.

If `α` is an ordered semiring with `a ≤ 0`, then for all `x, y ∈ α`, `x ≤ y` implies `y * a ≤ x * a`.


theorem small_lift : ∀ (α : Type u) [hα : Small.{v, u} α], Small.{max v w, u} α := by sorry

The theorem `small_lift` states that for any type `α`, if `α` is a small type in a certain sense, which is specified by the structure `Small.{v, u} α`, then `α` is also a small type in a more general sense, specified by the structure `Small.{max v w, u} α`. This theorem is essentially lifting the "smallness" of a type from one context to a larger one. This concept of "smallness" is a technical one in the type theory underlying Lean 4, involving the size of types and the hierarchy of universes of types.

If `α` is a small type in the context `Small.{v} α`, then it is also a small type in the context `Small.{max v w, u} α`.


theorem Set.pi_univ_Ici :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i),
      (Set.pi Set.univ fun i => Set.Ici (x i)) = Set.Ici x :=
  by sorry

This theorem states that for any index set `ι` and a family of sets `α`, where each `α i` is preordered, and for any function `x : ι → α i`, the set of all dependent functions that for every index `i` map to an element greater or equal to `x i` is the same as the set of all functions greater or equal to `x`. In other words, the left-closed right-infinite interval of the universal set of dependent functions, where each function maps to a value equal or greater than the corresponding value in `x`, equals the left-closed right-infinite interval starting at `x`.

For any indexed family of preordered sets `α i` and function `x : ι → α i`, the set of functions `f : ι → α i` with `i in ι` implying `f i ≥ x i` equals the set of functions greater than or equal to `x`.


theorem IsHomeomorphicTrivialFiberBundle.proj_eq :
    ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      [inst_2 : TopologicalSpace Z] {proj : Z → B},
      IsHomeomorphicTrivialFiberBundle F proj → ∃ e, proj = Prod.fst ∘ ⇑e :=
  by sorry

This theorem states that for any types `B`, `F`, and `Z`, where `B`, `F`, and `Z` are topological spaces, and given a projection `proj` from `Z` to `B`, if `Z` is a trivial fiber bundle with fiber `F` over base `B` that is homeomorphic to the product space `B × F`, then there exists a function `e` such that the projection function `proj` is equal to the composition of the first projection function `Prod.fst` and the application of `e`. In other words, every point in `Z` projected onto `B` via `proj` can be obtained by first applying the mapping `e` and then taking the first component of the resulting pair in `B × F`.

Given a trivial fiber bundle with projection `proj` from a topological space `Z` to `B` with fiber `F`, if `Z` is homeomorphic to `B × F`, then there exists a function `e` such that `proj = Prod.fst ∘ e`.


Nat.Primrec'.prec'

theorem Nat.Primrec'.prec' :
    ∀ {n : ℕ} {f g : Vector ℕ n → ℕ} {h : Vector ℕ (n + 2) → ℕ},
      Nat.Primrec' f →
        Nat.Primrec' g → Nat.Primrec' h → Nat.Primrec' fun v => Nat.rec (g v) (fun y IH => h (y ::ᵥ IH ::ᵥ v)) (f v) :=
  by sorry

The theorem `Nat.Primrec'.prec'` states that for any natural number `n`, and for any functions `f`, `g`, `h` where `f` and `g` map a vector of length `n` to a natural number and `h` maps a vector of length `n + 2` to a natural number, if `f`, `g`, and `h` are primitive recursive (denoted by `Nat.Primrec'`), then the function defined by natural number recursion on `f v` with `g v` as the base case and `h` applied to the constructed vector as the recursive step is also primitive recursive.

If `f` and `g` are primitive recursive functions mapping vectors of length `n` to natural numbers, and `h` is a primitive recursive function mapping vectors of length `n + 2` to natural numbers, then the function defined by natural number recursion on `f` with `g` as the base case and `h` as the recursive step is also primitive recursive.


/-- The value of `χ₄ n`, for `n : ℕ`, depends only on `n % 4`.  -/
theorem ZMod.χ₄_nat_mod_four : ∀ (n : ℕ), ZMod.χ₄ ↑n = ZMod.χ₄ ↑(n % 4) := by sorry

The theorem `ZMod.χ₄_nat_mod_four` states that for any natural number `n`, the value of `χ₄ n` is only dependent on the remainder of `n` when divided by 4. In other words, the quadratic character `χ₄` on `ZMod 4` mapped to any natural number `n` is the same as it mapped to the remainder of `n` divided by 4. This theorem links the quadratic character to the concept of congruence in modular arithmetic.

For all natural numbers n, the quadratic character χ₄ on ZMod 4 maps n to the same value as the remainder of n divided by 4.


theorem SimpleGraph.Walk.IsEulerian.mem_edges_iff :
    ∀ {V : Type u_1} {G : SimpleGraph V} [inst : DecidableEq V] {u v : V} {p : SimpleGraph.Walk G u v},
      SimpleGraph.Walk.IsEulerian p → ∀ {e : Sym2 V}, e ∈ SimpleGraph.Walk.edges p ↔ e ∈ SimpleGraph.edgeSet G :=
  by sorry

This theorem states that for any simple graph `G` with vertex set `V` (where `V` has decidable equality) and any vertices `u`, `v` in `V`, if `p` is an Eulerian walk from `u` to `v` in `G` (which means `p` is a walk that visits each edge of `G` exactly once), then for any edge `e` (represented as an unordered pair of vertices), `e` is an edge of the walk `p` if and only if `e` is an edge in the graph `G`. This captures the idea that an Eulerian walk precisely uses all the edges in the graph once.

For any simple graph with decidable vertex equality and any two vertices, an Eulerian walk connects them if and only if the edges in the walk belong to the graph.


theorem Matrix.updateRow_self :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {b : n → α} [inst : DecidableEq m],
      Matrix.updateRow M i b i = b :=
  by sorry

The theorem `Matrix.updateRow_self` states that for any given matrix `M` with entries of type `α`, indexed by `m` for rows and `n` for columns, and for any function `b` mapping indices `n` to entries `α`, if we update the `i`th row of matrix `M` with the values given by `b`, then when we access the `i`th row of the updated matrix, we get the exact function `b` back. This is under the condition that equality is decidable for the row indices `m`. In other words, replacing the `i`th row of a matrix with a certain function results in that function when we look at the `i`th row of the resulting matrix.

For any matrix `M` of type `α` with decidable row equality, updating the `i`th row with function `b` results in a matrix where the `i`th row equals `b`.


AddMonCat.ext

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

This theorem, `AddMonCat.ext`, states that for any two objects `X` and `Y` in the category of additive monoids (`AddMonCat`), and for any two morphisms `f` and `g` from `X` to `Y`, if `f` and `g` have the same effect on all elements of `X` (i.e., for all `x` in `X`, `f(x) = g(x)`), then `f` and `g` must be the same morphism. This is a statement about the uniqueness of morphisms in the category of additive monoids subject to a certain condition on their action.

In the category of additive monoids, two morphisms with the same effect on all elements are equivalent.


theorem hasDerivAt_neg : ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜), HasDerivAt Neg.neg (-1) x := by
  sorry

The theorem `hasDerivAt_neg` states that, for every point `x` in a nontrivially normed field `𝕜`, the function `Neg.neg`, which computes the negative or opposite of a number, has a derivative of `-1` at that point. This means that if we look at the change in the `Neg.neg` function as we infinitesimally move away from `x`, this change is proportional to `-1`, i.e., the function is decreasing at a constant rate.

The negative function `Neg.neg` has a derivative of `-1` in the nontrivially normed field `𝕜`.


/-- The definition of `0 ≤ x` on pre-games, in terms of `0 ≤` two moves later.  -/
theorem SetTheory.PGame.zero_le :
    ∀ {x : SetTheory.PGame},
      0 ≤ x ↔
        ∀ (j : SetTheory.PGame.RightMoves x), ∃ i, 0 ≤ SetTheory.PGame.moveLeft (SetTheory.PGame.moveRight x j) i :=
  by sorry

The theorem `SetTheory.PGame.zero_le` states that for any pre-game `x`, `0` is less than or equal to `x` if and only if for every allowable move `j` by the right player in game `x`, there exists a move `i` by the left player such that `0` is less than or equal to the new game obtained after right's move `j` and left's subsequent move `i`. This definition of `0 ≤ x` on pre-games reflects the concept that `0 ≤ x` if, no matter what move the right player makes, the left player can respond in a way that maintains the inequality.

For any pre-game `x`, `0` is less than or equal to `x` if and only if for every allowable move `j` by the right player, there exists a move `i` by the left player such that `0 ≤ x'` where `x'` is the new game obtained after right's move `j` and left's subsequent move `i`.


theorem Matrix.StdBasisMatrix.mul_left_apply_same :
    ∀ {n : Type u_3} {α : Type u_5} [inst : DecidableEq n] [inst_1 : Semiring α] (i j : n) (c : α) [inst_2 : Fintype n]
      (b : n) (M : Matrix n n α), (Matrix.stdBasisMatrix i j c * M) i b = c * M j b :=
  by sorry

The theorem `Matrix.StdBasisMatrix.mul_left_apply_same` states that for any given semiring `α`, indices `i`, `j` and `b`, a scalar `c` of `α`, and a square matrix `M` indexed by `n` with elements in `α`, if we left multiply the standard basis matrix (where the `i`-th row and `j`-th column is `c` and zeroes elsewhere) with `M`, the `i`-th row and `b`-th column of the resulting matrix is equal to `c` times the `j`-th row and `b`-th column of `M`. This theorem assumes that equality in the index set `n` is decidable and that `n` is finite.

For any square matrix M indexed by a finite and decidably equated set, the product of the standard basis matrix with row i and column j, and M, equals the product of the scalar c and the product of row i and column j of M.


theorem Nat.dist_eq_sub_of_le_right : ∀ {n m : ℕ}, m ≤ n → Nat.dist n m = n - m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `m` is less than or equal to `n`, then the distance between `n` and `m`, as defined by the `Nat.dist` function, is equal to the difference `n - m`. This means that when `m` is less than or equal to `n`, the distance between these two numbers is simply the subtraction of `m` from `n` in the set of natural numbers.

For all natural numbers `n` and `m`, `Nat.dist n m = n - m` when `m ≤ n`.


theorem Mathlib.Algebra.Associated._auxLemma.19 :
    ∀ {α : Type u_1} [inst : Monoid α] {p : Associates α → Prop},
      (∀ (a : Associates α), p a) = ∀ (a : α), p (Associates.mk a) :=
  by sorry

The theorem `Mathlib.Algebra.Associated._auxLemma.19` asserts that for any type `α` that has a Monoid structure, and any property `p` defined on the `Associates` of `α`, stating that this property holds for all elements in the `Associates` of `α` is equivalent to stating that the property holds for all elements in `α` after they are mapped into the `Associates` of `α` by the canonical quotient map `Associates.mk`. In other words, a property is true for all associates if and only if it is true for all original elements before being transformed by `Associates.mk`.

For any monoid `α` and property `p` on its associates, `p` holds for all associates if and only if it holds for all elements of `α` after being quotiented by the associates relation.


theorem Finset.Ioo_eq_empty :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, ¬a < b → Finset.Ioo a b = ∅ := by
  sorry

This theorem states that for any type `α` that has a preorder and is a locally finite order, and for any two elements `a` and `b` of this type, if `a` is not less than `b` then the finite set of elements `x` such that `a < x` and `x < b` is empty. In layman's terms, if our lower bound `a` is not less than the upper bound `b`, then there are no elements between `a` and `b`.

If `α` is a type with a preorder and is locally finite, and `a` is not less than `b` in `α`, then there are no elements `x` in `α` such that `a` is less than `x` and `x` is less than `b`.


theorem sdiff_le_comm : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, a \ b ≤ c ↔ a \ c ≤ b := by
  sorry

This theorem states that for any three elements `a`, `b`, and `c` of a type `α` that is a Generalized Coheyting Algebra, the statement "the set difference of `a` and `b` is less than or equal to `c`" is equivalent to the statement "the set difference of `a` and `c` is less than or equal to `b`". Here, the less than or equal operation is defined in the context of the Generalized Coheyting Algebra structure.

In a Generalized Coalgebra, the set difference `a \ b` is equivalent to `a \ c` if and only if `b` is less than or equal to `c` in the order defined by the Coalgebra structure.


theorem Filter.map_val_atTop_of_Ici_subset :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] {a : α} {s : Set α},
      Set.Ici a ⊆ s → Filter.map Subtype.val Filter.atTop = Filter.atTop :=
  by sorry

This theorem states that for any type `α` under a semilattice with supremum, given any element `a` of that type and any set `s` of elements of that type, if the set of all elements greater or equal to `a` (denoted as `Set.Ici a`) is a subset of `s`, then the forward map `Filter.map` of the filter `Filter.atTop` (representing limit at infinity) using the `Subtype.val` function (which yields the underlying element of a subtype) equals the filter at infinity `Filter.atTop`. This essentially means that under the given conditions, mapping the elements of the filter at infinity using `Subtype.val` does not affect the filter.

For any semilattice with supremum `α`, if `a` is an element of `α` and `Set.Ici a ⊆ s`, then `Filter.map Filter.atTop Subtype.val = Filter.atTop` for filters on the set `s` of elements of `α`.


theorem Int.floor_lt :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, ⌊a⌋ < z ↔ a < ↑z := by sorry

This theorem, `Int.floor_lt`, states that for any type `α`, where `α` is a linearly ordered ring and a floor ring, and for any integer `z` and element `a` of type `α`, the floor of `a` is less than `z` if and only if `a` is less than the coercion of `z` to type `α`. In mathematical terms, it can be expressed as: if `⌊a⌋ < z` then `a < ↑z`, and if `a < ↑z` then `⌊a⌋ < z`.

For any linearly ordered ring and floor ring `α`, and for all `z` an integer and `a` an element of `α`, `⌊a⌋ < z` if and only if `a < ↑z`.


theorem MeasureTheory.Measure.rnDeriv_withDensity_left :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ENNReal} {μ ν : MeasureTheory.Measure α}
      [inst : MeasureTheory.SigmaFinite μ] [inst : MeasureTheory.SigmaFinite ν],
      AEMeasurable f μ →
        AEMeasurable f ν →
          (∀ᵐ (x : α) ∂μ, f x ≠ ⊤) →
            (μ.withDensity f).rnDeriv ν =ᶠ[MeasureTheory.Measure.ae ν] fun x => f x * μ.rnDeriv ν x :=
  by sorry

This theorem, `MeasureTheory.Measure.rnDeriv_withDensity_left`, states that for any given measurable space `α`, a function `f : α → ENNReal` (mapping elements of `α` to extended nonnegative real numbers), and two sigma-finite measures `μ` and `ν` on `α`, if `f` is almost everywhere measurable with respect to both `μ` and `ν`, and `f` is almost everywhere finite with respect to `μ`, then the Radon-Nikodym derivative of the measure obtained by scaling `μ` by `f` with respect to `ν`, is almost everywhere equal (with respect to `ν`) to the function that maps `x` in `α` to the product of `f(x)` and the Radon-Nikodym derivative of `μ` with respect to `ν` at `x`.

In simpler terms, it relates the Radon-Nikodym derivative of a weighted measure to the weight function and the Radon-Nikodym derivative of the original measure, under certain conditions on the weight function and the measures.

Given measurable spaces `α`, a sigma-finite measure `μ`, a sigma-finite measure `ν`, a measurable function `f : α → ENNReal` that is almost everywhere finite and measurable with respect to both `μ` and `ν`, the Radon-Nikodym derivative `d(μ / f) / dν` almost everywhere equals the product of `f` and the Radon-Nikodym derivative `dμ / dν`.


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.37 :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α},
      (f x = f y) = (x = y) :=
  by sorry

This theorem, denoted as `Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.37`, states that for any types `F`, `α`, and `β`, if `F` is a function-like from `α` to `β` (i.e., there is an injective coercion from `F` to the function space `α → β`) and `F` is also embedding-like from `α` to `β`, then for any function `f` of type `F` and any given elements `x` and `y` of type `α`, `f x` equals to `f y` if and only if `x` equals to `y`. In other words, it asserts that under these conditions, `f` is an injective function: it maps distinct elements of `α` to distinct elements of `β`.

If `F` is a function-like and embedding-like from type `α` to type `β`, then the associated function `f` of type `F` is injective, i.e., `f x = f y` implies `x = y`.


theorem Filter.tendsto_inv₀_cobounded :
    ∀ {α : Type u_1} [inst : NormedDivisionRing α], Filter.Tendsto Inv.inv (Bornology.cobounded α) (nhds 0) := by sorry

This theorem states that for any normed division ring `α`, the inverse function `Inv.inv` tends to the neighborhood filter at `0` when applied to the filter of cobounded sets in the bornology of `α`. In other words, for every neighborhood of `0`, the preimage of this neighborhood under the inverse function is a cobounded set in `α`. This is a generalized result in the field of topology, particularly dealing with concepts of limits and continuity of the inverse function in normed division rings.

For any normed division ring `α`, the inverse function `Inv.inv` maps the filter of cobounded sets in the bornology of `α` to the neighborhood filter at `0`.


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.41 :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y := by sorry

This theorem is part of the `Mathlib.GroupTheory.Perm.Cycle.Basic` in Lean 4 and is named `_auxLemma.41`. It states that for any types `α` and `β`, a function `f` from `α` to `β`, a set `s` of type `α`, and an element `y` of type `β`, the property of `y` being in the image of set `s` under the function `f` (denoted as `y ∈ f '' s`) is equivalent to the existence of an element `x` in the set `s` such that `f` applied to `x` yields `y` (denoted as `∃ x ∈ s, f x = y`). Essentially, it provides a characterization of the image of a set under a function.

For any types α and β, a function f from α to β, and a set s of type α, the image of s under f (y ∈ f '' s) if and only if there exists an x in s such that f(x) = y.


theorem Metric.disjoint_nhds_cobounded :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), Disjoint (nhds x) (Bornology.cobounded α) := by sorry

The theorem `Metric.disjoint_nhds_cobounded` states that for any pseudometric space `α` and any element `x` in that space, the neighborhood filter of `x` (which contains all open sets around `x`) is disjoint from the filter of cobounded sets in the bornology of the space. In other words, there are no sets that are both a neighborhood of `x` and cobounded in the same space. Here, two sets are considered to be disjoint if their intersection (infimum in the lattice of sets) is the empty set, or equivalently, the bottom element in the lattice of sets.

For any pseudometric space and its element, the neighborhood filter and the filter of cobounded sets are disjoint.


theorem AddCommute.add_add_add_comm :
    ∀ {S : Type u_2} [inst : AddSemigroup S] {b c : S},
      AddCommute b c → ∀ (a d : S), a + b + (c + d) = a + c + (b + d) :=
  by sorry

This theorem, `AddCommute.add_add_add_comm`, states that for any type `S` that has an addition operation (forming an additive semigroup), if two elements `b` and `c` commute under addition (i.e., `b + c = c + b`), then for all elements `a` and `d` in `S`, the equation `a + b + (c + d) = a + c + (b + d)` will hold. In other words, if `b` and `c` can be added in either order without changing the result, then you can rearrange the addition of four elements `a`, `b`, `c`, `d` in a specific way without changing the sum.

For any additive semigroup `S` and elements `a`, `b`, `c`, `d` in `S` with `b` and `c` commuting under addition, `a + b + (c + d) = a + c + (b + d)`.


theorem CliffordAlgebra.contractLeftAux_contractLeftAux :
    ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (Q : QuadraticForm R M) (d : Module.Dual R M) (v : M) (x fx : CliffordAlgebra Q),
      ((CliffordAlgebra.contractLeftAux Q d) v)
          ((CliffordAlgebra.ι Q) v * x, ((CliffordAlgebra.contractLeftAux Q d) v) (x, fx)) =
        Q v • fx :=
  by sorry

This theorem states that for any commutative ring `R`, additive commutative group `M`, and `M` being an `R`-module, given a quadratic form `Q` of `R` and `M`, a dual module `d` of `R` and `M`, a vector `v` in `M`, and two elements `x` and `fx` of the Clifford algebra of `Q`, the result of applying the contractLeftAux function of the Clifford algebra to `d` and `v`, and then applying it to the product of the canonical linear map applied to `v` and `x`, and the pair `(x, fx)`, is equal to the result of scaling `fx` by the value of the quadratic form `Q` applied to `v`. This expresses a property of the contractLeftAux function in the context of Clifford algebras.

For any commutative ring `R`, additive commutative group `M`, `R`-module `M`, quadratic form `Q` on `M`, its dual module `d`, vector `v` in `M`, and elements `x` and `fx` in the Clifford algebra of `Q`, the scalar value obtained by contracting `d` with `v` using `contractLeftAux` and then scaling `fx` by `Q(v)` is equal.


theorem CategoryTheory.map_hom_inv_app_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) {X Y : C} (e : X ≅ Y) (Z : D) {Z_1 : E}
      (h : (F.obj X).obj Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp ((F.map e.hom).app Z)
          (CategoryTheory.CategoryStruct.comp ((F.map e.inv).app Z) h) =
        h :=
  by sorry

This theorem, `CategoryTheory.map_hom_inv_app_assoc`, states that for any categories `C`, `D`, and `E`, given a functor `F` from `C` to the category of functors from `D` to `E`, any two objects `X` and `Y` in `C` related by an isomorphism `e`, an object `Z` of `D` and a morphism `h` from the functor object `(F.obj X).obj Z` to an object `Z_1` in `E`, the composition of the application of the homomorphism part `e.hom` of the isomorphism `e` followed by the composition of the application of the inverse part `e.inv` of the isomorphism `e` and the morphism `h` is equal to `h`. This can be interpreted as a kind of cancellation law for morphisms in a category, showing that the inverse of a morphism behaves as expected under composition.

Given functors F from category C to Functor(D, E), isomorphisms e : X ≅ Y in C, objects Z in D, and morphisms h : (F.obj X).obj Z → Z'\_, the composition of e.hom ∘ (e.inv ∘ h) equals h.


theorem List.mem_join : ∀ {α : Type u_1} {a : α} {L : List (List α)}, a ∈ List.join L ↔ ∃ l ∈ L, a ∈ l := by sorry

This theorem, `List.mem_join`, states that for any type `α`, any element `a` of type `α`, and any list `L` of lists of type `α`, the element `a` is a member of the list resulting from joining all lists in `L` (i.e., `List.join L`) if and only if there exists a sublist `l` in `L` such that `a` is a member of `l`. In other words, an element is in the joined list if it was in one of the original sublists.

For any type `α`, list `L` of lists of `α`, and element `a` of `α`, `a` is in `List.join L` if and only if there exists `l` in `L` such that `a` is in `l`.


theorem CategoryTheory.Limits.IsImage.isoExt_inv_m :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F)
      (hF' : CategoryTheory.Limits.IsImage F'),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsImage.isoExt hF hF').inv F.m = F'.m :=
  by sorry

The theorem `CategoryTheory.Limits.IsImage.isoExt_inv_m` states that for any category `C` and objects `X`, `Y` in `C` with a morphism `f` from `X` to `Y`, and given two monomorphisms `F` and `F'` of `f`, if `F` and `F'` satisfy the universal property of an image (i.e., `F` and `F'` are images), then the composition of the inverse of the isomorphism between `F.I` and `F'.I` (obtained by `CategoryTheory.Limits.IsImage.isoExt`) and the morphism `F.m` equals the morphism `F'.m`. In simpler terms, this theorem states a property about the particular composition of morphisms involving inverse isomorphisms in the context of images in category theory.

For any category C, morphisms f : X -> Y, and monomorphisms F, F' of f in C such that F and F' are images, the composition of the inverse of the isomorphism between F.I and F'.I and F.m equals F'.m.


theorem Subring.mk'.proof_2 : ∀ {R : Type u_1} [inst : Ring R] (s : Set R) (sa : AddSubgroup R), ↑sa = s → s = ↑sa := by
  sorry

This theorem, `Subring.mk'.proof_2`, states that for any type `R` that is a Ring, given a set `s` of elements of `R` and an AddSubgroup `sa` of `R`, if the AddSubgroup `sa` coerced to a set is equal to `s`, then `s` is equal to the AddSubgroup `sa` coerced to a set. This theorem is demonstrating that the equality operation on sets of elements in a Ring and additive subgroups of the Ring is symmetric.

For any ring `R`, if the additive subgroup `sa` of `R` equals the set `s` of its elements, then `s` and `sa` coerced to sets are equal.


theorem IsOpenMap.image_interior_subset :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f → ∀ (s : Set X), f '' interior s ⊆ interior (f '' s) :=
  by sorry

This theorem states that for any two types `X` and `Y`, and any function `f` from `X` to `Y`, given that both `X` and `Y` are topological spaces and `f` is an open map, for any set `s` of type `X`, the image under `f` of the interior of `s` is a subset of the interior of the image of `s` under `f`. In simpler terms, applying `f` to the interior of a set doesn't produce values outside of the interior of the set's image under `f`.

Given topological spaces X and Y and an open map f from X to Y, the image under f of the interior of any set in X is a subset of the interior of the image of that set under f.


theorem PowerSeries.derivativeFun_C :
    ∀ {R : Type u_1} [inst : CommSemiring R] (r : R), PowerSeries.derivativeFun ((PowerSeries.C R) r) = 0 := by sorry

This theorem states that the derivative of a constant formal power series is zero. In other words, for any commutative semiring `R` and any element `r` of `R`, if we form the constant formal power series `r` (using the `PowerSeries.C` function) and then take its derivative (using `PowerSeries.derivativeFun`), the result is the zero power series. This is analogous to the fact in calculus that the derivative of a constant function is zero.

The derivative of a constant formal power series over a commutative semiring is the zero power series.


theorem circleMap_zero_radius : ∀ (c : ℂ), circleMap c 0 = Function.const ℝ c := by sorry

This theorem states that for any complex number `c`, if we apply the function `circleMap` with `c` as the center and zero as the radius, we will obtain a constant function that always returns `c`. In other words, when the radius of the circle in the complex plane is zero, the `circleMap` function reduces to a singleton point at the center `c`.

For any complex number `c`, the `circleMap` function with `c` as the center and radius 0 is the constant function equal to `c`.


theorem uniformity_prod_eq_comap_prod :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β],
      uniformity (α × β) = Filter.comap (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (uniformity α ×ˢ uniformity β) :=
  by sorry

The theorem `uniformity_prod_eq_comap_prod` states that for any two types `α` and `β` each equipped with a uniformity (i.e. a UniformSpace structure), the uniformity on the product type `α × β` is equal to the filter obtained by applying the `Filter.comap` function to the pair-wise product of the uniformities on `α` and `β`. The function used for the `Filter.comap` takes a product of pairs (from `α × β`) and produces a pair of pairs (for `α` and `β` separately). This theorem, therefore, establishes the connection between the uniform structure on a product type and the uniform structures on the constituent types.

The uniformity on the product type of two uniform spaces is equal to the composite of their pair-wise product and the `Filter.comap` function.


theorem Cardinal.prod_const :
    ∀ (ι : Type u) (a : Cardinal.{v}),
      (Cardinal.prod fun x => a) = Cardinal.lift.{u, v} a ^ Cardinal.lift.{v, u} (Cardinal.mk ι) :=
  by sorry

The theorem `Cardinal.prod_const` states that for any type `ι` and any cardinal number `a`, the cardinality of the product type where each type in the product has the cardinality `a` is equal to `a` to the power of the cardinality of `ι`. This is expressed in the theorem as `(Cardinal.prod fun x => a) = Cardinal.lift.{u, v} a ^ Cardinal.lift.{v, u} (Cardinal.mk ι)`. Here, `Cardinal.prod` is the cardinality of the dependent product of a type-indexed family of types, `Cardinal.lift` raises the level of a cardinal number, and `Cardinal.mk` gives the cardinality of a type. The theorem essentially expresses a property of cardinal arithmetic for type-indexed products of types.

The theorem `Cardinal.prod_const` asserts that the cardinality of the product of `ι` types, each having cardinality `a`, equals `a` raised to the power of the cardinality of `ι`.


theorem CategoryTheory.GradedObject.mapMap_id :
    ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C]
      (X : CategoryTheory.GradedObject I C) (p : I → J) [inst_1 : CategoryTheory.GradedObject.HasMap X p],
      CategoryTheory.GradedObject.mapMap (CategoryTheory.CategoryStruct.id X) p =
        CategoryTheory.CategoryStruct.id (CategoryTheory.GradedObject.mapObj X p) :=
  by sorry

The theorem `CategoryTheory.GradedObject.mapMap_id` states that for any types `I`, `J`, and `C` with `C` being a category, any graded object `X` of type `I` in category `C`, and any function `p: I → J`, if `X` has a map associated with function `p`, then applying the identity morphism of `X` and then mapping with `p` is the same as applying the identity morphism of the mapped object (i.e., the object obtained by mapping the graded object `X` using the function `p`). In other words, this is essentially a statement of the identity law in the context of graded objects in a category.

For any category `C`, any graded object `X` over `C` of type `I`, and any function `p: I → J`, if `X` has a map `f: X ➝ Ob C`, then `id X �circ f = f (id I)`.


theorem ball_mul_one :
    ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (s : Set E), Metric.ball 1 δ * s = Metric.thickening δ s :=
  by sorry

This theorem states that for any set `s` in a semi-normed commutative group `E`, and any real number `δ`, the set of all points within distance `δ` from `1` in the set `s` (denoted by `Metric.ball 1 δ * s`) is equal to the `δ`-thickening of the set `s` (denoted by `Metric.thickening δ s`). The `δ`-thickening of a set is the set of all points that are less than a distance `δ` away from any point in the set.

For any semi-normed commutative group `E` and set `s` in it, and real number `δ`, the `Metric.ball 1 δ` around `1` in `s` equals the `Metric.thickening δ` of `s`.


theorem Directed.finite_set_le :
    ∀ {α : Type u_1} {r : α → α → Prop} [inst : IsTrans α r] {γ : Type u_3} [inst : Nonempty γ] {f : γ → α},
      Directed r f → ∀ {s : Set γ}, Set.Finite s → ∃ z, ∀ i ∈ s, r (f i) (f z) :=
  by sorry

The theorem `Directed.finite_set_le` states that for any type `α` with a transitive relation `r`, and any type `γ` which is nonempty, along with a function `f` mapping elements of `γ` to `α`, if the function `f` is directed with respect to `r`, then for any finite set `s` of elements from `γ`, there exists an element `z` such that for all elements `i` in the set `s`, `r (f i) (f z)` holds, meaning `f z` is `r`-above every element `f i` where `i` is in the set `s`. This essentially says that in a directed family over a finite set, there exists an element that is above all elements in the relation `r`.

Given a type `α` with a transitive relation `r`, a nonempty type `γ` and a function `f` mapping `γ` to `α` that is directed with respect to `r`, for any finite set `s` of elements from `γ`, there exists an element `z` in `γ` such that `r (f i) (f z)` holds for all `i` in `s`.


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

This theorem states that for any types `R` and `S` that are both instances of a semiring, and for any injective ring homomorphism `f` from `R` to `S`, the natural degree of the polynomial obtained by mapping a polynomial `p` over `R` with `f` is equal to the natural degree of the original polynomial `p`. In mathematical terms, if `f : R → S` is an injective ring homomorphism and `p` is a polynomial over `R`, then the degree of the polynomial `f(p)` in `S` is the same as the degree of `p` in `R`.

For any injective ring homomorphism between semirings `f : R → S` and polynomial `p` over `R`, the degree of `f(p)` over `S` equals the degree of `p` over `R`.


theorem SetTheory.PGame.lf_of_le_moveLeft :
    ∀ {x y : SetTheory.PGame} {i : SetTheory.PGame.LeftMoves y},
      x ≤ SetTheory.PGame.moveLeft y i → SetTheory.PGame.LF x y :=
  by sorry

This theorem establishes a property of pre-games in set theory. Specifically, it states that for all pre-games `x` and `y`, and for any allowed move `i` by the 'Left' player in the game `y`, if `x` is less than or equal to the game resulting after the 'Left' player makes move `i` in `y`, then `x` is in a less or fuzzy relation with `y`. In other words, if the 'Left' player can transition the game `y` to a state `x` or better (from their perspective), then the 'Left' player has a winning strategy for the game `y`.

For all pre-games x and y, and allowed move i for the 'Left' player in y, if x ≤ y[i] then x ⪯ y. (Here, ≤ denotes the preorder relation in the set of pre-games, and ⪯ denotes the reflexive and transitive closure of the relation that holds between two pre-games x and y if there exists a winning strategy for player 'Left' in the game y starting from initial state x.)


theorem Finset.filter_product :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (p : α → Prop) (q : β → Prop) [inst : DecidablePred p]
      [inst_1 : DecidablePred q],
      Finset.filter (fun x => p x.1 ∧ q x.2) (s ×ˢ t) = Finset.filter p s ×ˢ Finset.filter q t :=
  by sorry

The theorem `Finset.filter_product` states that for every pair of finite sets `s` and `t` over arbitrary types `α` and `β` respectively, and for any pair of decidable predicates `p` on `α` and `q` on `β`, filtering the Cartesian product `s ×ˢ t` by the conjunction of `p` and `q` (i.e., selecting those pairs `(x, y)` for which `p(x)` and `q(y)` both hold) is equivalent to forming the Cartesian product of `s` filtered by `p` and `t` filtered by `q`. In other words, it asserts that the filtering operation distributes over the Cartesian product of finite sets.

For finite sets $s$ and $t$ over types $\alpha$ and $\beta$ respectively, and decidable predicates $p$ on $\alpha$ and $q$ on $\beta$, the sets of pairs $(x, y)$ in $s \times t$ satisfying $p(x) \land q(y)$ and $(x, y) \in (s \times p) \times (t \times q)$ are equal.


theorem Set.toFinset_inj :
    ∀ {α : Type u_1} {s t : Set α} [inst : Fintype ↑s] [inst_1 : Fintype ↑t], Set.toFinset s = Set.toFinset t ↔ s = t :=
  by sorry

This theorem, `Set.toFinset_inj`, states that for any two sets `s` and `t` of some type `α`, with both sets having `Fintype` instances, the function `Set.toFinset` returns the same `Finset` for `s` and `t` if and only if `s` and `t` are the same set. This theorem essentially asserts the injectivity of the `Set.toFinset` function — it maps distinct sets to distinct finite sets.

For sets `s` and `t` of type `α` with `Fintype` instances, `Set.toFinset s = Set.toFinset t` if and only if `s = t`.


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.24 :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β), Set.BijOn f ∅ ∅ = True := by sorry

This theorem states that for all types `α` and `β`, and for any function `f` from `α` to `β`, the function `f` is bijective on the empty set to the empty set. In other words, for any function `f`, it is true that `f` maps every element of the empty set to a unique element of the empty set (which is vacuously true, as the empty set has no elements), `f` is injective on the empty set (meaning that distinct elements of the empty set map to distinct elements in the image, again vacuously true), and `f` is surjective on the empty set (meaning that every element of the empty set is the image of an element of the empty set under `f`, also vacuously true).

The empty function is bijective between any two empty sets.


/-- **Shrinking lemma**. A point-finite open cover of a closed subset of a normal space can be
"shrunk" to a new closed cover so that each new closed set is contained in the corresponding
original open set. See also `exists_subset_iUnion_closure_subset` for a stronger statement.  -/
theorem exists_subset_iUnion_closed_subset :
    ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : NormalSpace X] {u : ι → Set X} {s : Set X},
      IsClosed s →
        (∀ (i : ι), IsOpen (u i)) →
          (∀ x ∈ s, Set.Finite {i | x ∈ u i}) →
            s ⊆ ⋃ i, u i → ∃ v, s ⊆ Set.iUnion v ∧ (∀ (i : ι), IsClosed (v i)) ∧ ∀ (i : ι), v i ⊆ u i :=
  by sorry

The **Shrinking Lemma** states that given a normal topological space `X`, an indexed collection `u` of open sets in `X`, and a closed set `s` in `X`, if every point in `s` is contained in a finite number of sets from the collection `u` (making `u` a point-finite open cover of `s`), and `s` is a subset of the union of the sets in `u`, then there exists a new indexed collection `v` of sets such that: `s` is a subset of the union of the sets in `v`; each set in `v` is closed; and each set in `v` is a subset of the corresponding set in `u`. This means we can "shrink" the open cover `u` to a closed cover `v` such that each new closed set is contained in the corresponding original open set.

Given a normal topological space, a point-finite open cover, and a closed subset lying in the cover's union, there exists a closed subcover with the same union.


theorem Mathlib.GroupTheory.Perm.Cycle.Basic._auxLemma.28 :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x : α}, Equiv.Perm.SameCycle f x x = True := by sorry

This theorem states that for any type `α`, any permutation `f` of `α`, and any element `x` of `α`, it is always true that `x` is in the same cycle as itself under the permutation `f`. In other words, in the context of group theory, this theorem is saying that an element of a set will always belong to its own cycle when a permutation is applied. The cycle of an element under a permutation is a sequence of elements obtained by iteratively applying the permutation to the element.

For any type `α`, any permutation `f` of `α`, and any element `x` of `α`, `x` and `f^n(x)` belong to the same cycle for some natural number `n`.


theorem AddCommute.nsmul_nsmul :
    ∀ {M : Type u_2} [inst : AddMonoid M] {a b : M}, AddCommute a b → ∀ (m n : ℕ), AddCommute (m • a) (n • b) := by
  sorry

This theorem states that for any given type `M` which is an additive monoid, if two elements `a` and `b` of `M` commute additively (i.e., `a + b = b + a`), then for any two natural numbers `m` and `n`, the `m`-fold repeated addition of `a` (denoted `m • a`) and the `n`-fold repeated addition of `b` (denoted `n • b`) also commute additively. In other words, if `a` and `b` commute, then `m • a + n • b = n • b + m • a` holds true for all natural numbers `m` and `n`. Here, `•` denotes the nsmul operation in Lean, which is equivalent to repeated addition.

If `a` and `b` are commuting elements of an additive monoid `M`, then for all natural numbers `m` and `n`, `m • a + n • b = n • b + m • a`.


theorem lowerBounds_empty : ∀ {α : Type u} [inst : Preorder α], lowerBounds ∅ = Set.univ := by sorry

This theorem states that for any type `α` with a preorder (a binary relation that is reflexive and transitive), the set of lower bounds of the empty set is the universal set. In other words, every element of `α` is a lower bound of the empty set. This arises from the vacuous truth property in logic: an implication is always true if its premise is false, and since there are no elements in the empty set, any statement about "all" elements in it is true.

For any type `α` with a preorder, every element of `α` is a lower bound of the empty set.


theorem ManyOneDegree.add_le : ∀ {d₁ d₂ d₃ : ManyOneDegree}, d₁ + d₂ ≤ d₃ ↔ d₁ ≤ d₃ ∧ d₂ ≤ d₃ := by sorry

This theorem states that for any three many-one degrees `d₁`, `d₂`, and `d₃`, the many-one degree of the sum `d₁ + d₂` is less than or equal to `d₃` if and only if both `d₁` and `d₂` are individually less than or equal to `d₃`. Here, the sum and inequalities are in the context of many-one degrees, which are equivalence classes of sets connected by a many-one equivalence relation.

For any many-one degrees d₁, d₂, and d₃, d₁ + d₂ ≤ d₃ if and only if d₁ ≤ d₃ and d₂ ≤ d₃. (In the context of many-one degrees, "+", and "<=" denote the sum and inequality relations, respectively.)


/-- The intersection of the subspace and the orthogonal subspace
through the given point is the `orthogonalProjectionFn` of that
point onto the subspace. This lemma is only intended for use in
setting up the bundled version and should not be used once that is
defined.  -/
theorem EuclideanGeometry.inter_eq_singleton_orthogonalProjectionFn :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {s : AffineSubspace ℝ P} [inst_4 : Nonempty ↥s]
      [inst_5 : HasOrthogonalProjection (AffineSubspace.direction s)] (p : P),
      ↑s ∩ ↑(AffineSubspace.mk' p (AffineSubspace.direction s)ᗮ) = {EuclideanGeometry.orthogonalProjectionFn s p} :=
  by sorry

This theorem in Euclidean geometry states that for any point `p` in a metric space `P` equipped with an inner product space `V`, the intersection of an affine subspace `s` and the orthogonal subspace through the point `p` is a singleton set containing only the orthogonal projection of the point `p` onto the subspace `s`. This is true when the space `V` is a normed add-commutative group, `P` is a metric space, and `s` is a nonempty affine subspace of `P` that has an orthogonal projection onto `s`. The theorem is primarily used in setting up the bundled version and should not be used once that is defined.

Given a metric space `P` with an inner product space `V`, any point `p` in a nonempty affine subspace `s` of `P` has a unique point of intersection with the orthogonal subspace of `s` passing through `p`, which is the orthogonal projection of `p` onto `s`.


theorem MeasureTheory.OuterMeasure.biUnion_null_iff :
    ∀ {α : Type u_1} {β : Type u_2} (m : MeasureTheory.OuterMeasure α) {s : Set β},
      Set.Countable s → ∀ {t : β → Set α}, ↑m (⋃ i ∈ s, t i) = 0 ↔ ∀ i ∈ s, ↑m (t i) = 0 :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.biUnion_null_iff` states that for any two types `α` and `β`, a given outer measure `m` on `α`, and a countable set `s` of objects of type `β`, the outer measure of the union of a family of sets `t i` (for each `i` in `s`) is zero if and only if the outer measure of each individual set `t i` is zero. In simpler terms, it states that for a countable collection of sets, the total measure is zero if and only if each individual set has measure zero.

For any outer measure `m` and a countable family of sets `(t\_i : β → Set α)_i`, the outer measure of their union is zero if and only if the outer measure of each `t\_i` is zero.


/-- For a quasi ergodic map, sets that are almost invariant (rather than strictly invariant) are
still either almost empty or full.  -/
theorem QuasiErgodic.ae_empty_or_univ' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {s : Set α} {μ : MeasureTheory.Measure α},
      QuasiErgodic f μ →
        MeasurableSet s →
          f ⁻¹' s =ᶠ[MeasureTheory.Measure.ae μ] s →
            s =ᶠ[MeasureTheory.Measure.ae μ] ∅ ∨ s =ᶠ[MeasureTheory.Measure.ae μ] Set.univ :=
  by sorry

This theorem is stating that for a quasi ergodic map, any set that is almost invariant (meaning the preimage of the set under the map is almost equal to the set itself) is either almost empty or is almost equal to the universal set. Here, "almost" is in the sense of the filter of co-null sets, or sets of measure zero. This applies to any measurable set in a measurable space, and the map and the measure are both specified as parameters.

For any quasi-ergodic map and measurable set in a measurable space, if the set is almost invariant with respect to the map under the measure of co-null sets, then the set is either almost empty or almost equal to the universal set.


theorem HomologicalComplex.exactAt_single_obj :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      (j : ι) (A : C) (i : ι), i ≠ j → HomologicalComplex.ExactAt ((HomologicalComplex.single C c j).obj A) i :=
  by sorry

The theorem `HomologicalComplex.exactAt_single_obj` states that for any category `C` that has zero morphisms and a zero object, and any complex shape `c` indexed by a type `ι` with decidable equality, if `i` and `j` are indices such that `i` is not equal to `j`, and `A` is an object of `C`, then the homological complex created by taking the single object indexed by `j` from `C` and applying it to `A` is exact at `i`. This means that in the short complex formed from this homological complex at `i`, the image of the morphism from the `i-1`th object to the `i`th object is equal to the kernel of the morphism from the `i`th object to the `i+1`th object, according to the definition of exactness in category theory.

For any category with zero morphisms and a zero object, and any complex over a decidably equated type index, the homological complex formed by a single object application is exact at indices not equal to that object's index.


theorem iInf_true : ∀ {α : Type u_1} [inst : CompleteLattice α] {s : True → α}, iInf s = s trivial := by sorry

The theorem `iInf_true` states that for any type `α` that forms a complete lattice, and for any function `s` from the type `True` (containing a single element) to `α`, the indexed infimum (`iInf`) of `s` is equal to `s` applied to `trivial`. Here, `trivial` is a term of type `True`, essentially the single value that the `True` type contains. Essentially, it says that if we take the least element over all elements returned by `s` for every possible input (in this case there's only one, `trivial`), we just get `s trivial`.

For any complete lattice `α` and function `s : True → α`, the indexed infimum `iInf (s : α)` equals `s trivial`.


Set.MapsTo.congr

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

This theorem states that for any two types `α` and `β`, any set `s` of type `α`, any set `t` of type `β`, and any two functions `f₁` and `f₂` from `α` to `β`, if `f₁` maps all elements of set `s` into set `t` (`Set.MapsTo f₁ s t`), and `f₁` and `f₂` are equal on all elements within set `s` (`Set.EqOn f₁ f₂ s`), then `f₂` also maps all elements of set `s` into set `t` (`Set.MapsTo f₂ s t`). In other words, if two functions agree over a set, and one function maps that set into another set, then the other function does the same.

If two functions agree on a set and map that set into another set, then they have the same image under that set.


theorem Irrational.ne_nat : ∀ {x : ℝ}, Irrational x → ∀ (m : ℕ), x ≠ ↑m := by sorry

The theorem `Irrational.ne_nat` states that for all real numbers `x`, if `x` is irrational (i.e., it is not equal to any rational number), then `x` is not equal to the cast of any natural number `m`. In other words, an irrational real number cannot be equal to any natural number.

An irrational real number does not equal any natural number.


theorem Asymptotics.isBigO_abs_right :
    ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
      (f =O[l] fun x => |u x|) ↔ f =O[l] u :=
  by sorry

This theorem, `Asymptotics.isBigO_abs_right`, states that for any types α and E, with E being a normed space, and any functions `f : α → E` and `u : α → ℝ`, and a filter `l` on α, `f` is Big O of the absolute value function of `u` with respect to the filter `l` if and only if `f` is Big O of `u` with respect to the same filter. In simpler terms, it means that the big O notation is not affected by taking the absolute value of the second function.

For functions `f : α → E` and `u : α → ℝ` on type `α` with `E` a normed space, and filter `l` on `α`, `f` is Big O of the absolute value of `u` with respect to `l` if and only if `f` is Big O of `u` with respect to `l`.


theorem Finset.image_zero :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : DecidableEq β] {f : α → β}, Finset.image f 0 = {f 0} := by
  sorry

This theorem states that, for any types `α` and `β`, if `α` has a zero element and `β` has decidable equality, then the image of the zero element under any function `f` from `α` to `β` is a finite set containing only the image of the zero element. In other words, if we apply `f` to the zero element of `α` and consider it as a finite set, we get a singleton set consisting of `f(0)`.

Given types `α` with a zero element and decidable equality `β`, for any function `f` from `α` to `β`, the image of the zero element under `f` is a singleton set containing `f(0)`.


theorem Ordinal.apply_lt_nfpFamily_iff :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} [inst : Nonempty ι],
      (∀ (i : ι), Ordinal.IsNormal (f i)) →
        ∀ {a b : Ordinal.{max u v}}, (∀ (i : ι), f i b < Ordinal.nfpFamily f a) ↔ b < Ordinal.nfpFamily f a :=
  by sorry

The theorem `Ordinal.apply_lt_nfpFamily_iff` states that for any type `ι`, any function `f` from `ι` to the set of ordinals, and any two ordinals `a` and `b`, as long as `ι` is nonempty and every function `f i` is a normal ordinal function, then for all `i` in `ι`, `f i b` is less than the next common fixed point at least `a` for the family of functions if and only if `b` is less than the next common fixed point at least `a` for the family of functions. In other words, the property of `b` being less than the next common fixed point is equivalent to the property of the image of `b` under all the functions being less than this next common fixed point.

For any nonempty type `ι` and normal ordinal function `f` from `ι` to ordinals, `b` is less than the next common fixed point at least `a` for `f` if and only if `f i b` is less than the next common fixed point for all `i` in `ι`.


theorem MeasureTheory.L1.SimpleFunc.setToL1S_add :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      (T : Set α → E →L[ℝ] F),
      (∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0) →
        MeasureTheory.FinMeasAdditive μ T →
          ∀ (f g : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
            MeasureTheory.L1.SimpleFunc.setToL1S T (f + g) =
              MeasureTheory.L1.SimpleFunc.setToL1S T f + MeasureTheory.L1.SimpleFunc.setToL1S T g :=
  by sorry

The theorem `MeasureTheory.L1.SimpleFunc.setToL1S_add` states that for a given measure space `α`, types `E` and `F` equipped with normed add commutative group structures, and also where `E` is a real normed space and `F` is a normed space over the real numbers, if we have a function `T` that maps sets of `α` to continuous linear maps from `E` to `F`, and if `T` has the property that it maps any measurable set with measure zero to the zero function, and `T` is `FinMeasAdditive` (i.e., for any two disjoint measurable sets of finite measure, the value of `T` on their union is the sum of its values on each set), then for any two functions `f` and `g` in the subspace of Lp (with p = 1) consisting of equivalence classes of an integrable simple function, the value of the extension of `T` to this subspace at the sum of `f` and `g` is equal to the sum of its values at `f` and `g` separately. This is essentially saying that the extension of `T` to this specific subspace is linear.

For a measurable function T from measurable sets of a measure space to continuous linear maps between real normed spaces, satisfying the property of mapping measure zero sets to zero functions and being additive on disjoint sets of finite measure, the extended T is a linear operator on the subspace of L1 functions consisting of equivalence classes of integrable simple functions.


/-- **Alias** of the reverse direction of `PartialHomeomorph.IsImage.iff_preimage_eq`. -/
theorem PartialHomeomorph.IsImage.of_preimage_eq :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      e.source ∩ ↑e ⁻¹' t = e.source ∩ s → PartialHomeomorph.IsImage e s t :=
  by sorry

This theorem, which is an alias of the reverse direction of `PartialHomeomorph.IsImage.iff_preimage_eq`, states that for any types `X` and `Y` with an associated topological space, for any partial homeomorphism `e` from `X` to `Y`, and for any sets `s` of `X` and `t` of `Y`, if the intersection of the source of `e` and the preimage of `t` under `e` equals the intersection of the source of `e` and `s`, then `t` is an image of `s` under the partial homeomorphism `e`. In other words, given specific conditions on the source of the homeomorphism and the sets, we can conclude that the set `t` can be obtained by mapping the set `s` under the homeomorphism `e`.

If the source of a partial homeomorphism from X to Y and the preimage of a set t under this homeomorphism intersect equally with a given set s from the source, then t is the image of s under the homeomorphism.


theorem CategoryTheory.NatTrans.leftDerived_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1}
      [inst_1 : CategoryTheory.Category.{u_2, u_1} D] [inst_2 : CategoryTheory.Abelian C]
      [inst_3 : CategoryTheory.HasProjectiveResolutions C] [inst_4 : CategoryTheory.Abelian D]
      (F : CategoryTheory.Functor C D) [inst_5 : CategoryTheory.Functor.Additive F] (n : ℕ),
      CategoryTheory.NatTrans.leftDerived (CategoryTheory.CategoryStruct.id F) n =
        CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.leftDerived F n) :=
  by sorry

This theorem, `CategoryTheory.NatTrans.leftDerived_id`, states that for any category `C` with instances `inst`, `inst_2`, and `inst_3` (which indicate that `C` is a category, an Abelian category, and has projective resolutions), and another category `D` with instances `inst_1` and `inst_4` (which indicate that `D` is a category and an Abelian category), given a functor `F` from `C` to `D` that is additive (as indicated by `inst_5`), for any natural number `n`, the `n`th left derived natural transformation of the identity morphism on `F` is equal to the identity morphism on the `n`th left derived functor of `F`. In other words, the theorem is about the naturality of the process of taking left derived functors in the context of Abelian categories.

For any additive functor F between Abelian categories C and D, the n-th left derived natural transformation of the identity morphism on F is equal to the identity morphism on the n-th left derived functor of F.


theorem Set.iUnion_of_singleton : ∀ (α : Type u_11), ⋃ x, {x} = Set.univ := by sorry

This theorem, named `Set.iUnion_of_singleton`, states that for any type `α`, the union over all elements `x` of the set containing only `x` is equal to the universal set of `α`. In other words, if we take every single-element set `{x}` for all `x` in `α` and unite them all together, we'll have covered the entire set of `α`. This is essentially saying that every element in the universal set `α` can be singled out into its own set, and combining these singleton sets will recover the original universal set.

For any type `α`, the union of all singleton sets in `α` equals `α`.


/-- An object is initial if and only if its fiber is empty.  -/
theorem CategoryTheory.PreGaloisCategory.initial_iff_fiber_empty :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.PreGaloisCategory C]
      (F : CategoryTheory.Functor C FintypeCat) [inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C),
      Nonempty (CategoryTheory.Limits.IsInitial X) ↔ IsEmpty ↑(F.obj X) :=
  by sorry

The theorem `CategoryTheory.PreGaloisCategory.initial_iff_fiber_empty` states that for any category `C` equipped with a structure of a PreGalois category and any functor `F` from `C` to the category of finite types `FintypeCat`, an object `X` in `C` is initial if and only if the fiber of `X` under the functor `F` is empty. The fiber of an object under a functor is the inverse image of the object under the functor, and here we use the type `IsEmpty` to represent the empty type, so `IsEmpty ↑(F.obj X)` means the fiber of `X` under `F` is empty. Here, initial objects are characterized specifically via the property of having a colimiting cocone induced on the empty diagram.

In a PreGalois category equipped with a functor to the category of finite types, an object is initial if and only if its fiber under the functor is empty.


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

This theorem states that for any two real numbers `r` and `s`, the difference of their complex equivalents (denoted by `↑r` and `↑s`) is equal to the complex equivalent of their real difference (`r - s`). In mathematical terms, it asserts that for all real numbers r and s, (r - s) as a complex number is the same as the complex number r minus the complex number s.

For all real numbers r and s, the complex numbers representing their real differences are equal: (r - s) = ↑r - ↑s.


theorem continuous_iff_ultrafilter :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      Continuous f ↔ ∀ (x : X) (g : Ultrafilter X), ↑g ≤ nhds x → Filter.Tendsto f (↑g) (nhds (f x)) :=
  by sorry

This theorem, named `continuous_iff_ultrafilter`, states that a function `f` between two topological spaces `X` and `Y` is continuous if and only if for every element `x` in `X` and any ultrafilter `g` on `X` such that `g` is included in the neighborhood of `x`, the image of `g` under `f` converges to the image of `x` under `f`. In other words, the function `f` preserves the convergence of ultrafilters.

A function between topological spaces is continuous if and only if it preserves the convergence of ultrafilters, that is, for every ultrafilter on the domain and every point in its base, the image of the ultrafilter converges to the image of that point under the function.


theorem Filter.IsBoundedUnder.bddAbove_range :
    ∀ {β : Type u_2} [inst : Preorder β] [inst_1 : IsDirected β fun x x_1 => x ≤ x_1] {f : ℕ → β},
      Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) Filter.atTop f → BddAbove (Set.range f) :=
  by sorry

This theorem states that for a type `β` that is preordered and is directed (i.e., for any two elements `x` and `x_1` there exists a third element that is greater than or equal to both `x` and `x_1`), if a function `f : ℕ → β` is such that the image of the filter `atTop` (which represents the limit tending to infinity) under `f` is eventually bounded under the relation `≤` (i.e., there exists a uniform bound that all elements in the image of `f` do not exceed after some point), then the range of `f` is bounded above, meaning there exists an upper bound for the set of all values that `f` can take.

If `β` is a preordered and directed type, and `f : ℕ → β` is a function such that the image of the filter at infinity under `f` is eventually bounded, then `f` has an upper bound.


theorem LinearOrderedField.inducedMap_rat :
    ∀ (α : Type u_2) (β : Type u_3) [inst : LinearOrderedField α] [inst_1 : ConditionallyCompleteLinearOrderedField β]
      [inst_2 : Archimedean α] (q : ℚ), LinearOrderedField.inducedMap α β ↑q = ↑q :=
  by sorry

The theorem `LinearOrderedField.inducedMap_rat` states that for all types `α` and `β` where `α` is a linear ordered field, `β` is a conditionally complete linear ordered field, and `α` is Archimedean, the result of applying the induced map function from the linear ordered field to the conditionally complete linear ordered field on a rational number `q` is the same as the original rational number `q`. More formally, for every rational number `q`, the supremum in `β` of all the elements of `α` less than `q` is equivalent to `q`.

For every Archimedean linear ordered field `α` and conditionally complete linear ordered field `β`, the induced map from `α` to `β` maps every rational number `q` to the supremum of all elements in `α` less than `q`.


theorem MonotoneOn.mapsTo_Icc :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β] {a b : α},
      MonotoneOn f (Set.Icc a b) → Set.MapsTo f (Set.Icc a b) (Set.Icc (f a) (f b)) :=
  by sorry

This theorem states that for any function `f` from a type `α` to a type `β`, where `α` and `β` have a predefined order, and for any `a` and `b` of type `α`, if the function `f` is monotone on the closed interval `[a, b]`, then the image of the interval `[a, b]` under the function `f` is contained within the closed interval `[f(a), f(b)]`. In other words, a monotone function maps any closed interval, in its original space, to a closed interval in its target space.

If `f` is a monotone function from a type `α` to a type `β` with predefined order, then `[f(a), f(b)]` contains the image `{f(x) | x ∈ [a, b]}` of the closed interval `[a, b]` under `f`.


IsGLB.bddBelow

/-- If `s` has a greatest lower bound, then it is bounded below.  -/
theorem IsGLB.bddBelow : ∀ {α : Type u} [inst : Preorder α] {s : Set α} {a : α}, IsGLB s a → BddBelow s := by sorry

The theorem `IsGLB.bddBelow` states that for any type `α` that has a preorder relation, if a set `s` of type `α` has a greatest lower bound `a`, then the set `s` is bounded below. In other words, if there exists an element `a` in the set `s` such that no other element in `s` is lower than `a`, then there exists at least one element in `s` that acts as a lower bound.

If a preordered set `α` with greatest lower bound `a` in `s ⊆ α` exists, then `s` is non-empty and has a lower bound.


theorem BinaryHeap.size_pos_of_max :
    ∀ {α : Type u_1} {x : α} {lt : α → α → Bool} {self : BinaryHeap α lt},
      BinaryHeap.max self = some x → 0 < BinaryHeap.size self :=
  by sorry

This theorem states that for any type `α`, any element `x` of type `α`, a binary heap `self` of type `α` and a binary relation `lt` of type `α → α → Bool`, if the maximum element of the binary heap `self` is `x` (i.e., `BinaryHeap.max self` equals `some x`), then the size of the binary heap `self` must be greater than zero. That is, the heap is non-empty.

If `self` is a binary heap of type `α` with maximum element `x` of type `α`, then `#self > 0`. (Here, `#self` represents the size of the binary heap.)


theorem Set.surjective_mapsTo_image_restrict :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Function.Surjective (Set.MapsTo.restrict f s (f '' s) ⋯) :=
  by sorry

The theorem `Set.surjective_mapsTo_image_restrict` states that for any given function `f` from type `α` to type `β` and a set `s` of type `α`, the function obtained by restricting the domain of `f` to `s` and the codomain to the image of `s` under `f` (i.e., `Set.MapsTo.restrict f s (f '' s)`) is surjective. In other words, for any element in the image of `s` under `f`, there exists an element in `s` such that applying the restricted function to this element yields the given element in the image.

For any function `f` from type `α` to type `β` and set `s` of type `α`, the restriction of `f` to `s` and its image under `f` is a surjective function.


theorem CategoryTheory.ihom.coev_ev :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A B : C)
      [inst_2 : CategoryTheory.Closed A],
      CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.coev A).app ((CategoryTheory.ihom A).obj B))
          ((CategoryTheory.ihom A).map ((CategoryTheory.ihom.ev A).app B)) =
        CategoryTheory.CategoryStruct.id ((CategoryTheory.ihom A).obj B) :=
  by sorry

The theorem `CategoryTheory.ihom.coev_ev` states that for any type C, in the context of a category structure and a monoidal category, and for any two objects A and B in C such that A is a closed object, the composition of the application of the coevaluation natural transformation on the object B transformed by the internal hom functor with the map of the application of the evaluation natural transformation on B through the internal hom functor, equals the identity morphism on the object B transformed by the internal hom functor. This is a property of internal hom functors in a monoidal category with a specified closed object.

For any object B in a monoidal category with a closed object A, the composition of the coevaluation and evaluation morphisms through the internal hom functor equals the identity morphism on B.