theorem NNReal.summable_coe : ∀ {α : Type u_1} {f : α → NNReal}, (Summable fun a => ↑(f a)) ↔ Summable f := by sorry

This theorem states that for any type `α` and function `f` from `α` to nonnegative real numbers (`NNReal`), the function `f` is summable (i.e., it has an infinite sum) if and only if the function that takes `a` in `α` to the real number equivalent of `f(a)` (denoted by `↑(f a)`) is summable. In other words, `f` and the function mapping each `a` to its real-valued counterpart have the same summability status.

The function `f : α -> NNReal` is summable if and only if the function `↑(f) : α -> Real` is summable.


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

The theorem `Nat.mono_cast` states that for any type `α` that is an additive monoid with a one element, contains a partial order, has a covariant class with respect to addition and comparison, and includes zero and one as elements, the function that casts a natural number to that type is monotone. In other words, if `a` and `b` are natural numbers and `a ≤ b`, then casting `a` and `b` to `α` preserves this order: the cast of `a` is less than or equal to the cast of `b`.

If `α` is an additive monoid with a one element, a partial order, covariant class with respect to addition and comparison, and includes zero and one, then the function that casts natural numbers to `α` is monotone with respect to the natural number ordering.


theorem iInf_top : ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α], ⨅ x, ⊤ = ⊤ := by sorry

This theorem, `iInf_top`, states that for any type `α` that forms a complete lattice (which is a sort of partially ordered set where any subset has a least upper bound and a greatest lower bound), the infimum (greatest lower bound) of any set `x` of elements from this lattice is always equal to the top element (`⊤`) of the lattice. This is true regardless of the specific elements in `x`, or the sorting function `ι` used.

In a complete lattice, the infimum of any set is equal to the top element.


theorem Filter.prod_atTop_atTop_eq :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β],
      Filter.atTop ×ˢ Filter.atTop = Filter.atTop :=
  by sorry

The theorem `Filter.prod_atTop_atTop_eq` states that for any two types `α` and `β` that have a preorder (a reflexive and transitive binary relation), the product filter of `Filter.atTop` for `α` and `Filter.atTop` for `β` is equal to `Filter.atTop`. In other words, the limit towards infinity of the product of two ordered sets is the same as the limit towards infinity of the individual sets.

For preordered types `α` and `β`, the product filter of `Filter.atTop` for `α` and `Filter.atTop` for `β` equals `Filter.atTop`.


ContinuousOn.aestronglyMeasurable

/-- A function which is continuous on a set `s` is almost everywhere strongly measurable with
respect to `μ.restrict s` when either the source space or the target space is second-countable.  -/
theorem ContinuousOn.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalSpace β] [h : SecondCountableTopologyEither α β] [inst_3 : OpensMeasurableSpace α]
      [inst_4 : TopologicalSpace.PseudoMetrizableSpace β] {f : α → β} {s : Set α} {μ : MeasureTheory.Measure α},
      ContinuousOn f s → MeasurableSet s → MeasureTheory.AEStronglyMeasurable f (μ.restrict s) :=
  by sorry

The theorem states that for any function `f` from a type `α` to a type `β`, if `f` is continuous on a set `s` and `s` is a measurable set, then `f` is almost everywhere strongly measurable with respect to the measure `μ` restricted to set `s`. This holds provided that either the source type `α` or the target type `β` has a second-countable topology, the source type `α` has a topological space structure which is measurable, and the target type `β` is a pseudo-metrizable space. "Almost everywhere strongly measurable" means that the function is almost everywhere equal to the limit of a sequence of simple functions.

If `f` is a continuous function from a measurable set `s` of a second-countable, measurable topological space `α` to a pseudo-metrizable space `β`, then `f` is almost everywhere equal to the limit of a sequence of simple functions on `s` with respect to the measure `μ`.


theorem Set.preimage_range : ∀ {α : Type u_1} {β : Type u_2} (f : α → β), f ⁻¹' Set.range f = Set.univ := by sorry

The theorem `Set.preimage_range` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, the preimage of the range of `f` under `f` itself is the universal set of `α`. In other words, for every element `x` in `α`, there exists an element `y` in the range of `f` (which is a subset of `β`) such that `f(x) = y`. This coincides with the definition of the universal set, which contains all elements of a given type.

For any function `f` from type `α` to type `β`, the preimage of the range of `f` under `f` equals the universe of `α`.


theorem Mathlib.Data.Finset.Card._auxLemma.1 : ∀ {α : Type u_1} {s : Finset α}, (s.card = 0) = (s = ∅) := by sorry

This theorem states that for any type `α` and any finite set `s` of that type, the cardinality (or size) of `s` being zero is equivalent to `s` being the empty set. In other words, a finite set has zero elements if and only if it is the empty set.

For any finite type `α`, the set `s` of type `α` has zero cardinality if and only if it is empty.


IsometryEquiv.ext

theorem IsometryEquiv.ext :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] ⦃h₁ h₂ : α ≃ᵢ β⦄,
      (∀ (x : α), h₁ x = h₂ x) → h₁ = h₂ :=
  by sorry

This theorem states that for any two isometries `h₁` and `h₂` from a pseudo emetric space `α` to another pseudo emetric space `β`, if for all elements `x` in `α` the images under `h₁` and `h₂` are equal (i.e., `h₁ x = h₂ x`), then `h₁` and `h₂` are the same isometry. In other words, two isometries between the same pseudo emetric spaces are equal if they map each point in the domain to the same point in the codomain.

If two isometries between the same pseudo-metric spaces map each point to the same image, then they are equal.


theorem Polynomial.coeff_X_pow :
    ∀ {R : Type u} [inst : Semiring R] (k n : ℕ), Polynomial.coeff (Polynomial.X ^ k) n = if n = k then 1 else 0 := by
  sorry

The theorem `Polynomial.coeff_X_pow` states that for any semiring `R` and for any natural numbers `k` and `n`, the `n`-th coefficient of the polynomial `X^k` (where `X` is the polynomial variable) equals `1` if `n` equals `k` and `0` otherwise. Essentially, this theorem is stating that the `k`-th power of a polynomial `X` only has a non-zero coefficient at the `k`-th term, and that coefficient is `1`.

For any semiring R and natural numbers k and n, the n-th coefficient of X^k (in the polynomial basis of X) is 1 if n = k, and 0 otherwise.


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

This theorem states that for any type `α`, an element `a` of type `α`, and two sets `s` and `t` of type `α`, if set `s` is a subset of set `t`, then the set resulting from inserting element `a` into `s` is a subset of the set resulting from inserting `a` into `t`. Essentially, it explains how the subset relation is preserved when the same element is added to both the subset and its superset.

For any type `α`, sets `s` and `t` of type `α` with `s ⊆ t`, and element `a` of type `α`, we have `insert a s ⊆ insert a t`.


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

This theorem states that for any type `α` that forms a generalized coheyting algebra, given three elements `a`, `b`, and `c` of that type, if `a` is less than or equal to `b`, then the pseudo-difference of `a` and `c` (`a \ c`) is less than or equal to the pseudo-difference of `b` and `c` (`b \ c`). This theorem can be viewed as a property of order preservation in the context of generalized coheyting algebras.

In a generalized coheting algebra, if `a ≤ b` then `a \ c ≤ b \ c` for all elements `a, b, c` of the type.


theorem irreducible_iff_prime :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : DecompositionMonoid α] {a : α},
      Irreducible a ↔ Prime a :=
  by sorry

The theorem `irreducible_iff_prime` states that for any type `α` that is a cancellative commutative monoid with zero and also a decomposition monoid, an element `a` of `α` is irreducible if and only if it is prime.

In mathematical terms, this means that in this specific algebraic structure (a cancellative commutative monoid with zero that has a decomposition monoid structure), an element is irreducible (cannot be factored into two non-unit elements) if and only if it is prime (it is not zero, it is not a unit, and whenever it divides a product, it divides at least one of the factors).

In a cancellative commutative monoid with zero and decomposition monoid structure, an element is irreducible if and only if it is prime.


theorem OrderIso.le_iff_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {x y : α}, e x ≤ e y ↔ x ≤ y := by sorry

This theorem states that for any two types `α` and `β` with a less than or equal to (`≤`) ordering, if there exists an order isomorphism (`≃o`) `e` from `α` to `β`, then for any two elements `x` and `y` of type `α`, `x` is less than or equal to `y` if and only if `e(x)` is less than or equal to `e(y)`. Basically, the order isomorphism `e` preserves the order of elements when mapping from `α` to `β`.

For any order isomorphism `e` between types `α` and `β`, `x ≤ y` in `α` if and only if `e(x) ≤ e(y)` in `β`.


theorem Real.sin_add : ∀ (x y : ℝ), Real.sin (x + y) = Real.sin x * Real.cos y + Real.cos x * Real.sin y := by sorry

This theorem, `Real.sin_add`, states that for all real numbers `x` and `y`, the sine of the sum (`x + y`) is equal to the product of the sine of `x` and the cosine of `y`, plus the product of the cosine of `x` and the sine of `y`. In mathematical terms, it can be written as $\sin(x+y) = \sin(x)\cos(y) + \cos(x)\sin(y)$. This is a well-known trigonometric identity often used in the study of oscillations, waves, and many other areas of mathematics and physics.

The sine function is additive, that is, $\sin(x + y) = \sin(x)\cos(y) + \cos(x)\sin(y)$.


Ordinal.induction

/-- Reformulation of well founded induction on ordinals as a lemma that works with the
`induction` tactic, as in `induction i using Ordinal.induction with | h i IH => ?_`.  -/
theorem Ordinal.induction :
    ∀ {p : Ordinal.{u} → Prop} (i : Ordinal.{u}), (∀ (j : Ordinal.{u}), (∀ k < j, p k) → p j) → p i := by sorry

This theorem provides a formulation of well-founded induction on ordinals which is compatible with the `induction` tactic in Lean 4. This theorem states that for any property `p` and any ordinal `i`, if the property `p` holds for every ordinal `j` where `p` holds for all ordinals `k` less than `j`, then `p` also holds for the ordinal `i`. In other words, this theorem asserts that if a property is true for all smaller ordinals, then it is also true for the ordinal under consideration.

The theorem asserts that any property holding for all ordinals below a given ordinal also holds for that ordinal in the well-founded relation.


/-- **Alias** of `Filter.tendsto_atTop_atTop_of_monotone`. -/
theorem Monotone.tendsto_atTop_atTop :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → (∀ (b : β), ∃ a, b ≤ f a) → Filter.Tendsto f Filter.atTop Filter.atTop :=
  by sorry

The theorem `Monotone.tendsto_atTop_atTop` states that, for all types `α` and `β` equipped with a preorder, if a function `f` from `α` to `β` is monotone, and for all `b` in `β` there exists an `a` in `α` such that `b` is less than or equal to `f(a)`, then the function `f` tends to infinity as its argument tends to infinity. In other words, as we take larger and larger values in the domain of `f`, the function values also become larger and larger. This is a property of monotone functions that do not have an upper bound.

If `f` is a monotone function from type `α` to type `β`, where `α` and `β` have a preorder, and for each `b` in `β`, there exists an `a` in `α` with `f(a) ≤ b`, then `f` is unbounded.


theorem CategoryTheory.Limits.image.lift_fac :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasImage f] (F' : CategoryTheory.Limits.MonoFactorisation f),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.lift F') F'.m = CategoryTheory.Limits.image.ι f :=
  by sorry

The theorem `CategoryTheory.Limits.image.lift_fac` states that for any category `C`, and for any morphism `f` from `X` to `Y` in this category for which an image exists, given any monomorphism factorization `F'` of `f`, the composition of the lift (a special morphism) of the image of `f` through `F'` and the morphism `F'.m` is equal to the inclusion of the image of `f` into `Y`. In other words, this theorem specifies a commutative diagram related to the image and the monomorphism factorization in the category theory.

 Given a category `C`, a morphism `f : X → Y` with an image, and a monomorphism factorization `F' · m` of `f`, the diagram commutes: image `(f)` ≅ F'.m ∘ lift (image `(f)`) (F').

Alternatively, the lift of the image of `f` through `F'` equals the inclusion of the image of `f` into `Y`. In other words, `lift (image f) (F') = ⊆i (image f)`, where `⊆i` denotes the inclusion morphism.


CharP.exists

theorem CharP.exists : ∀ (R : Type u_1) [inst : NonAssocSemiring R], ∃ p, CharP R p := by sorry

This theorem states that for any type `R` which is a non-associative semiring, there exists a prime number `p` such that `R` has characteristic `p`. In other words, for any non-associative semiring, there exists a prime number `p` such that adding `p` copies of any element of `R` together will always yield the additive identity (zero) of the semiring.

For any non-associative semiring R, there exists a prime number p such that the sum of p elements of R is the additive identity.


theorem Finset.Ico_eq_empty_of_le :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ≤ a → Finset.Ico a b = ∅ := by
  sorry

This theorem states that for any type `α` which has a preorder and is also a locally finite order, if `b` is less than or equal to `a`, then the finite set of elements `x` such that `a ≤ x` and `x < b` is an empty set. In other words, there are no elements `x` that satisfy `a ≤ x` and `x < b` when `b ≤ a` in a set with a locally finite order.

In a locally finite order preorder type `α`, there are no elements `x` such that `a ≤ x` and `x < b` for `b ≤ a`.


theorem Units.eq_iff : ∀ {α : Type u} [inst : Monoid α] {a b : αˣ}, ↑a = ↑b ↔ a = b := by sorry

This theorem states that for all types `α` which possess a Monoid structure, two units `a` and `b` of type `α` are equal if and only if their canonical embeddings into `α` are equal. In other words, it provides a condition for the equality of two elements of the group of units of a monoid, using the equality of their representations in the monoid structure itself.

In mathematical terms, we're basically saying if a and b are elements of the unit group of a monoid, then a equals b if and only if their embeddings in the monoid are equal.

For all types `α` with a Monoid structure and units `a` and `b` in `α`, `a = b` if and only if their monoid embeddings `[a : α] = [b : α]` hold.


OrderEmbedding.strictMono

theorem OrderEmbedding.strictMono :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β), StrictMono ⇑f := by sorry

The theorem `OrderEmbedding.strictMono` states that for any two types `α` and `β`, both having a preorder (a binary relation that is reflexive and transitive), any order-embedding function `f` from `α` to `β` is strictly monotone. Here, an order-embedding function is a function that preserves the order of the elements. Strict monotonicity means that if `a` is less than `b` in the type `α`, then `f(a)` is less than `f(b)` in the type `β`.

Given types `α` and `β` with preorders, any order-embedding function `f` from `α` to `β` is a strictly increasing function.


Ordinal.IsNormal.strictMono

theorem Ordinal.IsNormal.strictMono : ∀ {f : Ordinal.{u_4} → Ordinal.{u_5}}, Ordinal.IsNormal f → StrictMono f := by
  sorry

This theorem states that for any function `f` from ordinals to ordinals, if `f` is a normal ordinal function, then `f` is also strictly monotone. In other words, if `f` is a function which is strictly increasing and the image of a limit ordinal under `f` is the supremum of the images of all smaller ordinals, then for any two ordinals `a` and `b`, if `a` is less than `b`, `f(a)` is less than `f(b)`.

If `f` is a normal ordinal function, then it is strictly increasing.


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

The theorem `mul_le_mul_of_nonpos_right` is a statement about ordered semirings. It says that for any type `α` which is an ordered semiring and for any elements `a`, `b`, and `c` of this type, if `b` is less than or equal to `a` and `c` is less than or equal to zero, then the product of `a` and `c` is less than or equal to the product of `b` and `c`. This can also be understood as: in an ordered semiring, if we multiply by a non-positive number, the order of multiplication is reversed.

In an ordered semiring, if one multiplier is non-positive and the other is less than or equal to the first, then their product is less than or equal to the product of the smaller multiplier and the non-positive multiplier.


theorem DFinsupp.coe_zero : ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)], ⇑0 = 0 := by sorry

This theorem states that for any type ι and a type family β indexed by ι, if each type in the family β has a zero element, then the zero element of the direct sum of the family β, denoted by 0 (or `DFinsupp.zero`) and its interpretation as a function (obtained by applying the coercion to function, denoted by `⇑`), is also the zero function. In simpler terms, it states that the zero element of a direct sum of types with zero acts like a zero function when interpreted as a function.

For any type family β indexed by ι, if each type in β has a zero element, then the zero element of the direct sum of β is the function with type ι → ∏{β i : ι} 0 i.


theorem isUnit_of_dvd_unit : ∀ {α : Type u_1} [inst : CommMonoid α] {x y : α}, x ∣ y → IsUnit y → IsUnit x := by sorry

The theorem `isUnit_of_dvd_unit` states that for any type `α` which forms a commutative monoid, given two elements `x` and `y` of `α`, if `x` divides `y` and `y` is a unit (meaning, `y` has a multiplicative inverse), then `x` is also a unit. In other words, if an element divides a unit in a commutative monoid, then that element must also be a unit.

If `x` divides `y` and `y` is a unit in a commutative monoid, then `x` is a unit.


theorem Filter.tendsto_neg_atBot_atTop :
    ∀ {β : Type u_4} [inst : OrderedAddCommGroup β], Filter.Tendsto Neg.neg Filter.atBot Filter.atTop := by sorry

The theorem `Filter.tendsto_neg_atBot_atTop` states that for any ordered additive commutative group `β`, the function that produces the negative of an element (`Neg.neg`) tends to infinity (`Filter.atTop`) as the input tends to negative infinity (`Filter.atBot`). In simpler terms, it says that as we go towards negative infinity in the group, flipping the sign of the elements will get us closer and closer to positive infinity.

For any ordered additive commutative group β, the function Neg.neg is infinitely increasing as we approach negative infinity.


theorem aemeasurable_id : ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}, AEMeasurable id μ :=
  by sorry

The theorem `aemeasurable_id` states that for any type `α`, any measurable space `m` over `α`, and any measure `μ` on that measurable space, the identity function is almost everywhere measurable. In other words, the identity function coincides almost everywhere with a measurable function.

The identity function is almost everywhere measurable with respect to any given measurable space and measure.


/-- If a predicate is true in a neighborhood of `x`, then it is true for `x`.  -/
theorem Filter.Eventually.self_of_nhds :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {p : X → Prop}, (∀ᶠ (y : X) in nhds x, p y) → p x := by sorry

The theorem `Filter.Eventually.self_of_nhds` asserts that if a property or predicate `p` holds true in a neighborhood of a point `x` in a topological space `X`, then that property `p` is also true for the point `x` itself. In more mathematical terminology, this theorem states that if for every neighborhood of `x` (in the sense of the neighborhood filter `nhds x`), there exists a point `y` where the predicate `p` holds, then `p` must also hold for `x`.

If every neighborhood of a point `x` in a topological space `X` contains a point `y` where property `p` holds, then `p` holds for `x` itself.


theorem Filter.preimage_mem_comap :
    ∀ {α : Type u} {β : Type v} {g : Filter β} {m : α → β} {t : Set β}, t ∈ g → m ⁻¹' t ∈ Filter.comap m g := by sorry

This theorem states that for all types `α` and `β`, a filter `g` on `β`, a function `m` from `α` to `β`, and a set `t` of type `β`, if `t` is in `g`, then the preimage of `t` under `m` is in the comap of `m` and `g`. Here, the preimage of `t` under `m` is the set of all elements in `α` that `m` maps to `t`, and the comap of `m` and `g` is the filter on `α` consisting of all preimages of sets in `g` under `m`.

For all types `α` and `β`, filters `g` on `β`, functions `m` from `α` to `β`, and sets `t` in `g`, the preimage of `t` under `m` belongs to the composite filter of `m` and `g`.


theorem Cardinal.one_lt_aleph0 : 1 < Cardinal.aleph0 := by sorry

The theorem `Cardinal.one_lt_aleph0` states that the cardinality of the set of natural numbers (also known as `ℵ₀` or `aleph0`) is greater than one. In other words, the size of the set of natural numbers is larger than the size of a singleton set, confirming the intuitive idea that there are infinitely many natural numbers.

The cardinality of the set of natural numbers is strictly greater than that of a singleton set.


theorem Submodule.span_mul_span :
    ∀ (R : Type u) [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Set A),
      Submodule.span R S * Submodule.span R T = Submodule.span R (S * T) :=
  by sorry

This theorem states that for any commutative semiring `R` and any semiring `A` that is also an `R`-algebra, given any two sets `S` and `T` of elements of `A`, the span over `R` of the set `S` multiplied by the span over `R` of the set `T` is equal to the span over `R` of the set of all products of an element from `S` and an element from `T`. In simpler terms, the product of the spans of two sets is the same as the span of the products of the elements in the two sets.

For any commutative semiring `R`, `R`-algebra `A`, sets `S` and `T` in `A`, the span of `S` multiplied by the span of `T` equals the span of the set of all products of elements from `S` and `T`.


theorem measurableSet_Iic :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [inst_2 : OpensMeasurableSpace α]
      [inst_3 : Preorder α] [inst : OrderClosedTopology α] {a : α}, MeasurableSet (Set.Iic a) :=
  by sorry

The theorem `measurableSet_Iic` states that for any type `α` which is both a topological space and a measurable space, and admits an order-closed topology and a preorder relation, the left-infinite right-closed interval, denoted as `Set.Iic a`, is a measurable set. In other words, for any given value `a` of type `α`, the set of all elements of type `α` that are less than or equal to `a` is a measurable set in the specified measure space.

For any topological space and measurable space α with an order-closed topology and preorder relation, the left-infinite right-closed interval Set.Iic a is a measurable set.


theorem ENNReal.mul_left_mono : ∀ {a : ENNReal}, Monotone fun x => a * x := by sorry

The theorem `ENNReal.mul_left_mono` states that for any extended nonnegative real number `a`, the function that multiplies `a` with a variable `x` is monotone. In other words, if `x` and `y` are two extended nonnegative real numbers such that `x ≤ y`, then `a * x ≤ a * y`. This property holds regardless of the specific value of `a`.

For all extended nonnegative real numbers `a` and `x` with `x <= y`, we have `a * x <= a * y`.


theorem measurableSet_setOf :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop}, MeasurableSet {a | p a} ↔ Measurable p := by sorry

The theorem `measurableSet_setOf` states that, for any given type `α` and a property `p` that elements of `α` may or may not satisfy (expressed as a predicate `p : α → Prop`), the set `{a | p a}` consisting of all elements in `α` that satisfy property `p` is a measurable set if and only if the predicate `p` is a measurable function. Here, "measurable" corresponds to the mathematical concept of measurability in the context of measure theory, which involves the structure of sets and their size. A function is considered measurable if the preimage of every measurable set is also measurable.

A set {a | p a} of elements in type α is measurable if and only if the predicate p is a measurable function.


theorem List.insert_of_mem :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α}, a ∈ l → List.insert a l = l := by sorry

This theorem, `List.insert_of_mem`, states that for any type `α` that has a binary equality operation (`BEq`) and for which this equality operation obeys certain laws (`LawfulBEq`), if an element of type `α` named `a` is an element of a list `l` of elements of type `α` (written as `a ∈ l`), then inserting `a` into `l` using the `List.insert` function doesn't change the list; i.e., `List.insert a l = l`. This means that if the list already contains the element, the `List.insert` function does not duplicate it.

If `α` is a type with a `BEq` relation satisfying `LawfulBEq`, and `a ∈ l` is an element in list `l` of type `α`, then `List.insert a l = l`.


/-- The indexed infimum of a function is bounded above by the value taken at one point -/
theorem ciInf_le :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {f : ι → α},
      BddBelow (Set.range f) → ∀ (c : ι), iInf f ≤ f c :=
  by sorry

This theorem states that for any type `α` with a Conditionally Complete Lattice structure, and any function `f` from an arbitrary type `ι` to `α`, if the range of the function `f` is bounded below, then the 'indexed infimum' (i.e., the greatest lower bound) of the function `f` is less than or equal to the value of the function at any point `c` in its domain. In mathematical terms, if `f : ι → α` and the set `{f(x) | x ∈ ι}` has a lower bound, then for any `c` in `ι`, we have `inf {f(x) | x ∈ ι} ≤ f(c)`.

For any function `f : ι → α` with domain `ι` and type `α` having a Conditionally Complete Lattice structure, if the range of `f` has an infimum then `inf (range f) ≤ f(c)` for any `c` in `ι`.


ModularForm.ext

theorem ModularForm.ext :
    ∀ {Γ : Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)} {k : ℤ} {f g : ModularForm Γ k},
      (∀ (x : UpperHalfPlane), f x = g x) → f = g :=
  by sorry

The theorem `ModularForm.ext` states that for any subgroup `Γ` of the special linear group of 2 by 2 matrices with integer entries, and for any integer `k`, if `f` and `g` are modular forms of weight `k` with respect to `Γ`, then if `f` and `g` are equal for every point in the upper half plane, then `f` and `g` are equal. In other words, a modular form is completely determined by its values in the upper half plane.

For any subgroup of the special linear group of 2 by 2 matrices with integer entries Γ and integer weight k, two modular forms f and g are equal if and only if they have the same value at every point in the upper half plane.


/-- The `nonsing_inv` of `A` is a right inverse.  -/
theorem Matrix.mul_nonsing_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      IsUnit (Matrix.det A) → A * A⁻¹ = 1 :=
  by sorry

This theorem states that for any square matrix `A` of type `Matrix n n α`, where `n` is a finite type with decidable equality, and `α` is a commutative ring, if the determinant of `A` is a unit (i.e., it has a multiplicative inverse), then the product of `A` and its nonsingular inverse `A⁻¹` equals the identity matrix. In other words, if the determinant of `A` is not zero (which indicates that `A` is nonsingular), then `A⁻¹` is a right inverse of `A`.

If `A` is a square matrix of type `n x n` over a commutative ring `α` with a nonzero determinant, then `A` and its inverse `A⁻¹` are multiplicative inverses: `A * A⁻¹ = id`.


theorem neg_eq_neg_one_mul : ∀ {α : Type u} [inst : MulOneClass α] [inst_1 : HasDistribNeg α] (a : α), -a = -1 * a := by
  sorry

This theorem states that for any type `α` that is a multiplication-one class (i.e., it supports multiplication and has an identity element for multiplication), and has a negation operation following the distributive law, the negative of an element `a` (`-a`) is equal to `-1` multiplied by `a` (`-1 * a`). This essentially encapsulates the mathematical property of negative numbers in a general algebraic structure.

For any multiplication-one class type `α` with negation operation following distributive law, negative of an element `a` equals `-1 * a`.


theorem Nat.min_zero : ∀ (a : ℕ), min a 0 = 0 := by sorry

This theorem states that for any natural number `a`, the minimum of `a` and `0` is `0`. In other words, zero is less than or equal to every natural number, so when comparing zero with any natural number, zero is always the minimum.

For all natural numbers `a`, `0 ≤ a`. (Zero is less than or equal to every natural number.)


theorem sub_add_eq_add_sub : ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - b + c = a + c - b := by
  sorry

This theorem states that for any type `α` that forms a subtraction commutative monoid, for any three elements `a`, `b`, and `c` of type `α`, the result of subtracting `b` from `a`, then adding `c` is equal to the result of adding `c` to `a`, then subtracting `b`. In mathematical notation, this would be written as: `a - b + c = a + c - b`.

For any commutative subtraction monoid type `α`, the result of `a - b + c` is equal to `a + c - b`.


/-- An additive subsemigroup `S` includes `closure s` if and only if it includes `s` -/
theorem AddSubsemigroup.closure_le :
    ∀ {M : Type u_1} [inst : Add M] {s : Set M} {S : AddSubsemigroup M}, AddSubsemigroup.closure s ≤ S ↔ s ⊆ ↑S := by
  sorry

This theorem states that for any type `M` that has an additive structure, a set `s` of elements of type `M`, and an additive subsemigroup `S` of `M`, the closure of `s` under the operation of `AddSubsemigroup` is included in `S` if and only if `s` is a subset of `S`. In other words, an additive subsemigroup `S` contains the least additive subsemigroup generated by a set `s` (the "closure" of `s`) if and only if `S` contains every element of `s`.

An additive subsemigroup contains the closure of a subset if and only if the subset is a subset of the subsemigroup.


theorem GaloisCoinsertion.u_l_eq :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : PartialOrder α] [inst_1 : Preorder β],
      GaloisCoinsertion l u → ∀ (a : α), u (l a) = a :=
  by sorry

This theorem states that for any types `α` and `β` and functions `l : α → β` and `u : β → α`, given a partial order on `α` and a preorder on `β`, if there exists a Galois coinsertion between `l` and `u`, then for any element `a` of type `α`, applying `l` to `a` and then `u` to the result returns `a`. In other words, the function `u` followed by `l` acts as the identity on `α`. This property is a fundamental characteristic of Galois coinsertions in order theory.

Given functions `l : α → β` and `u : β → α` between partially ordered types `α` and `β` with a preorder on `β`, if there is a Galois coinsertion between `l` and `u`, then `u ∘ l = id_α`.


/-- Restate `Set.Countable` as a `Countable` instance.  -/
theorem Set.Countable.to_subtype : ∀ {α : Type u} {s : Set α}, Set.Countable s → Countable ↑s := by sorry

This theorem restates the definition of a countable set as an instance of countability. Given a type `α` and a set `s` of this type, it states that if `s` is countable (in the sense of the `Set.Countable` predicate), then the subtype corresponding to `s` is also countable in the sense of the `Countable` type class. This theorem provides a bridge between the definition of countability for sets and the definition of countability for subtypes.

If `s` is a countable set of type `α`, then the subtype `{x : α | x ∈ s}` is also a countable subtype.


theorem MeasureTheory.Memℒp.aestronglyMeasurable :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
      {f : α → E} {p : ENNReal}, MeasureTheory.Memℒp f p μ → MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

This theorem states that for any measurable space `α`, type `E` that is a normed add commutative group, measure `μ` on this space, and function `f` from `α` to `E`, if `f` belongs to the space of essentially `p`-integrable functions (`MeasureTheory.Memℒp f p μ`), then `f` is almost everywhere strongly measurable (`MeasureTheory.AEStronglyMeasurable f μ`). In mathematical terms, this means that `f` is almost everywhere equal to the limit of a sequence of simple functions.

If a function `f` from a measurable space `α` to a normed add commutative group `E` is essentially `p`-integrable with respect to measure `μ`, then `f` is almost everywhere strongly measurable.


theorem Filter.mem_iInf_of_mem :
    ∀ {α : Type u} {ι : Sort x} {f : ι → Filter α} (i : ι) {s : Set α}, s ∈ f i → s ∈ ⨅ i, f i := by sorry

The theorem `Filter.mem_iInf_of_mem` states that for any type `α` and an index type `ι`, given a function `f` from `ι` to the type of filters on `α`, an index `i` of type `ι`, and a set `s` of type `α`, if the set `s` is an element of the filter `f(i)`, then `s` is also an element of the infimum (⨅ i) of all the filters generated by `f` across all indices. In simpler terms, it states that if a set belongs to a particular filter, then it also belongs to the intersection of all filters generated by the function `f`.

If `s` is an element of `f(i)` for some index `i` and function `f` mapping indices to filters on `α`, then `s` is an element of the infimum of all filters in the image of `f`.


theorem CategoryTheory.Limits.HasZeroObject.to_zero_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] {X : C}
      (f g : X ⟶ 0), f = g :=
  by sorry

This theorem states that in the context of category theory, given any category `C` that has a zero object, for any object `X` in `C`, any two morphisms `f` and `g` from `X` to the zero object are equal. In essence, it asserts the uniqueness of the morphism from any object to the zero object in a category with a zero object.

In a category with a zero object, any two morphisms from an object to the zero object are equal.


theorem Nat.div_pos : ∀ {a b : ℕ}, b ≤ a → 0 < b → 0 < a / b := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `b` is less than or equal to `a` and `b` is greater than 0, then the result of dividing `a` by `b` is also greater than 0. Essentially, it asserts that the division of a larger natural number by a smaller, positive natural number is always a positive natural number.

For all natural numbers `a` and `b` with `0 < b <= a`, the quotient `a / b` is a positive natural number.


MeasurableEquiv.ext

theorem MeasurableEquiv.ext :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {e₁ e₂ : α ≃ᵐ β},
      ⇑e₁ = ⇑e₂ → e₁ = e₂ :=
  by sorry

The theorem `MeasurableEquiv.ext` states the following: Given two types `α` and `β` where `α` and `β` both have measurable spaces respectively, and given two measurable equivalences `e₁` and `e₂` between `α` and `β`, if the function of `e₁` is equal to the function of `e₂`, then `e₁` is equal to `e₂`. In other words, this is a statement about the uniqueness of a measurable equivalence between two measurable spaces - if two measurable equivalences have the same function, they are indeed the same measurable equivalence.

If `α` and `β` are measurable spaces and `e₁` and `e₂` are measurable equivalences from `α` to `β` with equal functions, then `e₁ = e₂`.


theorem Mathlib.Probability.ProbabilityMassFunction.Basic._auxLemma.2 :
    ∀ {α : Type u_1} (p : PMF α) (a : α), (a ∈ PMF.support p) = (p a ≠ 0) := by sorry

This theorem states that for any type `α` and a probability mass function `p` over that type, and any element `a` of type `α`, `a` is in the support of `p` if and only if the value of `p` at `a` is not zero. The support of a probability mass function is the set of all points where the function is non-zero. So, this theorem is essentially defining the support of `p` in terms of the values of `p`.

The support of a probability mass function `p` over type `α` equals the set of elements `a` in `α` such that `p a ≠ 0`.


theorem Filter.Frequently.and_eventually :
    ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
      (∃ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, q x) → ∃ᶠ (x : α) in f, p x ∧ q x :=
  by sorry

This theorem states that for any type `α`, predicates `p` and `q`, and filter `f` on `α`, if there frequently exists an `x` in `f` such that predicate `p` holds, and if it is eventually the case that for all `x` in `f`, predicate `q` holds, then there frequently exists an `x` in `f` for which both `p` and `q` hold. In other words, if a condition `p` is frequently true and another condition `q` is eventually always true in a certain context determined by a filter, then it is frequently the case that both conditions hold together.

If a filter `f` on type `α` has infinitely many elements `x` where `p(x)` holds and eventually all elements `x` in `f` satisfy `q(x)`, then there exists an infinite subset `S` of `f` such that for all `x` in `S`, both `p(x)` and `q(x)` hold.


/-- A fact that is eventually true about all pairs `l ×ˢ l` is eventually true about
all diagonal pairs `(i, i)`  -/
theorem Filter.Eventually.diag_of_prod :
    ∀ {α : Type u_1} {f : Filter α} {p : α × α → Prop}, (∀ᶠ (i : α × α) in f ×ˢ f, p i) → ∀ᶠ (i : α) in f, p (i, i) :=
  by sorry

This theorem states that if a property is eventually true for all pairs `l ×ˢ l` drawn from a given filter `f`, then that property is also eventually true for all diagonal pairs `(i, i)` from the same filter. In other words, if a predicate `p` holds for almost all pairs in the product of a filter with itself, then `p` also holds for almost all elements in the filter when considered as pairs with identical first and second elements.

If a property holds for almost all pairs in the product of a filter with itself in Lean 4, then it also holds for almost all diagonal pairs from the same filter.


theorem List.nil_bind : ∀ {α : Type u_1} {β : Type u_2} (f : α → List β), List.bind [] f = [] := by sorry

The theorem `List.nil_bind` states that for all types `α` and `β`, and for any function `f` from `α` to List `β`, binding an empty list (`[]`) with `f` results in an empty list. In essence, this means that if you have an empty list and try to apply a list transformation function to it, you will simply get an empty list back. This is a basic property of the list monad's bind operation.

For all types `α` and `β`, `List.bind (λx. [], f) [] = []`.


/-- A morphism in `Type u` is an isomorphism if and only if it is bijective.  -/
theorem CategoryTheory.isIso_iff_bijective :
    ∀ {X Y : Type u} (f : X ⟶ Y), CategoryTheory.IsIso f ↔ Function.Bijective f := by sorry

The theorem states that, for any two types 'X' and 'Y' in the same universe 'u', a morphism 'f' from 'X' to 'Y' is an isomorphism if and only if it is bijective. In other words, in the category of types, a morphism (which is simply a function in this context) is an isomorphism (an invertible morphism) exactly when it is a bijective function, i.e., a function that is both injective (no two different inputs have the same output) and surjective (every element in the codomain is an output for at least one input).

A morphism between types is an isomorphism if and only if it is a bijective function.


theorem Polynomial.C_comp :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R},
      Polynomial.comp (Polynomial.C a) p = Polynomial.C a :=
  by sorry

This theorem states that for any semiring `R`, any element `a` of `R`, and any polynomial `p` over `R`, the composition of the constant polynomial `a` and `p` equals the constant polynomial `a`. In other words, when we substitute `p` into the constant polynomial `a`, the result is still the constant polynomial `a`. This makes sense because a constant polynomial doesn't have any variables to substitute into, so its value should remain the same no matter what polynomial we try to substitute in for its non-existent variable.

For any semiring `R`, any element `a` in `R`, and any polynomial `p` over `R`, the constant polynomial `a` and the composition `a ∘ p` are equal.


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

The theorem `normalize_gcd` states that for any type `α` that is a Cancel Commutative Monoid with Zero and a Normalized GCD Monoid, and for any two elements `a` and `b` of `α`, the normalized value of the greatest common divisor (gcd) of `a` and `b` is equal to the gcd of `a` and `b` itself. Here, normalization is achieved by multiplying an element by the unit associated with its norm. This shows an important property of the gcd in such a monoid, namely that it is invariant under normalization.

For any Cancel Commutative Monoid with Zero and a Normalized GCD Monoid `α`, the normalized gcd of `a` and `b` equals their standard gcd.


theorem true_and_iff : ∀ (p : Prop), True ∧ p ↔ p := by sorry

The theorem `true_and_iff` states that for any proposition `p`, the logical AND of `True` and `p` is logically equivalent to `p` itself. In mathematical terms, we can express this as: for any proposition `p`, `True ∧ p` if and only if `p`. Basically, it means that combining any proposition with `True` using a logical AND does not change the truth value of the proposition.

For any proposition `p`, `True ∧ p` is logically equivalent to `p`.


theorem List.erase_eq_eraseP :
    ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α) (l : List α),
      List.erase l a = List.eraseP (fun x => a == x) l :=
  by sorry

This theorem states that for any type `α` that has a binary equality relation (`BEq α`) and obeys the laws of binary equality (`LawfulBEq α`), and for any specific element `a` of type `α` and list `l` of elements of type `α`, the function `List.erase l a` (which removes the first occurrence of `a` from `l`) is equal to `List.eraseP (fun x => a == x) l`. In other words, the operation of erasing a particular element from a list is the same as removing the first element that satisfies the condition of being equal to the given element.

For any type `α` with a lawful binary equality relation, the function `List.erase` that removes the first occurrence of an element from a list is equal to the function `List.eraseP` that removes elements satisfying equality to a given element.


theorem or_assoc : ∀ {a b c : Prop}, (a ∨ b) ∨ c ↔ a ∨ b ∨ c := by sorry

This theorem, `or_assoc`, states that for any three propositions `a`, `b`, and `c`, the logical OR (`∨`) operation is associative. In other words, the proposition "`(a OR b) OR c`" is logically equivalent to "`a OR (b OR c)`". This means that the parentheses can be moved without changing the truth value of the entire expression.

The logical OR operation is associative, that is, `(a ∨ b) ∨ c` is equivalent to `a ∨ (b ∨ c)` for any propositions `a`, `b`, and `c`.


theorem CategoryTheory.Limits.biprod.inr_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f : X ⟶ W) (g : Y ⟶ W),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr (CategoryTheory.Limits.biprod.desc f g) = g :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.inr_desc` states that in any category `C` with zero morphisms and binary biproducts, for any three objects `W`, `X`, and `Y` in `C`, and given any two morphisms `f : X ⟶ W` and `g : Y ⟶ W`, the composition of the morphism `CategoryTheory.Limits.biprod.inr` (which is the inclusion into the second summand of a binary biproduct) with the morphism `CategoryTheory.Limits.biprod.desc f g` is equal to the morphism `g`. Essentially, it asserts a fundamental property of the construction of binary biproducts in a category.

In a category with zero morphisms and binary biproducts, the inclusion morphism into the second summand of a binary biproduct, composed with the description morphism of two given morphisms to the same object, equals one of those morphisms.


theorem Set.surjective_onto_range :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, Function.Surjective (Set.rangeFactorization f) := by sorry

The theorem `Set.surjective_onto_range` asserts that for any type `α` and any type-indexed collection `ι`, and any function `f` mapping from `ι` to `α`, the function that factors `f` through its range, `Set.rangeFactorization f`, is surjective. In mathematical terms, this means that for any element in the range of `f`, there exists an element in the domain of `f` such that when this element is mapped by `Set.rangeFactorization f`, we obtain the original element from the range.

For any function $f$ from a type-indexed collection $\ι$ to a type $\alpha$, the factorization of $f$ through its range is a surjection. In other words, for every $y$ in the range of $f$, there exists $x$ in the domain of $f$ such that $f(x) = y$ and $(Set.rangeFactorization~f)(x) = y$.


theorem Mathlib.Data.Sigma.Basic._auxLemma.4 :
    ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p { fst := a, snd := b } := by
  sorry

This theorem, `Mathlib.Data.Sigma.Basic._auxLemma.4`, states that for any type `α`, any type function `β` that maps an instance of `α` to a type, and any property `p` that applies to a pair consisting of an instance of `α` and an instance of `β a`, the statement "There exists an `x` such that property `p` holds for `x`" is equivalent to the statement "There exists an `a` and `b` such that property `p` holds for the pair whose first element is `a` and second element is `b`." Here, `a` is an instance of `α` and `b` is an instance of `β a`.

For any type `α`, type function `β`, property `p`, and instances `a : α` and `b : β a`, the existence of an `x` such that `p(x)` holds is equivalent to the existence of `a` and `b` such that `p(a, b)` holds.


theorem Filter.tendsto_map :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x : Filter α}, Filter.Tendsto f x (Filter.map f x) := by sorry

This theorem `Filter.tendsto_map` asserts that for any function `f` from type `α` to `β` and any filter `x` on `α`, the function `f` tends to the map of the filter `x` under `f`. In other words, for every neighborhood of `f`-images (or set of `f`-images) in the `f`-mapped filter `x`, the preimage under `f` of this set is a neighborhood in the original filter `x`. This is a universal property of functions and filters, essentially stating that the function `f` respects the filter structure.

For any filter `x` on `α` and function `f` from `α` to `β`, if for every neighborhood `V` of `f(x)` in `β`, `f⁁¹(V)` is a neighborhood of `x` in `α`, then `x` tends to the map `f(x)` under `f`.


DifferentiableAt.continuousAt

theorem DifferentiableAt.continuousAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E}, DifferentiableAt 𝕜 f x → ContinuousAt f x :=
  by sorry

This theorem states that for any function `f` mapping from a normed vector space `E` to another normed vector space `F` (both over a nontrivially normed field `𝕜`), if the function `f` is differentiable at a point `x` in `E`, then `f` is also continuous at that point `x`. This echoes the fundamental concept in calculus that differentiability implies continuity.

If `f` is a differentiable function from a normed vector space `E` to another normed vector space `F` over a nontrivially normed field `𝕜`, then `f` is continuous at every point `x` in `E`.


ContinuousMonoidHom.ext

theorem ContinuousMonoidHom.ext :
    ∀ {A : Type u_2} {B : Type u_3} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
      [inst_3 : TopologicalSpace B] {f g : ContinuousMonoidHom A B}, (∀ (x : A), f x = g x) → f = g :=
  by sorry

This theorem states that for any two continuous monoid homomorphisms `f` and `g` from a topological monoid `A` to another topological monoid `B`, if for all elements `x` in `A`, the images under `f` and `g` are the same, i.e., `f x = g x`, then `f` and `g` are the same continuous monoid homomorphism. In more mathematical terms, it asserts the uniqueness of continuous monoid homomorphisms between topological monoids.

Given topological monoids A and B, and continuous monoid homomorphisms f and g from A to B with the property that f(x) = g(x) for all x in A, then f = g.


theorem not_isUnit_zero : ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Nontrivial M₀], ¬IsUnit 0 := by sorry

This theorem states that for any type `M₀`, if it is equipped with a structure of a `MonoidWithZero` (which is a monoid that has an element called zero that satisfies certain properties) and it is nontrivial (meaning it contains at least two distinct elements), then zero is not a unit in this monoid. In other words, there doesn't exist any element in `M₀` that when multiplied by zero gives the multiplicative identity (which is usually one in the context of monoids).

In a nontrivial monoid `M₀` equipped with a `MonoidWithZero` structure, the zero element does not have a multiplicative inverse.


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

The theorem named `sub_nonneg_of_le` states that for any type `α` that has the structure of an additive group, and for which addition is a covariant operation with respect to an order relation on `α`, if `b` is less than or equal to `a`, then `a - b` is nonnegative, i.e., `0 ≤ a - b`. Here, `a` and `b` are elements of the type `α`. In mathematical notation this is equivalent to the statement: ∀a,b ∈ α, if b ≤ a then 0 ≤ a - b.

For any additive group type `α` with covariant addition and order relation, if `b` is less than or equal to `a`, then `a - b` is nonnegative. In mathematical notation: `∀a, b: α, b ≤ a → 0 ≤ a - b`.


theorem Rat.divInt_eq_div : ∀ (n d : ℤ), Rat.divInt n d = ↑n / ↑d := by sorry

This theorem states that for any two integers `n` and `d`, the function `Rat.divInt` applied to `n` and `d` is equal to the division of the rational numbers corresponding to `n` and `d` respectively. In other words, for any integers `n` and `d`, the operation of forming the rational number quotient using `Rat.divInt` is equivalent to first converting those integers to rational numbers (indicated by the ↑ notation) and then performing the division operation.

For any integers `n` and `d`, `Rat.divInt n d = Rat.castFromInt n / Rat.castFromInt d`.


theorem ZMod.nat_cast_self : ∀ (n : ℕ), ↑n = 0 := by sorry

This theorem states that for any natural number `n`, the result of applying the modular integer (ZMod) coercion to `n` is always `0`. In other words, when any natural number is cast to an integer modulo that same natural number, the result will always be `0`. This is essentially a formalization of the property in modular arithmetic that a number modulo itself is always `0`.

For all natural numbers n, the result of converting n to an integer modulo n is 0. (In mathematics notation: ∀ (n : ℕ), (n : ℤ) = 0)


theorem Complex.re_add_im : ∀ (z : ℂ), ↑z.re + ↑z.im * Complex.I = z := by sorry

The theorem `Complex.re_add_im` states that for every complex number `z`, the real part of `z` plus the imaginary part of `z` times the imaginary unit equals `z` itself. In mathematical notation, this would be expressed as: for all complex numbers `z`, `Re(z) + Im(z) * i = z`. This theorem is a formalization of the standard presentation of a complex number in terms of its real and imaginary parts.

For every complex number z, Re(z) + Im(z) * i = z.


theorem Finset.coe_biUnion :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β],
      ↑(Finset.biUnion s t) = ⋃ x ∈ ↑s, ↑(t x) :=
  by sorry

The theorem `Finset.coe_biUnion` states that for any two types `α` and `β`, a finite set `s` of type `α`, and a function `t` mapping elements of `α` to a finite set of `β`, given that `β` has decidable equality, the set of elements generated by taking the union of `t a` for each `a` in `s` (represented as `Finset.biUnion s t`), when converted to a set, is equal to the union of sets `t x` for each `x` in the set converted from `s`. In mathematical notation, it says that the set of `Finset.biUnion s t` is equivalent to the union of the sets `t x` for all `x` in the set `s`, i.e., $↑(Finset.biUnion\ s\ t) = ⋃_{x ∈ ↑s} ↑(t\ x)$.

For any finite set $s$ and function $t$, if $\beta$ has decidable equality, then $↑(Finset.biUnion\ s\ t) = ⋃_{x \in s} ↑(t\ x)$.


theorem uniformContinuous_pi :
    ∀ {ι : Type u_1} {α : ι → Type u} [U : (i : ι) → UniformSpace (α i)] {β : Type u_4} [inst : UniformSpace β]
      {f : β → (i : ι) → α i}, UniformContinuous f ↔ ∀ (i : ι), UniformContinuous fun x => f x i :=
  by sorry

The theorem `uniformContinuous_pi` states that for any index type `ι` and any family of types `α : ι → Type` equipped with uniform spaces, for any type `β` also equipped with a uniform space, and for any function `f : β → (i : ι) → α i`, the function `f` is uniformly continuous if and only if for each index `i : ι`, the function `fun x => f x i` is uniformly continuous. In other words, a function from `β` to a family of types `α i` is uniformly continuous if and only if its projections to each `α i` are uniformly continuous.

A function from a uniform space to a family of types, each equipped with a uniform structure, is uniformly continuous if and only if the projection functions to each type are uniformly continuous.


theorem inv_inj : ∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, a⁻¹ = b⁻¹ ↔ a = b := by sorry

This theorem, `inv_inj`, states that for any given type `G` that has an involutive inverse (denoted as `InvolutiveInv G`), for any two elements `a` and `b` of type `G`, the inverse of `a` being equal to the inverse of `b` implies that `a` is equal to `b`. Essentially, it's saying that the operation of taking an inverse is injective in the type `G` with an involutive inverse. This theorem applies to any group-like structure with an well-defined inverse operation.

If `G` is a type with an involutive inverse and `a` and `b` are elements of `G` such that `Inv a = Inv b`, then `a = b`.


theorem Monoid.CoprodI.lift_of :
    ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {N : Type u_4} [inst_1 : Monoid N]
      (fi : (i : ι) → M i →* N) {i : ι} (m : M i), (Monoid.CoprodI.lift fi) (Monoid.CoprodI.of m) = (fi i) m :=
  by sorry

The theorem `Monoid.CoprodI.lift_of` states that for any types `ι` and `M`, where `M` is a function from `ι` to a type, and for every index `i` in `ι` there is a monoid structure on `M i`, and given any type `N` with a monoid structure and a function `fi` that maps each `i` in `ι` and each element of `M i` to `N`, if you lift `fi` over the coproduct of the monoids `M i` and then apply it to the coproduct inclusion of an element `m` from `M i`, the result is the same as if you had applied `fi` directly to `i` and `m`. In other words, the theorem asserts the property of the `Monoid.CoprodI.lift` operation behaving as expected with respect to the `Monoid.CoprodI.of` operation in the context of monoid homomorphisms.

For any type `ι` and function `M : ι → Type` with each `M i` being a monoid, and given a monoid `N` and a function `fi : ∀ i, M i → N`, the monoid homomorphism `Monoid.CoprodI.lift fi` satisfies `fi (Monoid.CoprodI.of i m) = Monoid.lift (fi i) m`, for all `i ∈ ι` and `m ∈ M i`.


theorem Nat.le_succ_of_le : ∀ {n m : ℕ}, n ≤ m → n ≤ Nat.succ m := by sorry

This theorem states that for any two natural numbers `n` and `m`, if `n` is less than or equal to `m`, then `n` is also less than or equal to the successor of `m` (i.e., `m+1`). This essentially captures the intuitive notion that if a number is less than or equal to another number, it will also be less than or equal to any number greater than that number.

For all natural numbers `n` and `m`, if `n ≤ m`, then `n ≤ m + 1`.


theorem Irreducible.isUnit_or_isUnit :
    ∀ {α : Type u_1} [inst : Monoid α] {p : α}, Irreducible p → ∀ {a b : α}, p = a * b → IsUnit a ∨ IsUnit b := by sorry

This theorem states that for any type `α` that has a `Monoid` structure, given an element `p` of `α` that is irreducible, if `p` can be expressed as the product of two elements `a` and `b` of `α`, then either `a` or `b` is a unit. In terms of group theory, a unit is an element which has a two-sided inverse. In other words, if an irreducible element can be factored, then one of the factors must have an inverse, which in the context of multiplication, means that one of them is a unit.

For any irreducible element `p` of a `Monoid` type `α`, if `p` can be written as the product of elements `a` and `b` in `α`, then exactly one of `a` or `b` is a unit.


/-- See `lt_tsub_iff_left_of_le` for a weaker statement in a partial order.  -/
theorem lt_tsub_iff_left :
    ∀ {α : Type u_1} {a b c : α} [inst : LinearOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α]
      [inst_3 : OrderedSub α], a < b - c ↔ c + a < b :=
  by sorry

This theorem `lt_tsub_iff_left` is about linear orders, addition and subtraction in a commutative semigroup. It states that for any type `α` that has a linear order, is an additive commutative semigroup and has a notion of subtraction and an ordered subtraction, the inequality `a < b - c` is equivalent to `c + a < b`. This can also be understood as 'subtracting `c` from `b` and comparing the result with `a` is the same as adding `a` to `c` and comparing the result with `b`'.

For any commutative semigroup with additions, subtractions, and a linear order, the inequality `a < b - c` is equivalent to `c + a < b`.


theorem sInf_range : ∀ {α : Type u_1} {ι : Sort u_5} [inst : InfSet α] {f : ι → α}, sInf (Set.range f) = iInf f := by
  sorry

The theorem `sInf_range` asserts that for any function `f` from a type `ι` to another type `α` (where `α` is equipped with an infimum operation over sets), the supremum of the image of `f` (i.e., `sInf (Set.range f)`) is equal to the indexed infimum of `f` (i.e., `iInf f`). In other words, taking the supremum of the set consisting of all values `f` can take (the range of `f`), is the same as taking the infimum of `f` itself.

For any function from a type to a type equipped with an infimum operation, the supremum of the function's image is equal to the indexed infimum of the function.


theorem Equiv.Perm.coe_pow : ∀ {α : Type u} (f : Equiv.Perm α) (n : ℕ), ⇑(f ^ n) = (⇑f)^[n] := by sorry

This theorem states that for any type `α`, a permutation `f` of type `α` and a natural number `n`, the application of the permutation `f` raised to the power of `n` (`f^n`) is equal to the `n`-fold iteration of the application of `f`. In mathematical terms, if `f` is a bijection from a set to itself, then applying `f^n` to an element is the same as applying `f` to that element `n` times.

For any bijection (permutation) `f` and natural number `n`, `f^n` equals the `n`-fold composition of `f` with itself.


theorem PartialHomeomorph.continuousOn_symm :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      (e : PartialHomeomorph X Y), ContinuousOn (↑(PartialHomeomorph.symm e)) e.target :=
  by sorry

The theorem `PartialHomeomorph.continuousOn_symm` states that for any two types `X` and `Y` both equipped with a topological space structure, and given a partial homeomorphism `e` from `X` to `Y`, the inverse function (or the symmetry) of the given partial homeomorphism is continuous on the target set of the original partial homeomorphism.
In mathematical terms, if we have a partial homeomorphism `e : X → Y`, then the inverse function `e^-1` is continuous on the image of `e`.

If `e : X → Y` is a partial homeomorphism, then the inverse function `e^-1` is continuous on the image of `e`.


theorem Filter.HasBasis.neBot_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → (Filter.NeBot l ↔ ∀ {i : ι}, p i → Set.Nonempty (s i)) :=
  by sorry

This theorem states that for any type `α`, any sort `ι`, any filter `l` of `α`, and any properties `p` and sets `s` indexed by `ι`, if the filter `l` has a filter basis given by the properties `p` and sets `s`, then the filter `l` is not a bottom filter if and only if for every index `i` of sort `ι` for which the property `p i` holds, the corresponding set `s i` is nonempty. In other words, the filter is nonempty if every set in its basis that satisfies a certain condition is also nonempty.

For any filter `l` over type `α` with basis given by properties `p` and sets `s` indexed by sort `ι`, `l` is not a bottom filter if and only if for all `i` in `ι` where `p i` holds, `s i` is nonempty.


/-- The real logarithm function tends to `+∞` at `+∞`.  -/
theorem Real.tendsto_log_atTop : Filter.Tendsto Real.log Filter.atTop Filter.atTop := by sorry

This theorem states that the real logarithm function tends to positive infinity as the input approaches positive infinity. In other words, as we take larger and larger positive real numbers as inputs to the logarithm function, the output of the function also grows without bound. Formally, the theorem asserts that for every set of real numbers that extends indefinitely towards positive infinity, the preimage of this set under the logarithm function also extends indefinitely towards positive infinity. This is a formal way of saying that the limit of the logarithm function is positive infinity as its argument approaches positive infinity.

The limit of the real logarithm function is positive infinity as its argument approaches positive infinity.


theorem Mathlib.Order.LocallyFinite._auxLemma.6 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a x : α}, (x ∈ Finset.Ioi a) = (a < x) :=
  by sorry

This theorem states that for any type `α` having a preorder and a locally finite order with top, and for any elements `a` and `x` of this type, `x` is in the finite set of elements greater than `a` (`Finset.Ioi a`) if and only if `a` is less than `x`. In other words, it establishes a correspondence between the membership of `x` in the set of elements greater than `a` and the truth of the inequality `a < x`.

For any type with a preorder and locally finite order having a top element, the element `x` is in the upward closed set `{y | y > a}` if and only if `a` is strictly less than `x`.


theorem Mathlib.Order.LocallyFinite._auxLemma.8 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, (x ∈ Finset.Iio a) = (x < a) :=
  by sorry

This theorem states that for any type `α` that has a preorder and a locally finite order at the bottom, and for any elements `a` and `x` of that type, `x` belongs to the finset `Finset.Iio a` if and only if `x` is less than `a`. In simpler words, the theorem is saying that the finset `Finset.Iio a` is exactly the set of elements less than `a`.

For any type `α` with a preorder and locally finite order at the bottom, `Finset.Iio a` equals the set of elements less than `a`.


AddCon.add

/-- Additive congruence relations preserve addition. -/
theorem AddCon.add : ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {w x y z : M}, c w x → c y z → c (w + y) (x + z) :=
  by sorry

This theorem states that for any type `M` that has an addition operation, given an additive congruence relation `c` on `M`, if `w` is congruent to `x` and `y` is congruent to `z` under `c`, then the sum of `w` and `y` is congruent to the sum of `x` and `z` under the same congruence relation. In other words, congruence under `c` is preserved through the operation of addition, hence the name `AddCon.add`.

For any additive congruence relation `c` on a type `M` with addition, if `w ≡x under c` and `y ≡ z under c`, then `w + y ≡ x + z under c`.


ContinuousAt.continuousOn

theorem ContinuousAt.continuousOn :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
      (∀ x ∈ s, ContinuousAt f x) → ContinuousOn f s :=
  by sorry

This theorem states that for any two types `α` and `β`, with both being topological spaces, any function `f` from `α` to `β`, and any set `s` of `α`, if `f` is continuous at every point `x` in `s`, then `f` is continuous on the set `s`. In more mathematical terms, it says that if for each `x` in `s`, the image under `f` of points in `α` arbitrarily close to `x` becomes arbitrarily close to `f(x)`, then for every `x` in `s`, the restriction of `f` to `s` is continuous at `x` within `s`.

If `f` is a continuous function from topological space `α` to topological space `β`, and `f` is continuous at every point in a subset `s` of `α`, then `f` is continuous on `s`.


theorem MeasureTheory.Lp.snorm_ne_top :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] (f : ↥(MeasureTheory.Lp E p μ)), MeasureTheory.snorm (↑↑f) p μ ≠ ⊤ :=
  by sorry

The theorem `MeasureTheory.Lp.snorm_ne_top` states that for any measurable space `α`, any type `E` that has a normed add commutative group structure, any extended nonnegative real number `p`, any measure `μ` on `α`, and any function `f` in the Lp space over `α` with respect to `E`, `p`, and `μ`, the Lp seminorm (`MeasureTheory.snorm`) of `f` with respect to `p` and `μ` is not equal to positive infinity. In mathematical terms, this asserts that all functions in the Lp space have finite Lp seminorm.

For any measurable space, normed add commutative group, measure, and Lp function, their Lp seminorm is finite.


theorem CircleDeg1Lift.monotone : ∀ (f : CircleDeg1Lift), Monotone ⇑f := by sorry

The theorem `CircleDeg1Lift.monotone` asserts that for every function `f` of type `CircleDeg1Lift`, `f` is monotonic. In terms of mathematics, this means that for every function `f` from the type `CircleDeg1Lift`, if `a` is less than or equal to `b` then `f(a)` is less than or equal to `f(b)`. This property is true for all `a` and `b` in the domain of `f`.

For every function `f` in `CircleDeg1Lift`, if `a` is less than or equal to `b`, then `f(a)` is less than or equal to `f(b)`.


theorem MeasureTheory.Measure.restrict_empty :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.restrict ∅ = 0 := by sorry

This theorem states that for any type `α`, any measurable space `m0` over this type, and any measure `μ` over this measurable space, restricting the measure `μ` to the empty set results in a measure of zero. Written mathematically, if we have a measure μ on a measurable space, then μ restricted to the empty set is equal to zero.

For any measure `μ` on a measurable space, `μ(∅) = 0`.


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

This theorem states that for any commutative semiring `R`, semirings `A` and `B`, with `A` and `B` as `R`-algebras, and any algebra homomorphism `φ` from `A` to `B`, the image of the zero element of `A` under `φ` is the zero element of `B`. In other words, an algebra homomorphism always maps the zero element to the zero element.

Given commutative semirings `R`, `A`, and `B` with `A` and `B` as `R`-algebras, and an algebra homomorphism `φ` from `A` to `B`, the image of the additive identity of `A` under `φ` is the additive identity of `B`.


/-- Given an AddMonoidHom `f : M →+ N` and Submonoid `S ⊆ M` such that
`f(S) ⊆ AddUnits N`, for all `w, z : N` and `y ∈ S`, we have `w - f y = z ↔ w = f y + z`. -/
theorem AddSubmonoid.LocalizationMap.add_neg_left :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
      {f : M →+ N} (h : ∀ (y : ↥S), IsAddUnit (f ↑y)) (y : ↥S) (w z : N),
      w + ↑(-(IsAddUnit.liftRight (AddMonoidHom.restrict f S) h) y) = z ↔ w = f ↑y + z :=
  by sorry

This theorem states that given an additive monoid homomorphism `f` from `M` to `N` and a submonoid `S` of `M` such that the image of `S` under `f` lies within the additive units of `N`, for any elements `w` and `z` from `N` and `y` from `S`, the equation `w - f(y) = z` holds if and only if `w` equals the sum of `f(y)` and `z`. The minus sign `-` in `w - f(y)` is actually representing the additive inverse of `f(y)`, as the context is within additive monoids. This theorem is essentially capturing the notion of manipulating equations in a setting of additive monoids.

Given an additive monoid homomorphism `f` from `M` to `N` with image of submonoid `S` in the additive units of `N`, for any `w`, `z` in `N` and `y` in `S`, the equation `w = f(y) + z` if and only if `w - f(y) = z`.


theorem Cardinal.lt_ord : ∀ {c : Cardinal.{u_3}} {o : Ordinal.{u_3}}, o < Cardinal.ord c ↔ Ordinal.card o < c := by
  sorry

The theorem `Cardinal.lt_ord` states that for any cardinal number `c` and any ordinal number `o`, `o` is less than the ordinal corresponding to `c` if and only if the cardinal of `o` is less than `c`. In other words, it establishes a relation between the cardinal and ordinal representations of a number, asserting that the ordinal representation of a cardinal is less than the cardinal if and only if the cardinal representation of the ordinal is less than the cardinal.

For any cardinal number `c` and ordinal number `o`, `o` is an ordinal equivalent to the cardinality of a set with cardinality `c` if and only if `o` is strictly less than the ordinal corresponding to `c`.


theorem Nat.choose_self : ∀ (n : ℕ), Nat.choose n n = 1 := by sorry

The theorem `Nat.choose_self` states that for any natural number `n`, the number of `n`-element subsets in an `n`-element set, also known as the binomial coefficient, is 1. In other words, it states that there is only one way to choose `n` elements from a set of `n` elements, which makes sense because the only possible subset is the set itself.

The theorem `Nat.choose_self` asserts that for any natural number `n`, the number of `n`-element subsets of a set with `n` elements is equal to 1.


theorem ContinuousMap.Homotopy.apply_one :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
      (F : ContinuousMap.Homotopy f₀ f₁) (x : X), F (1, x) = f₁ x :=
  by sorry

This theorem states that for any two continuous maps `f₀` and `f₁` from a topological space `X` to another topological space `Y`, and any homotopy `F` between `f₀` and `f₁`, the value of `F` at `(1, x)` is equal to the value of `f₁` at `x` for any `x` in `X`. In other words, at the end of the homotopy (when the first parameter is 1), the homotopy function `F` becomes the target function `f₁`. This is connected to the concept of homotopy in topology, where a homotopy is a continuous transformation from one function to another.

For any continuous functions `f₀` and `f₁` from a topological space `X` to a topological space `Y` with a homotopy `F` between them, `F (1, x) = f₁ (x)` for all `x` in `X`.


theorem Mathlib.Algebra.Order.Group.Defs._auxLemma.4 :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, (0 ≤ -a) = (a ≤ 0) :=
  by sorry

This theorem, named `Mathlib.Algebra.Order.Group.Defs._auxLemma.4`, states for any type `α` which is an additive group and ordered in such a way that addition respects the order, for any element `a` of `α`, the statement that 0 is less than or equal to the negation of `a` is equivalent to the statement that `a` is less than or equal to 0. In mathematical notation, this theorem can be expressed as: for all `a` in some ordered additive group `α`, `0 ≤ -a` if and only if `a ≤ 0`.

For any ordered additive group `α`, the element `0` is equal to the additive inverse of `a` if and only if `a` is equal to the additive inverse of `0`, i.e., `0 ≤ -a` if and only if `a ≤ 0`.


theorem Finset.card_image₂_le :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] (f : α → β → γ) (s : Finset α) (t : Finset β),
      (Finset.image₂ f s t).card ≤ s.card * t.card :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, given a binary function `f` from `α` and `β` to `γ`, and finite sets `s` of type `α` and `t` of type `β`, the cardinality (or size) of the image set formed by applying the function `f` to every pair of elements in `s` and `t` is less than or equal to the product of the cardinalities of `s` and `t`. This can be interpreted as a form of the Pigeonhole principle: if we map each possible pair of elements from two sets into another set, we can't have more unique results than the total number of pairs. The equality in `γ` is assumed to be decidable.

For any finite sets $s$ of type $\alpha$, $t$ of type $\beta$, and assuming decidable equality in $\gamma$, the number of elements in the image of the binary function $f : \alpha \times \beta \rightarrow \gamma$ applied to all pairs in $s \times t$ is less than or equal to the product of the cardinalities of $s$ and $t$.


theorem Mathlib.Data.Finset.Basic._auxLemma.3 :
    ∀ {α : Type u_1} {a : α} {s : Multiset α} {nd : Multiset.Nodup s}, (a ∈ { val := s, nodup := nd }) = (a ∈ s) := by
  sorry

This theorem states that for any type `α`, any element `a` of this type, and any multiset `s` of type `α` which has no duplicates (represented by `Multiset.Nodup s`), the condition for `a` being an element of the set `{ val := s, nodup := nd }` is equivalent to `a` being an element of the multiset `s` itself. Simply put, it means `a` is an element of a set derived from `s` if and only if `a` is an element of `s`. This set is defined as a multiset `s` with a proof `nd` that it has no duplicates.

For any type `α`, any element `a` of type `α`, and any multiset `s` of type `α` without duplicates, `a` belongs to the multiset `s` if and only if `a` is an element of the set `{val := s, nodup := ⊤}`.


theorem one_le_pow_of_one_le : ∀ {R : Type u_3} [inst : OrderedSemiring R] {a : R}, 1 ≤ a → ∀ (n : ℕ), 1 ≤ a ^ n := by
  sorry

This theorem states that for any ordered semiring `R` and any element `a` of `R`, if `a` is greater than or equal to 1 (`1 ≤ a`), then any natural number power of `a` (`a ^ n` for any `n` in the set of natural numbers, `ℕ`) is also greater than or equal to 1 (`1 ≤ a ^ n`). In other words, if a number is greater than or equal to 1, raising it to any natural number power will not make it less than 1 in an ordered semiring.

For any ordered semiring `R` and its element `a` greater than or equal to 1, the natural power `a ^ n` is also greater than or equal to 1 for all `n` in the natural numbers.


IsUnit.mul

theorem IsUnit.mul : ∀ {M : Type u_1} [inst : Monoid M] {a b : M}, IsUnit a → IsUnit b → IsUnit (a * b) := by sorry

This theorem states that for any type `M` with a `Monoid` structure and any two elements `a` and `b` of `M`, if `a` and `b` are both units (i.e., each has a two-sided inverse), then their product `a * b` is also a unit. In other words, the product of two invertible elements in a monoid is itself invertible.

If `M` is a monoid and `a` and `b` are invertible elements of `M`, then `a * b` is an invertible element of `M`.


theorem Polynomial.eq_C_of_natDegree_eq_zero :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
      Polynomial.natDegree p = 0 → p = Polynomial.C (Polynomial.coeff p 0) :=
  by sorry

This theorem states that for any polynomial `p` of type `R`, where `R` is a semiring, if the natural degree of `p` is zero, then `p` is equal to the constant polynomial `C` with the coefficient of `p` at zero. In mathematical terms, if a polynomial has a degree of zero, then it is a constant polynomial, with the constant being the coefficient of the polynomial at zero.

For any polynomial `p` over a semiring `R` of degree zero, `p` equals the constant polynomial `C` with coefficient `p.0`.


theorem Polynomial.sum_monomial_eq :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R),
      (Polynomial.sum p fun n a => (Polynomial.monomial n) a) = p :=
  by sorry

The theorem `Polynomial.sum_monomial_eq` states that for any polynomial `p` over a semiring `R`, if we sum the values of the function that applies the coefficients of the polynomial `p` to the monomial function `Polynomial.monomial`, we get back the original polynomial `p`. In other words, the sum of the monomials of the polynomial, each multiplied by its corresponding coefficient, reconstitutes the original polynomial. This is analogous to expressing a polynomial as the sum of its monomial terms.

For any polynomial `p` over a semiring `R`, the sum of the products of its coefficients with the monomial functions is equal to `p`.


theorem Polynomial.monomial_zero_right : ∀ {R : Type u} [inst : Semiring R] (n : ℕ), (Polynomial.monomial n) 0 = 0 := by
  sorry

The theorem `Polynomial.monomial_zero_right` states that for all natural numbers `n` and for any type `R` in the context of a semiring, the monomial generated by the function `Polynomial.monomial` when applied to `n` and 0 is equal to 0. In other words, when multiplying 0 by any power of a variable `X`, the result will always be 0.

For all natural numbers `n` and in any semiring `R`, the monomial generated by the function `Polynomial.monomial` from `R` with variables `X` and coefficient `n`, applied to `X` and `0`, equals `0`.


theorem Set.mem_union_left : ∀ {α : Type u} {x : α} {a : Set α} (b : Set α), x ∈ a → x ∈ a ∪ b := by sorry

The theorem `Set.mem_union_left` states that for any type `α`, any element `x` of type `α`, and any two sets `a` and `b` of type `α`, if `x` is a member of set `a`, then `x` is also a member of the union of sets `a` and `b`. This is a fundamental property of set theory, represented in Lean 4. The symbol `∪` represents the union operation in set theory.

For any type `α`, if `x` is an element of set `a` and `a` is a subset of `a ∪ b`, then `x` is an element of `b ∪ a`. (This is the converse statement of `Set.mem_union_left` in Lean 4.)


theorem Complex.add_re : ∀ (z w : ℂ), (z + w).re = z.re + w.re := by sorry

This theorem states that for any two complex numbers `z` and `w`, the real part of the sum of `z` and `w` is equal to the sum of the real parts of `z` and `w`. In mathematical notation, this is saying that Re(z + w) = Re(z) + Re(w) for all complex numbers z and w. This is a fundamental property of complex numbers relating their addition operation to the real part operation.

The real part of the sum of two complex numbers is equal to the sum of their real parts. (i.e. Re(z + w) = Re(z) + Re(w) for all complex numbers z and w)


/-- To show continuity of a map `α → C(β, γ)`, it suffices to show that its uncurried form
`α × β → γ` is continuous.  -/
theorem ContinuousMap.continuous_of_continuous_uncurry :
    ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] (f : X → C(Y, Z)),
      Continuous (Function.uncurry fun x y => (f x) y) → Continuous f :=
  by sorry

The theorem `ContinuousMap.continuous_of_continuous_uncurry` states that for any types `X`, `Y`, and `Z` that are topological spaces, if you have a function `f` mapping from `X` to the continuous maps from `Y` to `Z` (`C(Y, Z)`), and you can show that the uncurried version of this function (which maps a pair of elements from `X` and `Y` to `Z`) is continuous, then the original function `f` is also continuous. In other words, to demonstrate the continuity of a function that outputs continuous functions, it's sufficient to show that the function's uncurried form is continuous.

If `X`, `Y`, and `Z` are topological spaces, and `f : X → C(Y, Z)` is a function such that the uncurried version `\× → f x y` of `f` is continuous, then `f` is continuous.


theorem Submodule.one_eq_span :
    ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A],
      1 = Submodule.span R {1} :=
  by sorry

The theorem `Submodule.one_eq_span` states that for any commutative semiring `R`, any semiring `A`, and any algebra structure over `A` with `R` as the scalar ring, the submodule generated by `{1}` (i.e., the set containing only the multiplicative identity) in the algebra is equal to `1`. This means that the smallest submodule of `A` that contains the multiplicative identity `1` is, in fact, the `1` itself. This is typically an important property in algebra where the multiplicative identity plays a critical role.

In any commutative semiring-algebra, the submodule generated by {1} is equal to the multiplicative identity 1.


theorem Stream'.Seq.map_get? :
    ∀ {α : Type u} {β : Type v} (f : α → β) (s : Stream'.Seq α) (n : ℕ),
      Stream'.Seq.get? (Stream'.Seq.map f s) n = Option.map f (Stream'.Seq.get? s n) :=
  by sorry

The theorem `Stream'.Seq.map_get?` states that for any types `α` and `β`, a function `f` from `α` to `β`, a sequence `s` of type `α`, and a natural number `n`, the `n`-th element of the sequence obtained by mapping `f` over `s` is equal to the result of applying `f` to the `n`-th element of `s`. In other words, mapping a function over a sequence and then getting the `n`-th element is the same as first getting the `n`-th element and then applying the function.

For any types α and β, function f from α to β, sequence s of length n + 1 in α, and natural number n, the (n+1)-th element of the sequence obtained by applying f to each element of s is equal to f applied to the n-th element of s.


theorem isOpen_sInter :
    ∀ {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : AlexandrovDiscrete α] {S : Set (Set α)},
      (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S) :=
  by sorry

The theorem `isOpen_sInter` states that for any type `α` equipped with a topological space structure and an Alexandrov discrete topology, if `S` is a set of subsets of `α` such that all subsets in `S` are open in `α`, then the intersection of all subsets in `S` (denoted by `⋂₀ S`) is also an open set in `α`.

If `α` is a topological space with Alexandrov discrete topology and `S` is a non-empty family of open subsets of `α`, then their intersection is open in `α`.


theorem NNReal.rpow_zero : ∀ (x : NNReal), x ^ 0 = 1 := by sorry

This theorem states that for any nonnegative real number `x`, the zeroth power of `x` (`x` to the power of 0) is equal to 1. This is consistent with the general mathematical principle that any number (except 0) raised to the power of 0 is 1.

For any non-negative real number x, x^0 = 1.


theorem Filter.prod_mono :
    ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β}, f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ := by
  sorry

The theorem `Filter.prod_mono` states that for all types `α` and `β`, and for all pairs of filters `(f₁, f₂)` on `α` and `(g₁, g₂)` on `β`, if `f₁` is a sub-filter of `f₂` and `g₁` is a sub-filter of `g₂`, then the product filter `f₁ ×ˢ g₁` is a sub-filter of the product filter `f₂ ×ˢ g₂`.

In other words, if we have filters `f₁` and `f₂` on type `α` and filters `g₁` and `g₂` on type `β`, and if `f₁` is contained in `f₂` and `g₁` is contained in `g₂`, then the product of `f₁` and `g₁` is contained in the product of `f₂` and `g₂`. The product of two filters is a filter on the product of the respective types.

Given filters `f₁` on `α` and `g₁` on `β`, if `f₁` is a sub-filter of `f₂` and `g₁` is a sub-filter of `g₂`, then the product filter `f₁ × g₁` is a sub-filter of `f₂ × g₂`.


theorem Complex.contDiff_exp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {n : ℕ∞},
      ContDiff 𝕜 n Complex.exp :=
  by sorry

This theorem states that for any non-trivial normed field `𝕜` with a normed algebra structure over the complex numbers, the complex exponential function is continuously differentiable any number of times `n`, where `n` could be a natural number or infinity. In mathematical terms, the theorem asserts that the complex exponential function is `𝕜`-smooth.

The complex exponential function is continuously differentiable an arbitrary number of times in any non-trivial normed field with a normed algebra structure over the complex numbers.


/-- A subsemigroup `S` includes `closure s` if and only if it includes `s`.  -/
theorem Subsemigroup.closure_le :
    ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {S : Subsemigroup M}, Subsemigroup.closure s ≤ S ↔ s ⊆ ↑S := by sorry

The theorem `Subsemigroup.closure_le` states that for any type `M` with a multiplication operation and for any set `s` of elements in `M` and any subsemigroup `S` of `M`, the subsemigroup generated by the closure of `s` is a subset of `S` if and only if the set `s` itself is a subset of `S`. This theorem encapsulates an important property of subsemigroups in relation to the concept of closure, showing that the inclusion of the closure of a set in a subsemigroup implies the inclusion of the set itself, and vice versa.

The subsemigroup generated by the closure of a set is contained in the subsemigroup if and only if the original set is contained in it.


theorem Filter.HasBasis.inf_principal :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → ∀ (s' : Set α), Filter.HasBasis (l ⊓ Filter.principal s') p fun i => s i ∩ s' :=
  by sorry

This theorem states that for any type `α`, any indexing type `ι`, any filter `l` on `α`, any predicate `p` on `ι`, any function `s` from `ι` to a set of `α`, and any given set `s'` of `α`, if the filter `l` has a basis characterized by the predicate `p` and the function `s`, then the intersection of the filter `l` and the principal filter of `s'` (that is, the filter containing all supersets of `s'`) has a basis characterized by the predicate `p` and the function that maps `i` to the intersection of `s i` and `s'`. In simpler terms, the basis of a filter and the basis of its intersection with a principal filter are closely related.

If filters `l` and `m` have bases characterized by predicate `p` and functions `s` and `t` respectively, then the intersection `l ∩ ℙ(s')` has a basis characterized by predicate `p` and the function `x ↦ s x ∩ s'`.


theorem min_def : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), min a b = if a ≤ b then a else b := by sorry

This theorem states that for every type `α` that has a linear order, the minimum of two elements `a` and `b` of type `α` is defined as `a` if `a` is less than or equal to `b` and `b` otherwise. This theorem essentially provides a definition for the minimum function in the context of any ordered type.

For any type `α` with a linear order, the minimum of `a` and `b` is `a` if `a ≤ b` and `b` otherwise.


/-- The cardinality of the reals, as a type.  -/
theorem Cardinal.mk_real : Cardinal.mk ℝ = Cardinal.continuum := by sorry

This theorem establishes that the cardinality of the set of real numbers, denoted as ℝ, is equal to the cardinality of the continuum. In set theory, the cardinality of a set refers to the "number of elements" in the set. The cardinality of the continuum is defined as the cardinality of the set of all infinite sequences of binary digits, which is the same as the power set of the set of natural numbers (often denoted as 2^(aleph_0) in mathematics). Thus, this theorem is stating that there are as many real numbers as there are infinite sequences of binary digits.

The theorem asserts that the cardinality of the set of real numbers equals that of the set of infinite binary sequences, i.e., ℝ ≈ 2^(aleph\_0).


theorem nhdsSet_mono : ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, s ⊆ t → nhdsSet s ≤ nhdsSet t := by
  sorry

This theorem, `nhdsSet_mono`, states that for any type `X` equipped with a topological structure (`TopologicalSpace X`), and for any two sets `s` and `t` of this type, if `s` is a subset of `t` (denoted by `s ⊆ t`), then the filter of neighborhoods of `s` (`nhdsSet s`) is less than or equal to the filter of neighborhoods of `t` (`nhdsSet t`). This is expressed as `nhdsSet s ≤ nhdsSet t`. It means that every neighborhood of `t` contains a neighborhood of `s`, or any set that is "close" to `t` is also "close" to `s`.

For any topological space `X` and subsets `s` and `t` of `X`, if `s ⊆ t`, then the filter of neighborhoods of `s` is contained in the filter of neighborhoods of `t`.


/-- See note [partially-applied ext lemmas].  -/
theorem MvPolynomial.ringHom_ext' :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A]
      {f g : MvPolynomial σ R →+* A},
      RingHom.comp f MvPolynomial.C = RingHom.comp g MvPolynomial.C →
        (∀ (i : σ), f (MvPolynomial.X i) = g (MvPolynomial.X i)) → f = g :=
  by sorry

This theorem, denoted as `MvPolynomial.ringHom_ext'`, states that for any commutative semiring `R` with an index set of variables `σ`, and for any semiring `A`, if we have two ring homomorphisms `f` and `g` from multivariate polynomials over `R` and `σ` to `A`, and if these two homomorphisms agree on the constant polynomial and on the degree `1` monomials, then these two ring homomorphisms are indeed the same. In other words, a ring homomorphism from the ring of multivariate polynomials to another ring is uniquely determined by its values on the constant polynomials and on the degree `1` monomials.

Given commutative semirings R with index set σ, and semiring A, if two ring homomorphisms from the multivariate polynomial ring R[σ] to A agree on the constant polynomial and degree 1 monomials, then they are equal.


PrimrecRel.comp

theorem PrimrecRel.comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {R : β → γ → Prop} [inst_3 : (a : β) → (b : γ) → Decidable (R a b)] {f : α → β}
      {g : α → γ}, PrimrecRel R → Primrec f → Primrec g → PrimrecPred fun a => R (f a) (g a) :=
  by sorry

The theorem `PrimrecRel.comp` states that for any types `α`, `β`, and `γ`, if all three are primitive encodable (as denoted by `Primcodable α`, `Primcodable β`, and `Primcodable γ`), and if we have a primitive recursive relation `R` between `β` and `γ` (with `R : β → γ → Prop`), and the relation `R` is decidable for all `a : β` and `b : γ`, then given any two functions `f : α → β` and `g : α → γ` which are both primitive recursive, the function that maps an element of type `α` to the boolean value of the relationship `R` applied to `(f a, g a)` is also primitive recursive. This implies that the composition of primitive recursive functions and relations retains the property of being primitive recursive.

If types `α`, `β`, and `γ` are primitive encodable, `R : β → γ → Prop` is a decidable primitive recursive relation between `β` and `γ`, and `f : α → β` and `g : α → γ` are primitive recursive functions, then the function `x => Decide R (f x) (g x)` is primitive recursive.


theorem openEmbedding_of_continuous_injective_open :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Continuous f → Function.Injective f → IsOpenMap f → OpenEmbedding f :=
  by sorry

The theorem `openEmbedding_of_continuous_injective_open` states that for any two types `X` and `Y`, given a function `f` from `X` to `Y`, and instances of `TopologicalSpace` for `X` and `Y`, if the function `f` is continuous, injective, and is an open map (i.e., it maps open sets in `X` to open sets in `Y`), then `f` is an open embedding. An open embedding is a continuous, injective function that also maps open sets to open sets. Therefore, this theorem provides a sufficient condition for a function to be an open embedding in the context of topology.

If a continuous, injective function between topological spaces maps open sets to open sets, then it is an open embedding.


theorem MonoidAlgebra.single_mul_single :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Mul G] {a₁ a₂ : G} {b₁ b₂ : k},
      MonoidAlgebra.single a₁ b₁ * MonoidAlgebra.single a₂ b₂ = MonoidAlgebra.single (a₁ * a₂) (b₁ * b₂) :=
  by sorry

The theorem `MonoidAlgebra.single_mul_single` states that for any semiring `k` and any set `G` with a multiplication operation, and for any elements `a₁, a₂` from `G` and `b₁, b₂` from `k`, the product of two `MonoidAlgebra.single` elements, first formed by `a₁` and `b₁` and second by `a₂` and `b₂`, is equal to another `MonoidAlgebra.single` element which is formed by the multiplication of `a₁` and `a₂` and the multiplication of `b₁` and `b₂`. In the context of abstract algebra, this is a property of multiplication in the monoid algebra of a semiring over a set with multiplication.

For any semiring `k` and set `G` with multiplication, and for all `a₁, a₂ in G` and `b₁, b₂ in k`, the product of `MonoidAlgebra.single a₁ b₁` and `MonoidAlgebra.single a₂ b₂` equals `MonoidAlgebra.single (a₁ * a₂) (b₁ * b₂)`.


theorem MonoidHom.range_eq_map :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
      MonoidHom.range f = Subgroup.map f ⊤ :=
  by sorry

The theorem `MonoidHom.range_eq_map` states that for any group homomorphism `f` from a group `G` to another group `N`, the range of `f` is equal to the image of the whole group `G` under `f`. In other words, mapping the whole group `G` to `N` using `f` covers the same set of elements in `N` as the range of `f`.

The range of a group homomorphism equals the image of the entire group under the homomorphism.


theorem Set.iUnion_inter : ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), (⋃ i, t i) ∩ s = ⋃ i, t i ∩ s :=
  by sorry

This theorem states that for any type `β` and an index type `ι`, given a set `s` of type `β` and a function `t`, that maps from index type `ι` to a set of type `β`, the intersection of `s` and the union over `t i` for all `i` is equal to the union of the intersections of `s` and `t i` for all `i`. In mathematical notation, this would be:

`(⋃ i, t(i)) ∩ s = ⋃ i, (t(i) ∩ s)`

It is essentially an assertion of a distributive property of intersection over union for sets.

The theorem asserts that for any set `s` and function `t` mapping index type `ι` to sets of type `β`, the intersection of `s` with the union of `t(i)` over all `i` is equal to the union of intersections of `s` with each `t(i)`. In mathematical notation, `(⋃ i, t(i)) ∩ s = ⋃ i, (t(i) ∩ s)`.


theorem SimpleGraph.ne_of_adj : ∀ {V : Type u} (G : SimpleGraph V) {a b : V}, G.Adj a b → a ≠ b := by sorry

This theorem, `SimpleGraph.ne_of_adj`, states that for any simple graph `G` of type `V`, if two nodes `a` and `b` are adjacent (i.e., `G.Adj a b`), then `a` and `b` must not be identical, denoted by `a ≠ b`. In simpler terms, this theorem ensures that in any simple graph, there are no loops; a node cannot be adjacent to itself.

In a simple graph, no node is adjacent to itself.


Option.some.inj

theorem Option.some.inj : ∀ {α : Type u} {val val_1 : α}, some val = some val_1 → val = val_1 := by sorry

This theorem, `Option.some.inj`, states that for all types `α` and for any two values `val` and `val_1` of that type, if `some val` equals `some val_1`, then `val` must equal `val_1`. Essentially, it ensures the injectivity of the `some` constructor of the `Option` type in Lean: distinct values get mapped to distinct `Option` values.

If `Option.some val = Option.some val_1` for types `α` and values `val` and `val_1` of type `α`, then `val = val_1`.


theorem MeasureTheory.integral_neg :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} (f : α → G), ∫ (a : α), -f a ∂μ = -∫ (a : α), f a ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_neg`, states that for any measure space `α`, any normed add commutative group `G`, any normed space over reals `ℝ` with `G` as the base set, any measurable space `m`, and any measure `μ`, the integral of the negative of a function `f` over the measure `μ` is equal to the negative of the integral of the function `f` over the measure `μ`. In mathematical terms, it says that ∫ -f dμ = -∫ f dμ.

For any measurable function `f` on a measure space `(α, Σ, μ)` over a normed add commutative group `G` with normed space `ℝ`, the integral of `-f` with respect to `μ` equals the negative of the integral of `f` with respect to `μ`, that is, ∫ -`f` d`μ` = -∫ `f` d`μ`.