theorem AddAction.mem_fixedBy :
    ∀ {M : Type u} [inst : AddMonoid M] {α : Type v} [inst_1 : AddAction M α] {m : M} {a : α},
      a ∈ AddAction.fixedBy α m ↔ m +ᵥ a = a :=
  by sorry

The theorem `AddAction.mem_fixedBy` states that, for any additive monoid `M`, any type `α` with an additive action of `M`, any element `m` of `M`, and any element `a` of `α`, the element `a` is in the set of elements fixed by `m` (denoted as `AddAction.fixedBy α m`) if and only if the result of the additive action of `m` on `a` (denoted as `m +ᵥ a`) is equal to `a`. In other words, `a` is deemed "fixed" by `m` exactly when `m` acting on `a` leaves `a` unchanged.

For any additive monoid M, any type α with an additive action of M, and any m in M and a in α, a is in the fixed set of m if and only if m + a = a.


theorem Multiset.toFinset_nsmul :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α) (n : ℕ),
      n ≠ 0 → Multiset.toFinset (n • s) = Multiset.toFinset s :=
  by sorry

The theorem `Multiset.toFinset_nsmul` states that for any type `α` with decidable equality, for any multiset `s` of type `α`, and for any natural number `n` that is not zero, the finset obtained by removing duplicates from the multiset resulting from `n` times scalar multiplication of `s` is equal to the finset obtained by removing duplicates from `s` itself. In other words, multiple scalar multiplication of a multiset does not change the set of unique elements in the multiset.

For any type `α` with decidable equality and any multiset `s` of type `α`, the finset obtained from `n` times scalar multiplication of `s` (without duplicates) is equal to the finset `s` itself (without duplicates), for any non-zero natural number `n`.


Cardinal.eq

theorem Cardinal.eq : ∀ {α β : Type u}, Cardinal.mk α = Cardinal.mk β ↔ Nonempty (α ≃ β) := by sorry

This theorem states that for any two types `α` and `β`, the cardinality of `α` is equal to the cardinality of `β` if and only if there exists a bijection between `α` and `β`. In other words, there's a one-to-one correspondence between the elements of `α` and `β`.

For types `α` and `β`, their cardinalities are equal if and only if there exists a bijection between them.


theorem Finset.nonempty_of_ne_empty : ∀ {α : Type u_1} {s : Finset α}, s ≠ ∅ → s.Nonempty := by sorry

This theorem states that for any type `α` and any finite set `s` of type `α`, if `s` is not equal to the empty set, then `s` is nonempty. In other words, it establishes that if a finite set is not equal to the empty set, it must contain at least one element.

For any finite non-empty set `s` of type `α`, it holds that `s` is nonempty.


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

The theorem `AddAction.period_eq_minimalPeriod` states that for any type `α`, any type `M` that forms an additive monoid, any additive action of `M` on `α`, and any elements `m` of type `M` and `a` of type `α`, the period of the additive action of `m` on `a` is exactly the same as the minimal period of `a` under the endomorphism defined by adding `m` to every element of `α`. The period of an additive action of `m` on `a` is the smallest positive natural number `n` for which `n*m + a = a`, or `0` if no such `n` exists, while the minimal period of `a` under an endomorphism is the smallest number of applications of the endomorphism required to return `a` to its original value, or `0` if `a` is not a periodic point of the endomorphism.

The period of an additive action of an element on a type equals the minimal period of the type under the corresponding endomorphism.


Finpartition.disjoint

theorem Finpartition.disjoint :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a),
      Set.PairwiseDisjoint (↑P.parts) id :=
  by sorry

This theorem states that for any type `α` with a lattice structure and a least element, and given any `α`-element `a`, if `P` is a finite partition of `a` then the parts of `P` (obtained by coercing `P.parts` to a set) are pairwise disjoint under the identity function. In other words, for any distinct parts `p1` and `p2` of the partition `P`, their images under the identity function (which are just `p1` and `p2` themselves) are disjoint. This reflects the definition of a partition, where each part is disjoint from the others.

Given a lattice `α` with a least element and a finite partition `P` of an `α`-element `a`, the parts of `P` are pairwise disjoint.


theorem isCompact_iff_totallyBounded_isComplete :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {s : Set α}, IsCompact s ↔ TotallyBounded s ∧ IsComplete s := by
  sorry

This theorem states that for any set `s` in a uniform space `α`, the set is compact if and only if it is both totally bounded and complete. In other words, a set is compact when, given any nontrivial filter that contains the set, there exists an element within the set such that every set of the filter meets every neighborhood of this element, and this is equivalent to the set being totally bounded, where for every entourage there exists a finite set of points such that every element of the original set is near to some element of the finite set, and complete, where any Cauchy filter that includes the set has a limit in the set.

A set in a uniform space is compact if and only if it is both totally bounded and complete.


theorem CategoryTheory.ShortComplex.toCycles_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.toCycles S)
          (CategoryTheory.ShortComplex.iCycles S) =
        S.f :=
  by sorry

The theorem `CategoryTheory.ShortComplex.toCycles_i` states that, for any category 'C' with zero morphisms and a short complex 'S' with left homology, the composition of the morphism 'toCycles' of 'S' and the inclusion of the cycles of 'S' into 'S.X₂', denoted by 'iCycles', is equal to the morphism 'f' of the short complex 'S'. In other words, in the category-theoretic context, it asserts that certain morphisms in a short complex form a commutative diagram.

For any short complex in a category with zero morphisms and left homology, the morphism 'toCycles' composing with the inclusion of cycles equals the morphism 'f' in the complex.


theorem Finset.mem_sym_iff :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {n : ℕ} {m : Sym α n}, m ∈ Finset.sym s n ↔ ∀ a ∈ m, a ∈ s :=
  by sorry

The theorem `Finset.mem_sym_iff` states that for any given type `α` equipped with decidable equality, a `Finset` `s` of type `α`, a natural number `n`, and a symmetric power `m` of type `Sym α n`, `m` is an element of the symmetric power `Finset.sym s n` if and only if every element `a` in `m` is also an element of `s`. In other words, an unordered tuple `m` is in the `n`-th symmetric power of the set `s` if and only if all of its elements are in `s`.

For any type `α` with decidable equality, a finite set `s` of `α`, and a natural number `n`, the element `m` is in the `n`-th symmetric power of `Finset.sym s` if and only if all elements in `m` are in `s`.


theorem add_mem_cancel_left :
    ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_6} {H : S} [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G]
      {x y : G}, x ∈ H → (x + y ∈ H ↔ y ∈ H) :=
  by sorry

This theorem states that for any given type `G` with an addition group structure, a type `S`, an instance `H` of `S`, and two elements `x` and `y` of `G`, if `x` is in `H` (where `H` is treated as a set of elements of type `G` by the `SetLike S G` instance), then `y` is in `H` if and only if the sum of `x` and `y` is in `H`. Note that `H` is assumed to be an additive subgroup of `G` due to the `AddSubgroupClass S G` instance.

For any additive subgroup `H` of a group `G`, if `x` is an element of `H` and `x + y` is an element of `G`, then `y` is an element of `H`.


theorem inv_le_inv_of_le : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < a → a ≤ b → b⁻¹ ≤ a⁻¹ := by
  sorry

This theorem states that in a linear ordered semifield, given two elements `a` and `b`, if `a` is positive and `a` is less than or equal to `b`, then inverse of `b` is less than or equal to the inverse of `a`. In other words, it is a statement about the "reversal" of order when taking inverses in such a structure. The order of elements is inverted when taking the inverse in positive realm of a linear ordered semifield.

In a linear ordered semifield, if `a` is positive and `a` < `b`, then `b^(-1)` < `a^(-1)`.


theorem not_lt_of_gt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, a > b → ¬a < b := by sorry

This theorem states that for all types `α` that possess a linear order, if a specific element `a` of this type is greater than another element `b`, then `a` cannot be less than `b`. In other words, in any ordered set, if one element is strictly greater than another, it cannot also be less than that other element. This is a formalization of a fundamental property of ordered sets.

In any ordered set, for all elements `a` and `b`, if `a` is strictly greater than `b` (`a > b`), then it is not the case that `b` is strictly greater than `a` (`b > a`).


theorem sdiff_compl : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], x \ yᶜ = x ⊓ y := by sorry

This theorem states that for any type `α` that forms a Boolean algebra, and for any elements `x` and `y` of type `α`, the set difference of `x` and the complement of `y` (`x \ yᶜ`) is equal to the intersection of `x` and `y` (`x ⊓ y`). This is a property of Boolean algebra structures, which include sets and certain types of logic systems.

In a Boolean algebra, for all elements x and y, x intersect y is equal to x minus the complement of y.


theorem one_div_nonneg : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 ≤ 1 / a ↔ 0 ≤ a := by sorry

This theorem states that for any type `α` that forms a linearly ordered semiring (a structure with both addition and multiplication that behaves like the real numbers in some sense), if `a` is an element of `α`, then `1 / a` is non-negative if and only if `a` itself is non-negative. Here, non-negativity means the value is either greater than or equal to zero.

For any linearly ordered semiring type `α`, element `a` belongs to `α` is non-negative if and only if its multiplicative inverse `1 / a` is non-negative.


theorem Equiv.Perm.sameCycle_zpow_left :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ},
      Equiv.Perm.SameCycle f ((f ^ n) x) y ↔ Equiv.Perm.SameCycle f x y :=
  by sorry

The theorem `Equiv.Perm.sameCycle_zpow_left` states that for any given permutation `f` of a type `α`, and any two elements `x` and `y` of type `α`, as well as an integer `n`, the statement that `y` is in the same cycle of the permutation `f` as `f^n(x)` is equivalent to the statement that `y` is in the same cycle as `x`. Here `f^n(x)` denotes applying the permutation `f` `n` times to `x`. In other words, applying a permutation multiple times to a point doesn't change the cycle that the point belongs to.

For any permutation `f` on type `α` and elements `x, y` of type `α`, if `x` and `y` are in the same cycle of `f`, then `y` is in the same cycle as `f^n(x)` for any integer `n`.


theorem ZeroMemClass.coe_eq_zero :
    ∀ {A : Type u_4} {M₁ : Type u_5} [inst : SetLike A M₁] [inst_1 : Zero M₁] [hA : ZeroMemClass A M₁] {S' : A}
      {x : ↥S'}, ↑x = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any type `A` and `M₁`, given that `A` behaves like a set of `M₁`, `M₁` has a zero element, and `A` belongs to the `ZeroMemClass` of `M₁`, for any element `S'` of `A` and any element `x` within `S'`, the condition of `x` being equal to zero is equivalent to the embedding of `x` (denoted by `↑x`) being zero. In other words, an element of a subset of `A` is zero if and only if its embedding in `M₁` is also zero.

For any type `A` and `M₁` such that `A` is a set-like structure over `M₁`, `M₁` has a zero element, and `A` is in the zero-membership class of `M₁`, the embedding of an element `x` in `A` is zero if and only if `x` is zero in `A`.


theorem ProbabilityTheory.kernel.withDensity_apply :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β → ENNReal}
      (κ : ↥(ProbabilityTheory.kernel α β)) [inst : ProbabilityTheory.IsSFiniteKernel κ],
      Measurable (Function.uncurry f) →
        ∀ (a : α), (ProbabilityTheory.kernel.withDensity κ f) a = (κ a).withDensity (f a) :=
  by sorry

The theorem `ProbabilityTheory.kernel.withDensity_apply` states that for any types `α` and `β` with measurable spaces `mα` and `mβ`, and for any function `f` from `α` and `β` to the extended nonnegative real numbers (`ENNReal`), if `κ` is a probability kernel from `α` to `β` which is also `s-finite`, and the uncurried version of `f` is measurable, then for any `α`, the density of `κ` with respect to `f` at `α` is equal to the density of `κ` at `α` with respect to the function `f` at `α`.

In simpler terms, this theorem expresses the relationship between a probability kernel and a probability density. If the density function is measurable, then the density of the kernel with respect to that measurable function does not change when evaluated at any point in the domain.

For an s-finite probability kernel κ from measurable spaces (α, mα) to (β, mβ) and a measurable function f : α × β → ENNReal, the density of κ with respect to f equals the density of κ with respect to f's uncurried version, where f' is the function defined by f'(α) = ∫β f(α, β) d(κ α)(β).


theorem inf_sup_assoc_of_le :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : IsModularLattice α] {x : α} (y : α) {z : α},
      z ≤ x → x ⊓ y ⊔ z = x ⊓ (y ⊔ z) :=
  by sorry

This theorem, `inf_sup_assoc_of_le`, states that for any type `α` that forms a lattice and is a modular lattice, and for any elements `x`, `y`, and `z` in `α`, if `z` is less than or equal to `x`, then the infimum (greatest lower bound) of `x` and `y` combined with the supremum (least upper bound) of `z`, is equal to the infimum of `x` and the supremum of `y` and `z`. This is a property of the associativity between the infimum and supremum operations in a modular lattice.

In a modular lattice, the infimum of the infimum of two elements and the supremum of a third element equals the infimum of the first two elements and the supremum of the third.


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

This theorem states that for any type `α`, and for any two objects `X` and `Y` in the category `CategoryTheory.Discrete α`, if the underlying objects of `X` and `Y` (accessed via the `.as` function) are equal, then `X` and `Y` themselves are also equal. In other words, two elements of a discrete category are identical if and only if their underlying objects are identical. This implies that the discrete category is fully determined by its underlying set of objects.

In the discrete category of type `α`, two objects are equal if and only if their underlying elements are equal.


theorem ENNReal.top_toReal : ⊤.toReal = 0 := by sorry

This theorem states that the real-number representation (`toReal`) of "top" (`⊤`), in the extended non-negative real number system (`ENNReal`), is equal to zero. In the context of `ENNReal`, "top" typically represents an element that is greater than any ordinary (non-top) element in the set, which is typically seen as positive infinity. However, when this "top" is converted to real numbers, it equals zero according to this theorem.

The theorem asserts that the conversion of the top element in the extended non-negative real number system to real numbers equals zero. (or more concisely: The top element in the extended non-negative real number system maps to zero when converted to real numbers.)


theorem nhdsWithin_restrict' :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} (s : Set α) {t : Set α},
      t ∈ nhds a → nhdsWithin a s = nhdsWithin a (s ∩ t) :=
  by sorry

This theorem states that for any type `α` equipped with a `TopologicalSpace` structure and any element 'a' of that type, for any two sets `s` and `t` of type `α`, if `t` is a neighborhood of `a`, then the neighborhood within `s` of `a` is equal to the neighborhood within the intersection of `s` and `t` of `a`. In other words, restricting the neighborhood of `a` within set `s` by a set `t` that is itself a neighborhood of `a`, results in the neighborhood within the intersection of `s` and `t` of `a`.

For any topological space (α, τ), element a ∈ α, and sets s, t ∈ τ such that t is a neighborhood of a, the neighborhood of a in s is equal to the neighborhood of a in the intersection of s and t.


theorem isNoetherian_submodule :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {N : Submodule R M}, IsNoetherian R ↥N ↔ ∀ s ≤ N, Submodule.FG s :=
  by sorry

The theorem `isNoetherian_submodule` states that for any semiring `R`, any additive commutative monoid `M`, and any module `M` over `R`, and for any submodule `N` of `M`, `N` is Noetherian if and only if all submodules `s` of `N` are finitely generated. Here, "Noetherian" means that every ascending chain of submodules in `N` stabilizes (i.e., for every chain, there exists some point after which all further elements are the same), and "finitely generated" means that the submodule can be expressed as the span of a finite subset of `M`.

A submodule of an `R`-module `M` is Noetherian if and only if every submodule of it is finitely generated.


theorem Submodule.mem_map_of_mem :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} [inst_6 : RingHomSurjective σ₁₂] {F : Type u_9} [inst_7 : FunLike F M M₂]
      [inst_8 : SemilinearMapClass F σ₁₂ M M₂] {f : F} {p : Submodule R M} {r : M}, r ∈ p → f r ∈ Submodule.map f p :=
  by sorry

The theorem `Submodule.mem_map_of_mem` states that given two semirings `R` and `R₂`, two additive commutative monoids `M` and `M₂` that are also modules over `R` and `R₂` respectively, a surjective ring homomorphism from `R` to `R₂`, and a function `f` that has a `FunLike` relationship between `M` and `M₂`, then for any submodule `p` of `M` and any element `r` of `M`, if `r` is in `p`, then `f(r)` is in the image of `p` under the map `f`. This is a property of submodule maps in the context of semilinear algebra.

If `f` is a surjective homomorphism of semirings from `R` to `R₂`, `M` and `M₂` are modules over `R` and `R₂` respectively, `p` is a submodule of `M`, and `r` is an element of `M` in `p`, then `f(r)` is in the image of `p` under `f`.


theorem PiNat.dist_self : ∀ {E : ℕ → Type u_1} (x : (n : ℕ) → E n), dist x x = 0 := by sorry

This theorem, `PiNat.dist_self`, states that for all functions `x` from natural numbers `ℕ` to some type `Type u_1`, the distance between `x` and itself is `0`. This essentially means that any function from natural numbers to any type is at a 'distance' of zero from itself.

For any function `x : ℕ → Type u_1`, the distance from `x` to itself is `0`.


theorem DFinsupp.sumAddHom_single :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
      [inst_2 : AddCommMonoid γ] (φ : (i : ι) → β i →+ γ) (i : ι) (x : β i),
      (DFinsupp.sumAddHom φ) (DFinsupp.single i x) = (φ i) x :=
  by sorry

This theorem, `DFinsupp.sumAddHom_single`, states that for any types `ι`, `γ`, and a type function `β : ι → Type v` with `DecidableEq ι`, `AddZeroClass` on `β i` for each `i : ι`, and `AddCommMonoid γ`, and for any additive homomorphism `φ : (i : ι) → β i →+ γ`, and any `i : ι` and `x : β i`, applying the sum-additive homomorphism `DFinsupp.sumAddHom φ` to the direct sum of `β`'s `DFinsupp.single i x` (which sends `i` to `x` and all other points to `0`) is equivalent to applying `φ i` to `x`. In simpler terms, it's saying that summing over a single-element direct sum (with `DFinsupp.sumAddHom φ`) is the same as just applying the homomorphism directly to the single element (`φ i x`).

For any additive homomorphism `φ` and `i : ι`, applying `DFinsupp.sumAddHom φ` to the direct sum of `β i`'s single-element finite support discrete additive monoid element `DFinsupp.single i x` is equal to applying `φ i` to `x`.


theorem nsmul_nonneg :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : M}, 0 ≤ a → ∀ (n : ℕ), 0 ≤ n • a :=
  by sorry

This theorem states that for any type `M` that is an ordered additive monoid (i.e., a structure with an addition operation and an order relation that respects this addition), if an element `a` of `M` is nonnegative (i.e., greater than or equal to zero), then the `n`-fold sum of `a` (denoted `n • a`), for any natural number `n`, is also nonnegative. In other words, repeatedly adding a nonnegative element to itself any number of times keeps the result nonnegative.

For any ordered additive monoid `M` and non-negative element `a` in `M`, the `n`-fold sum `n • a` is non-negative for all natural numbers `n`.


theorem lowerBounds_mono_set :
    ∀ {α : Type u} [inst : Preorder α] ⦃s t : Set α⦄, s ⊆ t → lowerBounds t ⊆ lowerBounds s := by sorry

The theorem `lowerBounds_mono_set` states that for any type `α` with a preorder (`≤`), and any two sets `s` and `t` of type `α`, if `s` is a subset of `t`, then the set of lower bounds of `t` is a subset of the set of lower bounds of `s`. This means that any lower bound of the larger set `t` is also a lower bound of the smaller set `s`. In other words, if every element of `s` is also in `t`, then every lower bound for `t` is also a lower bound for `s`.

If `s` is a subset of `t` in a preordered type `α`, then the set of lower bounds of `t` includes the set of lower bounds of `s`.


theorem CategoryTheory.Limits.imageSubobject_arrow' :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
      [inst_1 : CategoryTheory.Limits.HasImage f],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.imageSubobjectIso f).inv
          (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.imageSubobject f)) =
        CategoryTheory.Limits.image.ι f :=
  by sorry

The theorem `CategoryTheory.Limits.imageSubobject_arrow'` states that for any category `C` and morphism `f` from `X` to `Y`, if `f` has an image, then the composition of the inverse of the isomorphism between the image subobject of `f` and the image of `f`, and the arrow from the image subobject of `f` to `Y`, is equivalent to the inclusion of the image of `f` into `Y`. In other words, we have this equality of morphisms: `(imageSubobjectIso f).inv ≫ Subobject.arrow (imageSubobject f) = image.ι f` where `≫` signifies the composition of morphisms.

For any morphism `f` in a category `C` with an image subobject, the composition of the inverse of the isomorphism between the image subobject and the image of `f`, and the inclusion of the image of `f` into `Y`, is equal to the morphism `image.ι f`.


theorem Mathlib.CategoryTheory.Sites.EffectiveEpimorphic._auxLemma.1 :
    ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h :=
  by sorry

The theorem `Mathlib.CategoryTheory.Sites.EffectiveEpimorphic._auxLemma.1` states that for any objects `W`, `X`, `Y`, and `Z` in a category, and any morphisms `f` from `W` to `X`, `g` from `X` to `Y`, and `h` from `Y` to `Z`, the composition of `f` with the composition of `g` and `h` is equal to the composition of the composition of `f` and `g` with `h`. In the language of category theory, this is asserting the associativity of morphism composition, i.e., the equation `(f ≫ (g ≫ h)) = ((f ≫ g) ≫ h)`.

The theorem asserts the associativity of morphism composition in a category, that is, `(f ≫ g) ≫ h = f ≫ (g ≫ h)` for any morphisms `f: W → X`, `g: X → Y`, and `h: Y → Z`.


theorem Ideal.span_singleton_generator :
    ∀ {R : Type u} [inst : Ring R] (I : Ideal R) [inst_1 : Submodule.IsPrincipal I],
      Ideal.span {Submodule.IsPrincipal.generator I} = I :=
  by sorry

The theorem `Ideal.span_singleton_generator` asserts that for any ring `R` and any ideal `I` of `R` that is a principal submodule, the ideal generated by the singleton set containing the generator of `I` is equal to `I` itself. In other words, if `I` is a principal ideal in `R` with generator `x`, then the ideal spanned by `{x}` is precisely `I`. This essentially states that a principal ideal in a ring is entirely determined by its generator.

If `I` is a principal ideal in a ring `R` with generator `x`, then the ideal generated by `{x}` equals `I`.


theorem Set.indicator_apply_le' :
    ∀ {α : Type u_2} {M : Type u_4} [inst : LE M] [inst_1 : Zero M] {s : Set α} {f : α → M} {a : α} {y : M},
      (a ∈ s → f a ≤ y) → (a ∉ s → 0 ≤ y) → Set.indicator s f a ≤ y :=
  by sorry

The theorem `Set.indicator_apply_le'` states that for any types `α` and `M`, where `M` has an order relation (`LE M`) and zero element (`Zero M`), a set `s` of type `Set α`, a function `f` from `α` to `M`, an element `a` of type `α`, and an element `y` of type `M`, if `f a` is less than or equal to `y` whenever `a` is in `s` and 0 is less than or equal to `y` whenever `a` is not in `s`, then the indicator function `Set.indicator s f a` is less than or equal to `y`. In other words, the value of the indicator function at `a` is always less than or equal to `y` under these conditions. The indicator function here is defined such that it gives the value of `f a` if `a` is in `s` and gives 0 otherwise.

For any set `s` of type `α`, function `f` from `α` to an ordered type `M` with zero element `Zero M`, if `f a ≤ y` whenever `a ∈ s` and `0 ≤ y` whenever `a ∉ s`, then `Set.indicator s f a ≤ y`.


theorem QPF.comp_map :
    ∀ {F : Type u → Type u} [inst : Functor F] [q : QPF F] {α β γ : Type u} (f : α → β) (g : β → γ) (x : F α),
      (g ∘ f) <$> x = g <$> f <$> x :=
  by sorry

This theorem, named 'QPF.comp_map', states that for any types `α`, `β`, and `γ`, and for any functions `f` from `α` to `β` and `g` from `β` to `γ`, operating on any instance `x` of type F α with the composition of `g` and `f` (i.e., `(g ∘ f) <$> x`) is equivalent to first applying `f` to `x`, then applying `g` to the result (i.e., `g <$> f <$> x`). Here, `<$>` denotes a functor map operation. The theorem holds for any Functor `F` that also has a Quotient Polynomial Functor (QPF) structure.

For any Functor `F` with a QPF structure and any functions `f : α → β` and `g : β → γ`, the composition `(g ∘ f) <$> x` is equivalent to `g <$> f <$> x` for any `x : F α`.


theorem Int.div_neg : ∀ (a b : ℤ), Int.div a (-b) = -Int.div a b := by sorry

This theorem states that for all integers `a` and `b`, the integer division of `a` by the negation of `b` is equal to the negation of the integer division of `a` by `b`. In mathematical terms, for every pair of integers `(a, b)`, we have that `a ÷ (-b) = -(a ÷ b)`. This theorem establishes a property of integer division concerning division by negative numbers.

For all integers `a` and `b`, `a / (-b) = -(a / b)`.


Computable.ofOption

theorem Computable.ofOption :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → Option β},
      Computable f → Partrec fun a => ↑(f a) :=
  by sorry

The theorem `Computable.ofOption` states that for any two types `α` and `β` that are Primcodable (that is, they can be encoded as and decoded from natural numbers), given a function `f` from `α` to `Option β`, if `f` is computable, then the function that maps each element `a` in `α` to the part of `f a` is partial recursive. In other words, if you can compute `f` on any input, then you can also compute the partial function that converts `f(a)` to a part, verifying that `f(a)` is defined, for any `a` in `α`.

If `f : α → Option β` is a computable function between Primcodable types `α` and `β`, then the function that extracts the part of `f` is partial recursive.


theorem dist_triangle_left : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y z : α), dist x y ≤ dist z x + dist z y :=
  by sorry

This theorem, named 'dist_triangle_left', is a statement about pseudo metric spaces. It asserts that for any type 'α' which forms a pseudo metric space, and for any three elements 'x', 'y', and 'z' of this type, the distance from 'x' to 'y' is always less than or equal to the sum of the distances from 'z' to 'x' and 'z' to 'y'. This is a generalization of the triangle inequality to pseudo metric spaces.

In any pseudo metric space, the distance from x to y is less than or equal to the sum of the distances from z to x and z to y (triangle inequality).


theorem Nat.strictMono_cast :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α], StrictMono Nat.cast :=
  by sorry

The theorem `Nat.strictMono_cast` states that for any type `α` with the structures of an `AddMonoidWithOne`, `PartialOrder`, `CovariantClass` for addition and order, `ZeroLEOneClass`, and `CharZero`, the function that casts natural numbers to `α` is strictly monotone. In other words, for any two natural numbers `a` and `b`, if `a` is strictly less than `b`, then the casting of `a` into `α` is strictly less than the casting of `b` into `α`. The `CovariantClass` ensures an interaction between the addition operation and the order relation, while `ZeroLEOneClass` and `CharZero` provide specific properties about the elements `0` and `1` in the type `α`.

If `α` is a type with the structures of an AddMonoidWithOne, PartialOrder, CovariantClass for addition and order, ZeroLEOneClass, and CharZero, then the function that casts natural numbers to `α` is a strict monotone function with respect to the order relation on natural numbers.


theorem MeasureTheory.NullMeasurableSet.toMeasurable_ae_eq :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → MeasureTheory.toMeasurable μ s =ᶠ[MeasureTheory.Measure.ae μ] s :=
  by sorry

This theorem states that for any type `α`, any measurable space `m0` on `α`, any measure `μ` on `α`, and any set `s` of `α`, if `s` is a Null Measurable Set with respect to the measure `μ`, then the set `s` is almost everywhere equal to the measurable version of set `s` under the measure `μ`. In other words, the measurable version of a Null Measurable Set is equivalent to the original set almost everywhere with respect to the given measure.

A Null Measurable Set `s` with respect to measure `μ` on type `α` equals its measurable version almost everywhere.


CategoryTheory.Limits.HasImage.mk

theorem CategoryTheory.Limits.HasImage.mk :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y},
      CategoryTheory.Limits.ImageFactorisation f → CategoryTheory.Limits.HasImage f :=
  by sorry

This theorem states that for any category `C` with objects `X` and `Y`, and for any morphism `f` from `X` to `Y`, if there exists an image factorisation of `f`, then `f` has an image. The 'image' here refers to the category-theoretic concept of an image, which is a kind of optimal factorisation of a morphism.

If a morphism in a category has an image factorization, then it has an image.


theorem Nat.binaryRec_eq :
    ∀ {C : ℕ → Sort u} {z : C 0} {f : (b : Bool) → (n : ℕ) → C n → C (Nat.bit b n)},
      f false 0 z = z → ∀ (b : Bool) (n : ℕ), Nat.binaryRec z f (Nat.bit b n) = f b n (Nat.binaryRec z f n) :=
  by sorry

The theorem `Nat.binaryRec_eq` states that for any predicate `C` over natural numbers, given an instance `z` of `C 0` and a function `f` that constructs an instance of `C (Nat.bit b n)` from `b` (a boolean), `n` (a natural number), and an instance of `C n`, if `f false 0 z` equals `z`, then for any boolean `b` and natural number `n`, applying the binary recursion of `C` to the binary number formed by appending `b` to `n` equals applying `f` to `b`, `n`, and the result of the binary recursion of `C` on `n`. This theorem essentially provides a condition under which the binary recursion function behaves as expected with respect to the function `f`.

If for all natural numbers `n` and booleans `b`, if `C 0` holds for some instance `z` and `C (Nat.bit b (Nat.succ n)) = f b (Nat.bit b n) (C n)`, then `C (Nat.bit b (Nat.succ (Nat.succ n))) = f b (Nat.succ n) (C (Nat.bit b (Nat.succ n)))`.


theorem Mathlib.Data.List.Cycle._auxLemma.30 : ∀ {α : Type u_1} {l : List α}, Cycle.Nodup ↑l = List.Nodup l := by sorry

This theorem, named `Mathlib.Data.List.Cycle._auxLemma.30`, states that for any type `α` and any list of elements of this type `l`, the property of having no duplicates in the cycle form of `l` (denoted by `Cycle.Nodup ↑l`) is equivalent to the property of having no duplicates in `l` directly (denoted by `List.Nodup l`). In other words, a list `l` has no duplicate elements if and only if the cycle form of `l` also has no duplicate elements.

The theorem `Mathlib.Data.List.Cycle._auxLemma.30` in Lean 4 states that a list `l` has no duplicate elements if and only if its cycle form also has no duplicate elements.


/-- `zsmul` is equal to any other module structure via a cast.  -/
theorem zsmul_eq_smul_cast :
    ∀ (R : Type u_2) {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (n : ℤ) (b : M),
      n • b = ↑n • b :=
  by sorry

This theorem states that for any ring `R`, any additive commutative group `M`, any module `M` over the ring `R`, any integer `n` and any element `b` of `M`, the scaled multiple of `b` by `n` in the context of integer multiples (`n • b`) is equal to the scaled multiple of `b` by the casting of `n` to a ring element (`↑n • b`). This essentially formalizes the notion that scaling by an integer in a module context is the same as scaling by that integer treated as a ring element.

For any ring `R`, additive commutative group `M`, module `M` over `R`, integer `n`, and element `b` of `M`, `n • b` = ↑n • b`.


theorem Real.toNNReal_le_iff_le_coe : ∀ {r : ℝ} {p : NNReal}, Real.toNNReal r ≤ p ↔ r ≤ ↑p := by sorry

This theorem states that for any real number `r` and any non-negative real number `p`, the non-negative real number interpretation of `r` is less than or equal to `p` if and only if `r` is less than or equal to the real number representation of `p`. In other words, it allows for a direct comparison between a real number `r` and a non-negative real number `p` by either comparing `r` with the real part of `p`, or comparing the non-negative real interpretation of `r` with `p` itself.

For any real numbers r and non-negative real number p, r ≤ p if and only if ℝ≤[r] ≤ p, where ℝ≤[r] denotes the non-negative real interpretation of r.


/-- See also `nonempty_fintype`, `nonempty_denumerable`.  -/
theorem nonempty_encodable : ∀ (α : Type u_1) [inst : Countable α], Nonempty (Encodable α) := by sorry

This theorem, called `nonempty_encodable`, states that for any type `α` that is countable (i.e., there exists a bijection from the set of natural numbers to `α`), there exists an encoding (an explicit, constructive way of representing elements of `α` as natural numbers). In other words, if you can establish a one-to-one correspondence between the set of natural numbers and any type `α`, then you can ensure that the elements of `α` can be represented as natural numbers.

If `α` is a countable type, then there exists a function that encodes elements of `α` as natural numbers.


theorem Mathlib.ModelTheory.Semantics._auxLemma.25 :
    ∀ {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.iff φ ψ) v xs =
        (FirstOrder.Language.BoundedFormula.Realize φ v xs ↔ FirstOrder.Language.BoundedFormula.Realize ψ v xs) :=
  by sorry

The theorem `Mathlib.ModelTheory.Semantics._auxLemma.25` states that for any first-order language `L`, any structure `M` of that language, any type `α`, any natural number `l`, any two bounded formulas `φ` and `ψ` of the language `L` with a bound `l`, any function `v` from `α` to `M`, and any function `xs` from the finite set of size `l` to `M`, the realization of the biimplication (iff) between `φ` and `ψ` is equivalent to the biimplication between the realizations of `φ` and `ψ`. In other words, realizing the logical equivalence of two bounded formulas is the same as the logical equivalence of their realizations.

For any first-order language L, structure M, type α, natural number l, bounded formulas φ and ψ of L with bound l, function v from α to M, and function xs of size l to M, the realization of the biimplication between φ and ψ under assignments v and xs is equivalent to the biimplication between the realizations of φ and ψ.


theorem BoxIntegral.Prepartition.isPartition_iff_iUnion_eq :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π : BoxIntegral.Prepartition I},
      BoxIntegral.Prepartition.IsPartition π ↔ BoxIntegral.Prepartition.iUnion π = ↑I :=
  by sorry

This theorem establishes the equivalence between a prepartition `π` of a box `I` being a partition and the union of the boxes in `π` being equal to `I`. In other words, for any type `ι`, any box `I` of type `BoxIntegral.Box ι`, and any prepartition `π` of `I`, `π` is a partition if and only if the union of the sets covered by the boxes of `π` is exactly `I`.

A prepartition π of a box I in Lean is equal to its corresponding partition if and only if the union of the boxes in π equals I.


OrderIso.continuous

theorem OrderIso.continuous :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : TopologicalSpace α]
      [inst_3 : TopologicalSpace β] [inst_4 : OrderTopology α] [inst_5 : OrderTopology β] (e : α ≃o β), Continuous ⇑e :=
  by sorry

The theorem `OrderIso.continuous` states that for any two types `α` and `β`, given that `α` and `β` are endowed with a partial order, a topological space structure, and an order topology, any order isomorphism `e` between `α` and `β` is continuous. In other words, if `α` and `β` are topological spaces that have an order topology (a topology based on a partial order), any function that preserves this order is a continuous function.

Given types `α` and `β` endowed with a partial order and a topology, any order isomorphism between them is a continuous function.


/-- The seminorm of an element in a product space is `≤ r` if
and only if the norm of each component is. -/
theorem pi_norm_le_iff_of_nonneg :
    ∀ {ι : Type u_4} {π : ι → Type u_9} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedAddGroup (π i)]
      {x : (i : ι) → π i} {r : ℝ}, 0 ≤ r → (‖x‖ ≤ r ↔ ∀ (i : ι), ‖x i‖ ≤ r) :=
  by sorry

This theorem, `pi_norm_le_iff_of_nonneg`, states that for a given non-negative real number `r`, and a given element `x` of a product space (where the product space is defined over a finite type `ι`, with each component being an element of a seminormed add group), the seminorm of `x` is less than or equal to `r` if and only if the norm of each component of `x` is less than or equal to `r`. In mathematical terms, if `0 ≤ r`, then `‖x‖ ≤ r` is equivalent to the condition that for all `i` in `ι`, `‖x i‖ ≤ r`.

For a non-negative real number `r` and an element `x` of a product space over a finite type `ι`, where each component is an element of a seminormed add group, `‖x‖ ≤ r` if and only if for all `i` in `ι`, `‖x i‖ ≤ r`.


theorem ENNReal.iInf_add : ∀ {ι : Sort u_1} {f : ι → ENNReal} {a : ENNReal}, iInf f + a = ⨅ i, f i + a := by sorry

The theorem `ENNReal.iInf_add` states that for any index type `ι`, any function `f` from `ι` to the extended nonnegative real numbers (`ENNReal`), and any extended nonnegative real number `a`, the indexed infimum of `f` plus `a` is equal to the infimum over all `i` of `f i` plus `a`. This essentially says that adding a constant `a` to the indexed infimum of a function is the same as finding the infimum of the function values plus `a`.

For any index type `ι`, function `f` from `ι` to `ENNReal`, and extended nonnegative real number `a`, the indexed infimum of `f` equals the infimum of `(fi + a)` for all `i` in `ι`.


theorem Set.subset_inter_iff : ∀ {α : Type u} {s t r : Set α}, r ⊆ s ∩ t ↔ r ⊆ s ∧ r ⊆ t := by sorry

This theorem, named `Set.subset_inter_iff`, says that for any type `α`, and any three sets `s`, `t`, and `r` of this type, `r` is a subset of the intersection of `s` and `t` if and only if `r` is a subset of `s` and `r` is a subset of `t`. In other words, a set is contained within two others simultaneously exactly when it is contained within their intersection.

For any type `α` and sets `s`, `t`, and `r` of type `α`, `r` is a subset of `s INTER t` if and only if `r` is a subset of both `s` and `t`.


theorem Rat.coe_toNNRat : ∀ (q : ℚ), 0 ≤ q → ↑(Rat.toNNRat q) = q := by sorry

This theorem asserts that for any rational number `q`, if `q` is non-negative (i.e., `q` is greater than or equal to zero), then converting `q` to a non-negative rational number using the function `Rat.toNNRat` and then converting it back to a regular rational number yields the original value `q`. In mathematical terms, it states that for all `q` in the set of rational numbers, `ℚ`, such that `0 ≤ q`, the function `Rat.toNNRat` is effectively an identity operation.

For all non-negative rational numbers `q`, `Rat.toNNRat q = q`.


theorem isMin_iff_eq_bot : ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsMin a ↔ a = ⊥ := by
  sorry

This theorem states that, for any type `α` that has a partial order and a minimum element (`⊥`), an element `a` of `α` is a minimal element (as defined by the `IsMin` property) if and only if `a` is equal to the minimum element (`⊥`). In other words, in such a structure, the only element that satisfies the minimal element property is the designated minimum element.

For any type `α` with a partial order and a minimum element, an element `a` is a minimal element if and only if `a = ⊥`.


theorem Real.log_div : ∀ {x y : ℝ}, x ≠ 0 → y ≠ 0 → Real.log (x / y) = Real.log x - Real.log y := by sorry

This theorem states that for any two non-zero real numbers `x` and `y`, the logarithm of their quotient (`x / y`) is equal to the difference of their individual logarithms (`Real.log x - Real.log y`). This follows the logarithmic property `log(a/b) = log(a) - log(b)`. This property holds true for all non-zero real numbers `x` and `y`, as dictated by the conditions `x ≠ 0` and `y ≠ 0` in the theorem.

For any non-zero real numbers `x` and `y`, `Real.log (x / y) = Real.log x - Real.log y`.


theorem Submonoid.smul_def :
    ∀ {M' : Type u_5} {α : Type u_6} [inst : MulOneClass M'] [inst_1 : SMul M' α] {S : Submonoid M'} (g : ↥S) (a : α),
      g • a = ↑g • a :=
  by sorry

This theorem, `Submonoid.smul_def`, states that for any type 'M' that forms a multiplicative group with an identity element (which we signify with `MulOneClass M'`) and any type 'α' that can be scaled by elements of type 'M' (which we capture with `SMul M' α`), if we have a submonoid 'S' of 'M' and an element 'g' of that submonoid, the scalar multiplication of 'g' and an element 'a' of type 'α' is the same as the scalar multiplication of the representative of 'g' (which belongs to 'M') and 'a'. In simpler terms, the theorem states that scalar multiplication behaves the same way in the submonoid as in the parent group.

For any submonoid 'S' of a multiplicative group 'M' with identity, and any 'g' in 'S' and 'a' in the type 'α' scalable by 'M', the scalar multiplication of 'g' and 'a' equals the scalar multiplication of any representative of 'g' in 'M' and 'a'.


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

This theorem states that for any two types `α` and `β`, both equipped with a pseudo emetric space structure, given an isometric isomorphism `h` from `α` to `β`, the preimage under the inverse isomorphism is equal to the image under the original isomorphism.

In the context of mathematics, this theorem can be interpreted as follows: if you take a set in `β`, apply the inverse isometric isomorphism and find the corresponding set in `α`, it would be the same as if you started with the corresponding set in `α` and applied the original isometric isomorphism to find the set in `β`. This emphasizes the bijective nature of the isometric isomorphism.

For any isometric isomorphisms between pseudo metric spaces `h: α → β` and `g: β → α`, we have `g⁻¹(h(A)) = A` for any set `A` in `α`.


/-- Induct using `tprodCoeff`  -/
theorem PiTensorProduct.induction_on' :
    ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
      [inst_2 : (i : ι) → Module R (s i)] {motive : (PiTensorProduct R fun i => s i) → Prop}
      (z : PiTensorProduct R fun i => s i),
      (∀ (r : R) (f : (i : ι) → s i), motive (PiTensorProduct.tprodCoeff R r f)) →
        (∀ (x y : PiTensorProduct R fun i => s i), motive x → motive y → motive (x + y)) → motive z :=
  by sorry

The theorem `PiTensorProduct.induction_on'` is an induction principle for the tensor product of a family of modules over a commutative semiring. It states that for any type `ι`, a commutative semiring `R`, a function `s` that maps each element of `ι` to a type, and a `motive` which is a property of elements of the tensor product of the 's `i`s over `R`, if the `motive` holds for each tensor product of the coefficients `r` and a function `f` from `ι` to `s i`, and if the `motive` is preserved under addition (i.e., if it holds for `x` and `y` then it also holds for `x + y`), then the `motive` holds for all elements `z` of the tensor product.

Given a commutative semiring `R`, a type `ι`, and a family `{M_i : Type}_i.{0 < i < ℰ}` of `R`-modules indexed by `ι`, if for all `i` and `r : R`, `f : ι → M_i`, and `x, y : ∏ i, M_i`, the property `motive (r, f, x, y)` holds and is preserved under addition, then `motive (r, f, z)` holds for all `z : ∏ i, M_i`.


/-- If `u` is a family of uniform structures on `γ`, then
`𝒰(α, γ, (⨅ i, u i)) = ⨅ i, 𝒰(α, γ, u i)`.  -/
theorem UniformFun.iInf_eq :
    ∀ {α : Type u_1} {γ : Type u_3} {ι : Type u_4} {u : ι → UniformSpace γ},
      UniformFun.uniformSpace α γ = ⨅ i, UniformFun.uniformSpace α γ :=
  by sorry

The theorem `UniformFun.iInf_eq` states that for any types `α`, `γ`, and `ι`, and any family `u` of uniform structures on `γ`, the uniform structure of uniform convergence `𝒰(α, γ, (⨅ i, u i))`  is equal to the infimum over all `i` of the uniform structures `𝒰(α, γ, u i)`. In other words, it asserts the equality between the uniform structure of uniform convergence on the infimum of a family of uniform structures and the infimum of the uniform structures of uniform convergence on each member of the family.

The theorem `UniformFun.iInf_eq` asserts that the uniform structure of uniform convergence on the infimum of a family of uniform structures is equal to the infimum of the uniform structures of uniform convergence on each member of the family.


theorem Cardinal.power_le_power_right : ∀ {a b c : Cardinal.{u_1}}, a ≤ b → a ^ c ≤ b ^ c := by sorry

This theorem, named `Cardinal.power_le_power_right`, states that for every three cardinal numbers `a`, `b`, and `c` in a particular universe `u_1`, if `a` is less than or equal to `b`, then `a` raised to the power of `c` is less than or equal to `b` raised to the power of `c`. This is a statement about the preservation of order under exponentiation in the context of cardinal numbers.

For all cardinal numbers `a`, `b`, and `c`, if `a ≤ b` then `a^c ≤ b^c`.


theorem Set.disjoint_singleton_right : ∀ {α : Type u} {a : α} {s : Set α}, Disjoint s {a} ↔ a ∉ s := by sorry

This theorem states that for any type `α`, any element `a` of that type, and any set `s` of elements of that type, the set `s` and the singleton set `{a}` are disjoint if and only if `a` is not an element of `s`. Here, two sets are considered disjoint if their intersection, or infimum, is the empty set (the bottom element in the context of sets). Hence, the theorem provides a characterization of disjointness in terms of non-membership of an element in a set.

For any type `α`, sets `s` of elements of `α`, and `a` in `α`, the sets `s` and `{a}` are disjoint if and only if `a` is not in `s`.


theorem Subring.gc_map_comap :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S),
      GaloisConnection (Subring.map f) (Subring.comap f) :=
  by sorry

This theorem, `Subring.gc_map_comap`, states that for any two types `R` and `S` with instances of the `Ring` typeclass, and a ring homomorphism `f` from `R` to `S`, there is a Galois connection between the mapping of a subring along `f` and the preimage of a subring along `f`. A Galois connection is a pair of functions that satisfy a certain property: in this case, the mapping of a subring along `f` is less than or equal to a subring in `S` if and only if the original subring in `R` is less than or equal to the preimage of the subring along `f`. This reflects a fundamental duality principle in order theory.

Given rings `R` and `S` with ring homomorphism `f` between them, the mapping of a subring of `R` along `f` is equal to the preimage along `f` of the subring of `S` if and only if the original subring of `R` is contained in the preimage along `f`.


GaloisConnection.compose

theorem GaloisConnection.compose :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {l1 : α → β} {u1 : β → α} {l2 : β → γ} {u2 : γ → β},
      GaloisConnection l1 u1 → GaloisConnection l2 u2 → GaloisConnection (l2 ∘ l1) (u1 ∘ u2) :=
  by sorry

The theorem `GaloisConnection.compose` states that if we have two Galois connections, the first one between sets of types `α` and `β` with functions `l1` and `u1`, and the second one between sets of types `β` and `γ` with functions `l2` and `u2`, then the composition of these Galois connections, with `l2 ∘ l1` and `u1 ∘ u2`, is also a Galois connection. Here `α`, `β`, and `γ` are types with a preorder, and a Galois connection between two preordered sets is a pair of functions `l` and `u` where for all elements `a` of the first set and `b` of the second set, `l a ≤ b` if and only if `a ≤ u b`.

Given Galois connections between sets `α` and `β` with functions `l1` and `u1`, and between sets `β` and `γ` with functions `l2` and `u2`, the composition of these Galois connections, defined by `l2 ∘ l1` and `u1 ∘ u2`, is itself a Galois connection between `α` and `γ`.


theorem LinearMap.trace_mul_comm :
    ∀ (R : Type u) [inst : CommSemiring R] {M : Type v} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (f g : M →ₗ[R] M), (LinearMap.trace R M) (f * g) = (LinearMap.trace R M) (g * f) :=
  by sorry

The theorem `LinearMap.trace_mul_comm` states that for any commutative semiring `R` and any module `M` over `R`, the trace of the product of two linear maps `f` and `g` is the same as the trace of the product of `g` and `f`. In other words, the trace of the composition of two linear maps is commutative. In mathematical terms, this can be written as $\text{Tr}(f \circ g) = \text{Tr}(g \circ f)$, where $\text{Tr}$ denotes the trace of a linear map.

For any commutative semiring R and module M over R, the trace of the product of two linear maps f and g is commutative, that is, Tr(fg) = Tr(gf).


theorem Real.negMulLog_eq_neg : Real.negMulLog = fun x => -(x * Real.log x) := by sorry

The theorem `Real.negMulLog_eq_neg` states that the function `Real.negMulLog`, which maps a real number x to the negative of the product of x and the logarithm of x, is equivalent to an anonymous function that performs the same operation, i.e., maps x to the negative of the product of x and the logarithm of x. This is a crucial identity that ensures the consistent definition and behavior of the `Real.negMulLog` function.

The theorem `Real.negMulLog_eq_anonymous` asserts that `Real.negMulLog x = -(x * log x)` for all real numbers `x`.


theorem Primrec.option_some_iff :
    ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f : α → σ},
      (Primrec fun a => some (f a)) ↔ Primrec f :=
  by sorry

The theorem `Primrec.option_some_iff` establishes an equivalence condition for the primitive recursiveness of a function `f` which maps from type `α` to `σ`, under the assumption that both `α` and `σ` are primcodable. Specifically, it states that wrapping the output of `f` with `some` (thereby mapping `α` to `Option σ`) is primitive recursive if and only if `f` itself is primitive recursive.

The function `f : α -> σ` is primitive recursive if and only if the function `x => some (f x) : Option σ` is primitive recursive, given that both `α` and `σ` are primcodable.


theorem Matrix.diagonal_apply_ne' :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] (d : n → α) {i j : n},
      j ≠ i → Matrix.diagonal d i j = 0 :=
  by sorry

The theorem `Matrix.diagonal_apply_ne'` states that for any types `n` and `α`, given that `n` has decidable equality and `α` has an additive identity (zero), for any function `d : n → α` and any elements `i` and `j` of type `n` where `j` is not equal to `i`, the `ij`-th element of the square matrix obtained by applying the `Matrix.diagonal` function to `d` is zero. In essence, this theorem is saying that all off-diagonal elements of a diagonal matrix (constructed via the given function `d`) are zero.

For any type `n` with decidable equality and type `α` with an additive identity, the `ij`-th element of the diagonal matrix obtained by applying `Matrix.diagonal` to a function `d : n → α` is zero when `i` and `j` are distinct.


theorem Set.singleton_add : ∀ {α : Type u_2} [inst : Add α] {t : Set α} {a : α}, {a} + t = (fun x => a + x) '' t := by
  sorry

This theorem states that for any type `α` which has an addition operation, given a set `t` of elements of type `α` and an element `a` of type `α`, the sum of the singleton set containing `a` and the set `t` is equal to the image of the set `t` under the function that adds `a` to each element. In other words, every element in the resultant set is formed by adding `a` to some element in set `t`.

For any set `t` of elements from a type `α` with addition, the set `t ∪ {a}` is equal to the image of `t` under the function `x => x + a`.


/-- The function `x ^ y` tends to `+∞` at `+∞` for any positive real `y`.  -/
theorem tendsto_rpow_atTop : ∀ {y : ℝ}, 0 < y → Filter.Tendsto (fun x => x ^ y) Filter.atTop Filter.atTop := by sorry

The theorem `tendsto_rpow_atTop` states that for any given positive real number `y`, the function `x ^ y` tends to positive infinity as `x` tends to positive infinity. In other words, as `x` gets larger and larger without bound, so does the value of `x ^ y` when `y` is a positive real number. This is expressed in the context of filters, where `Filter.Tendsto` is a generic limit of a function predicate, and `Filter.atTop` represents the limit towards positive infinity.

For any positive real number `y`, the function `x ^ y` tends to positive infinity as `x` approaches positive infinity.


theorem Polynomial.Separable.of_dvd :
    ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R},
      Polynomial.Separable f → g ∣ f → Polynomial.Separable g :=
  by sorry

The theorem `Polynomial.Separable.of_dvd` states that for any commutative semiring `R` and any two polynomials `f` and `g` over `R`, if `f` is a separable polynomial and `g` divides `f`, then `g` is also a separable polynomial. Here, a polynomial is considered separable if it is coprime with its derivative, i.e., the polynomial and its derivative share no common factor other than 1.

If `f` is a separable polynomial over a commutative semiring `R` and `g` is a divisor of `f`, then `g` is also a separable polynomial.


theorem lt_add_of_lt_of_nonneg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      b < c → 0 ≤ a → b < c + a :=
  by sorry

This theorem, `lt_add_of_lt_of_nonneg`, states that for any type `α` that has an addition operation and zero element (expressed by `AddZeroClass α`), and a preorder relation (expressed by `Preorder α`), and satisfies the `CovariantClass` property, if you have three elements `a`, `b`, and `c` such that `b` is less than `c` and `a` is non-negative (i.e., greater than or equal to zero), then `b` is less than the sum of `c` and `a`. In simpler terms, it says that adding a non-negative number to another number increases (or at least doesn't decrease) the value of the latter.

If `α` is an additive preordered type with zero, and `a` is non-negative and `b` is less than `c`, then `b < c + a`.


/-- **Alias** of `dist_eq_norm_sub'`. -/
theorem dist_eq_norm' : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (a b : E), dist a b = ‖b - a‖ := by sorry

This theorem, `dist_eq_norm'`, is a statement in the context of seminormed add groups. Given any two elements `a` and `b` from a seminormed add group `E`, the distance between `a` and `b` is defined to be the norm of the difference `b - a`. In other words, it provides an alternate expression for the distance between two points in such a group, namely as the norm (or length) of the vector representing the difference between the two points.

In a seminormed add group, the distance between two elements is equal to the norm of their difference.


theorem Filter.Tendsto.eventually_gt_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] [inst_1 : NoMaxOrder β] {f : α → β} {l : Filter α},
      Filter.Tendsto f l Filter.atTop → ∀ (c : β), ∀ᶠ (x : α) in l, c < f x :=
  by sorry

The theorem `Filter.Tendsto.eventually_gt_atTop` states that for any types `α` and `β`, where `β` is a type with a preorder and having no maximum element, if a function `f : α → β` tends towards `Filter.atTop` (or in other words, the function `f` approaches infinity) for any filter `l` of type `α`, then for any value `c` of type `β`, eventually (for all elements `x` in the filter `l` beyond a certain point), the value of the function `f(x)` is greater than `c`. Essentially, this theorem guarantees that a function which tends to infinity will eventually surpass any given value.

For any filter \(l\) on type \(\alpha\) and any \(c \in \beta\), without a maximum element, if \(f : \alpha \to \beta\) tends to \(\operatorname{atTop}\) for filter \(l\), then for all \(x \in l\) beyond some index, we have \(f(x) > c\).


theorem IsOpen.measure_eq_zero_iff :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X)
      [inst_1 : MeasureTheory.Measure.IsOpenPosMeasure μ] {U : Set X}, IsOpen U → (↑↑μ U = 0 ↔ U = ∅) :=
  by sorry

This theorem states that for any type `X` that is equipped with both a topological space structure and a measurable space structure, given a measure `μ` which is a positive measure on open sets, and any set `U` of type `X`, if `U` is an open set (in the topological space sense), then the measure of `U` is zero if and only if `U` is an empty set. In other words, in such a setting, an open set has zero measure precisely when it's the empty set.

In the setting of a type `X` with both topological and measurable structures, an open set `U` has measure zero if and only if it is empty.


theorem ENNReal.continuous_sub_left : ∀ {a : ENNReal}, a ≠ ⊤ → Continuous fun x => a - x := by sorry

This theorem states that for every extended nonnegative real number `a` that is not equal to infinity, the operation of subtracting another extended nonnegative real number `x` from `a` is a continuous function. In the context of topology, a function is continuous if the preimage of every open set is open. Here, the subtraction operation is viewed as a function that maps from the set of all extended nonnegative real numbers to itself.

For every extended nonnegative real number `a` not equal to infinity, the function `x => a - x` from extended nonnegative real numbers to itself is continuous.


theorem Filter.prod_comm :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, f ×ˢ g = Filter.map (fun p => (p.2, p.1)) (g ×ˢ f) :=
  by sorry

The theorem `Filter.prod_comm` states that for any types `α` and `β` and any filters `f` of type `α` and `g` of type `β`, the product of `f` and `g` is equal to the result of mapping the function that swaps the components of a pair over the product of `g` and `f`. In other words, the order of the filters in the product does not matter as long as we correspondingly adjust the order in the pairs of the resulting filter.

For any filters $f$ on type $\alpha$ and $g$ on type $\beta$, we have $f \times g = g \times f := \{ (x, y) \mid (x, y) \in f \times g \land (y, x) \in g \times f \}$.


/-- We have that `ringChar (ZMod n) = n`.  -/
theorem ZMod.ringChar_zmod_n : ∀ (n : ℕ), ringChar (ZMod n) = n := by sorry

This theorem states that for all natural numbers `n`, the unique characteristic of the semiring `ZMod n` (the integers modulo `n`) is equal to `n` itself. In other words, it says that the characteristic of the ring of integers modulo `n` is `n`.

The characteristic of the ring of integers modulo n is equal to n for all natural numbers n.


/-- **Alias** of the reverse direction of `sub_pos`. -/
theorem sub_pos_of_lt :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b : α},
      b < a → 0 < a - b :=
  by sorry

This theorem, named `sub_pos_of_lt`, is a variant of the theorem `sub_pos` in the reverse direction. It states that for any type `α` that is an additive group and has an order relation `<`, and a particular covariance property, if `b` is less than `a` (written as `b < a`), then `a - b` is positive (written as `0 < a - b`).

If `α` is an additive group with an order relation `<` and `b` is less than `a` in `α`, then `a - b` is positive.


theorem UniqueFactorizationMonoid.dvd_iff_normalizedFactors_le_normalizedFactors :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {x y : α},
      x ≠ 0 →
        y ≠ 0 →
          (x ∣ y ↔ UniqueFactorizationMonoid.normalizedFactors x ≤ UniqueFactorizationMonoid.normalizedFactors y) :=
  by sorry

This theorem states that for any types `α` that form a `CancelCommMonoidWithZero`, a `NormalizationMonoid`, and a `UniqueFactorizationMonoid`, and for any two nonzero elements `x` and `y` of type `α`, the element `x` divides `y` if and only if the multiset of normalized prime factors of `x` is less than or equal to the multiset of normalized prime factors of `y`. Here, 'less than or equal to' is in the multiset sense, meaning every prime factor of `x` (with its multiplicity) is also a prime factor of `y` (with equal or greater multiplicity).

For any type `α` that is a `CancelCommMonoidWithZero`, `NormalizationMonoid`, and `UniqueFactorizationMonoid`, two nonzero elements `x` and `y` of type `α` are related by `x | y` if and only if the multisets of normalized prime factors of `x` are less than or equal to those of `y`.


theorem Polynomial.roots_C :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (x : R), Polynomial.roots (Polynomial.C x) = 0 := by sorry

The theorem `Polynomial.roots_C` states that for any commutative ring `R` that is also an integral domain, and any element `x` from `R`, the roots of the constant polynomial `C x` (i.e., a polynomial that has the same value `x` at every point) are an empty set. In other words, a constant polynomial has no roots.

In an integral domain, the constant polynomial has no roots.


theorem Polynomial.ext_iff :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      p = q ↔ ∀ (n : ℕ), Polynomial.coeff p n = Polynomial.coeff q n :=
  by sorry

This theorem states that for any semiring R, two polynomials p and q (of type R) are equal if and only if their coefficients for every natural number n are equal. In other words, two polynomials are identical exactly when they have the same coefficients for the power of `X` in each term.

For any semiring R, two polynomials p and q over R are equal if and only if their corresponding coefficients are equal for all natural numbers n.


theorem chart_mem_atlas :
    ∀ (H : Type u_5) {M : Type u_6} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] (x : M), chartAt H x ∈ atlas H M :=
  by sorry

The theorem `chart_mem_atlas` asserts that for any topological space `H` and a charted space `M` over `H`, any chart at a point `x` in `M` is an element of the atlas of `M`. The atlas of a charted space is a set of charts that covers the entire space, so this theorem essentially says that each point in the space `M` is covered by at least one chart from the atlas.

For any charted space `M` over a topological space `H` and any point `x` in `M`, there exists a chart in the atlas of `M` containing `x`.


theorem Multiset.mem_toEnumFinset :
    ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α) (p : α × ℕ),
      p ∈ Multiset.toEnumFinset m ↔ p.2 < Multiset.count p.1 m :=
  by sorry

This theorem, `Multiset.mem_toEnumFinset`, states that for any type `α` with a decidable equality and any multiset `m` of this type, a pair `p` (consisting of an element of `α` and a natural number) is a member of the finset obtained from `m` by the `toEnumFinset` function if and only if the second component of `p` is less than the count of the first component of `p` in `m`. In simpler terms, the theorem relates the membership of an element in a finset, derived from a multiset, to the count of that element in the original multiset.

For any type `α` with decidable equality and any multiset `m` of `α`, an element `x` of `α` with a natural number `n` is a member of the finset obtained from `m` by `toEnumFinset` if and only if `n` is less than the count of `x` in `m`.


theorem MeasureTheory.Ioo_ae_eq_Icc :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.NoAtoms μ]
      [inst : PartialOrder α] {a b : α}, Set.Ioo a b =ᶠ[MeasureTheory.Measure.ae μ] Set.Icc a b :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m0` over `α`, a measure `μ` on `α` that has no atoms, and a partial order on `α`, for any two elements `a` and `b` of `α` the left-open right-open interval `(a, b)` is equal "almost everywhere" (according to the measure `μ`) to the left-closed right-closed interval `[a, b]`. In other words, apart from a set of measure zero (which may contain countably many points), the open interval `(a, b)` and the closed interval `[a, b]` are the same.

For any measurable space, measure without atoms, and partial order on a type `α`, the left-open right-open interval `(a, b)` and the left-closed right-closed interval `[a, b]` differ only on a set of measure zero.


theorem Finset.mem_uIcc :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      x ∈ Finset.uIcc a b ↔ a ⊓ b ≤ x ∧ x ≤ a ⊔ b :=
  by sorry

This theorem is about membership in the set `Finset.uIcc a b` in a lattice. It states that for any type `α` that has a lattice structure and a locally finite order, and for any elements `a`, `b`, and `x` of this type, `x` is an element of `Finset.uIcc a b` if and only if `x` is greater than or equal to the meet of `a` and `b` (denoted `a ⊓ b`) and less than or equal to the join of `a` and `b` (denoted `a ⊔ b`). In other words, `x` lies within the "bounding box" formed by `a` and `b`, inclusive.

For any type `α` with a lattice structure and a locally finite order, `x` is an element of `Finset.uIcc a b` if and only if `a ⊓ b ≤ x ≤ a ⊔ b`.


theorem Real.logb_one : ∀ {b : ℝ}, Real.logb b 1 = 0 := by sorry

This theorem states that for any real number `b`, the logarithm base `b` of `1` is equal to `0`. In standard mathematical notation, this would be written as log_b(1) = 0 for all real numbers `b`. This is a well-known property of logarithms: any number raised to the power of 0 equals 1, therefore the logarithm (the power to which the base number must be raised to produce the number being logged) of 1 in any base is always 0.

For all real numbers b, the logarithm base b of 1 equals 0.


Filter.Tendsto.pow

theorem Filter.Tendsto.pow :
    ∀ {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Monoid M] [inst_2 : ContinuousMul M]
      {l : Filter α} {f : α → M} {x : M},
      Filter.Tendsto f l (nhds x) → ∀ (n : ℕ), Filter.Tendsto (fun x => f x ^ n) l (nhds (x ^ n)) :=
  by sorry

The theorem `Filter.Tendsto.pow` states that for any type `α`, another type `M` which has an underlying topological space structure, a monoid structure, and a structure of continuous multiplication, given a filter `l` on `α`, a function `f` from `α` to `M`, and an element `x` of type `M`, if the function `f` tends to `x` with respect to the filter `l` (meaning, the limit of `f` as `α` approaches `x` is `x`), then for any natural number `n`, the function which sends `x` to the `n`-th power of `f(x)` also tends to the `n`-th power of `x` with respect to the filter `l`. In short, if a function's limit is `x` then the limit of the function's `n`-th power is the `n`-th power of `x`.

If a continuous function from a topological space to a monoid with continuous multiplication tends to a point x with respect to a filter, then the function's n-th power also tends to the n-th power of x with respect to that filter.


theorem Polynomial.natDegree_eq_card_roots :
    ∀ {K : Type v} {L : Type w} [inst : Field K] [inst_1 : Field L] {p : Polynomial K} {i : K →+* L},
      Polynomial.Splits i p → Polynomial.natDegree p = Multiset.card (Polynomial.roots (Polynomial.map i p)) :=
  by sorry

This theorem states that for any given polynomial `p` over a field `K` and a ring homomorphism `i` from `K` to another field `L`, if the polynomial `p` splits under the ring homomorphism `i` (meaning that it is either zero or all of its irreducible factors have degree one), then the natural degree of the polynomial `p` is equal to the cardinality of the multiset of roots of the polynomial `p` when mapped via `i`. The natural degree of a polynomial is the degree forced to natural numbers, where the degree of the zero polynomial is defined as zero. The cardinality of a multiset is the sum of the multiplicities of all its elements, and the roots of a polynomial are all the solutions of the polynomial equation, including their multiplicities.

If polynomial `p` over field `K` splits under ring homomorphism `i` from `K` to field `L`, then the natural degree of `p` equals the cardinality of the multiset of roots of `p` when mapped via `i`.


theorem AffineMap.lineMap_apply_one :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddTorsor V1 P1] (p₀ p₁ : P1), (AffineMap.lineMap p₀ p₁) 1 = p₁ :=
  by sorry

The theorem `AffineMap.lineMap_apply_one` states that for any two points `p₀` and `p₁` in an affine space `P1`, the affine map defined by `lineMap p₀ p₁` sends the scalar `1` to the point `p₁`. Here, `P1` is a type representing an affine space, `V1` is a type representing the associated vector space, and `k` is the type representing the underlying field of scalars. The space `P1` is assumed to be a torsor over the vector space `V1` (given by `inst_3 : AddTorsor V1 P1`). The operation of the affine map on `1` directly gives the end point `p₁` of the line segment defined by `p₀` and `p₁`.

For any affine space P1 over a field k with associated vector space V1 and given points p0 and p1, the affine map lineMap p0 p1 sends the scalar 1 to point p1.


/-- If a submodule has maximal dimension in a finite dimensional space, then it is equal to the
whole space.  -/
theorem Submodule.eq_top_of_finrank_eq :
    ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      [inst_3 : FiniteDimensional K V] {S : Submodule K V},
      FiniteDimensional.finrank K ↥S = FiniteDimensional.finrank K V → S = ⊤ :=
  by sorry

The theorem `Submodule.eq_top_of_finrank_eq` states that if a submodule of a finite dimensional space has the same dimension (rank) as the whole space, then the submodule is, in fact, the entire space itself. Here, `K` denotes a division ring, `V` is an additive commutative group which is also a `K`-module, and `S` is a submodule of `V`. The theorem states that if the rank of `S` (given by `FiniteDimensional.finrank K ↥S`) is equal to the rank of `V` (given by `FiniteDimensional.finrank K V`), then `S` is equal to the entire space, denoted by `⊤` in Lean.

If two finite dimensional subspaces of a vector space over a division ring have the same rank, then they are equal.


theorem Option.not_mem_none : ∀ {α : Type u_1} (a : α), a ∉ none := by sorry

This theorem states that for all types `α` and any element `a` of type `α`, `a` is not in the `none` option. In other words, no matter what type and element you choose, it cannot be a member of an option that is `none`, as `none` represents the absence of a value in the `Option` type in Lean.

For all types `α` and elements `a` of type `α`, `a` is not contained in an option of type `option α` that is equal to `none`.


theorem LocalizedModule.smul'_mk :
    ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {M : Type v} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (r : R) (s : ↥S) (m : M), r • LocalizedModule.mk m s = LocalizedModule.mk (r • m) s :=
  by sorry

The theorem `LocalizedModule.smul'_mk` states that for any commutative semiring `R`, submonoid `S` of `R`, and an `R`-module `M`, and for any element `r` of `R`, element `s` of `S`, and element `m` of `M`, the act of scaling the localized module element `LocalizedModule.mk m s` by `r` is the same as first scaling `m` by `r` and then localizing. In other words, scalar multiplication commutes with the localization process.

For any commutative semiring R, submonoid S of R, and R-module M, the scalar multiplication of an element m of M by r in the localized module M��ss is equivalent to the localization of the scalar multiplication of m by r in M.


theorem Multiset.cons_le_cons_iff : ∀ {α : Type u_1} {s t : Multiset α} (a : α), a ::ₘ s ≤ a ::ₘ t ↔ s ≤ t := by sorry

This theorem states that for any type `α`, and for any multisets `s` and `t` of type `α`, and any element `a` of type `α`, adding `a` to the front of `s` gives a multiset that is less than or equal to (in the sense of multiset ordering) adding `a` to the front of `t` if and only if the multiset `s` is less than or equal to the multiset `t`.

For any type `α` and multisets `s` and `t` of type `α`, `add_front a s ≤ add_front a t` if and only if `s ≤ t`, where `≤` denotes multiset ordering and `add_front` adds an element to the front of a multiset.


/-- The resolution maps intertwine the descent of a morphism and that morphism.  -/
theorem CategoryTheory.InjectiveResolution.desc_commutes :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y)
      (I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z),
      CategoryTheory.CategoryStruct.comp J.ι (CategoryTheory.InjectiveResolution.desc f I J) =
        CategoryTheory.CategoryStruct.comp ((CochainComplex.single₀ C).map f) I.ι :=
  by sorry

This theorem states that for any two objects `Y` and `Z` in an abelian category `C` and a morphism `f` from `Z` to `Y`, the resolution maps intertwine the descent of the morphism `f` and the morphism itself. More concretely, if `I` is an injective resolution of `Y` and `J` is an injective resolution of `Z`, then the composition of `J.ι` and the descent of `f` from `I` to `J` is equal to the composition of `f` mapped through the functor `CochainComplex.single₀ C` and `I.ι`. In other words, the diagram commutes in the category of cochain complexes.

Given abelian categories `C`, objects `Y` and `Z`, and injective resolutions `I` of `Y` and `J` of `Z`, the diagram commutes in the category of cochain complexes between `CochainComplex.single₀ C(J.ι, I.ι)` and `J.ι ∘ f ∘ I.ι`, where `f` is a morphism from `Z` to `Y`.


theorem Hyperreal.infinitePos_neg : ∀ {x : ℝ*}, Hyperreal.InfinitePos (-x) ↔ Hyperreal.InfiniteNeg x := by sorry

The theorem `Hyperreal.infinitePos_neg` states that for any hyperreal number `x`, `-x` is positively infinite if and only if `x` is negatively infinite. In other words, a hyperreal number `x` is negatively infinite (meaning it is less than all real numbers) if its negation `-x` is positively infinite (meaning `-x` is greater than all real numbers), and vice versa.

For any hyperreal number `x`, `-x` is positively infinite if and only if `x` is negatively infinite.


theorem ENNReal.ne_top_of_tsum_ne_top : ∀ {α : Type u_1} {f : α → ENNReal}, ∑' (a : α), f a ≠ ⊤ → ∀ (a : α), f a ≠ ⊤ :=
  by sorry

The theorem `ENNReal.ne_top_of_tsum_ne_top` states that for any type `α` and any function `f` from `α` to the extended nonnegative real numbers (denoted as `ENNReal`), if the infinite sum (also known as series) of `f(a)` for all `a` from `α` is not equal to positive infinity (`⊤`), then `f(a)` is not equal to positive infinity for all `a` in `α`. In other words, if the series of values of a function doesn't reach infinity, then the function itself doesn't reach infinity for any of its inputs.

If the series of a function from a type to the extended nonnegative real numbers is finite, then the function is bounded.


theorem FirstOrder.Language.Structure.cg_def :
    ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : FirstOrder.Language.Structure L M],
      FirstOrder.Language.Structure.CG L M ↔ FirstOrder.Language.Substructure.CG ⊤ :=
  by sorry

This theorem states that for any first-order language `L` and any type `M` which has a `FirstOrder.Language.Structure` instance, a structure of language `L` on `M` is countably generated if and only if the top-level substructure (`⊤`) of the same language on `M` is countably generated. In other words, a structure is countably generated (i.e., it can be built from a countable set) if the most encompassing substructure can also be constructed from a countable set.

For any first-order language L and type M with a Structure instance, the structure of language L on M is countably generated if and only if the top-level substructure of L on M is countably generated.


theorem Set.neg_singleton : ∀ {α : Type u_2} [inst : InvolutiveNeg α] (a : α), -{a} = {-a} := by sorry

The theorem `Set.neg_singleton` asserts that for all types `α` and for all elements `a` of type `α`, where `α` has an involutive negation operation (i.e., applying the negation operation twice yields the original element), the negation of the singleton set containing `a` is the singleton set containing the negation of `a`. In simpler terms, it states that negating the set containing only `a` is equivalent to creating a set that contains only the negation of `a`.

For any type `α` with an involutive negation operation, the negation of a singleton set `{a : α}` is the singleton set `{−a : α}`.


TopHom.ext

theorem TopHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Top α] [inst_1 : Top β] {f g : TopHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any types `α` and `β` which have a topology (`Top α` and `Top β`), if there are two continuous functions (`TopHom α β`), `f` and `g`, that map elements of `α` to `β`, then if for each element `a` in `α`, `f(a)` equals `g(a)`, it implies that the functions `f` and `g` are equal. In simpler terms, it says that if two continuous functions from one topological space to another always yield the same results for the same inputs, then those two functions are considered to be the same.

If `α` and `β` are topological spaces, and `f` and `g` are continuous functions `α → β` with `f(a) = g(a)` for all `a ∈ α`, then `f = g`.


theorem Isometry.prod_map :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : PseudoEMetricSpace γ] {δ : Type u_2} [inst_3 : PseudoEMetricSpace δ] {f : α → β} {g : γ → δ},
      Isometry f → Isometry g → Isometry (Prod.map f g) :=
  by sorry

The theorem `Isometry.prod_map` states that for any two given isometric mappings `f` and `g` - where `f` is a map from a pseudoemetric space `α` to another pseudoemetric space `β`, and `g` is a map from a pseudoemetric space `γ` to another pseudoemetric space `δ` - the function `Prod.map f g` is also an isometry. In other words, if `f` and `g` preserve the pseudoemetric distance between elements of their respective domains, then the function that applies `f` to the first component of a pair and `g` to the second also preserves the pseudoemetric distance.

If `f` is an isometry from pseudometric space `α` to `β` and `g` is an isometry from pseudometric space `γ` to `δ`, then the function `Prod.map f g : α × γ → β × δ` is an isometry.


theorem Hyperreal.infinitesimal_def : ∀ {x : ℝ*}, Hyperreal.Infinitesimal x ↔ ∀ (r : ℝ), 0 < r → -↑r < x ∧ x < ↑r := by
  sorry

The theorem `Hyperreal.infinitesimal_def` states that for every hyperreal number 'x', 'x' is infinitesimal if and only if for every real number 'r' greater than zero, 'x' lies in the interval (-r, r). In other words, a hyperreal number is infinitesimal if and only if it is strictly between the negated and the positive representation of every positive real number.

A hyperreal number is infinitesimal if and only if it lies strictly between the negated and positive representations of every positive real number.


theorem ascPochhammer_eval_cast :
    ∀ (S : Type u) [inst : Semiring S] (n k : ℕ),
      ↑(Polynomial.eval k (ascPochhammer ℕ n)) = Polynomial.eval (↑k) (ascPochhammer S n) :=
  by sorry

The theorem `ascPochhammer_eval_cast` states that for any semiring `S`, and any natural numbers `n` and `k`, the evaluation of the `ascPochhammer` polynomial with coefficients in the natural numbers, at `k`, cast to `S`, is equal to the evaluation of the `ascPochhammer` polynomial with coefficients in `S`, at `k` cast to `S`. In other words, it asserts the equality between the result of evaluating the ascending Pochhammer symbol (represented as a polynomial) when coefficients are in natural numbers and then cast into semiring `S`, and directly evaluating the ascending Pochhammer symbol in the semiring `S`.

The theorem `ascPochhammer_eval_cast` asserts that the evaluation of the ascending Pochhammer polynomial with natural number coefficients in semiring `S`, and the direct evaluation of the ascending Pochhammer polynomial in `S`, are equal.


theorem Subfield.gc_map_comap :
    ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] (f : K →+* L),
      GaloisConnection (Subfield.map f) (Subfield.comap f) :=
  by sorry

The theorem `Subfield.gc_map_comap` states that for any division rings `K` and `L`, and any ring homomorphism `f` from `K` to `L`, there exists a Galois connection between the mapping of a subfield along `f` and the preimage of a subfield along `f`. In other words, for any subfield `a` of `K` and subfield `b` of `L`, `a` is mapped to a subfield that's less than or equal to `b` through `f` if and only if `a` is less than or equal to the preimage of `b` through `f`. This connects the concepts of subfield mapping and preimage, and shows that they form a Galois connection, a special case of adjoint functors in category theory.

For any division rings K and L and ring homomorphism f from K to L, the mapping of subfields of K along f and the preimage of subfields of L along f form a Galois connection.


theorem Real.Angle.coe_toReal : ∀ (θ : Real.Angle), ↑(Real.Angle.toReal θ) = θ := by sorry

This theorem, `Real.Angle.coe_toReal`, states that for every angle `θ` of type `Real.Angle`, the operation of converting `θ` to a real number in the interval `Ioc (-π) π` via the function `Real.Angle.toReal`, and then lifting it back to the `Real.Angle` type through the coercion operation (`↑`), yields the original angle `θ`. In simpler terms, this theorem asserts that the conversion between `Real.Angle` and real numbers via `Real.Angle.toReal` and back is lossless - you end up with the exact same angle you started with.

The conversion of a real number in the interval `(-π, π)` to an `Real.Angle` type and back using `Real.Angle.toReal` and coercion is a lossless operation. In mathematical notation, given `θ : Real.Angle` such that `Real.Angle.toReal θ ∈ (-π, π)`, we have `θ = ↑(Real.Angle.toReal θ)`.


theorem Mathlib.Data.Set.Intervals.Disjoint._auxLemma.10 :
    ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), ⋃ i, s ∩ t i = s ∩ ⋃ i, t i := by sorry

The theorem `Mathlib.Data.Set.Intervals.Disjoint._auxLemma.10` states that for any type `β`, any Sort `ι`, any set `s` of type `β`, and any function `t` from `ι` to sets of type `β`, the union over `i` of the intersection of `s` and `t i` is equal to the intersection of `s` and the union over `i` of `t i`. In other words, this is a distributive law of intersection over union for sets in mathematics, often written in LaTeX as $\bigcup_{i} (s \cap t_{i}) = s \cap \bigcup_{i} t_{i}$.

For any type `β` and Sort `ι`, the intersection of a set `s` of type `β` with the union of functions `t : ι → sets β` equals the union of intersections `s ∩ ⋃i ti`.


theorem Mathlib.Data.Set.Intervals.Disjoint._auxLemma.12 :
    ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), ⋃ i, t i ∩ s = (⋃ i, t i) ∩ s := by sorry

This theorem, named `Mathlib.Data.Set.Intervals.Disjoint._auxLemma.12`, states that for any type `β`, and any indexed collection of sets `t` (of type `ι → Set β`), and any set `s` of the same type `β`, the union over `i` of the intersection of `t i` and `s` is equal to the intersection of the union over `i` of `t i` and `s`. In other words, it expresses the distributive property of union over intersection, also known as the Law of Distribution, for sets. This property states that intersecting a set with a union of sets yields the same result as taking the union of the intersections of the set with each of the sets in the union. In mathematical terms, this theorem can be written as $\bigcup_i (t_i \cap s) = (\bigcup_i t_i) \cap s$.

The theorem asserts that for any indexed collection `t` and set `s` of the same type, the intersection of the union of `t i` and `s` is equal to the union of intersections of `t i` and `s`. In symbols, $\bigcup\_i (t\_i \cap s) = (\bigcup\_i t\_i) \cap s$.


theorem isGLB_Ioo :
    ∀ {γ : Type w} [inst : SemilatticeSup γ] [inst_1 : DenselyOrdered γ] {a b : γ}, a < b → IsGLB (Set.Ioo a b) a := by
  sorry

The theorem `isGLB_Ioo` states that for any type `γ` that is both a semilattice with sup operation and densely ordered, and for any two elements `a` and `b` of this type such that `a` is less than `b`, `a` is the greatest lower bound (GLB) of the open interval between `a` and `b`. This means that `a` is less than or equal to every element in the open interval from `a` to `b` (`a` and `b` excluded), and any other element that is also less than or equal to every element of the interval is less than or equal to `a`.

For any semilattice `γ` with sup operation and dense ordering, if `a` is the least element greater than or equal to `a` in the open interval `(a, b)`, then `a` is the greatest lower bound of `(a, b)`.


theorem Polynomial.mem_rootSet' :
    ∀ {T : Type w} [inst : CommRing T] {p : Polynomial T} {S : Type u_1} [inst_1 : CommRing S] [inst_2 : IsDomain S]
      [inst_3 : Algebra T S] {a : S},
      a ∈ Polynomial.rootSet p S ↔ Polynomial.map (algebraMap T S) p ≠ 0 ∧ (Polynomial.aeval a) p = 0 :=
  by sorry

The theorem `Polynomial.mem_rootSet'` states the following: For any commutative ring `T` and any polynomial `p` with coefficients in `T`, and for any other commutative ring `S` which is also assumed to be a domain, and an algebra over `T`, and an element `a` in `S`, `a` is a root of the polynomial `p` in `S` if and only if the image of the polynomial `p` under the ring homomorphism from `T` to `S` (given by the algebra structure) is nonzero and the polynomial `p` evaluated at `a` (using the unique algebra homomorphism from the polynomial ring over `T` to `S` that sends the variable to `a`) is zero.
This means that `a` is a root of `p` in `S` precisely when `p` doesn't map to the zero polynomial in `S` and `p` evaluated at `a` yields zero.

A element `a` in a commutative ring `S` is a root of polynomial `p` with coefficients in a commutative ring `T` if and only if the image of `p` under the ring homomorphism from `T` to `S` is nonzero and `p(a)` equals zero in `S`.


theorem Mathlib.Data.Int.Parity._auxLemma.4 : ∀ {n : ℤ}, Odd n = ¬Even n := by sorry

The theorem `Mathlib.Data.Int.Parity._auxLemma.4` states that for any integer `n`, `n` is odd if and only if `n` is not even. In mathematical terms, an integer `n` is considered odd (as per the given definition) if there exists another integer `k` such that `n = 2*k + 1`, and it is considered even if there exists an integer `r` such that `n = r + r`. The theorem establishes the mutual exclusivity of these two properties, meaning an integer can't be both odd and even at the same time.

An integer is odd if and only if it is not even. In other words, an integer is odd if and only if it cannot be expressed as the sum of two equal integers.


theorem inner_sub_right :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y z : E), ⟪x, y - z⟫_𝕜 = ⟪x, y⟫_𝕜 - ⟪x, z⟫_𝕜 :=
  by sorry

The theorem `inner_sub_right` states that for all elements `x`, `y`, and `z` of an inner product space `E` over a field `𝕜`, the inner product of `x` and the difference `y - z` equals the difference of the inner products of `x` and `y`, and of `x` and `z`. This can be written in mathematical notation as `⟪x, y - z⟫_𝕜 = ⟪x, y⟫_𝕜 - ⟪x, z⟫_𝕜`. Here `⟪., .⟫_𝕜` denotes the inner product operation, `E` is assumed to be a normed additive commutative group, and `𝕜` is assumed to support operations that make it behave like the real or complex numbers.

The inner product of an element with the difference of two other elements is equal to the difference of their inner products.


theorem mul_eq_one :
    ∀ {α : Type u} [inst : CommMonoid α] [inst_1 : Subsingleton αˣ] {a b : α}, a * b = 1 ↔ a = 1 ∧ b = 1 := by sorry

This theorem, `mul_eq_one`, states that for any type `α` that is a commutative monoid, and where `αˣ` (the units of `α`) is a subsingleton (i.e., has at most one element), if the product of any two elements `a` and `b` of `α` equals one, then it is necessary and sufficient that both `a` and `b` are equal to one.

For any commutative monoid `α` with a subsingleton unit set, `α × α` consists only of the pair `(1, 1)` if and only if for all `a, b ∈ α`, `a * b = 1` implies `a = b = 1`.


theorem TopologicalSpace.gc_generateFrom :
    ∀ (α : Type u_1),
      GaloisConnection (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual) :=
  by sorry

The theorem `TopologicalSpace.gc_generateFrom` asserts that for any type `α`, there exists a Galois connection between the function that maps a set to the dual order of the set of its open subsets and the generator function of the smallest topological space containing a collection of basic sets transformed by the dual order of a linear order function. In other words, the theorem describes a relationship between certain operations on open sets in topological spaces and the generation of topological spaces from sets of basic open sets under an order reversal. Thus, it creates a link between the structure of topological spaces and the dual order of their open sets.

The theorem `TopologicalSpace.gc_generateFrom` states that for any type `α`, there exists a Galois connection between the function mapping sets to their dual orders of open subsets and the generator function of the smallest topological space containing a collection of basic sets transformed by a linear order's dual order.


theorem Mathlib.Data.Polynomial.Lifts._auxLemma.1 :
    ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {f : R →+* S} {y : S},
      (y ∈ RingHom.rangeS f) = ∃ x, f x = y :=
  by sorry

This theorem states that for any two types `R` and `S` that are non-associative semirings, along with a ring homomorphism `f` from `R` to `S`, and an element `y` of `S`, `y` is in the range of `f` if and only if there exists an element `x` in `R` such that `f(x)` equals `y`. Simply put, `y` is in the range of `f` iff `y` is the image of some element under `f`.

For any non-associative semirings R and S, and a ring homomorphism f from R to S, y ∈ Im(f) if and only if there exists x ∈ R such that f(x) = y.


/-- It is equivalent to sum a function over `fin n` or `finset.range n`. -/
theorem Fin.sum_univ_eq_sum_range :
    ∀ {α : Type u_1} [inst : AddCommMonoid α] (f : ℕ → α) (n : ℕ),
      (Finset.sum Finset.univ fun i => f ↑i) = Finset.sum (Finset.range n) fun i => f i :=
  by sorry

The theorem `Fin.sum_univ_eq_sum_range` states that for any natural number `n`, and for any function `f` from the natural numbers to a type `α` that is an additive commutative monoid, the sum of `f` over all elements in `fin n` (the finite set of natural numbers less than `n`) is equal to the sum of `f` over all elements in the set `finset.range n` (also the set of natural numbers less than `n`). Essentially, this theorem shows that these two ways of summing a function over a range of natural numbers are equivalent.

For any additive commutative monoid type `α` and natural number `n`, the sum of a function from `Fin n` to `α` is equal to the sum of the restriction of that function to `finset.range n`.


theorem Nat.Linear.Poly.denote_sort_go :
    ∀ (ctx : Nat.Linear.Context) (p r : Nat.Linear.Poly),
      Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.sort.go p r) =
        Nat.Linear.Poly.denote ctx p + Nat.Linear.Poly.denote ctx r :=
  by sorry

This theorem states that for any natural number linear context `ctx` and any two natural number linear polynomials `p` and `r`, the denotation (interpretation as a natural number) of the sorted polynomial obtained by the function `sort.go` applied on `p` and `r`, is equal to the sum of the denotations of `p` and `r` in the context `ctx`. In other words, the function `sort.go` preserves the sum operation under the denotation from polynomials to natural numbers.

For any natural number linear context `ctx` and natural number linear polynomials `p` and `r`, the denotation of `sort.go (p + r)` equals the denotation of `p` plus the denotation of `r` in context `ctx`.


/-- The substructure generated by a set includes the set.  -/
theorem FirstOrder.Language.Substructure.subset_closure :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {s : Set M},
      s ⊆ ↑((FirstOrder.Language.Substructure.closure L).toFun s) :=
  by sorry

This theorem states that for any first-order language `L`, a type `M`, and a set `s` of elements of type `M`, the substructure generated by `s` in the language `L` contains `s` itself. In other words, every element of the set `s` is also an element of the substructure generated by `s`. This is usually the case in algebraic structures where the substructure generated by a set is the smallest substructure containing that set.

For any first-order language L and set s of elements from a type M, the substructure of M generated by s includes s itself.


theorem MeasureTheory.withDensity_apply' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ]
      (f : α → ENNReal) (s : Set α), ↑↑(μ.withDensity f) s = ∫⁻ (a : α) in s, f a ∂μ :=
  by sorry

The theorem `MeasureTheory.withDensity_apply'` states that, for any type `α`, any measurable space `m0` on `α`, any measure `μ` on `α` that is sigma-finite, any function `f` from `α` to the extended nonnegative real numbers, and any set `s` of `α`, the measure of `s` with respect to the measure `μ` "weighted" by `f` (denoted `μ.withDensity f`) is equal to the integral over `s` of `f` with respect to `μ`. In mathematical terms, `∫⁻ (a : α) in s, f a ∂μ` represents the Lebesgue integral of the function `f` over the set `s` with respect to the measure `μ`.

For any sigma-finite measure `μ` on a measurable space `(α, m0)` and measurable function `f` from `α` to the extended nonnegative reals, the integral of `f` with respect to `μ` equals the measure of the set where `f` is positive, weighted by `f` itself, according to `μ.withDensity f`.


theorem CategoryTheory.Functor.locallyCoverDense_of_isCoverDense :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2}
      [inst_1 : CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D)
      (K : CategoryTheory.GrothendieckTopology D) [inst_2 : CategoryTheory.Full G]
      [inst_3 : CategoryTheory.Functor.IsCoverDense G K], CategoryTheory.LocallyCoverDense K G :=
  by sorry

The theorem `CategoryTheory.Functor.locallyCoverDense_of_isCoverDense` states that for any categories `C` and `D`, a functor `G` from `C` to `D`, and a Grothendieck topology `K` on `D`, if `G` is fully faithful and is cover dense with respect to `K`, then `G` is locally cover dense with respect to `K`. In category theory, a functor being "cover dense" or "locally cover dense" roughly means that it interacts with the Grothendieck topology in a way that the topology can be transferred across the functor in some sense, making it useful for studying sheaves and toposes.

If `G: C -> D` is a fully faithful functor between categories and is cover dense with respect to a Grothendieck topology `K` on `D`, then `G` is locally cover dense with respect to `K`.