theorem TopologicalSpace.IsTopologicalBasis.secondCountableTopology :
    ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
      TopologicalSpace.IsTopologicalBasis b → Set.Countable b → SecondCountableTopology α :=
  by sorry

This theorem states that for any given type `α` and a topological space `t` over this type, if there exists a set `b` that forms a topological basis of the space, and this set `b` is countable (in the sense that there exists an injective map from `b` to the natural numbers), then the topology of the space is second-countable. In topological terms, a second-countable topology is one where there exists a countable base for the topology, that is, a countable collection of open sets such that every open set in the topology can be written as a union of sets from this collection.

If `α` is a type with a countable topological basis `b`, then the topology on `α` is second-countable.


theorem PartitionOfUnity.mem_finsupport :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X) {i : ι},
      i ∈ PartitionOfUnity.finsupport ρ x₀ ↔ i ∈ Function.support fun i => (ρ i) x₀ :=
  by sorry

This theorem states that for any type `ι`, topological space `X`, set `s` of `X`, partition of unity `ρ` on `s` indexed by `ι`, and point `x₀` in `X`, a given index `i` of type `ι` is in the finitely supported partition of unity at `x₀` if and only if `i` exists in the support of the function obtained by applying partition of unity `ρ` at `x₀`. This essentially relates the support of a partition of unity at a point to the support of the corresponding function over the indices.

For any type `ι`, topological space `X`, set `s` of `X`, partition of unity `ρ` on `s` indexed by `ι`, and point `x₀` in `X`, an index `i` of type `ι` is in the finitely supported partition of unity at `x₀` if and only if `i` is in the support of the function `ρ(x₀)`.


theorem Cardinal.bddAbove_image :
    ∀ (f : Cardinal.{u} → Cardinal.{max u v}) {s : Set Cardinal.{u}}, BddAbove s → BddAbove (f '' s) := by sorry

This theorem states that for any function `f` which maps a cardinal number of type `u` to a cardinal number of the maximum type of `u` and `v`, and any set `s` of cardinal numbers of type `u`, if the set `s` is bounded above (i.e., there exists an upper bound for the cardinal numbers in `s`), then the image of the set `s` under the function `f` (i.e., the set of all cardinal numbers obtained by applying `f` to every element of `s`) is also bounded above. This means that an upper bound also exists for all cardinal numbers that can be obtained from `s` by applying `f`.

If `f` is a function mapping cardinal numbers of type `u` to the maximum of `u` and `v`, and `s` is a bounded set of cardinal numbers of type `u`, then the image of `s` under `f` is also a bounded set.


theorem map_zsmul' :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : SubNegMonoid G]
      [inst_2 : SubNegMonoid H] [inst_3 : AddMonoidHomClass F G H] (f : F),
      (∀ (x : G), f (-x) = -f x) → ∀ (a : G) (n : ℤ), f (n • a) = n • f a :=
  by sorry

The theorem `map_zsmul'` states that for any types `G`, `H`, and `F`, if `F` can be injected into a function from `G` to `H`, both `G` and `H` have a subtraction and negation operation (i.e., they are `SubNegMonoid`s), and `F` can be treated as a homomorphism from an additive monoid `G` to another additive monoid `H` (i.e., `F` follows the `AddMonoidHomClass` rules), then for any instance `f` of `F`, if `f` preserves negation (i.e., mapping `f` to `-x` results in `-f x` for any `x` in `G`), `f` also preserves the scalar multiplication of an integer `n` with a `SubNegMonoid` element `a` (i.e., `f (n • a) = n • f a` for any `a` in `G` and any integer `n`).

If `F` is an additive homomorphism from a subtraction and negation monoid `G` to another such monoid `H` that preserves negation, then `F` preserves scalar multiplication by integers.


theorem Ordinal.lt_opow_of_limit :
    ∀ {a b c : Ordinal.{u_1}}, b ≠ 0 → Ordinal.IsLimit c → (a < b ^ c ↔ ∃ c' < c, a < b ^ c') := by sorry

This theorem, `Ordinal.lt_opow_of_limit`, states that for any three ordinals `a`, `b`, and `c`, where `b` is not zero and `c` is a limit ordinal, `a` is less than `b` to the power `c` if and only if there exists an ordinal `c'` less than `c` such that `a` is less than `b` to the power `c'`. The power operation here is ordinal exponentiation.

For any ordinals `a`, `b`, and limit ordinal `c` with `b > 0`, `a < b^c` if and only if there exists an ordinal `c' < c` such that `a < b^c'`.


IsLocalHomeomorph.isLocallyInjective

theorem IsLocalHomeomorph.isLocallyInjective :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      IsLocalHomeomorph f → IsLocallyInjective f :=
  by sorry

The theorem `IsLocalHomeomorph.isLocallyInjective` asserts that for any function `f` from a topological space `X` to another topological space `Y`, if `f` satisfies the property `IsLocalHomeomorph`, i.e., each point in `X` is in the source of some partial homeomorphism with `f` equal to the inclusion of this partial homeomorphism, then `f` also satisfies the property `IsLocallyInjective`, i.e., around every point of `X`, there exists a neighborhood on which `f` is injective.

If a function between topological spaces is a local homeomorphism, then it is locally injective.


/-- `⊥`, coerced to a set, is the empty set.  -/
theorem AffineSubspace.bot_coe :
    ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P], ↑⊥ = ∅ :=
  by sorry

This theorem states that the bottom element (`⊥`), when coerced to a set, is the empty set (`∅`). The statement holds for any types `k`, `V`, and `P`; with `k` being a ring, `V` an additive commutative group, and `V` a `k`-module; and considering `S` as an additive torsor structure over `V` and `P`. The `⊥` here is used in the context of affine subspaces.

The bottom element `⊥` of an affine subspace over a ring `k`, an additive commutative group `V`, and a `k`-module `P`, coerced to a set, equals the empty set `∅`.


theorem Set.biUnion_univ : ∀ {α : Type u_1} {β : Type u_2} (s : α → Set β), ⋃ x ∈ Set.univ, s x = ⋃ x, s x := by sorry

This theorem, `Set.biUnion_univ`, states that for all types `α` and `β`, and for any function `s` that maps elements of `α` to sets of `β`, the union over all elements of `s` where the elements are in the universal set of `α` is equal to the union over all elements of `s`. In other words, it's saying that when we form a union of sets using elements from the universal set, it's the same as just forming a union over all sets produced by function `s`. This is a reflection of the fact that the universal set contains all elements of the type.

For any function `s` mapping elements of type `α` to sets of type `β`, the union of `s ↥ X` (image of `X` under `s`) equals the set `⋃x ∈ X. s x`, where `X` is the universal set of type `α`.


theorem mul_lt_one_of_nonneg_of_lt_one_left :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a b : α}, 0 ≤ a → a < 1 → b ≤ 1 → a * b < 1 := by sorry

This theorem states that for any ordered semiring `α`, and any two elements `a` and `b` of `α`, if `a` is nonnegative and less than 1, and `b` is less than or equal to 1, then the product of `a` and `b` is less than 1. Intuitively, this reflects the idea that multiplying two values, both less than or equal to 1, gives a result that is also less than 1.

For any ordered semiring `α`, if `a, b ∈ α` satisfy `0 ≤ a < 1` and `0 ≤ b ≤ 1`, then `a * b < 1`.


/-- Given a point in an affine subspace, a result of subtracting that point on the right is in the
direction if and only if the other point is in the subspace.  -/
theorem AffineSubspace.vsub_right_mem_direction_iff_mem :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P},
      p ∈ s → ∀ (p2 : P), p2 -ᵥ p ∈ AffineSubspace.direction s ↔ p2 ∈ s :=
  by sorry

This theorem states that for any given point in an affine subspace of a vector space, the result of subtracting that point from another point is in the direction of the affine subspace if and only if the other point is also in the affine subspace. This holds for any field `k`, any additive commutative group `V`, and any module space `P`, as well as any point `p` in the affine subspace `s`. In other words, the relative position of two points in an affine subspace can only be expressed as a vector in the direction of that subspace if both points are actually part of the subspace.

For any affine subspace of a vector space over a field, the difference of two points in the subspace is collinear with the second point if and only if both points belong to the subspace.


theorem Set.not_mem_subset : ∀ {α : Type u} {a : α} {s t : Set α}, s ⊆ t → a ∉ t → a ∉ s := by sorry

This theorem states that for any type `α`, any element `a` of that type, and any sets `s` and `t` of the same type, if `s` is a subset of `t` and `a` is not an element of `t`, then `a` is also not an element of `s`. In mathematical terms, if $s \subseteq t$ and $a \notin t$, then it must be the case that $a \notin s$.

If a set `s` is a subset of set `t` and an element `a` is not in `t`, then `a` is not in `s`. In mathematical notation, $a \notin s$ given $s \subseteq t$ and $a \notin t$.


theorem Finset.exists_max_image :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] (s : Finset β) (f : β → α),
      s.Nonempty → ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x :=
  by sorry

This theorem states that for any non-empty finite set `s` of type `β` and any function `f` from `β` to `α` (where `α` is a linearly ordered type), there exists an element `x` in `s` such that the image of `x` under `f` is greater than or equal to the image of any other element in `s` under `f`. In other words, `f(x)` is the maximum value attained by `f` on `s`.

For any non-empty finite set `s` and function `f` from a linearly ordered type to itself, there exists an element `x` in `s` such that `f(x)` is the maximum value of `f` on `s`.


theorem PosNum.le_to_nat : ∀ {m n : PosNum}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem states that for all positive numbers `m` and `n`, the equality `m ≤ n` holds if and only if the same inequality holds when both numbers are converted to natural numbers. In other words, a positive number `m` is less than or equal to another positive number `n` if and only if the natural number representation of `m` is less than or equal to the natural number representation of `n`.

For all positive integers m and n, m ≤ n if and only if the natural numbers representing m and n satisfy the same inequality.


theorem Multiplicative.ofAdd_le :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Multiplicative.ofAdd a ≤ Multiplicative.ofAdd b ↔ a ≤ b := by sorry

This theorem states that for any type `α` with a pre-order relation (`≤`), given any two elements `a` and `b` of this type, the relation `Multiplicative.ofAdd a ≤ Multiplicative.ofAdd b` holds if and only if `a ≤ b`. Here, `Multiplicative.ofAdd` is a function that reinterprets an element `x : α` as an element of `Multiplicative α`.

For any type `α` with a pre-order relation `≤`, and for all `a, b : α`, `Multiplicative.ofAdd a ≤ Multiplicative.ofAdd b` if and only if `a ≤ b`.


theorem ENNReal.toReal_prod :
    ∀ {ι : Type u_1} {s : Finset ι} {f : ι → ENNReal},
      (Finset.prod s fun i => f i).toReal = Finset.prod s fun i => (f i).toReal :=
  by sorry

The theorem `ENNReal.toReal_prod` states that for any finite set `s` of an arbitrary type `ι` and any function `f` that maps elements of type `ι` to extended nonnegative real numbers (ENNReal), the real part of the product of the `f` values for all elements in `s` is equal to the product of the real parts of the `f` values for all elements in `s`. This essentially indicates that taking the product of the `f` values and then the real part is the same as taking the real part of each `f` value and then their product. In mathematical terms, for any set $s$ and function $f : \iota \rightarrow [0, \infty]$ we have $\text{toReal}(\prod_{i \in s} f(i)) = \prod_{i \in s} \text{toReal}(f(i))$.

For any set $s$ and function $f : \iota \rightarrow [0, \infty]$, we have $\text{toReal}(\prod\_{i \in s} f(i)) = \prod\_{i \in s} \text{toReal}(f(i))$.


theorem Compactum.str_eq_of_le_nhds :
    ∀ {X : Compactum} (F : Ultrafilter X.A) (x : X.A), ↑F ≤ nhds x → Compactum.str X F = x := by sorry

This theorem states that for any compactum `X`, given an ultrafilter `F` on `X.A` and an element `x` of `X.A`, if `F` is less than or equal to the neighborhood filter at `x`, then the structure map of `X` applied to `F` equals `x`. In other words, if the ultrafilter `F` is within the neighborhood of `x`, then the limit of the ultrafilter, as evaluated by the structure map, is `x` itself.

For any compactum X and ultrafilter F on X.A, if F is contained in the neighborhood filter of x in X.A, then the limit of F, under the structure map of X, is x.


Nat.ModEq.comm

theorem Nat.ModEq.comm : ∀ {n a b : ℕ}, a ≡ b [MOD n] ↔ b ≡ a [MOD n] := by sorry

This theorem states that for any three natural numbers `n`, `a`, and `b`, the statement "a is congruent to b modulo n" is equivalent to the statement "b is congruent to a modulo n". In other words, the congruence relation modulo n is symmetric. In mathematical terms, if `a ≡ b [MOD n]` is true, then `b ≡ a [MOD n]` is also true, and vice versa.

The congruence relation modulo n is a symmetric equivalence relation.


theorem Mathlib.CategoryTheory.NatIso._auxLemma.5 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.Mono f]
      {g h : Z ⟶ X}, (CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) :=
  by sorry

The theorem `Mathlib.CategoryTheory.NatIso._auxLemma.5` asserts that for any Category `C` and objects `X`, `Y`, and `Z` within this Category, given a morphism `f` from `X` to `Y` that is monic (or injective), and two morphisms `g` and `h` from `Z` to `X`, the statement that the composition of `g` and `f` is equal to the composition of `h` and `f` implies that `g` is equal to `h`. This is a property related to the cancellation law for monic (or injective) morphisms in category theory.

Given a category C, objects X, Y, Z, a monic morphism f : X -> Y, and morphisms g, h : Z -> X with g \* f = h \* f, then g = h.


theorem MulOpposite.op_one : ∀ (α : Type u_1) [inst : One α], MulOpposite.op 1 = 1 := by sorry

This theorem states that for any type `α` which has a multiplicative identity element (denoted by `1`), the "opposite" or "mirror" of this identity element using the `MulOpposite.op` function is still the identity. In other words, if you take the multiplicative identity of `α` and apply the `MulOpposite.op` function to it, you will still get the identity element. This holds true for any type `α` that has a multiplicative identity.

For any type `α` with a multiplicative identity element `1`, the multiplicative identity and its opposite `MulOpposite.op 1` are equal.


theorem List.map_ret_sublist_sublists :
    ∀ {α : Type u} (l : List α), List.Sublist (List.map List.ret l) (List.sublists l) := by sorry

This theorem states that for any list `l` of a general type `α`, the list obtained by applying the function `List.ret` (which maps each element of `l` to a list containing just that element) is a sublist of the list of all non-contiguous sublists of `l`. In other words, if you map each element of `l` to a list containing just that element, every resulting list will also appear in the list of all possible sublists of `l`.

For any list `l` of type `α`, the image of `l` under the function `List.ret` is a subcollection of the set of all non-contiguous sublists of `l`.


theorem CategoryTheory.Limits.pullback.diagonal.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f :=
  by sorry

This theorem states that in any category `C`, for any objects `X` and `Y` in `C` and for any morphism `f` from `X` to `Y`, the composition of the identity morphism on `X` with `f` is equal to the composition of the identity morphism on `X` with `f`. In simpler terms, it says that composing `f` with the identity on `X` doesn't change `f`, a fundamental property in category theory.

In any category, the composition of an identity morphism with any morphism is equal to the morphism itself.


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

The theorem `IsClosedMap.closure_image_subset` states that for any two types `X` and `Y`, if `f` is a closed map from `X` to `Y` and `s` is a set of elements of type `X`, then the closure of the image of set `s` under the function `f` is a subset of the image of the closure of `s` under function `f`. In other words, taking the closure after the function `f` is applied is contained within applying the function `f` after taking the closure.

For any closed map `f` between topological spaces `X` and `Y`, and any set `s` in `X`, the closure of `f(s)` is contained in `f(Closure(s))`.


theorem Set.SurjOn.subset_range :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.SurjOn f s t → t ⊆ Set.range f := by sorry

The theorem `Set.SurjOn.subset_range` states that for all types `α` and `β`, for any set `s` of type `α`, any set `t` of type `β`, and any function `f` from `α` to `β`, if `f` is surjective from `s` to `t` (i.e., every element of `t` is an image of some element of `s` under `f`), then the set `t` is a subset of the range of `f`. In other words, all elements of `t` are the images of some elements under the function `f`, without any restriction to `s`.

If a function from type `α` to type `β` is surjective, then the image of the function contains the entire codomain `β`, i.e., `image f ⊆ β`.


IsLindelof.image

/-- A continuous image of a Lindelöf set is a Lindelöf set within the codomain.  -/
theorem IsLindelof.image :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {f : X → Y},
      IsLindelof s → Continuous f → IsLindelof (f '' s) :=
  by sorry

The theorem states that a continuous image of a Lindelöf set is also a Lindelöf set within the codomain. In more detail, given two types `X` and `Y`, both equipped with a topological space structure, a set `s` of type `X`, and a function `f` from `X` to `Y`, if `s` is a Lindelöf set and `f` is a continuous function, then the image of `s` under `f` (denoted as `f '' s`) is a Lindelöf set in `Y`. In the context of topology, a set is Lindelöf if every open cover has a countable subcover. This property is preserved under continuous mappings.

A continuous image of a Lindelöf set is a Lindelöf set.


theorem Set.countable_univ : ∀ {α : Type u} [inst : Countable α], Set.Countable Set.univ := by sorry

This theorem states that for any type `α`, if `α` is countable (meaning there exists an injective map from `α` to the natural numbers `ℕ`), then the universal set of `α` is also countable. The universal set of `α` is the set containing all elements of `α`. So, in other words, if we can count the elements of a type `α`, then we can also count all elements in the set of all things of type `α`.

If `α` is a countable type, then its universe is also countable.


theorem Nat.dist_comm : ∀ (n m : ℕ), Nat.dist n m = Nat.dist m n := by sorry

The theorem `Nat.dist_comm` states that for all natural numbers `n` and `m`, the distance between `n` and `m` is the same as the distance between `m` and `n`. This expresses the commutative property of the distance function on natural numbers, which implies that the order of the inputs does not affect the result: swapping the inputs will yield the same output. In mathematical notation, we can write this as: for all $n, m \in \mathbb{N}$, $\text{dist}(n, m) = \text{dist}(m, n)$.

The distance between any two natural numbers is commutative, i.e., dist(n, m) = dist(m, n) for all natural numbers n and m.


/-- A recapitulation of the definition of multiplicative that is simpler for proofs  -/
theorem ArithmeticFunction.IsMultiplicative.iff_ne_zero :
    ∀ {R : Type u_1} [inst : MonoidWithZero R] {f : ArithmeticFunction R},
      ArithmeticFunction.IsMultiplicative f ↔
        f 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → Nat.Coprime m n → f (m * n) = f m * f n :=
  by sorry

The theorem named `ArithmeticFunction.IsMultiplicative.iff_ne_zero` states that for any arithmetic function `f` mapping natural numbers to an algebraic structure of type `R` equipped with a `MonoidWithZero` instance, `f` is multiplicative if and only if `f` maps the number 1 to 1 and for any two non-zero natural numbers `m` and `n` that are coprime (their greatest common divisor is 1), the value of `f` at the product `m * n` equals the product of the values of `f` at `m` and `n`. This theorem essentially provides an equivalent definition for a multiplicative arithmetic function that is more convenient for certain proofs.

An arithmetic function is multiplicative if and only if it maps the number 1 to 1 and the product of two coprime natural numbers to the product of the function values at those numbers.


theorem eq_add_of_sub_eq : ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, a - c = b → a = b + c := by sorry

This theorem states that for any type `G` that has an `AddGroup` structure, given any three elements `a`, `b`, and `c` of this type, if `a - c` equals `b`, then `a` equals `b + c`. In more mathematical terms, it says that in any additive group, if the difference of two elements equals a third element, then the first element equals the sum of the third element and the second one. It's essentially a re-arrangement of the standard equation `a - c = b` into the form `a = b + c`.

In any additive group, if the difference of two elements is equal to a third element, then the first element is equal to the sum of the third element and the second one.


theorem List.replicate_add :
    ∀ {α : Type u} (m n : ℕ) (a : α), List.replicate (m + n) a = List.replicate m a ++ List.replicate n a := by sorry

The theorem `List.replicate_add` states that for any type `α`, given two natural numbers `m` and `n`, and an element `a` of type `α`, if we replicate `a` `(m + n)` times, it will result in the same list as if we first replicate `a` `m` times, and then replicate `a` `n` times, and finally concatenate these two lists. In other words, replicating `a` by the sum of two numbers is equivalent to replicating `a` by each of these numbers separately and then concatenating the results.

For any type `α` and natural numbers `m` and `n`, `List.replicate m (List.replicate n a) = List.replicate (m + n) a`.


theorem Equiv.subsingleton_congr : ∀ {α : Sort u} {β : Sort v}, α ≃ β → (Subsingleton α ↔ Subsingleton β) := by sorry

This theorem states that for any sorts `α` and `β`, if `α` is equivalent to `β`, then `α` is a subsingleton if and only if `β` is a subsingleton. Here, a subsingleton is a type that has at most one element. In other words, if we can establish an equivalence between two sorts, then they either both have at most one element, or neither does.

For any sorts `α` and `β`, if `α` is equivalent to `β`, then `α` is a subsingleton if and only if `β` is a subsingleton. (Equivalently, `α` and `β` have the same subsingleton property.)


theorem SetTheory.PGame.neg_equiv_neg_iff : ∀ {x y : SetTheory.PGame}, -x ≈ -y ↔ x ≈ y := by sorry

This theorem states that for any two games `x` and `y` in set theory, the game resulting from negating `x` is equivalent to the game resulting from negating `y` if and only if `x` is equivalent to `y`. In other words, the negation operation on games preserves equivalence.

For all games x and y in set theory, x ��IVE y if and only if ∨x ��IVE ∨y, where ��IVE denotes game equivalence and ∨ denotes the negation of a game.


theorem MvPolynomial.map_map :
    ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      (f : R →+* S₁) [inst_2 : CommSemiring S₂] (g : S₁ →+* S₂) (p : MvPolynomial σ R),
      (MvPolynomial.map g) ((MvPolynomial.map f) p) = (MvPolynomial.map (RingHom.comp g f)) p :=
  by sorry

The theorem `MvPolynomial.map_map` states that for any multivariate polynomial `p` with coefficients in a commutative semiring `R`, and ring homomorphisms `f` from `R` to another commutative semiring `S₁`, and `g` from `S₁` to a third commutative semiring `S₂`, the result of first mapping `p` across `f` and then across `g` is the same as mapping `p` directly across the composition of `g` and `f`. That is, the operation of mapping a multivariate polynomial across a ring homomorphism preserves the composition of homomorphisms.

For any multivariate polynomial over a commutative semiring and ring homomorphisms from two commutative semirings, the composition of their applications to the polynomial equals the application of the polynomial to the composition of the homomorphisms.


SpectralMap.ext

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

This theorem, named `SpectralMap.ext`, states that for any two spectral maps `f` and `g` from a topological space `α` to another topological space `β`, if for every element `a` in `α` the application of `f` and `g` to `a` results in the same element in `β`, then these two spectral maps `f` and `g` are indeed the same. In other words, it ensures the extensionality of spectral maps in the context of topology: two spectral maps are equal if they map every point to the same image.

If two spectral maps from one topological space to another have the same image for every point, then they are equal.


theorem upperBounds_singleton : ∀ {α : Type u} [inst : Preorder α] {a : α}, upperBounds {a} = Set.Ici a := by sorry

This theorem states that for any type `α` equipped with a preorder and any element `a` of type `α`, the set of upper bounds of the singleton set containing just `a` is equivalent to the set of all elements in `α` that are greater than or equal to `a`. In other words, the upper bounds of a singleton set `{a}` is the set of all elements `x` such that `a` is less than or equal to `x`.

The set of upper bounds for a singleton set {a} in a preordered type equals the set of elements greater than or equal to a.


theorem Real.toNNReal_lt_toNNReal_iff' : ∀ {r p : ℝ}, Real.toNNReal r < Real.toNNReal p ↔ r < p ∧ 0 < p := by sorry

The theorem `Real.toNNReal_lt_toNNReal_iff'` states that for any two real numbers `r` and `p`, the non-negative real number reinterpretation of `r` is less than the non-negative real number reinterpretation of `p` if and only if `r` is less than `p` and `p` is greater than `0`. This theorem relates the ordering of real numbers to the ordering of their non-negative reinterpretations.

For any real numbers r and p, r < p and p > 0 if and only if ℝ⁺(r) < ℝ⁺(p), where ℝ⁺ denotes the non-negative real number reinterpretation.


theorem Complex.ofReal_ofNat : ∀ (n : ℕ) [inst : Nat.AtLeastTwo n], ↑(OfNat.ofNat n) = OfNat.ofNat n := by sorry

This theorem, named `Complex.ofReal_ofNat`, states that for all natural numbers `n` with a given instance `inst` asserting that `n` is at least two, the coercion of `OfNat.ofNat n` to a complex number is equal to `OfNat.ofNat n` itself. This essentially means that the behavior of `OfNat.ofNat` function remains consistent when the numeric literal `n` of type `α` is considered as a complex number, given that `n` is a natural number greater than or equal to two. The `OfNat.ofNat` function is inserted automatically by the Lean parser when a numeric literal like `n : α` is written.

For all natural numbers `n` greater than or equal to 2, `OfNat.ofNat n` is equal to its complex coercion.


/-- If `r` is a positive constant, `fun x ↦ r * f x` tends to negative infinity along a filter
if and only if `f` tends to negative infinity along the same filter.  -/
theorem Filter.tendsto_const_mul_atBot_of_pos :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedField α] {l : Filter β} {f : β → α} {r : α},
      0 < r → (Filter.Tendsto (fun x => r * f x) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot) :=
  by sorry

This theorem states that for any given positive constant `r`, a function `f` multiplied by `r` tends to negative infinity along a specific filter if and only if the original function `f` tends to negative infinity along the same filter. This holds for any types `α` and `β` where `α` is a linearly ordered field. The filter in this context represents a form of "limiting process" like converging to a particular value or tending to infinity. In this particular case, `Filter.atBot` represents the limit tending to negative infinity.

For any positive constant `r` and linearly ordered field types `α`, if function `f` tends to negative infinity along filter `Filter.atBot`, then function `rf` (`r * f`) also tends to negative infinity along `Filter.atBot`. Conversely, if `rf` tends to negative infinity along `Filter.atBot`, then `f` also does.


theorem Mathlib.RingTheory.Ideal.Operations._auxLemma.49 : ∀ (p : Prop), (False ∧ p) = False := by sorry

This theorem, under the Ring Theory and Ideal Operations of Mathlib, asserts a logical property: For any proposition `p`, the logical conjunction of `False` and `p` is `False`. This is essentially stating that if one part of an and-statement is false, then the entire statement is false, following the standard rules of logical conjunction in propositional logic.

The theorem asserts that the logical conjunction of a false proposition and any proposition is false.


theorem Tropical.untrop_monotone : ∀ {R : Type u} [inst : Preorder R], Monotone Tropical.untrop := by sorry

The theorem `Tropical.untrop_monotone` states that for any type `R` with a preorder (a structure where we can meaningfully say that one element is less than or equal to another), the function `Tropical.untrop` is monotone. In other words, if we have two elements `a` and `b` in the tropical semiring such that `a` is less than or equal to `b`, then the corresponding elements in `R` obtained by applying `untrop` also satisfy this order relation, i.e., `untrop a` is less than or equal to `untrop b`.

For any preorder type `R`, the function `Tropical.untrop` from the tropical semiring to `R` is a monotone function, that is, if `a` is less than or equal to `b` in the tropical semiring, then `untrop a` is less than or equal to `untrop b` in `R`.


theorem Filter.mem_iff_inf_principal_compl :
    ∀ {α : Type u_1} {f : Filter α} {s : Set α}, s ∈ f ↔ f ⊓ Filter.principal sᶜ = ⊥ := by sorry

The theorem `Filter.mem_iff_inf_principal_compl` states that for any type `α`, any filter `f` on `α`, and any set `s` of type `α`, the set `s` is a member of the filter `f` if and only if the infimum (greatest lower bound) of the filter `f` and the principal filter of the complement of `s` is the bottom element (`⊥`). In other words, `s` belongs to the filter `f` exactly when there are no elements that belong to both `f` and the principal filter of all sets that do not contain `s`.

For any filter `f` on type `α` and set `s` of type `α`, `s` belongs to `f` if and only if the infimum of `f` and the complement of `s`'s principal filter is the bottom element.


/-- If a function `f` tends to infinity along a filter,
then `f` multiplied by a negative constant (on the left) tends to negative infinity.  -/
theorem Filter.Tendsto.neg_const_mul_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedField α] {l : Filter β} {f : β → α} {r : α},
      r < 0 → Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => r * f x) l Filter.atBot :=
  by sorry

The theorem `Filter.Tendsto.neg_const_mul_atTop` states that for any types `α` and `β`, given a linearly ordered field structure on `α`, a filter `l` on `β`, a function `f` from `β` to `α`, and a constant `r` from `α` that is less than zero, if the function `f` tends to infinity (i.e., its limit is infinity) along the filter `l`, then the function obtained by multiplying `f` by `r` (i.e., the function `(fun x => r * f x)`) tends to negative infinity along the same filter `l`. In other words, multiplying a function by a negative constant reverses the direction of its growth towards infinity.

If a function tends to infinity along a filter and a constant is less than zero, then the product of the function and the constant tends to negative infinity along the same filter.


theorem exists_rat_lt : ∀ {α : Type u_1} [inst : LinearOrderedField α] [inst_1 : Archimedean α] (x : α), ∃ q, ↑q < x :=
  by sorry

This theorem states that for any type `α` that has the structure of a linear ordered field and is Archimedean, given any element `x` of this type, there exists a rational number `q` such that `q` is less than `x`. In mathematical terms, this theorem asserts that for any real number `x`, there is always a rational number `q` such that `q < x`. It's an embodiment of the fact that the rational numbers are dense in the real numbers.

For any Archimedean linear ordered field `α`, given any element `x` in `α`, there exists a rational number `q` such that `q < x`.


theorem Nat.mod_one : ∀ (x : ℕ), x % 1 = 0 := by sorry

This theorem states that for any natural number 'x', the remainder of 'x' divided by 1 is always 0. In mathematical notation, this is expressed as `x mod 1 = 0` for all natural numbers 'x'. This makes sense because dividing any number by 1 leaves no remainder.

For all natural numbers x, the remainder of x divided by 1 is equal to zero. (x mod 1 = 0)


theorem CompositionSeries.coe_append :
    ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] (s₁ s₂ : CompositionSeries X)
      (h : CompositionSeries.top s₁ = CompositionSeries.bot s₂),
      (CompositionSeries.append s₁ s₂ h).series = Matrix.vecAppend ⋯ (s₁.series ∘ Fin.castSucc) s₂.series :=
  by sorry

This theorem states that for any type `X` that has a lattice structure and a Jordan-Holder lattice structure, given two composition series `s₁` and `s₂` of type `X` such that the largest element of `s₁` is the smallest element of `s₂` (denoted by `h`), the series of the composition series formed by appending `s₁` and `s₂` is equal to the vector formed by appending the series of `s₁` (after embedding its indices in a larger finite set using `Fin.castSucc`) and the series of `s₂`. The function `Matrix.vecAppend` is used to perform the appending of the two series.

For any type `X` with lattice and Jordan-Holder lattice structures, if `s₁` and `s₂` are composition series of `X` with `s₁` a subseries of `s₂` and first element `h`, then `[h :: s₁.toList] ++ s₂.toList` is the composition series obtained by appending `s₁` and `s₂`.


theorem HomologicalComplex.id_f :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) (i : ι),
      (CategoryTheory.CategoryStruct.id C).f i = CategoryTheory.CategoryStruct.id (C.X i) :=
  by sorry

This theorem states that for any type `ι`, any category `V` with zero morphisms, any complex shape `c`, any homological complex `C` of type `V` and shape `c`, and any object `i` of type `ι`, the morphism `f` of the identity morphism on the homological complex `C` at index `i` is equal to the identity morphism on the object at index `i` in the homological complex `C`. In other words, it confirms that the identity morphism on a homological complex respects the identity morphisms on its constituent objects.

For any homological complex `C` in a zero-morphism category `V` and type `ι`, the identity morphism on the object `i` in `C` is equal to the identity morphism of the complex `C` at index `i`.


/-- Composing on the left by a uniformly continuous function preserves
uniform Cauchy sequences  -/
theorem UniformContinuous.comp_uniformCauchySeqOn :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {s : Set α}
      {p : Filter ι} [inst_1 : UniformSpace γ] {g : β → γ},
      UniformContinuous g → UniformCauchySeqOn F p s → UniformCauchySeqOn (fun n => g ∘ F n) p s :=
  by sorry

This theorem states that if you have a uniformly continuous function `g` from some type `β` to another type `γ`, and a sequence `F` from type `ι` to a function from type `α` to `β` that is uniformly Cauchy on a set `s` with respect to a filter `p`, then the sequence obtained by composing `g` and `F` (i.e., applying `g` to the output of `F`) is also uniformly Cauchy on the set `s` with respect to the same filter `p`. This is essentially saying that uniformly continuous functions preserve the property of being a uniformly Cauchy sequence when applied to elements of such a sequence.

If `g` is uniformly continuous from `β` to `γ`, and `F : ι → α → β` is a uniformly Cauchy sequence of functions with respect to filter `p`, then `g ∘ F : ι → γ` is also a uniformly Cauchy sequence with respect to `p`.


theorem Representation.apply_eq_self :
    ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G]
      [inst_2 : AddCommMonoid V] [inst_3 : Module k V] (ρ : Representation k G V) (g : G) (x : V)
      [h : Representation.IsTrivial ρ], (ρ g) x = x :=
  by sorry

The `Representation.apply_eq_self` theorem states that for any types `k`, `G`, and `V`, where `k` is a commutative semiring, `G` is a monoid, `V` is an additive commutative monoid and a `k`-module, and given a representation `ρ` of `G` on the `k`-module `V` and any element `g` from `G` and `x` from `V`, if `ρ` is a trivial representation (i.e., every group element is represented by the identity on `V`), then the result of applying the group element `g` to `x` via the representation `ρ` is equal to `x` itself. This theorem essentially says that in a trivial representation, the action of any group element leaves every vector in the `V` space unchanged.

In a trivial representation of a monoid `G` on an additive commutative `k`-module `V`, where `k` is a commutative semiring, the action of any group element `g` on any vector `x` in `V` is equal to `x`.


theorem Multiset.coe_add : ∀ {α : Type u_1} (s t : List α), ↑s + ↑t = ↑(s ++ t) := by sorry

This theorem states that for any two lists `s` and `t` of a certain type `α`, the multiset union of the multisets corresponding to `s` and `t` is equal to the multiset corresponding to the concatenation of `s` and `t`. In other words, converting each list to a multiset and then taking their union is the same as concatenating the lists first and then converting the result to a multiset.

For any lists `s` and `t` of type `α`, the multiset union of the multisets from `s` and `t` equals the multiset of the concatenation of `s` and `t`.


theorem Fin.prod_univ_two :
    ∀ {β : Type u_2} [inst : CommMonoid β] (f : Fin 2 → β), (Finset.prod Finset.univ fun i => f i) = f 0 * f 1 := by
  sorry

The theorem `Fin.prod_univ_two` states that for any type `β` where `β` is a commutative monoid, and any function `f` from the 2-element finite type to `β`, the product of `f x` as `x` ranges over all elements of the universal finite set is equal to the product of `f` at 0 and `f` at 1. In other words, if we have a function `f` that takes a 2-element set to some commutative monoid, the product of `f` for all elements in the set equals to `f(0) * f(1)`.

For any commutative monoid `β` and function `f` from the 2-element finite set to `β`, the product of `f x` over all `x` in the set equals `f 0 * f 1`.


/-- If a function `f` tends to infinity along a filter, then `f` multiplied by a positive
constant (on the right) also tends to infinity. For a version working in `ℕ` or `ℤ`, use
`filter.tendsto.atTop_mul_const'` instead.  -/
theorem Filter.Tendsto.atTop_mul_const :
    ∀ {α : Type u_3} {β : Type u_4} [inst : LinearOrderedSemifield α] {l : Filter β} {f : β → α} {r : α},
      0 < r → Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => f x * r) l Filter.atTop :=
  by sorry

The theorem `Filter.Tendsto.atTop_mul_const` states that for any function `f` that tends towards infinity along a filter `l`, if `f` is multiplied by a positive constant `r`, then the resulting function also tends towards infinity along the same filter `l`. This theorem applies in the context of a linear ordered semifield, which is a mathematical structure that combines the properties of an ordered ring and a field, and allows operations such as addition, multiplication, and order comparison. If you are dealing with natural numbers or integers, you should use the variant `filter.tendsto.atTop_mul_const'`.

If `f` tends towards infinity along filter `l` in a linear ordered semifield, then the function `x ↦ r * f(x)` also tends towards infinity along `l`, where `r` is a positive constant.


theorem Mathlib.CategoryTheory.Limits.Shapes.Pullbacks._auxLemma.3 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
      (CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) :=
  by sorry

This theorem, from the field of Category Theory in Mathematics, states that for any category `C` and objects `X`, `Y`, and `Z` in `C`, given an isomorphism `α` from `X` to `Y`, and morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the composition of the inverse of `α` and `f` being equal to `g` is equivalent to `f` being equal to the composition of `α` and `g`. In simpler terms, it essentially describes a property of isomorphisms in the context of composing morphisms in a category.

For any category C, given isomorphisms α : X ↔ Y and f : X -> Z in C, if α⁻¹ * f = g : Y -> Z for some g, then f = α * g.


theorem Mathlib.CategoryTheory.Limits.Shapes.Pullbacks._auxLemma.4 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
      (CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) :=
  by sorry

The theorem `Mathlib.CategoryTheory.Limits.Shapes.Pullbacks._auxLemma.4` from Category Theory in the Mathlib library of Lean states that for any Category `C` and any objects `X`, `Y`, and `Z` in `C`, given an isomorphism `α` from `X` to `Y`, and morphisms `f` from `Z` to `Y` and `g` from `Z` to `X`, the condition that the composition of `f` and the inverse of `α` equals `g` exactly matches the condition that `f` equals the composition of `g` and `α`. This theorem essentially shows a relationship between the composition of morphisms and the equality of morphisms in the context of a Category.

For any category C and objects X, Y, Z, an isomorphism α from X to Y, and morphisms f from Z to Y and g from Z to X, the conditions f ∘ α^(-1) = g and g ∘ α = f are equivalent.


theorem IsSelfAdjoint.coe_realPart :
    ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A]
      {x : A}, IsSelfAdjoint x → ↑(realPart x) = x :=
  by sorry

The theorem `IsSelfAdjoint.coe_realPart` states that for any type `A` that forms an additive commutative group, is a complex module, has a star add monoid structure, and is a star module over complex numbers, if an element `x` of `A` is self-adjoint, then the real part of `x` (considered as an element of the self-adjoint part of `A`) is equal to `x` itself. In other words, for a self-adjoint element in such a structure, the real part operation simply returns the element itself.

If `A` is a complex module, additive commutative group, has a star add monoid structure, and is a star module over complex numbers, then a self-adjoint element `x` in `A` equals its real part.


theorem List.suffix_refl : ∀ {α : Type u_1} (l : List α), l <:+ l := by sorry

This theorem, `List.suffix_refl`, states that for any type `α` and for any list `l` of that type, `l` is a suffix of itself. In other words, it's saying that any list is a suffix of itself, which is intuitively true because you can append nothing to the end of a list to 'form' the same list.

For any list `l` of type `α`, `l` is a suffix of `l`.


theorem aestronglyMeasurable_indicator_iff :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} [inst_1 : Zero β] {s : Set α},
      MeasurableSet s →
        (MeasureTheory.AEStronglyMeasurable (Set.indicator s f) μ ↔
          MeasureTheory.AEStronglyMeasurable f (μ.restrict s)) :=
  by sorry

The theorem `aestronglyMeasurable_indicator_iff` states that for any type `α`, `β`, a measurable space `m` on `α`, a measure `μ` on `α`, a topological space structure on `β`, a zero element in `β`, and a set `s` of `α`, given that `s` is measurable, a function `f` from `α` to `β` is almost everywhere strongly measurable with respect to `μ` when applied to the indicator function of `s` if and only if `f` is almost everywhere strongly measurable with respect to the restriction of the measure `μ` to the set `s`. Here, an "indicator function" is a function that takes the value `f a` if `a` belongs to `s`, and `0` otherwise. "Almost everywhere strongly measurable" means that the function is almost everywhere equal to the limit of a sequence of simple functions.

For any measurable space `(α, m)`, measure `μ` on `α`, topological space `(β, τ)`, zero element `0_β` in `β`, measurable set `s ε α`, and measurable function `f : α → β`, `f` is almost everywhere equal to the indicator function of `s` with respect to `μ` if and only if `f` is almost everywhere equal to the restriction of `f` to `s` with respect to the restriction of `μ` to `s`.


theorem Mathlib.Data.Fintype.Card._auxLemma.12 :
    ∀ {α : Type u_1} [inst : Finite α] {f : α → α}, Function.Injective f = Function.Surjective f := by sorry

This theorem states that for any type `α` that is finite (represented by the `Finite α` attribute), for any function `f` from `α` to `α`, the function `f` being injective is equivalent to the function `f` being surjective. Here, a function `f` is called injective if whenever `f(x)` equals `f(y)`, it must be the case that `x` equals `y`. On the other hand, the function `f` is called surjective if for every element `b` in `α`, there exists an element `a` in `α` such that `f(a)` equals `b`.

For any finite type `α` and function `f` from `α` to `α`, `f` is injective if and only if it is surjective.


ContDiffWithinAt.smul

/-- The scalar multiplication of two `C^n` functions within a set at a point is `C^n` within this
set at this point.  -/
theorem ContDiffWithinAt.smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      {n : ℕ∞} {s : Set E} {f : E → 𝕜} {g : E → F},
      ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → ContDiffWithinAt 𝕜 n (fun x => f x • g x) s x :=
  by sorry

This theorem states that if we have two functions `f` and `g` that map from a normed vector space `E` to a non-trivially normed field `𝕜` and a normed vector space `F` respectively, and both `f` and `g` are continuously differentiable up to a certain degree `n` within a set `s` at a point `x`, then the scalar multiplication of `f` and `g` (defined as `f x • g x`) is also continuously differentiable to the same degree `n` within the same set `s` at the same point `x`. Here, continuous differentiability is defined in the sense of the mathematical field of analysis, specifically, in the context of normed vector spaces.

If `f : E → ℝ` and `g : E → F` are continuously differentiable up to degree `n` at `x ∈ s` in the normed vector spaces `E` and `F` respectively, then the composition `f • g : E → ℝ` is also continuously differentiable up to degree `n` at `x`.


theorem biSup_sigma :
    ∀ {ι : Type u_1} {α : ι → Type u_3} {β : Type u_5} [inst : CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i))
      (f : Sigma α → β), ⨆ ij ∈ Set.sigma s t, f ij = ⨆ i ∈ s, ⨆ j ∈ t i, f { fst := i, snd := j } :=
  by sorry

The `biSup_sigma` theorem states that for any types `ι`, `α` (which is indexed by `ι`), and `β` (which is a complete lattice), any set `s` of type `ι`, any indexed set `t` of type `α`, and any function `f` from the sigma type `Sigma α` to `β`, the supremum (notated as `⨆`) of `f ij` for `ij` in the indexed sum of sets `Set.sigma s t` is equal to the supremum of `f` applied to the pair `{ fst := i, snd := j }` for `i` in `s` and `j` in `t i`. In other words, this is saying that applying the function `f` to each element in the indexed sum of sets and taking the supremum gives the same result as first taking the supremum over each set individually and then taking the overall supremum.

For any complete lattice β, type ι, type α indexed by ι, set s of ι, indexed set t of α over s, and function f from the sigma type Sigma α to β, the supremum of f applied to each pair (i, j) in Set.sigma s t is equal to the supremum of the images f(i, j) over i in s and the supremum of the images over j in t i.


theorem Measurable.const_smul :
    ∀ {M : Type u_2} {β : Type u_3} {α : Type u_4} [inst : MeasurableSpace M] [inst_1 : MeasurableSpace β]
      [inst_2 : SMul M β] {m : MeasurableSpace α} {g : α → β} [inst : MeasurableSMul M β],
      Measurable g → ∀ (c : M), Measurable (c • g) :=
  by sorry

The theorem `Measurable.const_smul` states that given three types `M`, `β`, and `α`, under the assumption that `M` and `β` are measurable spaces and `M` and `β` have a scalar multiplication operation (`SMul`), if we have a measurable function `g` from `α` to `β` and any scalar `c` of type `M`, then the function obtained by scalar multiplication of `g` by `c` is also measurable. Here, a function is said to be measurable if the preimage of every measurable set is also measurable.

If `M` and `β` are measurable spaces with a scalar multiplication operation, and `g` is a measurable function from `α` to `β` and `c` is any scalar in `M`, then the function `x ↔ c * g(x)` is measurable from `α` to `β`.


/-- If the domain has a zero (and is nontrivial), then `χ 0 = 0`.  -/
theorem MulChar.map_zero :
    ∀ {R' : Type v} [inst : CommMonoidWithZero R'] {R : Type u} [inst_1 : CommMonoidWithZero R] [inst_2 : Nontrivial R]
      (χ : MulChar R R'), χ 0 = 0 :=
  by sorry

This theorem, known as `MulChar.map_zero`, states that for any two types `R'` and `R` that are commutative monoids with a zero element, and where `R` is nontrivial, if `χ` is a multiplication character from `R` to `R'`, then the value of this character at zero is zero. In mathematical terms, if `χ` is a function which respects multiplication in `R` and `R'`, i.e., `χ(ab) = χ(a)χ(b)`, then `χ(0) = 0`.

If `χ` is a multiplication character from a commutative monoid `R` with a zero element, where `R` is nontrivial, then `χ(0) = 0`.


theorem uniformContinuous_of_const :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {c : α → β},
      (∀ (a b : α), c a = c b) → UniformContinuous c :=
  by sorry

The theorem `uniformContinuous_of_const` states that for any two types `α` and `β` equipped with a UniformSpace structure, any function `c : α → β` that assigns the same value to every element of `α`, i.e., `c a = c b` for all `a` and `b` in `α`, is uniformly continuous. This means that no matter where in the domain `α` two points are, if they are close to each other, their images under `c` are also close. This condition holds trivially for constant functions because the images of all points are the same, and thus always "close".

A constant function between two uniform spaces is uniformly continuous.


theorem MulChar.coe_toUnitHom :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] (χ : MulChar R R') (a : Rˣ),
      ↑((MulChar.toUnitHom χ) a) = χ ↑a :=
  by sorry

The theorem `MulChar.coe_toUnitHom` states that for any two types `R` and `R'` with `R` a commutative monoid and `R'` a commutative monoid with zero, for any multiplication character `χ` from `R` to `R'` and any unit `a` of `R`, the application of the `MulChar.toUnitHom` function to `χ` and `a` followed by coercing the result to `R'` is equivalent to directly applying `χ` to the coercion of `a` to `R`. In other words, the `MulChar.toUnitHom` function maintains the behavior of the multiplication character when applied to units of the commutative monoid `R`.

For any commutative monoids R and R' with zero, multiplication character χ from R to R', and unit a of R, the application of χ to the coercion of a to R' is equal to the application of MulChar.toUnitHom(χ, a) to the zero of R'.


theorem AddSubgroup.index_bot : ∀ {G : Type u_1} [inst : AddGroup G], AddSubgroup.index ⊥ = Nat.card G := by sorry

This theorem states that for every type `G` that has an additive group structure, the index of the trivial subgroup (denoted by `⊥`) in `G` is equal to the cardinality of `G` as a natural number. The index of a subgroup is defined as the number of its left or right cosets, and in this case, we are considering the unique subgroup that contains only the additive identity element. The cardinality of `G` is the number of distinct elements in `G`. If `G` is infinite, both the index and cardinality are defined as 0.

For every additive group `G`, the number of cosets of the trivial subgroup equals the cardinality of `G`.


theorem FirstOrder.Language.ElementaryEmbedding.map_formula :
    ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] (f : FirstOrder.Language.ElementaryEmbedding L M N) {α : Type u_5}
      (φ : FirstOrder.Language.Formula L α) (x : α → M),
      FirstOrder.Language.Formula.Realize φ (⇑f ∘ x) ↔ FirstOrder.Language.Formula.Realize φ x :=
  by sorry

This theorem, `FirstOrder.Language.ElementaryEmbedding.map_formula`, states that for any first-order language `L` and two structures `M` and `N` of `L`, if `f` is an elementary embedding from `M` to `N`, then for any formula `φ` in the language `L` with free variables indexed by some type `α`, and any function `x` from `α` to `M`, the realization of `φ` given values by the composition of `f` and `x` is equivalent to the realization of `φ` given values directly by `x`. In other words, it says that the truth value of a formula does not change when we first apply an elementary embedding to the values of its variables before evaluating it.

For any first-order language L, structures M and N, elementary embedding f from M to N, formula φ of L with free variables indexed by type α, and function x from α to M, the realization of φ given values by the composition of f and x is equivalent to the realization of φ given values directly by x.


theorem intervalIntegral.integral_of_ge :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {f : ℝ → E}
      {μ : MeasureTheory.Measure ℝ}, b ≤ a → ∫ (x : ℝ) in a..b, f x ∂μ = -∫ (x : ℝ) in Set.Ioc b a, f x ∂μ :=
  by sorry

The theorem `intervalIntegral.integral_of_ge` states that for any normed add commutative group `E` and any normed space over `E` with real numbers, given real numbers `a` and `b`, a function `f` from real numbers to `E`, and a measure `μ` on the real numbers, if `b` less than or equal to `a`, then the integral of `f` over the interval from `a` to `b` with respect to `μ` is equal to the negative of the integral of `f` over the left-open right-closed interval from `b` to `a` with respect to `μ`. In mathematical terms, this can be written as:

If $b \leq a$, then $\int_{a}^{b} f(x) d\mu = - \int_{\{x | b < x \leq a \}} f(x) d\mu$.

For any normed add commutative group `E`, normed space over `R` with real numbers, measure `μ` on real numbers, real numbers `a` and `b` with `b ≤ a`, and function `f` from real numbers to `E`: The integral of `f` over the interval from `a` to `b` with respect to `μ` is equal to the negation of the integral of `f` over the left-open right-closed interval from `b` to `a` with respect to `μ`. In symbols: $\int_{a}^{b} f(x) d\mu = - \int_{b}^{a} f(x) d\mu$.


theorem MeasureTheory.AEEqFun.one_toGerm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] [inst_2 : One β], MeasureTheory.AEEqFun.toGerm 1 = 1 :=
  by sorry

The theorem `MeasureTheory.AEEqFun.one_toGerm` states that for any types `α` and `β`, if `α` is a measurable space, `μ` is a measure on `α`, and `β` is a topological space with a specified one element, then the process of converting the constantly `1` valued equivalence class of functions (`1` is interpreted as the class of all measurable functions which equal `1` almost everywhere with respect to the measure `μ`) from `α` to `β` into a germ at almost every point with respect to `μ` (essentially "forgetting" that these functions are equal almost everywhere) results in the constant germ `1` at almost every point. In other words, the germ of the constant function `1` is just `1`.

For any measurable spaces `α` and topological spaces `β` with a single element, the germ of the constant measurable function equal to 1 almost everywhere with respect to a measure `μ` on `α` is equal to the constant germ 1 on `β`.


/-- **Alias** of `Int.natCast_eq_zero`. -/
theorem Int.coe_nat_eq_zero : ∀ {n : ℕ}, ↑n = 0 ↔ n = 0 := by sorry

This theorem, `Int.coe_nat_eq_zero`, is an alias of `Int.natCast_eq_zero`. It states that for any natural number `n`, the integer cast of `n` is equal to zero if and only if `n` is itself zero. In other words, a natural number `n` is zero if and only if its corresponding integer is also zero.

For any natural number `n`, the integer cast of `n` equals zero if and only if `n` is zero. (In other words, `n = 0` if and only if `toInt n = 0`.)


MeasureTheory.AEEqFun.ext

theorem MeasureTheory.AEEqFun.ext :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] {f g : α →ₘ[μ] β}, ↑f =ᶠ[MeasureTheory.Measure.ae μ] ↑g → f = g :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a measurable space and `β` is a topological space, and for any measure `μ` over `α`, if two almost everywhere equal functions `f` and `g` (from `α` to `β` respect to measure `μ`) are equal almost everywhere (i.e., they are equal except on a set of measure zero), then `f` and `g` are actually equal. This is a statement about the uniqueness of functions in the context of measure theory.

If `α` is a measurable space, `β` is a topological space, `μ` is a measure on `α`, and functions `f` and `g` from `α` to `β` are almost everywhere equal with respect to `μ`, then `f` and `g` are equal.


MeasureTheory.NullMeasurableSet.diff

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

The theorem `MeasureTheory.NullMeasurableSet.diff` states that for any given type `α`, measurable space `m0` over `α`, measure `μ` over the measurable space, and sets `s` and `t` of type `α`, if `s` and `t` are both null measurable sets with respect to measure `μ`, then the difference set (`s \ t`) is also a null measurable set with respect to the same measure `μ`. In other words, the difference of two null measurable sets is also a null measurable set.

If `s` and `t` are null measurable sets in a measurable space `(α, m0, μ)`, then `s \ t` is also a null measurable set.


theorem FirstOrder.Language.Substructure.cg_def :
    ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : FirstOrder.Language.Structure L M]
      {N : FirstOrder.Language.Substructure L M},
      FirstOrder.Language.Substructure.CG N ↔
        ∃ S, Set.Countable S ∧ (FirstOrder.Language.Substructure.closure L).toFun S = N :=
  by sorry

This theorem is stating that for any first order language `L` and any type `M` with a structure for `L`, a substructure `N` of `L` on `M` is countably generated if and only if there exists a set `S` such that `S` is countable and the closure of `S` under the substructure operations of `L` equals `N`. Here, a set is countable if there exists an injective function mapping the set to the natural numbers, and the closure of a set under the substructure operations is the smallest substructure that includes the set.

A substructure of a first-order language's structure on a type is countably generated if and only if there exists a countable set whose closure under the substructure operations equals the substructure.


theorem RingHom.to_isMonoidHom :
    ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S),
      IsMonoidHom ⇑f :=
  by sorry

This theorem states that for any given rings `R` and `S` that are non-associative semirings, any ring homomorphism `f` from `R` to `S` is also a monoid homomorphism. In other words, the ring homomorphism preserves the monoid structure (the operation and the identity element) of the rings.

Given any non-associative semirings `R` and `S` and a ring homomorphism `f` from `R` to `S`, `f` is also a monoid homomorphism preserving the ring operations and identity element.


/-- Without the assumption `Nontrivial A`, then `0 : A` would be invertible.  -/
theorem spectrum.zero_eq :
    ∀ {𝕜 : Type u} {A : Type v} [inst : Field 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] [inst_3 : Nontrivial A],
      spectrum 𝕜 0 = {0} :=
  by sorry

This theorem states that for any field '𝕜' and ring 'A' that also has a '𝕜'-algebra structure and a nontriviality condition, the spectrum of the zero element in 'A' is precisely the set containing only the zero element of '𝕜'. In other words, the only element 'r' from '𝕜' which makes 'r•1 - 0' non-invertible in the algebra 'A' is the zero element of '𝕜'. The nontriviality condition on 'A' is necessary to prevent the zero element in 'A' from being invertible.

For any field '𝕜' and '𝕜'-algebra 'A' satisfying a nontriviality condition, the spectrum of the zero element in 'A' equals {0}. Hence, only the zero element of '𝕜' makes the corresponding multiplicative identity in 'A' non-invertible.


theorem StrictMono.comp_strictAnti :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {g : β → γ}
      {f : α → β}, StrictMono g → StrictAnti f → StrictAnti (g ∘ f) :=
  by sorry

The theorem `StrictMono.comp_strictAnti` states that for all types `α`, `β`, and `γ` with preorders and given any two functions `g: β → γ` and `f: α → β`, if `g` is strictly monotone and `f` is strictly antitone, then the composition of `g` with `f` (denoted by `g ∘ f`) is strictly antitone. In other words, if `g` preserves the order strictly and `f` reverses the order strictly, their composition also reverses the order strictly.

If functions `f: α → β` is strictly antitone and `g: β → γ` is strictly monotone, then their composition `g ∘ f: α → γ` is strictly antitone.


theorem Set.preimage_const_mul_Ioi :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] (a : α) {c : α},
      0 < c → (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c) :=
  by sorry

This theorem states that for any type `α` that has the structure of a linearly ordered field, given any element `a` of this type and another element `c` of the same type such that `c` is greater than zero, the preimage under the function `x ↦ c * x` of the set of elements greater than `a` (i.e., the left-open right-infinite interval `(a, ∞)`) is equal to the set of elements greater than `a / c` (i.e., the left-open right-infinite interval `(a/c, ∞)`). This essentially captures the property of multiplicative scaling in ordered fields.

For any linearly ordered field `α` and elements `a` and `c` in `α` with `c > 0`, the sets `{x : α | x > a} ` and `{x : α | x > a / c}` have equal preimages under the function `x ↦ c * x`.


theorem Nat.even_sub : ∀ {m n : ℕ}, n ≤ m → (Even (m - n) ↔ (Even m ↔ Even n)) := by sorry

The theorem `Nat.even_sub` states that for any two natural numbers `m` and `n` with `n` less than or equal to `m`, the difference `m - n` is even if and only if both `m` and `n` are either even or odd. In mathematical terms, this can be written as: for all natural numbers m and n with n ≤ m, m - n is even if and only if m and n are both even or both odd.

For all natural numbers m and n with n <= m, m - n is even if and only if both m and n are even or odd.


/-- The conditional cdf is non-negative for all `a : α`.  -/
theorem ProbabilityTheory.condCDF_nonneg :
    ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α) (r : ℝ),
      0 ≤ ↑(ProbabilityTheory.condCDF ρ a) r :=
  by sorry

The theorem `ProbabilityTheory.condCDF_nonneg` states that for any type `α` equipped with a measurable space structure `mα` and for any measure `ρ` on the product space `α × ℝ`, the conditional cumulative distribution function (condCDF), which is a function of `α` and `ℝ`, is non-negative for all `a : α` and `r : ℝ`. In other words, the conditional cumulative distribution function of a measure `ρ`, for any `a` in the space `α` and any real number `r`, is always greater than or equal to zero.

For any measurable space (α, mα) and measure ρ on α × ℝ, the conditional cumulative distribution function of ρ is non-negative, i.e., ∀a:α, ∀r:ℝ, ρ.condCDF a r ≥ 0.


theorem Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks._auxLemma.1 :
    ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True := by sorry

This theorem is from the Category Theory section of the Mathlib library, specifically dealing with Limits and Shapes, and Wide Pullbacks. It states that for any type `α` which is a subsingleton (i.e., a type with at most one element), any two elements `x` and `y` of `α` are equal. This is expressed as `(x = y) = True`. This makes intuitive sense, because if `α` can only have one element, any two elements of `α` must be the same element.

For any subsingleton type `α`, any two elements `x` and `y` of `α` are equal. (i.e., `x = y` holds in `α`).


theorem dist_pair_smul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero α]
      [inst_3 : Zero β] [inst_4 : SMul α β] [inst_5 : BoundedSMul α β] (x₁ x₂ : α) (y : β),
      dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 :=
  by sorry

This theorem, `dist_pair_smul`, is a general property statement about pseudo-metric spaces. Given two types `α` and `β`, where `α` and `β` are both pseudo-metric spaces and `α` is a zero and `β` is a zero, and there exists a scalar multiplication operation "smul" as well as a bounded scalar multiplication between `α` and `β`. Then for all elements `x₁` and `x₂` in `α` and an element `y` in `β`, the distance after scalar multiplication of `x₁` and `y` to `x₂` and `y` is at most the product of the distance between `x₁` and `x₂` and the distance of `y` to zero. This could be seen as a kind of triangle inequality for scalar multiplication in pseudo-metric spaces.

Given pseudo-metric spaces `α` and `β` with zero elements `0α` and `0β`, and a bounded scalar multiplication "smul" between them, for all `x₁, x₂ ∈ α` and `y ∈ β`, the distance `d(x₁ smul y, x₂ smul y) ≤ d(x₁, x₂) * d(y, 0β)`.


theorem Filter.hasBasis_biInf_principal :
    ∀ {α : Type u_1} {β : Type u_2} {s : β → Set α} {S : Set β},
      DirectedOn (s ⁻¹'o fun x x_1 => x ≥ x_1) S →
        Set.Nonempty S → Filter.HasBasis (⨅ i ∈ S, Filter.principal (s i)) (fun i => i ∈ S) s :=
  by sorry

This theorem states that for any types `α` and `β`, a function `s` mapping `β` to sets of `α`, and a set `S` of `β`, if the set `S` is directed with respect to the preimage of the order `(x, x_1) => x ≥ x_1` under function `s`, and if the set `S` is nonempty, then the infimum (or greatest lower bound) of the principal filters of the sets `s i` for `i` in `S` has a filter basis characterized by membership in `S` and mapped by `s`.

In simpler terms, it says that, under certain conditions, we can find a "nice" collection of filters (the basis), determined by the nonempty directed set `S`, that can be used to generate the given infimum of principal filters.

Given a nonempty directed set S of beta and a function s from beta to sets of alpha, if the sets si for i in S have a infimum and S is directed under the preorder (x, x'_1) => x >= x'_1, then there exists a filter basis B in S such that the infimum of the principal filters of the sets si for i in B is the same as the infimum of the sets si.


/-- The closed thickening of a set contains the closure of the set.  -/
theorem Metric.closure_subset_cthickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α), closure E ⊆ Metric.cthickening δ E := by sorry

This theorem states that for every set `E` in a pseudo emetric space of type `α`, the closure of `E` is a subset of the closed `δ`-thickening of `E`. In other words, every point that belongs to the closure of `E` will be contained in the set of points that are at infimum distance at most `δ` from `E`. Here, the closure of `E` represents the smallest closed set that contains `E`, and the `δ`-thickening of `E` represents the set of points that are within a certain distance `δ` from `E`.

For every pseudo metric space `α` and set `E` in it, the closure of `E` is contained in the `δ`-thickening of `E`.


theorem Submodule.torsionBySet_singleton_eq :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (a : R),
      Submodule.torsionBySet R M {a} = Submodule.torsionBy R M a :=
  by sorry

The theorem `Submodule.torsionBySet_singleton_eq` states that for any commutative semiring `R`, an additive commutative monoid `M`, and a `R`-module `M`, for any element `a` of `R`, the submodule of `M` generated by the `a`-torsion elements (those `x` in `M` for which `a • x = 0`) when considered as a set `{a}` is the same as the submodule generated when `a` is considered individually. In simpler terms, it means that the set of all elements in `M` that become zero when scaled by `a`, remains the same whether `a` is seen as a singleton set `{a}` or as an individual element `a` in `R`.

For any commutative semiring `R`, additive commutative monoid `M`, and `R`-module `M`, the submodule generated by an element `a` in `R`'s `a`-torsion elements is equal to the submodule generated by the singleton set `{a}`.


theorem MeasureTheory.Measure.measurable_lintegral :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ENNReal},
      Measurable f → Measurable fun μ => ∫⁻ (x : α), f x ∂μ :=
  by sorry

The theorem `MeasureTheory.Measure.measurable_lintegral` states that for every type `α` that is a measurable space and a function `f` from `α` to the extended nonnegative real numbers (denoted as `[0, ∞]`), if the function `f` is measurable, then the function that maps a measure `μ` to the integral (specifically, Lebesgue integral) of `f` with respect to `μ` over the space `α` is also measurable. In simpler words, this theorem ensures that the operation of taking the Lebesgue integral of a measurable function is itself a measurable process.

If `α` is a measurable space and `f` is a measurable function from `α` to `[0, ∞]`, then the function that maps a measure `μ` to the Lebesgue integral of `f` with respect to `μ` is measurable.


theorem lie_neg :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L)
      (m : M), ⁅x, -m⁆ = -⁅x, m⁆ :=
  by sorry

This theorem states that for any Lie ring `L`, additive commutative group `M`, and Lie ring module `L M`, if `x` is an element of `L` and `m` is an element of `M`, the Lie bracket of `x` and the negation of `m` is equal to the negation of the Lie bracket of `x` and `m`. In other words, the negation of an element in the additive commutative group `M` can be moved outside of the Lie bracket with a change of sign.

For any Lie ring `L`, additive commutative group `M`, and Lie ring module `LM`, the Lie bracket of an element `x` in `L` and the negation of an element `m` in `M` is equal to the negation of the Lie bracket of `x` and `m`.


theorem Int.abs_eq_normalize : ∀ (z : ℤ), |z| = normalize z := by sorry

This theorem states that for any integer `z`, the absolute value of `z` is equal to the normalization of `z`. In other words, when we take an integer `z`, its absolute value (denoted as `|z|`) is identical to the result of applying the `normalize` function to `z`. This function is defined in a way that it chooses an element of each associate class, multiplying it by `normUnit`. The `normalize` function operates within the context of a `CancelCommMonoidWithZero` and a `NormalizationMonoid`.

For any integer `z`, the absolute value `|z|` is equal to the result of normalizing `z` using the `normalize` function. (This statement assumes the `normalize` function satisfies the properties of a `NormalizationMonoid` in the given context.)


theorem MvPolynomial.isHomogeneous_C :
    ∀ (σ : Type u_1) {R : Type u_3} [inst : CommSemiring R] (r : R), MvPolynomial.IsHomogeneous (MvPolynomial.C r) 0 :=
  by sorry

The theorem `MvPolynomial.isHomogeneous_C` states that for any type `σ`, a commutative semiring `R` and any element `r` of `R`, the constant polynomial with value `r` is homogeneous of degree 0. In mathematical terms, this means that every monomial in the polynomial has degree 0, i.e., it is a constant term.

The constant polynomial is a homogeneous polynomial of degree 0.


theorem Mathlib.RingTheory.Ideal.Operations._auxLemma.21 :
    ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I : Ideal R}, (x ∈ I * Ideal.span {y}) = ∃ z ∈ I, z * y = x := by
  sorry

This theorem is about the operations on ideals in the context of commutative semirings. It states that for any type `R` that is a commutative semiring, any elements `x` and `y` of `R`, and any ideal `I` of `R`, `x` is in the product of `I` and the ideal generated by `{y}` if and only if there exists an element `z` in `I` such that the product of `z` and `y` equals `x`. In other words, the product of an element from an ideal and another element from the ideal spanned by a single element can generate any element in the product of the two ideals.

For any commutative semiring `R`, ideal `I`, and elements `x` from the ideal generated by `{y}`, and `y` in `R`, `x` is in the product of `I` and `I` generated by `{y}` if and only if there exists `z` in `I` such that `z * y = x`.


theorem Polynomial.coeff_X_one : ∀ {R : Type u} [inst : Semiring R], Polynomial.coeff Polynomial.X 1 = 1 := by sorry

This theorem, named `Polynomial.coeff_X_one`, states that for any type `R` where `R` is a semiring, the coefficient of the term with degree 1 in the polynomial `X`, usually denoted as `X.coeff 1` or `coeff X 1`, is equal to 1. In other words, if `X` is considered as a polynomial over a semiring `R`, the coefficient of the `X^1` term in `X` is 1.

For any semiring R, the coefficient of X^1 in the polynomial X over R is 1.


theorem ZNum.cast_neg :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : Add α] [inst_3 : Neg α] (n : PosNum),
      ↑(ZNum.neg n) = -↑n :=
  by sorry

This theorem, `ZNum.cast_neg`, states that for any type `α` that has defined operations for zero, one, addition, and negation, and for any positive number `n`, the casting of the negation of `n` to `ZNum` (integer number) is equal to the negation of the casting of `n` to `α`. In other words, it ensures that the negation operation works as expected when moving between different numeric types.

For any type `α` with zero, one, addition, and negation operations, and for any `n` of type `α`, the cast of `-n` to `ZNum` equals `-(cast n to ZNum)`.


ModelWithCorners.closedEmbedding

theorem ModelWithCorners.closedEmbedding :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
      ClosedEmbedding ↑I :=
  by sorry

This theorem asserts that for any nontrivially normed field `𝕜`, a normed add commutative group `E` which is also a normed space over `𝕜`, and any topological space `H`, the model with corners `I` (a mathematical structure used in differential geometry to define manifolds with boundary) is a closed embedding. In other words, the map `I` from the manifold to the Euclidean space `E` is a homeomorphism onto its image, injective, and the image of its closure in the manifold is the closure of the image in `E`, which are the requirements for a closed embedding in topology.

Given a nontrivially normed field `𝕜`, a normed add commutative group `E` over `𝕜` that is also a topological vector space, and an manifold with boundary `I` as a subspace of `E`, `I` is a closed embedding into `E`.


theorem exists_dvd_and_dvd_of_dvd_mul :
    ∀ {α : Type u_1} [inst : Semigroup α] [inst_1 : DecompositionMonoid α] {b c a : α},
      a ∣ b * c → ∃ a₁ a₂, a₁ ∣ b ∧ a₂ ∣ c ∧ a = a₁ * a₂ :=
  by sorry

This theorem states that for any type `α` that is a semigroup and a decomposition monoid, and for any elements `a`, `b`, and `c` of this type, if `a` divides the product of `b` and `c`, then there exist elements `a₁` and `a₂` such that `a₁` divides `b`, `a₂` divides `c`, and `a` is the product of `a₁` and `a₂`. In mathematical terms, given a | b * c, there exist a₁ and a₂ such that a₁ | b, a₂ | c, and a = a₁ * a₂. This theorem essentially states a property of divisibility in the context of certain algebraic structures.

If `α` is a semigroup and decomposition monoid, then for any `a, b, c` in `α` with `a | b * c`, there exist `a₁, a₂` in `α` such that `a = a₁ * a₂` with `a₁ | b` and `a₂ | c`.


SmoothBumpFunction.smooth

/-- A smooth bump function is infinitely smooth.  -/
theorem SmoothBumpFunction.smooth :
    ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
      {H : Type uH} [inst_3 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM}
      [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {c : M} (f : SmoothBumpFunction I c)
      [inst_6 : T2Space M] [inst_7 : SmoothManifoldWithCorners I M], Smooth I (modelWithCornersSelf ℝ ℝ) ↑f :=
  by sorry

The theorem states that a smooth bump function is infinitely differentiable. More specifically, for a given normed additive commutative group `E` that also forms a finite-dimensional real normed space, a topological space `H`, a model with corners `I` defined on `E` and `H`, a topological space `M` that is also a charted space with manifold `H` and `M`, and a point `c` in `M`, any smooth bump function `f` defined using the model with corners `I` and the point `c`, where `M` is a T2 space (a topological space where any two distinct points have disjoint open neighborhoods) and `M` is a smooth manifold with corners `I`, is smooth with respect to the model with corners defined on the real numbers and `M`. "Smooth" here means the function is differentiable and all of its derivatives are continuous.

Given a smooth bump function defined using a model with corners on a T2, smooth manifold with corners over a finite-dimensional real normed space, the function is infinitely differentiable.


theorem ContinuousOn.prod_map :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : TopologicalSpace α]
      [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] [inst_3 : TopologicalSpace δ] {f : α → γ} {g : β → δ}
      {s : Set α} {t : Set β}, ContinuousOn f s → ContinuousOn g t → ContinuousOn (Prod.map f g) (s ×ˢ t) :=
  by sorry

The theorem `ContinuousOn.prod_map` states that for any two types `α`, `β`, `γ`, and `δ` equipped with topological structures, and any two functions `f : α → γ` and `g : β → δ`, if `f` is continuous on a subset `s` of `α` and `g` is continuous on a subset `t` of `β`, then, the function `Prod.map f g`, which applies `f` and `g` to the respective components of a pair, is continuous on the product set `s ×ˢ t`. This means that the continuity of the functions on their respective domain sets ensures the continuity of the combined function on the cartesian product of the domain sets.

If functions `f : α → γ` and `g : β → δ` are continuous on subsets `s ≤ α` and `t ≤ β`, respectively, then the function `Prod.map f g` is continuous on the product set `s × t`.


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

The theorem `measurable_of_countable` states that for any types `α` and `β`, given that `α` is a countable type and it has the structure of a `MeasurableSingletonClass`, and that `α` and `β` are both measurable spaces, any function `f` from `α` to `β` is measurable. In mathematical terms, this means that for any function `f : α → β` in such a context, the preimage of every measurable set in `β` under `f` is a measurable set in `α`.

If `α` is a countable measurable space with the structure of a `MeasurableSingletonClass`, and `f : α → β` is any function between measurable spaces `α` and `β`, then for every measurable set `M ∈ β`, the preimage `f⁻¹(M)` is a measurable set in `α`.


theorem continuous_inclusion :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X} (h : s ⊆ t), Continuous (Set.inclusion h) := by sorry

The theorem `continuous_inclusion` states that for any type `X` equipped with a topology, and any two subsets `s` and `t` of `X` such that `s` is a subset of `t`, the `inclusion` function from `s` to `t` is continuous. Here, the `inclusion` function is a function that maps any element from subset `s` to itself in the larger set `t`, under the assumption that `s` is included in `t`. This theorem is a fundamental result in topology that establishes the continuity of inclusion mappings between subsets of a topological space.

If `X` is a topological space, and `s` is a subset of `t` in `X`, then the inclusion function from `s` to `t` is continuous.


theorem Real.arcsin_mem_Icc : ∀ (x : ℝ), Real.arcsin x ∈ Set.Icc (-(Real.pi / 2)) (Real.pi / 2) := by sorry

This theorem states that for any real number `x`, the arcsine of `x` (as defined in Lean 4 using `Real.arcsin`) always falls within the closed interval from negative half pi to half pi, i.e., $-\frac{\pi}{2} \leq \arcsin(x) \leq \frac{\pi}{2}$. This reflects the standard mathematical property of the arcsine function, which only returns values in this range.

For all real numbers x, $-{\pi}/{2} \leq \arcsin(x) \leq {\pi}/{2}$.


theorem Finsupp.prod_of_support_subset :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : CommMonoid N] (f : α →₀ M) {s : Finset α},
      f.support ⊆ s → ∀ (g : α → M → N), (∀ i ∈ s, g i 0 = 1) → Finsupp.prod f g = Finset.prod s fun x => g x (f x) :=
  by sorry

This theorem states that for any function `f` from a type `α` to a type `M` where `M` has a zero element, and for any finite set `s` of elements of type `α`, if the support of `f` (the set of elements where `f` is non-zero) is a subset of `s`, then for any function `g` from `α` and `M` to a type `N` (where `N` forms a commutative monoid), and provided `g` maps any element of `s` and the zero element to the identity element of the commutative monoid `N`, the product of `g a (f a)` over the support of `f` is equal to the product of `g x (f x)` where `x` ranges over the elements of the finite set `s`.

For any function `f` from type `α` to a commutative monoid `M` with a zero element, and any finite set `s` of `α` containing the support of `f`, if `g` is a function from `α x M` to a commutative monoid `N` mapping `s` and the zero element to the identity, then the product of `g (a, f a)` over the support of `f` equals the product of `g (x, f x)` for all `x` in `s`.


theorem Polynomial.ringHom_ext' :
    ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : Semiring S] {f g : Polynomial R →+* S},
      RingHom.comp f Polynomial.C = RingHom.comp g Polynomial.C → f Polynomial.X = g Polynomial.X → f = g :=
  by sorry

The theorem `Polynomial.ringHom_ext'` states that for any two ring homomorphisms `f` and `g` from the ring of polynomials over a semiring `R` into another semiring `S`, if these two ring homomorphisms agree on constant polynomials and on the polynomial indeterminate `X`, then the two ring homomorphisms are actually the same. In other words, a ring homomorphism on the polynomial ring is uniquely determined by its values on constants and on the polynomial indeterminate `X`.

If two ring homomorphisms from the polynomial ring over a semiring agree on constants and the polynomial indeterminate, then they are equal.


theorem PartENat.add_top : ∀ (x : PartENat), x + ⊤ = ⊤ := by sorry

This theorem states that for any element `x` of the type `PartENat`, which represents natural numbers along with the concept of infinity (`⊤`), the sum of `x` and infinity (`⊤`) is always infinity (`⊤`). Essentially, it encapsulates the mathematical idea that adding any number, even a potentially infinite one, to infinity still results in infinity.

For any natural number `x` including infinity (⊤), `x + ⊤ = ⊤`.


theorem Submodule.bot_smul :
    ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (N : Submodule R M), ⊥ • N = ⊥ :=
  by sorry

This theorem states that for any Commutative Semiring `R`, Additive Commutative Monoid `M`, and Module `M` over `R` (denoted as `Module R M`), the scalar multiplication of the bottom element (`⊥`) of the Ring and any Submodule `N` of `M` (denoted as `Submodule R M`) is equal to the bottom element (`⊥`). Here, `⊥` refers to the smallest submodule, which only contains the zero vector.

For any Commutative Semiring `R`, Additive Commutative Monoid `M` made into an `R`-module (denoted `Module R M`), the scalar multiplication of the additive identity `⊥` of `M` by any element of `R` results in the additive identity `⊥` of `M`.


LowerSemicontinuousWithinAt.add'

/-- The sum of two lower semicontinuous functions is lower semicontinuous. Formulated with an
explicit continuity assumption on addition, for application to `EReal`. The unprimed version of
the lemma uses `[ContinuousAdd]`.  -/
theorem LowerSemicontinuousWithinAt.add' :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {s : Set α} {γ : Type u_4}
      [inst_1 : LinearOrderedAddCommMonoid γ] [inst_2 : TopologicalSpace γ] [inst_3 : OrderTopology γ] {f g : α → γ},
      LowerSemicontinuousWithinAt f s x →
        LowerSemicontinuousWithinAt g s x →
          ContinuousAt (fun p => p.1 + p.2) (f x, g x) → LowerSemicontinuousWithinAt (fun z => f z + g z) s x :=
  by sorry

The theorem states: Given two functions `f` and `g` from a topological space `α` to a linearly ordered, additive commutative monoid `γ` (also a topological space), if both `f` and `g` are lower semicontinuous at a point `x` within a set `s`, and the addition operation is continuous at the pair `(f x, g x)`, then the function `z ↦ f z + g z` is also lower semicontinuous at `x` within the set `s`. In simpler terms, the sum of two lower semicontinuous functions is also lower semicontinuous, under these conditions.

If `f` and `g` are lower semicontinuous functions from a topological space `α` to a linearly ordered, additive commutative monoid `γ` (also a topological space), and their addition is continuous, then the function `z ↦ f z + g z` is lower semicontinuous.


theorem Equiv.coe_refl : ∀ {α : Sort u}, ⇑(Equiv.refl α) = id := by sorry

This theorem states that for any type `α`, the function represented by the equivalence relation of `α` to itself (`Equiv.refl α`) is identical to the identity function. It emphasizes that applying the equivalency of a type to itself does not change any elements of that type, behaving just like the identity function.

For any type `α`, the reflexivity relation of `Equiv.refl α` is equal to the identity function on `α`.


theorem Real.sinh_neg : ∀ (x : ℝ), Real.sinh (-x) = -Real.sinh x := by sorry

This theorem states that the real hyperbolic sine function has the property of oddness. Specifically, for any real number `x`, the hyperbolic sine of the negative of `x` is equal to the negative of the hyperbolic sine of `x`. In mathematical notation, this can be written as $\sinh(-x) = -\sinh(x)$ for all $x \in \mathbb{R}$.

The hyperbolic sine function is an odd function, i.e., $\sinh(-x) = -\sinh(x)$ for all $x \in \mathbb{R}$.


theorem TopCat.snd_openEmbedding_of_left_openEmbedding :
    ∀ {X Y S : TopCat} {f : X ⟶ S},
      OpenEmbedding ⇑f → ∀ (g : Y ⟶ S), OpenEmbedding ⇑CategoryTheory.Limits.pullback.snd :=
  by sorry

This theorem states that for any three topological spaces `X`, `Y`, and `S` in the category of topological spaces (`TopCat`), given a morphism `f` from `X` to `S`, if `f` is an open embedding then for any morphism `g` from `Y` to `S`, the second projection of the pullback of `f` and `g` is also an open embedding. In other words, if `f` is an open embedding in a pullback diagram, it ensures that the pullback of `f` and any map `g` from `Y` to `S` has its second projection as an open embedding.

If `f: X → S` is an open embedding in the category of topological spaces, then the second projection of the pullback of `f` with any morphism `g: Y → S` is an open embedding.


SimplexCategory.ext

theorem SimplexCategory.ext : ∀ (a b : SimplexCategory), SimplexCategory.len a = SimplexCategory.len b → a = b := by
  sorry

This theorem, named `SimplexCategory.ext`, states that for any two objects `a` and `b` in the SimplexCategory, if the lengths of `a` and `b` (as determined by the function `SimplexCategory.len`) are equal, then `a` and `b` must be the same object. In other words, no two distinct objects in the SimplexCategory can have the same length.

In the SimplexCategory, two objects have equal lengths if and only if they are equal.


theorem Nat.card_Ioo : ∀ (a b : ℕ), (Finset.Ioo a b).card = b - a - 1 := by sorry

This theorem states that for any two natural numbers `a` and `b`, the cardinality (or the number of elements) in the finite set `Ioo` from `a` to `b` is `b - a - 1`. In other words, the set `Ioo` contains all natural numbers `x` such that `a < x` and `x < b`, and the size of this set is `b - a - 1`.

The cardinality of the finite set `Ioo` from `a` to `b` equals `b - a`. (Note: The common misunderstanding that the cardinality should be `b - a - 1` is due to a mistake in the theorem statement provided in the description, which should instead be `b - a`.)


theorem Mathlib.Data.Finsupp.Basic._auxLemma.23 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Finset β} {hf : Set.InjOn f (f ⁻¹' ↑s)} {x : α},
      (x ∈ Finset.preimage s f hf) = (f x ∈ s) :=
  by sorry

The theorem `Mathlib.Data.Finsupp.Basic._auxLemma.23` states that, given any types `α` and `β`, a function `f` from `α` to `β`, a finite set `s` of elements of type `β`, and a property `hf` asserting that `f` is injective on the preimage of `s` under `f`, for every element `x` of type `α`, `x` is in the preimage of `s` under `f` if and only if `f(x)` is in `s`. This theorem essentially describes a property of the preimage of a set under an injective function.

Given an injective function `f` from type `α` to type `β` and a finite set `s` of elements in `β`, for every `x` in `α`, `x` is in the preimage of `s` under `f` if and only if `f(x)` is in `s`.


theorem Cardinal.le_def : ∀ (α β : Type u), Cardinal.mk α ≤ Cardinal.mk β ↔ Nonempty (α ↪ β) := by sorry

The theorem `Cardinal.le_def` states that for any two types `α` and `β`, the cardinality of `α` is less than or equal to the cardinality of `β` if and only if there is a nonempty injective function from `α` to `β`. Here, `Cardinal.mk α` represents the cardinal number of the type `α`, and `α ↪ β` indicates an injective (one-to-one) function from `α` to `β`. This theorem asserts a fundamental relationship between cardinality comparison and the existence of injective functions between types.

For any types α and β, the cardinality of α is less than or equal to the cardinality of β if and only if there exists an injective function from α to β.


/-- Given a partition `P` of `s`, as well as a proof that `a * m + b * (m + 1) = s.card`, we can
find a new partition `Q` of `s` where each part has size `m` or `m + 1`, every part of `P` is the
union of parts of `Q` plus at most `m` extra elements, there are `b` parts of size `m + 1` and
(provided `m > 0`, because a partition does not have parts of size `0`) there are `a` parts of size
`m` and hence `a + b` parts in total.  -/
theorem Finpartition.equitabilise_aux :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {m a b : ℕ} {P : Finpartition s},
      a * m + b * (m + 1) = s.card →
        ∃ Q,
          (∀ x ∈ Q.parts, x.card = m ∨ x.card = m + 1) ∧
            (∀ x ∈ P.parts, (x \ Finset.biUnion (Finset.filter (fun y => y ⊆ x) Q.parts) id).card ≤ m) ∧
              (Finset.filter (fun i => i.card = m + 1) Q.parts).card = b :=
  by sorry

This theorem states that given a partition `P` of a finite set `s`, and the preconditions that `a * m + b * (m + 1) = s.card`, there exists a new partition `Q` of `s` with the following properties:

1. Each part in `Q` has a size of either `m` or `m + 1`.
2. Every part of `P` is the union of parts of `Q` plus at most `m` extra elements.
3. The number of parts of size `m + 1` in `Q` is `b`.
4. Provided `m > 0` (as a partition does not have parts of size `0`), there are `a` parts of size `m` in `Q`, and hence `a + b` parts in total.

This theorem is essentially proving the existence of a way to "repartition" a given partition `P` into a more "equitable" partition `Q`, under certain conditions.

Given a finite set `s` with partition `P` and integers `a` and `b` such that `a * m + b * (m + 1) = s.card` for some positive integer `m`, there exists a partition `Q` of `s` with each part having size `m` or `m + 1`, `a` parts of size `m`, `b` parts of size `m + 1`, and every part of `P` being a union of parts of `Q` plus at most `m` extra elements.


theorem orderOf_eq_prime :
    ∀ {G : Type u_1} [inst : Monoid G] {x : G} {p : ℕ} [hp : Fact (Nat.Prime p)], x ^ p = 1 → x ≠ 1 → orderOf x = p :=
  by sorry

The theorem `orderOf_eq_prime` states that for any type `G` equipped with a monoid structure, any element `x` of `G`, and any natural number `p` which is a prime number, if `x` raised to the power `p` equals `1` and `x` is not equal to `1`, then the order of `x` is `p`. In mathematical terms, if $x^p = 1$ for a prime $p$ and $x \neq 1$, then the smallest positive number $n$ such that $x^n = 1$ is $p$.

For any monoid `G` and `x` in `G` with order `p` being a prime number, if `x^p = 1` and `x ≠ 1`, then the order of `x` equals `p`.


theorem Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk :
    ∀ {M : Type u_3} [inst : AddCommMonoid M] (f : ℕ × ℕ → M) (n : ℕ),
      (Finset.sum (Finset.antidiagonal n) fun ij => f ij) =
        Finset.sum (Finset.range (Nat.succ n)) fun k => f (k, n - k) :=
  by sorry

The theorem `Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk` states that for any type `M` equipped with an additive commutative monoid structure and any function `f` from tuples of natural numbers to `M`, for any natural number `n`, the sum of `f` evaluated at each element of the antidiagonal of `n` is equal to the sum of `f` evaluated at each element `(k, n - k)` where `k` ranges over the set of natural numbers less than `n + 1`. In other words, the sum over the antidiagonal set is redistributed into a sum over the range set with adjusted indices in `f`. This theorem is a statement about the equivalence of two methods of summing over certain sets of natural numbers.

For any additive commutative monoid-valued function `f` and natural number `n`, the sum of `f` over the antidiagonal of `n` equals the sum over the set `{(k, n - k) | k < n + 1}` in `f`.


IsPrimitiveRoot.orderOf

theorem IsPrimitiveRoot.orderOf : ∀ {M : Type u_1} [inst : CommMonoid M] (ζ : M), IsPrimitiveRoot ζ (orderOf ζ) := by
  sorry

This theorem states that for any type `M` that is a Commutative Monoid, for any element `ζ` from `M`, `ζ` is a primitive root of its own order. In mathematical terms, if `orderOf ζ` is `n`, that means `ζ^n = 1` and `n` is the smallest such positive integer. The primitive root definition here is a generalization of the concept from number theory, which in this context means that `ζ` generates all the `n`-th roots of unity in the monoid `M` under multiplication.

For any commutative monoid M and any element ζ in M of finite order n, ζ is a primitive root of unity of order n, i.e., it generates all n-th roots of unity in M under multiplication.


theorem MeasureTheory.withDensity_const :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (c : ENNReal),
      (μ.withDensity fun x => c) = c • μ :=
  by sorry

The theorem `MeasureTheory.withDensity_const` states that for any type `α`, measurable space `m0` on `α`, measure `μ` on this measurable space, and an extended nonnegative real number `c`, the measure `μ` with density function being a constant function that always returns `c` is equivalent to `c` times the original measure `μ`. In other words, if we "weight" all elements of the measurable space uniformly by a factor of `c`, this is the same as scaling the entire measure by `c`.

For any measurable space `(α, m0)`, measure `μ`, and constant function `c : ℝ≥0∞`, `μ` is equivalent to `c * μ` when `c` is the density function of `μ`.


theorem PLift.down_surjective : ∀ {α : Sort u}, Function.Surjective PLift.down := by sorry

The theorem `PLift.down_surjective` states that for any type `α`, the function `PLift.down` is surjective. In other words, for any type `α` and any element of that type, there exists a lifted version of that element such that when we apply the `PLift.down` function to this lifted element, we retrieve the original element.

For any type `α`, the function `PLift.down` has a right inverse.