theorem Rat.divInt_mul_right : ∀ {n d a : ℤ}, a ≠ 0 → Rat.divInt (n * a) (d * a) = Rat.divInt n d := by sorry

This theorem, `Rat.divInt_mul_right`, states that for all integer values `n`, `d`, and `a`, if `a` is not equal to zero, then the result of dividing the product of `n` and `a` by the product of `d` and `a` (using the `Rat.divInt` function) is the same as the result of dividing `n` by `d` (also using the `Rat.divInt` function). Essentially, it depicts a property of division in the rational numbers: the multiplication of both the numerator and the denominator by a non-zero integer does not affect the value of the fraction. This is equivalent to the mathematical statement: ∀n, d, a ∈ ℤ, a ≠ 0 → n/d = (n*a)/(d*a).

For all integers n, d, and a not equal to zero, (n * a) / (d * a) equals n / d.


theorem AddAction.nsmul_vadd_eq_iff_period_dvd :
    ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] {n : ℕ} {m : M} {a : α},
      n • m +ᵥ a = a ↔ AddAction.period m a ∣ n :=
  by sorry

This theorem states that for any additive action of an element `m` (from an additive monoid `M`) on an element `a` (from a type `α`), the additive action repeated `n` times brings `a` back to itself if and only if the period of the additive action (i.e., the smallest positive number of times the action needs to be repeated to bring `a` back to itself) divides `n`. In the context of this theorem, `n • m +ᵥ a = a` denotes the additive action of `m` on `a` repeated `n` times, and `AddAction.period m a ∣ n` denotes that the period of the action divides `n`.

For any additive action of an element `m` on `α`, the repeated action `n • m +ᵥ a = a` holds if and only if the period of the action `AddAction.period m a` divides `n`.


/-- See also `IsCompact.measure_closure` for a version
that assumes the `σ`-algebra to be the Borel `σ`-algebra but makes no assumptions on `μ`.  -/
theorem MeasureTheory.Measure.OuterRegular.measure_closure_eq_of_isCompact :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] {μ : MeasureTheory.Measure α}
      [inst_2 : R1Space α] [inst_3 : MeasureTheory.Measure.OuterRegular μ] {k : Set α},
      IsCompact k → ↑↑μ (closure k) = ↑↑μ k :=
  by sorry

This theorem states that for every set `k` in a measurable space `α` that is both a topological space and a R1 space, if `k` is compact, then the measure of the closure of `k` (according to the outer regular measure `μ`) is equal to the measure of `k` itself. This theorem assumes the `σ`-algebra of the measure space to be arbitrary, and does not make any specific assumptions about the measure `μ`. This theorem is particularly related to the concept of outer regular measures in measure theory, and there exists a related version of this theorem (`IsCompact.measure_closure`) that specifically assumes the `σ`-algebra to be the Borel `σ`-algebra.

If `μ` is an outer regular measure on the measurable space `(α, σ)` where `α` is a compact, topological space and an R1 space, then the measure of the closure of any set `k` in `α` equals the measure of `k` itself.


theorem iUnion_disjointed : ∀ {α : Type u_1} {f : ℕ → Set α}, ⋃ n, disjointed f n = ⋃ n, f n := by sorry

The theorem `iUnion_disjointed` states that for any type `α` and any sequence of sets `f : ℕ → Set α`, the union over `n` of the disjointed form of `f` equals the union over `n` of `f` itself. In other words, if `f` is a sequence of sets, and `disjointed f` is the sequence formed by subtracting each set from the next ones in the sequence, then the union of all sets in the disjointed sequence is the same as the union of all sets in the original sequence.

For any sequence of sets `f : ℕ → Set α`, the union of the disjointed sequence `disjointed f` equals the union of `f`.


Monovary.symm

theorem Monovary.symm :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : LinearOrder β] {f : ι → α} {g : ι → β},
      Monovary f g → Monovary g f :=
  by sorry

The theorem `Monovary.symm` states that for any types ι, α, β where α has a preordered structure and β has a linear ordered structure, and for any functions f: ι → α and g: ι → β, if f monovaries with g (meaning that whenever g(i) is less than g(j), f(i) is less than or equal to f(j)), then g also monovaries with f. In other words, if the values of g increase strictly then the values of f do not decrease, and conversely if the values of f do not decrease then the values of g increase strictly.

If function `f: ι → α` monovaries with `g: ι → β`, where `α` has a preorder and `β` has a linear order, then `g` monovaries with `f`. (That is, if `g(i) < g(j)` implies `f(i) ≤ f(j)`, then `f(i) ≤ f(j)` implies `g(i) < g(j)`.)


/-- If a word reduces to another word, then they have a common maximal reduction. -/
theorem FreeAddGroup.reduce.eq_of_red :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} [inst : DecidableEq α],
      FreeAddGroup.Red L₁ L₂ → FreeAddGroup.reduce L₁ = FreeAddGroup.reduce L₂ :=
  by sorry

The theorem `FreeAddGroup.reduce.eq_of_red` states that for any type `α` with decidable equality and any two lists `L₁` and `L₂` consisting of pairs of elements of `α` and boolean values, if there exists a reflexive-transitive closure of the `Red.Step` relation between `L₁` and `L₂` (in other words, if `L₁` can be reduced to `L₂`), then the maximal reduction of `L₁` is equal to the maximal reduction of `L₂`. In simpler terms, this theorem indicates that if a word can be reduced to another word, then their respective maximal reductions are equivalent.

If `L₁` can be reduced to `L₂` via a series of `Red.Step` operations, then the maximal reduction of `L₁` equals the maximal reduction of `L₂`.


theorem Finset.filter_subset_filter :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s t : Finset α},
      s ⊆ t → Finset.filter p s ⊆ Finset.filter p t :=
  by sorry

The theorem `Finset.filter_subset_filter` states that for any type `α`, and any decidable predicate `p` over `α`, if a finite set `s` is a subset of another finite set `t` (both of type `α`), then the set obtained by filtering `s` using predicate `p` is a subset of the set obtained by filtering `t` using the same predicate. In other words, if we have two finite sets `s` and `t` such that every element of `s` is also an element of `t`, then all elements of `s` that satisfy a certain condition (defined by `p`) will also be part of the set of elements of `t` satisfying the same condition. This theorem thus deals with the preservation of subset relations under the operation of filtering sets based on some criterion.

For any type `α` and decidable predicate `p` over `α`, if `s` is a subset of `t` (both finite sets of `α`), then the filtered sets `s | p` and `t | p` satisfy the subset relation.


theorem CategoryTheory.Presieve.IsSheafFor.valid_glue :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X Y : C}
      {R : CategoryTheory.Presieve X} (t : CategoryTheory.Presieve.IsSheafFor P R)
      {x : CategoryTheory.Presieve.FamilyOfElements P R} (hx : CategoryTheory.Presieve.FamilyOfElements.Compatible x)
      (f : Y ⟶ X) (Hf : R f), P.map f.op (CategoryTheory.Presieve.IsSheafFor.amalgamate t x hx) = x f Hf :=
  by sorry

The theorem `CategoryTheory.Presieve.IsSheafFor.valid_glue` states that for any category `C`, functor `P` from the opposite category of `C` to any type `w`, objects `X` and `Y` in `C`, a presieve `R` on `X`, a proof `t` that `P` is a sheaf for `R`, a family of elements `x` of `P` over `R` that are compatible, an arrow `f` from `Y` to `X` and a proof `Hf` that `f` is in the presieve `R`, the application of the functor `P` to `f` and the amalgamation of `x` under `t` and `hx` equals to the application of `x` to `f` and `Hf`. In other words, this theorem ensures that the process of amalgamating a compatible family of elements preserves the structure of the sheaf.

For any category `C`, functor `P : C^op -> Type`, objects `X, Y in C`, presieve `R on X`, sheaf proof `t for R and P`, compatible family `x : P X -> R`, arrow `f : Y -> X` in `R`, and proof `Hf : f ∈ R`, we have `P f (amalgamate t x hx) = (P f x) (hx)`.


MeasureTheory.AECover.inter

/-- Elementwise intersection of two `AECover`s is an `AECover`.  -/
theorem MeasureTheory.AECover.inter :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      {φ ψ : ι → Set α},
      MeasureTheory.AECover μ l φ → MeasureTheory.AECover μ l ψ → MeasureTheory.AECover μ l fun i => φ i ∩ ψ i :=
  by sorry

The theorem titled `MeasureTheory.AECover.inter` states that for all types `α` and `ι`, where `α` is equipped with a measurable space structure and `μ` is a measure on this space, given a filter `l` on `ι` and two functions `φ` and `ψ` from `ι` to the set of `α`, if both `φ` and `ψ` are almost everywhere covers (AECovers) with respect to measure `μ` and filter `l`, then the elementwise intersection of the sets given by `φ` and `ψ` is also an almost everywhere cover with respect to the same measure `μ` and filter `l`. In terms of measure theory, this theorem ensures that intersection of two AECovers is also an AECover.

If `φ` and `ψ` are two almost everywhere covers of a measurable space `(α, Σ, μ)` with respect to filter `l`, then their elementwise intersection `φ ∩ ψ` is also an almost everywhere cover.


theorem List.take_length : ∀ {α : Type u_1} (l : List α), List.take (List.length l) l = l := by sorry

The theorem `List.take_length` states that, for all types `α` and any list `l` of type `α`, taking the first `n` elements of `l`, where `n` is the length of `l`, results in `l` itself. In other words, if you try to take as many elements from a list as the list's length itself, you will get the original list.

 For all types α and lists l of length n in α, List.take n l = l.

Or, more succinctly: The take operation with argument equal to a list's length returns the original list.


theorem Setoid.mem_classes : ∀ {α : Type u_1} (r : Setoid α) (y : α), {x | Setoid.Rel r x y} ∈ Setoid.classes r := by
  sorry

This theorem states that, for any type `α`, any setoid `r` on `α`, and any element `y` of `α`, the set of all elements `x` in `α` that are related to `y` by the equivalence relation defined by `r` (`Setoid.Rel r x y`) is a member of the set of equivalence classes induced by `r` (`Setoid.classes r`). In other words, the set of all elements equivalent to a given element forms an equivalence class under the setoid.

For any type `α`, setoid `r` on `α`, and `y` in `α`, `Setoid.Rel r x y` is a subset of `Setoid.classes r x`.


theorem Filter.mem_sup : ∀ {α : Type u} {f g : Filter α} {s : Set α}, s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g := by sorry

This theorem, named `Filter.mem_sup`, is about filters and sets in a general context where `α` denotes any Type. It states that for every type `α`, every pair of filters `f` and `g` on `α`, and every set `s` of elements of type `α`, the set `s` is in the supremum (defined as `f ⊔ g`) of the filters `f` and `g` if and only if `s` is in both the filter `f` and the filter `g`. In simpler words, a set is in the union of two filters if and only if it is in both filters.

For all types `α`, filters `f` and `g` on `α`, and sets `s` of elements of type `α`, `s ∈ f ⊔ g` if and only if `s ∈ f` and `s ∈ g`.


theorem Set.sigmaToiUnion_surjective :
    ∀ {α : Type u_1} {β : Type u_2} (t : α → Set β), Function.Surjective (Set.sigmaToiUnion t) := by sorry

This theorem states that for any type `α` and `β`, and for any function `t` from `α` to the set of `β`, the function `Set.sigmaToiUnion` with `t` as its argument is always surjective. In other words, every element of the union of sets `t i` for all `i` in `α` is an image of some element from the sigma type `(i : α) × ↑(t i)`. The sigma type aggregates all pairs of an element from `α` and an element from the corresponding set `t i`. The surjectivity implies that each element in the union of all `t i` can be traced back to at least one such pair in the sigma type.

For any function `t` from type `α` to sets of type `β`, the function `Set.sigmaToiUnion` of `t` is a surjection from the sigma type `(i : α) × ↑(t i)` to the union of images `t i` for all `i` in `α`.


theorem id_map' :
    ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Functor m] [inst_1 : LawfulFunctor m] (x : m α),
      (fun a => a) <$> x = x :=
  by sorry

This theorem, named 'id_map', states that for any Functor 'm' mapping from 'Type u_1' to 'Type u_2', and any type 'α' of 'Type u_1', given that 'm' is a lawful functor, the application of the identity function (which returns its input unchanged) to any value 'x' of type 'm α' using the fmap operation (denoted as '<$>') results in 'x' itself. In other words, mapping the identity function over any value of a lawful functor leaves the value unchanged.

For any lawful functor m and type α, the application of the identity function through fmap (denoted as '<$>') on an element x of type m α results in x itself.


theorem smul_left_cancel_iff :
    ∀ {α : Type u} {β : Type v} [inst : Group α] [inst_1 : MulAction α β] (g : α) {x y : β}, g • x = g • y ↔ x = y := by
  sorry

This theorem, `smul_left_cancel_iff`, holds for a group `α` and a type `β` with a multiplication action `MulAction α β`. It states that for any element `g` of the group `α`, and any two elements `x` and `y` of type `β`, the statement "the result of the scalar multiplication of `g` and `x` is equal to the scalar multiplication of `g` and `y`" is equivalent to the statement "element `x` is equal to element `y`". In other words, if the same group element `g` acts on two objects `x` and `y` of type `β` yielding equal results, then `x` and `y` must be equal.

For any group action of a group `α` on a type `β` with multiplication action `MulAction α β`, the scalar multiplication `g * x = g * y` implies `x = y`.


/-- The coercion `Cardinal.ofENat` and the projection `Cardinal.toENat` form a Galois connection.
See also `Cardinal.gciENat`.  -/
theorem Cardinal.enat_gc : GaloisConnection Cardinal.ofENat ⇑Cardinal.toENat := by sorry

The theorem `Cardinal.enat_gc` states that the functions `Cardinal.ofENat` and `Cardinal.toENat` form a Galois connection. In the context of this theorem, a Galois connection is a pair of functions `l` and `u` such that for all cardinals `a` and natural numbers `b`, the image of `a` under `l` is less than or equal to `b` if and only if `a` is less than or equal to the image of `b` under `u`. The function `Cardinal.ofENat` serves as the coercion function `l` which sends extended natural numbers to cardinals, and the function `Cardinal.toENat` serves as the projection function `u` which sends cardinals to extended natural numbers.

The functions `Cardinal.ofENat` and `Cardinal.toENat` form a Galois connection between the extended natural numbers and cardinals.


theorem Finsupp.coe_update :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (f : α →₀ M) (a : α) (b : M) [inst_1 : DecidableEq α],
      ⇑(Finsupp.update f a b) = Function.update (⇑f) a b :=
  by sorry

This theorem states that for any types `α` and `M` with `M` having an instance of the zero element, a given function `f` from `α` to `M` with finite support, a point `a` of type `α`, a value `b` of type `M`, and `α` having a decidable equality, applying `Finsupp.update` on `f` at point `a` with value `b` and then getting the result function is equivalent to first getting the function of `f` and then applying `Function.update` at point `a` with value `b`. In other words, updating a finitely supported function and then extracting the function is the same as first extracting the function and then updating it.

For functions `f : α → M` with finite support from a decidably equal type `α` to a type `M` with a zero element, updating `f` at point `a` with value `b` using `Finsupp.update` is equivalent to first extracting the function `g = f.get` and then updating `g` at point `a` with value `b` using `Function.update`.


theorem IsMin.eq_of_ge : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMin a → b ≤ a → a = b := by sorry

The theorem `IsMin.eq_of_ge` states that for any partially ordered type `α`, given two elements `a` and `b` of `α`, if `a` is a minimal element (meaning no other element is strictly less than `a`) and `b` is less than or equal to `a`, then `a` must be equal to `b`. Essentially, this theorem ensures that if `a` is a minimal element, there cannot exist another element that is less than or equal to `a` without being identical to `a`.

If `α` is a partially ordered type, `a` is a minimal element of `α`, and `b ≤ a`, then `a = b`.


HasDerivAtFilter.neg

theorem HasDerivAtFilter.neg :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {L : Filter 𝕜},
      HasDerivAtFilter f f' x L → HasDerivAtFilter (fun x => -f x) (-f') x L :=
  by sorry

The theorem `HasDerivAtFilter.neg` asserts that for every non-trivially normed field 𝕜, normed add commutative group F, and normed space over 𝕜 and F, if a function `f` from 𝕜 to F has a derivative `f'` at a point `x` as `x` goes along the filter `L`, then the function that maps `x` to the negation of `f(x)` has the derivative `-f'` at the same point `x` along the same filter `L`. This means that negating a function negates its derivative at any given point.

For any non-trivially normed field 𝕜, normed add commutative group F, and normed space over 𝕜 and F, if a function `f` from 𝕜 to F has a derivative `f'` at point `x` along filter `L`, then `-f` has derivative `-f'` at `x` along `L`.


RingEquiv.localRing

theorem RingEquiv.localRing :
    ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : LocalRing A] [inst_2 : CommSemiring B],
      A ≃+* B → LocalRing B :=
  by sorry

This theorem states that for any types `A` and `B`, if `A` is a commutative semiring and a local ring, and `B` is a commutative semiring as well, then if there exists a ring isomorphism between `A` and `B`, `B` is also a local ring. In other words, the property of being a local ring is preserved under ring isomorphisms.

If `A` is a commutative semiring and a local ring, and there exists a ring isomorphism between `A` and `B`, then `B` is a local ring.


theorem Nat.exists_prime_and_dvd : ∀ {n : ℕ}, n ≠ 1 → ∃ p, Nat.Prime p ∧ p ∣ n := by sorry

The theorem `Nat.exists_prime_and_dvd` states that for any natural number `n` that is not equal to 1, there exists a prime number `p` such that `p` is a divisor of `n`. In other words, every natural number greater than 1 has at least one prime number as a divisor.

For every natural number `n` greater than 1, there exists a prime number `p` such that `p` divides `n`.


theorem ExteriorAlgebra.algebraMap_leftInverse :
    ∀ {R : Type u1} [inst : CommRing R] (M : Type u2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      Function.LeftInverse ⇑ExteriorAlgebra.algebraMapInv ⇑(algebraMap R (ExteriorAlgebra R M)) :=
  by sorry

This theorem states that for any commutative ring `R` and any type `M` that has additional structures of an additive commutative group and an `R`-module, the function `ExteriorAlgebra.algebraMapInv` acts as a left inverse to the function `algebraMap R (ExteriorAlgebra R M)`. In other words, if you first apply `algebraMap R (ExteriorAlgebra R M)` to any element of `R`, and then apply `ExteriorAlgebra.algebraMapInv` to the result, you will get back your original element of `R`. This is expressed as `Function.LeftInverse ⇑ExteriorAlgebra.algebraMapInv ⇑(algebraMap R (ExteriorAlgebra R M))`.

For any commutative ring `R` and `R`-module `M` with additional structure of an additive commutative group, the map `ExteriorAlgebra.algebraMapInv` is the left inverse of `algebraMap R` on `ExteriorAlgebra R M`.


theorem Subgroup.coe_top : ∀ {G : Type u_1} [inst : Group G], ↑⊤ = Set.univ := by sorry

This theorem, `Subgroup.coe_top`, states that for any group `G` of a certain type `u_1`, the top subgroup (denoted by `⊤`) of this group, when coerced (`↑`), is equal to the universal set (`Set.univ`). In other words, it asserts that the set of all elements in the top subgroup of a given group `G` is equivalent to the complete set containing all elements of the type of `G`.

The coercion of the top subgroup of a group to a set is equal to the universal set.


/-- **Alias** of `not_isMax_of_lt`. -/
theorem LT.lt.not_isMax : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b → ¬IsMax a := by sorry

The theorem `LT.lt.not_isMax` states that for any type `α` that has a preorder relationship, if there exists an element `b` such that `a < b` for a certain `a`, then `a` is not a maximal element of `α`. In other words, if there is an element larger than `a`, then `a` cannot be the greatest element in the set.

If `α` is a type with a preorder relation and there exists `b` such that `a < b`, then `a` is not a maximal element of `α`.


theorem countable_bInter_mem :
    ∀ {α : Type u_2} {l : Filter α} [inst : CountableInterFilter l] {ι : Type u_4} {S : Set ι},
      Set.Countable S →
        ∀ {s : (i : ι) → i ∈ S → Set α}, ⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l :=
  by sorry

The theorem `countable_bInter_mem` states that for any type `α` and any filter `l` of type `α`, given that the filter is countable-inter, and for any set `S` of type `ι`, if `S` is countable, then for any function `s` which maps an element `i` of `S` to a set of type `α` (assuming `i` belongs to `S`), the intersection of all sets `s i hi` for each `i` in `S` belongs to the filter `l` if and only if each individual set `s i hi` belongs to `l`.

In other words, the intersection of all sets produced by the function `s` is in the filter `l` if and only if each of these sets is in the filter `l`. This statement is made under the conditions that the filter `l` is countable-inter and the set `S` is countable.

For any countable-inter filter `l` on type `α` and countable set `S`, the intersection of images of `S` under a function mapping each element to a set in `l` is in `l` if and only if each image set is in `l`.


theorem Real.rpow_def_of_neg :
    ∀ {x : ℝ}, x < 0 → ∀ (y : ℝ), x ^ y = Real.exp (Real.log x * y) * Real.cos (y * Real.pi) := by sorry

This theorem states that for any real number `x` that is less than zero, and for any real number `y`, the power of `x` raised to `y` (denoted as `x ^ y`) can be expressed in terms of the exponential, logarithm, and cosine functions. Specifically, `x ^ y` is equal to the product of the exponential of the logarithm of `x` multiplied by `y`, and the cosine of the product of `y` and the constant pi (`π`). In mathematical notation, this can be written as: if `x` is a real number such that `x < 0`, and `y` is any real number, then `x ^ y = exp(log(x) * y) * cos(y * π)`.

For any real number `x` with `x < 0` and any real number `y`, `x^y` equals the product of `exp(log(x)*y)` and `cos(y*π)`.


Set.Finite.isPWO

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

The theorem `Set.Finite.isPWO` states that for any type `α` with a preorder relation, and any set `s` of that type, if the set `s` is finite, then it is partially well-ordered. In other words, if we have a finite set from a preordered type, then any infinite sequence from that set contains a monotone subsequence of length 2 or equivalently, an infinite monotone subsequence.

If `α` is a type with a preorder relation and `s : α` is a finite set, then `s` is partially well-ordered, i.e., it has an infinite monotone subsequence.


theorem ENNReal.toNNReal_le_toNNReal : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toNNReal ≤ b.toNNReal ↔ a ≤ b) := by sorry

This theorem states that for any two extended nonnegative real numbers 'a' and 'b' that are not equal to positive infinity (notated as '⊤'), the nonnegative real number representation of 'a' is less than or equal to the nonnegative real number representation of 'b' if and only if 'a' is less than or equal to 'b'. Essentially, converting between the extended nonnegative real numbers and the nonnegative real numbers preserves the order of the numbers, as long as neither of them is positive infinity.

For any extended nonnegative real numbers 'a' and 'b' not equal to positive infinity, a ≤ b if and only if ℛ(a) ≤ ℛ(b), where ℛ(x) denotes the nonnegative real number representation of x.


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

The theorem `Nat.choose_one_right` states that for any natural number `n`, the binomial coefficient `Nat.choose n 1` (also known as "n choose 1") is equal to `n` itself. In other words, the number of distinct subsets of size 1 that can be formed from a set of `n` elements is just `n`. This is naturally true because, for a given set of `n` elements, we can form `n` different one-element subsets, each containing a different element of the set.

For any natural number `n`, the binomial coefficient `Nat.choose n 1` equals `n`. Alternatively, the number of subsets of size 1 in a set of `n` elements is `n`.


theorem MeasureTheory.Submartingale.stronglyMeasurable :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0} [inst_4 : LE E],
      MeasureTheory.Submartingale f ℱ μ → ∀ (i : ι), MeasureTheory.StronglyMeasurable (f i) :=
  by sorry

The theorem `MeasureTheory.Submartingale.stronglyMeasurable` states that for any pre-ordered set `ι`, a measure space `Ω`, a measure `μ` on `Ω`, a normed, ordered, complete vector space `E` over the real numbers, a function `f` from `ι` to `Ω → E`, and a filtration `ℱ` of the measure space `Ω` indexed by `ι`, if `f` is a submartingale with respect to the filtration `ℱ` and the measure `μ`, then for every index `i` in `ι`, the function `f i` mapping `Ω` to `E` is strongly measurable. Here, a function is said to be strongly measurable if it can be approximated by a sequence of simple functions.

If a function `f` is a submartingale with respect to a filtration `ℱ` and measure `μ` on a measure space `Ω` over a normed, ordered, complete vector space `E`, then for each index `i` in `ι`, the function `fi` is strongly measurable.


theorem neg_closedBall :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E),
      -Metric.closedBall x δ = Metric.closedBall (-x) δ :=
  by sorry

This theorem states that for any seminormed additive commutative group `E` and any real number `δ`, the negation of the closed ball around a point `x` in `E` with radius `δ` is equal to the closed ball around the negation of `x` with the same radius `δ`. In other words, reflecting the set of all points in the group that are within a distance `δ` from `x` around the origin yields the same set of points as those that are within a distance `δ` from `-x`.

For any seminormed additive commutative group `E` and real number `δ`, the negative of the closed ball around `x` in `E` with radius `δ` is equal to the closed ball around `-x`.


theorem memℓp_gen :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] {f : (i : α) → E i},
      (Summable fun i => ‖f i‖ ^ p.toReal) → Memℓp f p :=
  by sorry

The theorem `memℓp_gen` states that for any type `α`, any normed group `E` indexed by `α`, any extended nonnegative real number `p`, and any function `f` from `α` to `E`, if the series formed by taking the p-th norm of each output of `f` and summing them is summable, then the function `f` is in the L^p space (denoted as `Memℓp f p`).

In other words, it's saying that if we can sum the p-th power of the norms of a function's values, then that function is said to be "p-integrable" or within the p-th L^p space, a concept used in functional analysis and measure theory.

If a function from a type to a normed group has summable series of p-th powers of its values' norms, then the function belongs to the L^p space.


theorem Complex.ofReal_mem_slitPlane : ∀ {x : ℝ}, ↑x ∈ Complex.slitPlane ↔ 0 < x := by sorry

This theorem states that for any real number `x`, `x` belongs to the slit complex plane (defined as the set of complex numbers whose real part is greater than zero or whose imaginary part is not equal to zero) if and only if `x` is greater than zero. Here, we're considering `x` as a complex number with zero imaginary part, denoted by `↑x` in Lean's notation.

A real number `x` belongs to the slit complex plane if and only if `x` is a positive real number.


theorem FractionalIdeal.map_id :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      (I : FractionalIdeal S P), FractionalIdeal.map (AlgHom.id R P) I = I :=
  by sorry

This theorem states that for any commutative ring `R`, submonoid `S` of `R`, and any type `P` that forms a commutative ring and is an `R`-algebra, if `I` is a fractional ideal of `P` with respect to `S`, then mapping `I` via the identity algebra homomorphism leaves the fractional ideal unchanged. In mathematical terms, the mapping of a fractional ideal under the identity operation is the ideal itself.

For any commutative ring `R`, submonoid `S` of `R`, and `R`-algebra `P`, if `I` is a fractional ideal of `P` with respect to `S`, then applying the identity algebra homomorphism to `I` results in `I` itself.


theorem List.eraseP_cons_of_pos :
    ∀ {α : Type u_1} {a : α} {l : List α} (p : α → Bool), p a = true → List.eraseP p (a :: l) = l := by sorry

The theorem `List.eraseP_cons_of_pos` states that for all types `α`, for every element `a` of type `α`, for every list `l` of elements of type `α`, and for every predicate `p` that maps elements of type `α` to boolean values, if the predicate `p` applied to the element `a` returns `true`, then the result of applying the function `List.eraseP` with predicate `p` to the list that has `a` at the head and `l` as the rest of the list, is equal to the list `l`. In other words, if `p a` is `true`, then `a` is removed from the head of the list `(a :: l)` using `List.eraseP`.

For all types `α`, lists `l` of length greater than 0 in `α`, and predicates `p` on `α`, if `a ∈ l` and `p(a)` holds, then `List.eraseP p (a :: l) = l`.


/-- **Alias** of the reverse direction of `antitone_toDual_comp_iff`. -/
theorem Monotone.dual_right :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → Antitone (⇑OrderDual.toDual ∘ f) :=
  by sorry

The theorem `Monotone.dual_right` states that for any types `α` and `β` equipped with preorder structures, and for any function `f` from `α` to `β`, if the function `f` is monotone (i.e., if for any `a` and `b` in `α`, `a ≤ b` implies `f(a) ≤ f(b)`), then the function formed by composing `f` with the `toDual` function of the `OrderDual` of `α` (which effectively reverses the order) is antitone. This means that for any `a` and `b` in `α`, `a ≤ b` implies that `f(b)` is less than or equal to `f(a)` when considering the reversed order. In other words, if `f` preserves the order of elements, then the dual function reverses the order.

If `f` is a monotone function from a preordered type `α` to a preordered type `β`, then the composition of `f` and the order dual function `toDual` is an antitone function.


/-- Intermediate value theorem for two functions: if `f` and `g` are two continuous functions
on a preconnected space and `f a ≤ g a` and `g b ≤ f b`, then for some `x` we have `f x = g x`.  -/
theorem intermediate_value_univ₂ :
    ∀ {X : Type u} {α : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α]
      [inst_3 : OrderClosedTopology α] [inst_4 : PreconnectedSpace X] {a b : X} {f g : X → α},
      Continuous f → Continuous g → f a ≤ g a → g b ≤ f b → ∃ x, f x = g x :=
  by sorry

This theorem is a version of the Intermediate Value Theorem for two functions. Specifically, it states that if `f` and `g` are two continuous functions on a preconnected topological space (a topological space that cannot be represented as the union of two disjoint nonempty open sets), and `f(a)` is less than or equal to `g(a)`, and `g(b)` is less than or equal to `f(b)`, then there exists some point `x` in the space such that `f(x)` equals `g(x)`. In simpler terms, if two continuous functions cross over each other at least once between any two points, then there must be a point where they are equal.

If `f` and `g` are continuous functions on a connected topological space with `f(a) ≤ g(a)` and `g(b) ≤ f(b)`, then there exists an `x` in the space such that `f(x) = g(x)`.


theorem MeasureTheory.AEStronglyMeasurable.comp_quasiMeasurePreserving :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {g : α → β} {γ : Type u_5} {x : MeasurableSpace γ}
      {x_1 : MeasurableSpace α} {f : γ → α} {μ : MeasureTheory.Measure γ} {ν : MeasureTheory.Measure α},
      MeasureTheory.AEStronglyMeasurable g ν →
        MeasureTheory.Measure.QuasiMeasurePreserving f μ ν → MeasureTheory.AEStronglyMeasurable (g ∘ f) μ :=
  by sorry

This is a theorem about the composition of certain types of measurable functions. It states that if a function `g` is "almost everywhere strongly measurable" with respect to a measure `ν`, and another function `f` is "quasi-measure preserving" from a measure `μ` to `ν`, then the composition of the two functions `g ∘ f` is also "almost everywhere strongly measurable" with respect to the measure `μ`.

Here, a function is considered "almost everywhere strongly measurable" if it is almost everywhere equal to the limit of a sequence of simple functions. A function is "quasi-measure preserving" if it transforms one measure to another in a way that preserves the measure of sets up to sets of measure zero.

If a function `g` is almost everywhere strongly measurable with respect to measure `ν`, and another function `f` is quasi-measure preserving from measure `μ` to `ν`, then the composition `g ∘ f` is almost everywhere strongly measurable with respect to measure `μ`.


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

The theorem `Filter.Tendsto.eventually_ne_atTop` asserts that for any function `f` from a type `α` to a preorder type `β` with no maximum element, and any filter `l` on `α`, if `f` tends to positive infinity (`Filter.atTop`) along the filter `l`, then for every constant `c` in `β`, eventually in the filter `l`, the function `f(x)` is not equal to the constant `c`. In other words, if a function goes to infinity, then given any constant, there is a point beyond which the function value will not be equal to that constant.

If a function from a type without a maximum element tends to positive infinity along a filter, then for any constant, there exists a filter element such that the function value at that element is not equal to the constant.


theorem AddSubgroup.neg_mem_iff : ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x : G}, -x ∈ H ↔ x ∈ H := by
  sorry

This theorem states that for any given type `G` which has an addition group structure (`AddGroup G`), and for any addition subgroup `H` of `G`, an element `x` of `G` is in `H` if and only if the negation of `x` (denoted as `-x`) is also in `H`. In other words, it expresses the property of subgroups in an additive group where if `x` is an element of the subgroup, then its additive inverse `-x` is also an element of the subgroup, and vice versa.

For any additive group `G` and subgroup `H`, an element `x` in `G` belongs to `H` if and only if both `x` and `-x` belong to `H`.


theorem MeasureTheory.Measure.smul_toOuterMeasure :
    ∀ {α : Type u_1} {R : Type u_6} [inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal]
      {_m : MeasurableSpace α} (c : R) (μ : MeasureTheory.Measure α), ↑(c • μ) = c • ↑μ :=
  by sorry

This theorem states that for any given type `α` and `R`, given that `R` is a type that allows scalar multiplication (`SMul`) with the type `ENNReal` (extended nonnegative real numbers), and `ENNReal` forms a scalar tower over `R` and `ENNReal`, for any measurable space `_m` of type `α`, scalar multiplication of a measure `μ` from the measurable space by a scalar `c` from `R` is equal to the scalar multiplication of the embedding of `μ` by `c`. In other words, it means that in the context of measures, scalar multiplication commutes with the embedding operation.

For any measurable space `(α, μ)`, `ENNReal`-valued measure `μ`, and `c` in an `ENNReal`-scalable type `R`, the scalar multiplication of `μ` by `c` is equal to the scalar multiplication of the embedding of `μ` by `c`.


theorem List.mem_filter :
    ∀ {α : Type u_1} {x : α} {p : α → Bool} {as : List α}, x ∈ List.filter p as ↔ x ∈ as ∧ p x = true := by sorry

The theorem `List.mem_filter` states that for any type `α`, any element `x` of type `α`, any boolean function `p` from `α`, and any list `as` of type `α`, `x` is an element of the list obtained by filtering `as` with the function `p` if and only if `x` is an element of `as` and `p(x)` is true. In other words, an item is in the filtered list precisely when it is in the original list and it satisfies the filtering condition.

For any type `α`, list `as` of `α`, element `x` of `α`, and boolean function `p` on `α`, `x ∈ List.filter p as` if and only if `x ∈ as` and `p(x) = true`.


/-- A function `-f` is convex iff `f` is concave.  -/
theorem neg_convexOn_iff :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommGroup β] [inst_3 : SMul 𝕜 E] [inst_4 : Module 𝕜 β] {s : Set E} {f : E → β},
      ConvexOn 𝕜 s (-f) ↔ ConcaveOn 𝕜 s f :=
  by sorry

The theorem `neg_convexOn_iff` states that for any set `s` and any function `f` from `E` to `β`, where `𝕜` is an ordered semiring, `E` is an additive commutative monoid, `β` is an ordered additive commutative group, and `𝕜` acts on `E` and `β` through scalar multiplication, the negative of the function `f` is convex on the set `s` if and only if the function `f` is concave on the set `s`. In other words, a function is concave exactly when its negation is convex.

A function from an additive commutative monoid to an ordered additive commutative group over an ordered semiring is concave if and only if its negation is convex.


theorem NonUnitalAlgebra.coe_sInf :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
      [inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (S : Set (NonUnitalSubalgebra R A)),
      ↑(sInf S) = ⋂ s ∈ S, ↑s :=
  by sorry

This theorem, named `NonUnitalAlgebra.coe_sInf`, states that for any set `S` of non-unital subalgebras in a non-unital, non-associative semiring `A` over a commutative semiring `R`, the coercion of the infimum (`sInf`, also known as the greatest lower bound) of `S` is equal to the intersection of all elements `s` in `S`. Here, the semiring `A` is a module over `R`, there is a scalar multiplication operation for `R`, `A`, and `A` that forms a tower (i.e., scalar multiplication is compatible with the ring multiplication), and the scalar multiplication is commutative.

For any commutative semiring `R`, non-unital, non-associative semiring `A` over `R`, and set `S` of non-unital subalgebras of `A`, the coercion of the infimum of `S` equals the intersection of all elements in `S`.


theorem Real.Angle.two_nsmul_eq_iff : ∀ {ψ θ : Real.Angle}, 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑Real.pi := by sorry

This theorem states that for any two angles `ψ` and `θ`, the condition of doubling `ψ` to get the same result as doubling `θ` (expressed as `2 • ψ = 2 • θ`) holds if and only if `ψ` is either equal to `θ` or `ψ` equals `θ` plus π. Here, angles are defined in the type `Real.Angle`, which comprises real numbers modulo `2 * π`, and π is defined as twice a zero of the cosine function in the interval [1,2].

For angles `ψ` and `θ` in the real modulo `2π`, `2ψ = 2θ` if and only if `ψ` is equal to `θ` or `ψ` is `θ` plus `π`.


theorem AddMonoidHom.coe_mrange :
    ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_5}
      [inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F), ↑(AddMonoidHom.mrange f) = Set.range ⇑f :=
  by sorry

The theorem `AddMonoidHom.coe_mrange` states that for any types `M`, `N`, and `F`, with `M` and `N` being additive monoids (i.e., they contain a zero and an addition operation), and `F` being a function-like object from `M` to `N`, the range of a homomorphism `f : F` (which preserves the addition operation and the zero) is equal to the set of all images of elements in `M` under `f`. In other words, the range of `f` as an additive monoid homomorphism is the same as the range of `f` as a function.

The range of an additive monoid homomorphism from one additive monoid to another as a set equals the images of its elements under the homomorphism.


theorem ZMod.eq_iff_modEq_nat : ∀ (n : ℕ) {a b : ℕ}, ↑a = ↑b ↔ a ≡ b [MOD n] := by sorry

This theorem states that for any natural number `n`, and any two natural numbers `a` and `b`, the integer forms of `a` and `b` are equal if and only if `a` is congruent to `b` modulo `n`. In other words, `a` and `b` have the same remainder when divided by `n`. The theorem connects modular arithmetic to integer equality.

For any natural numbers `n`, `a`, and `b`, `a` and `b` have the same integer value modulo `n` if and only if `a` is equal to `b` as integers.


theorem Mathlib.SetTheory.Ordinal.Arithmetic._auxLemma.2 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) := by sorry

This theorem from the Mathlib library in Lean 4 states that for any type `α` which has a partial order, two elements `a` and `b` of this type are equal if and only if `a` is less than or equal to `b` and `b` is less than or equal to `a`. In more mathematical terms, for all `α` with a partial order, `a = b` is equivalent to the statement `a ≤ b` and `b ≤ a`. This is a formal statement of the antisymmetry property in order theory.

In a partially ordered type `α`, elements `a` and `b` are equal if and only if they are mutually less than or equal to each other: `a = b <-> a ≤ b and b ≤ a`.


/-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atTop` and `g`
tends to a positive constant `C` then `f * g` tends to `Filter.atTop`.  -/
theorem Filter.Tendsto.atTop_mul :
    ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜]
      [inst_2 : OrderTopology 𝕜] {l : Filter α} {f g : α → 𝕜} {C : 𝕜},
      0 < C →
        Filter.Tendsto f l Filter.atTop →
          Filter.Tendsto g l (nhds C) → Filter.Tendsto (fun x => f x * g x) l Filter.atTop :=
  by sorry

The theorem `Filter.Tendsto.atTop_mul` states the following: Suppose 𝕜 is a linearly ordered field with a topological space structure and an order topology. Given a filter `l` and two functions `f` and `g` from α to 𝕜, and a positive constant `C`. If the function `f` tends towards infinity (`Filter.atTop`) and `g` tends towards the neighborhood of the positive constant `C`, then the function defined by the product of `f` and `g` also tends towards infinity (`Filter.atTop`). In other words, in a linearly ordered field with an order topology, if one function goes to infinity and the other goes to a positive constant, their product will also go to infinity.

If a filter converges to infinity in a linearly ordered field with an order topology and another function converges to a positive constant, then their product converges to infinity.


theorem isOpen_lt' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] (a : α),
      IsOpen {b | a < b} :=
  by sorry

This theorem states that for any type `α` which has a topological space structure, a preorder (a binary relation that is reflexive and transitive), and an order topology (a certain topology defined on a totally ordered set), and for any element `a` of this type, the set of elements `b` in `α` such that `a` is less than `b` forms an open set in the given topological space. In mathematical terms, this can be written as: for all `a` in `α`, the set `{b | a < b}` is open in the topological space `α`.

For any type `α` endowed with a topological space structure, a preorder, and an order topology, the upward closed balls in the order topology are open sets. (Here, an upward closed ball with center `a` is the set `{b | a < b}`).


theorem Function.surjInv_eq :
    ∀ {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f) (b : β), f (Function.surjInv h b) = b := by
  sorry

The theorem `Function.surjInv_eq` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is surjective (meaning that for every element `b` in `β`, there exists some element `a` in `α` such that `f(a) = b`), then applying `f` to the inverse of `f` (as determined by the surjectivity proof `h`), when given any element `b` from `β`, equals `b`. The inverse function here, `Function.surjInv h b`, gives an element `a` in `α` such that `f(a) = b` for a given `b` in `β`, based on the surjective nature of `f`. The theorem thus essentially verifies the correctness of the surjective inverse function.

For all types `α` and `β` and surjective functions `f` from `α` to `β`, `f (Function.surjInv f b) = b` for all `b` in `β`.


theorem subset_interior_iff_isOpen :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], s ⊆ interior s ↔ IsOpen s := by sorry

This theorem states that for any type `X` and any set `s` of type `X` in a given topological space, the set `s` is a subset of its interior if and only if the set `s` is open. In terms of topology, this means that a set is open (i.e., each point in the set is an interior point) if and only if all of its points are interior points, which is true by definition of an open set.

A set `s` of type `X` in a topological space is equal to its interior if and only if it is open.


theorem Mathlib.SetTheory.ZFC.Basic._auxLemma.20 : ∀ {x y : ZFSet}, (x ∈ {y}) = (x = y) := by sorry

This theorem, from the Mathlib library in set theory and specifically Zermelo-Fraenkel set theory, states that for any two sets `x` and `y` in the ZFC universe, `x` is an element of the singleton set `{y}` if and only if `x` is equal to `y`. In other words, a set `x` is in the set that contains only `y` exactly when `x` is `y`.

For any sets `x` and `y` in the ZFC universe, `x` is an element of the singleton set `{y}` if and only if `x = y`.


Sigma.exists

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

This theorem, `Sigma.exists`, states that for any types `α` and `β` (with `β` being a type dependent on `α`), and any property `p` that can be applied to a pair consisting of a value of type `α` and a value of type `β a` (where `a` is a value of type `α`), there exists a value `x` such that the property `p` holds for `x` if and only if there exist values `a` and `b` such that `p` holds for the pair (`a`, `b`). Essentially, this theorem states that an existential quantification over a dependent pair type is equivalent to an existential quantification over the components of the pair.

For any types `α` and `β`, and any predicate `p` on `α × β`, the existence of `x : α × β` such that `p(x)` holds is equivalent to the existence of `a : α` and `b : β a` such that `p(a, b)` holds.


/-- The angle between two vectors is nonnegative.  -/
theorem InnerProductGeometry.angle_nonneg :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
      0 ≤ InnerProductGeometry.angle x y :=
  by sorry

The theorem `InnerProductGeometry.angle_nonneg` asserts that the angle between any two vectors is a nonnegative real number. This is true for all vectors in a vector space `V`, which is equipped with a norm (via `NormedAddCommGroup V`) and an inner product structure (via `InnerProductSpace ℝ V`). The angle is calculated using the formula derived from the inner product geometry.

The inner product of any two vectors in a normed inner product space results in a non-negative real number.


HasStrictDerivAt.neg

theorem HasStrictDerivAt.neg :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜},
      HasStrictDerivAt f f' x → HasStrictDerivAt (fun x => -f x) (-f') x :=
  by sorry

The theorem `HasStrictDerivAt.neg` states that for any non-trivial normed field `𝕜`, any normed additive commutative group `F` and any point `x` in `𝕜`, if a function `f : 𝕜 → F` has a strict derivative `f'` at the point `x`, then the negative function `-f` has a strict derivative `-f'` at the same point `x`. In other words, the derivative of the negation of a function is the negation of the derivative of the function, at any given point, under the condition of strict differentiability.

If `f : 𝕜 → F` is a function with strict derivative `f'` at `x` in a non-trivial normed field `𝕜` and normed additive commutative group `F`, then `-f` has strict derivative `-f'` at `x`.


theorem GaloisCoinsertion.u_l_leftInverse :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : PartialOrder α] [inst_1 : Preorder β],
      GaloisCoinsertion l u → Function.LeftInverse u l :=
  by sorry

This theorem, `GaloisCoinsertion.u_l_leftInverse`, states that for any two types `α` and `β` along with functions `l : α → β` and `u : β → α`, given a partial order on `α` and a preorder on `β`, if a Galois coinsertion exists between `l` and `u`, then `u` is a left inverse to `l`. In other words, applying `u` after `l` gives the original input, i.e., for all `x` in `α`, we have `u(l(x)) = x`.

If functions `l : α → β` and `u : β → α` have a Galois coinsertion and `α` is partially ordered, then `u` is a left inverse of `l`, that is, `u (l(x)) = x` for all `x` in `α`.


theorem mul_left_inj :
    ∀ {G : Type u_3} [inst : Mul G] [inst_1 : IsRightCancelMul G] (a : G) {b c : G}, b * a = c * a ↔ b = c := by sorry

This theorem, `mul_left_inj`, states that for any type `G` that has a multiplication operation (`Mul G`) and satisfies the right cancellation law for multiplication (`IsRightCancelMul G`), for any element `a` of type `G`, `b` and `c` are equal if and only if the product of `b` and `a` is equal to the product of `c` and `a`. Essentially, this theorem gives us a rule for canceling the same factor from both sides of an equation in this mathematical structure. This corresponds to the intuitive idea of "cancellation" from elementary algebra.

For any type `G` with multiplication `Mul G` and right cancellation law `IsRightCancelMul G`, the equation `b * a = c * a` implies `b = c`.


theorem Multiset.dedup_eq_self :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α}, Multiset.dedup s = s ↔ Multiset.Nodup s := by sorry

This theorem states that for any type `α` with decidable equality and any multiset `s` of type `α`, the `Multiset.dedup` operation applied to `s` results in `s` itself if and only if `s` has no duplicates (satisfies `Multiset.Nodup`). In other words, a multiset is the same as its deduplicated version if and only if it does not contain repeated elements.

For any type `α` with decidable equality, a multiset `s` of type `α` is equal to `Multiset.dedup s` if and only if `s` is a multiset without repetitions.


theorem FirstOrder.Language.BoundedFormula.isQF_bot :
    ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ}, FirstOrder.Language.BoundedFormula.IsQF ⊥ := by sorry

This theorem states that, for any first-order language `L`, any type `α`, and any natural number `n`, the bottom (falsum) of the set of bounded formulas in `L` is quantifier-free. In the context of first-order logic, a formula is quantifier-free (QF) if it doesn't contain any universal or existential quantifiers. The symbol `⊥` represents the logical constant for "false". This theorem thus asserts a very basic fact about the structure of logical formulas.

In any first-order language, the bottom formula is quantifier-free.


theorem Mathlib.GroupTheory.Subsemigroup.Operations._auxLemma.1 :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {S : Subsemigroup N} {f : M →ₙ* N} {x : M},
      (x ∈ Subsemigroup.comap f S) = (f x ∈ S) :=
  by sorry

This theorem states that for all types `M` and `N` with multiplication operations (`Mul M` and `Mul N` respectively), a subsemigroup `S` of `N`, and a semigroup homomorphism `f` from `M` to `N`, an element `x` from `M` is in the preimage of `S` under `f` (i.e., `x` is in `Subsemigroup.comap f S`) if and only if the image of `x` under `f` (i.e., `f x`) is in `S`. In other words, membership in the preimage subsemigroup defined by `f` and `S` corresponds exactly to membership in `S` under the mapping `f`.

For any semigroup homomorphism $f$ from type `M` to type `N` and any subsemigroup `S` of `N`, an element `x` from `M` is in the preimage of `S` under `f` if and only if $f(x) \in S$.


theorem Mathlib.GroupTheory.Subsemigroup.Operations._auxLemma.2 :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {S : AddSubsemigroup N} {f : AddHom M N} {x : M},
      (x ∈ AddSubsemigroup.comap f S) = (f x ∈ S) :=
  by sorry

The theorem `Mathlib.GroupTheory.Subsemigroup.Operations._auxLemma.2` states that for any types `M` and `N` with addition (`Add M` and `Add N`), a given `AddSubsemigroup` `S` of `N`, and an additive homomorphism `f` from `M` to `N`, an element `x` of `M` is in the preimage of `S` under `f` (i.e., `x` belongs to `AddSubsemigroup.comap f S`) if and only if `f(x)` is in `S`. In other words, it connects the membership of an element in the preimage of a subsemigroup with the mapping of that element into the subsemigroup by the homomorphism.

For any additive homomorphism from an additive semigroup to another, an element is in the preimage of a subsemigroup if and only if its image under the homomorphism is in the subsemigroup.


theorem right_ne_zero_of_mul_eq_one :
    ∀ {M₀ : Type u_2} [inst : MulZeroOneClass M₀] [inst_1 : Nontrivial M₀] {a b : M₀}, a * b = 1 → b ≠ 0 := by sorry

This theorem states that, for any instance of a `MulZeroOneClass` type `M₀` where `M₀` is nontrivial (i.e., it has at least two distinct elements), if the product of two elements `a` and `b` equals one, then `b` cannot be zero. In other words, in such a system, any element that when multiplied by another element yields one, must itself be nonzero.

If `MulZeroOneClass` `M₀` has at least two distinct elements, then for all `a` and `b` in `M₀`, `a * b = 1` implies `b ≠ 0`.


theorem Finset.sup_image₂_le :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α}
      {t : Finset β} [inst_1 : SemilatticeSup δ] [inst_2 : OrderBot δ] {g : γ → δ} {a : δ},
      Finset.sup (Finset.image₂ f s t) g ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, g (f x y) ≤ a :=
  by sorry

This theorem states that for any sets `s` of type `α` and `t` of type `β`, a binary function `f` from `α` and `β` to `γ`, a function `g` from `γ` to `δ`, and an element `a` of type `δ` (where `δ` has a join-semilattice structure with a least element), the supremum of the images of the elements of the Cartesian product of `s` and `t` under `f` and then `g` is less than or equal to `a` if and only if for every element `x` in `s` and every element `y` in `t`, the image of `f(x, y)` under `g` is less than or equal to `a`.

For sets `s` of type `α`, `t` of type `β`, functions `f : α × β → γ` and `g : γ → δ` (where `δ` is a join-semilattice with least element), and any `a : δ`, the following are equivalent: the supremum of `g ∘ f` over the Cartesian product `s × t` is less than or equal to `a`, and for all `x : α` in `s` and `y : β` in `t`, `g (f x y)` is less than or equal to `a`.


theorem Monotone.add_const :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α}
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      Monotone f → ∀ (a : α), Monotone fun x => f x + a :=
  by sorry

The theorem `Monotone.add_const` states that for any types `α` and `β`, where `α` has an addition operation and both `α` and `β` are preordered, if a function `f` from `β` to `α` is monotone, then adding a constant `a` from `α` to the function `f` results in another monotone function. This is under the condition that `α` is a covariant class under the swap operation on addition and the less than or equal to relation. In simpler words, if you have a function that maintains order (monotone), then adding a constant to each output of that function still maintains the order (remains monotone).

If `α` is a covariant preorder with respect to addition, and `f : β → α` is a monotone function, then `g : β → α` defined by `g(x) := f(x) + a` is also monotone for any constant `a ∈ α`.


theorem NNReal.coe_add : ∀ (r₁ r₂ : NNReal), ↑(r₁ + r₂) = ↑r₁ + ↑r₂ := by sorry

This theorem, `NNReal.coe_add`, states that for all non-negative real numbers `r₁` and `r₂`, the coercion of the sum of `r₁` and `r₂` to a real number is equal to the sum of the coercions of `r₁` and `r₂` to real numbers. In other words, this theorem ensures that the operation of sum in the set of non-negative real numbers is compatible with the natural inclusion of this set into the set of all real numbers.

For all non-negative real numbers `r₁` and `r₂`, Coerce(r₁ + r₂, Real) = Coerce(r₁, Real) + Coerce(r₂, Real).


theorem CategoryTheory.Limits.kernelSubobject_factors :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f]
      {W : C} (h : W ⟶ X),
      CategoryTheory.CategoryStruct.comp h f = 0 →
        CategoryTheory.Subobject.Factors (CategoryTheory.Limits.kernelSubobject f) h :=
  by sorry

The theorem `CategoryTheory.Limits.kernelSubobject_factors` states that in any category `C` with zero morphisms, given a morphism `f` from object `X` to `Y` that has a kernel, and another morphism `h` from an object `W` to `X`, if the composition of `h` and `f` (i.e., `h ≫ f`) is a zero morphism (essentially meaning that the morphism `h` maps into the kernel of `f`), then `h` factors through the kernel subobject of `f`. In other words, there exists a factorisation of `h` through the kernel of `f`. This is a general property in category theory that encapsulates one of the defining properties of the kernel of a morphism.

In a category with zero morphisms, if a morphism has a kernel and another morphism into the domain of the first one makes their composition a zero morphism, then the second morphism factors through the kernel of the first one.


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

This theorem states that for any first-order language `L` and any type `M` with a given `FirstOrder.Language.Structure L M`, the structure `L M` is finitely generated if and only if the maximal substructure, represented by `⊤`, is finitely generated. In mathematical terms, we say a structure is finitely generated if it can be produced by taking a finite set and repeatedly applying the operations of the language to elements of this set.

For any first-order language `L` and type `M` in Lean 4 with `FirstOrder.Language.Structure L M`, the structure `L M` is finitely generated if and only if its maximal substructure is finitely generated.


theorem gc_intentClosure_extentClosure :
    ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop),
      GaloisConnection (⇑OrderDual.toDual ∘ intentClosure r) (extentClosure r ∘ ⇑OrderDual.ofDual) :=
  by sorry

This theorem states that for any relation `r` between two arbitrary types `α` and `β`, there is a Galois Connection between the intent closure of `r` and the extent closure of `r`. This connection is established through the mapping of the intent closure of `r` to the dual order using the `OrderDual.toDual` function, and the extent closure of `r` is mapped from the dual order using the `OrderDual.ofDual` function. A Galois Connection implies that the order-preserving properties between these two sets are maintained.

For any relation `r` between types `α` and `β`, there exists a Galois Connection between the intent closure and extent closure of `r`, where the intent closure is mapped to the dual order and the extent closure is mapped from the dual order.


theorem Nat.nth_mem :
    ∀ {p : ℕ → Prop} (n : ℕ), (∀ (hf : Set.Finite (setOf p)), n < (Set.Finite.toFinset hf).card) → p (Nat.nth p n) := by
  sorry

The theorem `Nat.nth_mem` states that for any predicate `p` on natural numbers and any natural number `n`, if the set of natural numbers satisfying `p` is finite and `n` is less than the cardinality of that set (when converted into a `Finset`), then the `n`-th natural number that satisfies `p` (where indexing starts from 0) also satisfies `p`. In other words, it ensures that the `n`-th number in the ordered list of natural numbers (that satisfy the predicate `p`) is indeed a number that satisfies `p`.

If `p` is a finite predicate on natural numbers and `n` is less than the cardinality of the set of natural numbers satisfying `p`, then the `n`-th natural number satisfying `p` also satisfies `p`.


theorem compl_le_compl_iff_le : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], yᶜ ≤ xᶜ ↔ x ≤ y := by sorry

This theorem, `compl_le_compl_iff_le`, states that for any given Boolean algebra, the complement of `y` (denoted as `yᶜ`) is lesser than or equal to the complement of `x` (denoted as `xᶜ`) if and only if `x` is lesser than or equal to `y`. In other words, it establishes an order-reversing correspondence between elements and their complements in a Boolean algebra.

In a Boolean algebra, x≤y if and only if x′≤y′, where x and y are elements and x′ (respectively y′) denotes the complement of x (respectively y.


theorem Int.cast_nonneg : ∀ {α : Type u_3} [inst : OrderedRing α] [inst_1 : Nontrivial α] {n : ℤ}, 0 ≤ ↑n ↔ 0 ≤ n := by
  sorry

The theorem `Int.cast_nonneg` states that for any integer `n` and for any ordered ring `α` that is nontrivial (meaning it has at least two distinct elements), the integer `n` is non-negative if and only if the corresponding element in the ring `α` (obtained by casting `n`) is also non-negative. In mathematical terms, this can be expressed as: for any integer `n` and any ordered ring `α`, `0 ≤ n` if and only if `0 ≤ ↑n` in `α`.

For any integer `n` and ordered ring `α`, `0 ≤ n` if and only if `0 ≤ α.cast n`.


theorem CategoryTheory.Limits.coprod.inr_map_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z) {Z_1 : C} (h : Y ⨿ Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.map f g) h) =
        CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr h) :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.inr_map_assoc` states that in any category `C` with binary coproducts, for objects `W`, `X`, `Y`, `Z`, and `Z_1` in `C`, and morphisms `f : W ⟶ Y`, `g : X ⟶ Z`, and `h : Y ⨿ Z ⟶ Z_1`, the composition of the inclusion map from the second component of the coproduct (`coprod.inr`) with the composition of the coproduct map of `f` and `g` with `h` is equal to the composition of `g` with the composition of `coprod.inr` with `h`. In other words, the diagram commutes: if we first include `X` into `X ⨿ Y` using `coprod.inr`, then map `W ⟶ Y` and `X ⟶ Z` to `Y ⨿ Z`, and finally use `h` to map to `Z_1`, this is the same as first mapping `X` to `Z` using `g`, then including into `Y ⨿ Z`, and finally using `h` to map to `Z_1`.

In any category with binary coproducts, the composition of `h` with `coprod.inr` and the coproduct map of `f` and `g`, is equal to the composition of `g` with `coprod.inr` and `h`.


theorem Ordinal.opow_ne_zero : ∀ {a : Ordinal.{u_1}} (b : Ordinal.{u_1}), a ≠ 0 → a ^ b ≠ 0 := by sorry

The theorem `Ordinal.opow_ne_zero` states that for any two ordinals `a` and `b` in the same type `u_1`, if `a` is not equal to zero, then `a` raised to the power `b` (`a ^ b`) is also not equal to zero. Here, `Ordinal` refers to the type of well-ordered sets up to order isomorphism in a certain type. This is a fact about exponentiation in the context of ordinals: a non-zero ordinal raised to any ordinal power is always non-zero.

For any ordinals `a` and `b` in the same type `u_1` with `a` non-zero, `a^b` is also non-zero.


theorem Order.covBy_succ :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [inst_2 : NoMaxOrder α] (a : α), a ⋖ Order.succ a := by
  sorry

This theorem states that for any type `α` that has a preorder (i.e., a relation that is reflexive and transitive), a successor order (i.e., a function that assigns to each element a successor), and no maximal element, every element `a` of this type is covered by its successor. Here, "covered" (`⋖`) means that `a` is less than its successor and there is no element strictly between `a` and its successor.

In a preorder type without maximal elements, every element is covered by its successor.


Specializes.antisymm

theorem Specializes.antisymm :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x ⤳ y → y ⤳ x → Inseparable x y := by sorry

The theorem `Specializes.antisymm` states that for any topological space `X` and any two points `x` and `y` in `X`, if `x` specializes to `y` and `y` specializes to `x`, then `x` and `y` are inseparable. Here, specializing to, denoted `⤳`, is a relation in topology that involves comparing the closure of the singleton sets of the points, and two points are inseparable if they have the same neighborhood system in the topological space, which is equivalent to several other properties as defined by the `Inseparable` predicate.

If two points `x` and `y` in a topological space `X` specialized to each other (`x ⤳ y` and `y ⤳ x`), then `x` and `y` are inseparable in `X`.


/-- **Alias** of the reverse direction of `mem_closure_iff_frequently`. -/
theorem Filter.Frequently.mem_closure :
    ∀ {X : Type u} {x : X} {s : Set X} [inst : TopologicalSpace X], (∃ᶠ (x : X) in nhds x, x ∈ s) → x ∈ closure s := by
  sorry

This theorem states that for any type `X` with a topological space structure, any point `x` in `X`, and any set `s` of `X`, if `x` is frequently in `s` in the neighborhood filter of `x`, then `x` is in the closure of `s`. In other words, if there exists a neighborhood of `x` such that `x` is frequently within the set `s`, then `x` is an element of the smallest closed set containing `s`.

If a point `x` in a topological space `X` belongs to the neighborhood filter of every open set containing a set `s`, then `x` is an element of the closure of `s`.


theorem Directed.finset_le :
    ∀ {α : Type u} {r : α → α → Prop} [inst : IsTrans α r] {ι : Type u_1} [hι : Nonempty ι] {f : ι → α},
      Directed r f → ∀ (s : Finset ι), ∃ z, ∀ i ∈ s, r (f i) (f z) :=
  by sorry

This theorem, `Directed.finset_le`, states that for any type `α`, a relation `r` on `α` which is transitive, a type `ι` that is nonempty, and a function `f` mapping elements of `ι` to `α`, if the function `f` is directed with respect to the relation `r`, then for any finite set `s` of elements of type `ι`, there exists an element `z` such that for every element `i` in the finite set `s`, the relation `r` holds between the image of `i` under `f` and the image of `z` under `f`. In other words, the function `f` has an element `z` that is `r`-above all elements of the finite set `s`.

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


theorem Order.IsSuccLimit.succ_lt :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {a b : α},
      Order.IsSuccLimit b → a < b → Order.succ a < b :=
  by sorry

This theorem, `Order.IsSuccLimit.succ_lt`, states that for any partially ordered set `α` that also has a successor order, given any two elements `a` and `b` of this set, if `b` is a successor limit (meaning there's no element that is less than `b` but not equal to `b`), and `a` is less than `b`, then the successor of `a` is still less than `b`. In simpler terms, even if we move to the next element after `a`, we still haven't reached `b`, given that `b` is a successor limit and `a` is less than `b`.

If `α` is a partially ordered set with a successor order, `a` is an element less than the successor limit `b` in `α`, then `a.succ` is also less than `b`.


theorem Stream'.WSeq.destruct_cons :
    ∀ {α : Type u} (a : α) (s : Stream'.WSeq α),
      Stream'.WSeq.destruct (Stream'.WSeq.cons a s) = Computation.pure (some (a, s)) :=
  by sorry

The theorem `Stream'.WSeq.destruct_cons` states that for any type `α` and any element `a` of type `α` and weak sequence `s` of type `α`, the result of destructing a weak sequence obtained by prepending `a` to `s` is equivalent to the computation that immediately terminates with the result `some (a, s)`. Here, a weak sequence is a possibly infinite sequence that can be partially undefined, and the `destruct` operation is used to deconstruct this sequence into its elements.

For any type `α` and element `a` of type `α`, the destructed result of prepending `a` to a weak sequence `s` is equal to the `some` computation with value `(a, s)`.


theorem Cardinal.mk_le_aleph0_iff : ∀ {α : Type u}, Cardinal.mk α ≤ Cardinal.aleph0 ↔ Countable α := by sorry

This theorem states that for any type `α`, the cardinality of `α` is less than or equal to the smallest infinite cardinal (`ℵ₀`) if and only if `α` is countable. In mathematical terms, it establishes a relationship between the cardinality of a set (or type in Lean's context) and its countability, specifying that a type has cardinality at most `ℵ₀` precisely when it is countable, i.e., there exists an injective function from the type to the natural numbers.

A type `α` has cardinality at most that of the first infinite ordinal (`ℵ₀`) if and only if `α` is countable, i.e., there exists an injective function from `α` to the natural numbers.


NonUnitalStarAlgebra.gc

theorem NonUnitalStarAlgebra.gc :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
      [inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
      [inst_7 : StarModule R A], GaloisConnection (NonUnitalStarAlgebra.adjoin R) SetLike.coe :=
  by sorry

The theorem `NonUnitalStarAlgebra.gc` states that for any commutative semiring `R`, any non-unital semiring `A`, where `R` and `A` are both star rings and `A` is a module over `R` with the scalar multiplication satisfying the commutative law and tower law, and also `A` is a star module over `R`, there exists a Galois Connection between the operation of adjoining `R` to a non-unital star algebra and the operation of converting a `SetLike` object to its corresponding set. In other words, if `adjoin` is the left adjoint (`l` in the definition of Galois Connection) and `SetLike.coe` is the right adjoint (`u` in the definition), then for any `a` from the order `α` and `b` from the order `β`, `l a ≤ b` if and only if `a ≤ u b`, where `≤` denotes the order relation in the corresponding orders.

Given a commutative semiring `R`, a non-unital semiring `A` that is a star ring, a module over `R`, and a star module over `R`, there exists a Galois Connection between the operation of adjoining `R` to `A` and the operation of taking the set of elements of a `SetLike` object over `A`, such that for all `a` in one order and `b` in the other, `a` is less than or equal to `b` in the former if and only if `a` is less than or equal to the image of `b` in the latter.


theorem Ordinal.toPGame_le : ∀ {a b : Ordinal.{u_1}}, a ≤ b → Ordinal.toPGame a ≤ Ordinal.toPGame b := by sorry

The theorem `Ordinal.toPGame_le` states that for any two ordinals `a` and `b`, if `a` is less than or equal to `b`, then the pre-game corresponding to `a` (obtained using the `Ordinal.toPGame` function) is also less than or equal to the pre-game corresponding to `b`. This means that the function `Ordinal.toPGame`, which converts ordinals into pre-games, preserves the order of the ordinals.

For all ordinals `a` and `b`, if `a ≤ b`, then `Ordinal.toPGame a ≤ Ordinal.toPGame b`.


theorem disjoint_disjointed :
    ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (f : ℕ → α), Pairwise (Disjoint on disjointed f) := by sorry

The theorem `disjoint_disjointed` states that for any sequence `f` of elements of type `α` in a generalized boolean algebra, the `disjointed` sequence derived from `f` is pairwise disjoint. Here, a sequence `f` is `disjointed` by subtracting each element from its successors, and two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element of the lattice. This theorem thus asserts that any two distinct elements of the `disjointed` sequence have an infimum of the bottom element, which implies that the elements of the `disjointed` sequence are pairwise disjoint.

In a generalized boolean algebra, any two distinct elements in a sequence obtained by subtracting each element from its successors (i.e., the `disjointed` sequence) have infimum equal to the bottom element, implying they are pairwise disjoint.


Function.HasLeftInverse.injective

theorem Function.HasLeftInverse.injective :
    ∀ {α : Sort u₁} {β : Sort u₂} {f : α → β}, Function.HasLeftInverse f → Function.Injective f := by sorry

This theorem states that for any given function `f` mapping from a type `α` to another type `β`, if `f` has a left inverse (there exists a function that, when composed with `f` from the left, yields the identity function on `α`), then `f` is injective. In the language of mathematics, this means that if `f : α → β` has a function `g : β → α` such that `g ∘ f = id_α`, then `f` is injective (for any `x, y ∈ α`, if `f(x) = f(y)`, then `x = y`).

If a function `f : α → β` has a left inverse, then it is injective (i.e., for all `x, y ∈ α`, if `f(x) = f(y)` then `x = y`).


theorem tsub_add_eq_tsub_tsub :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst : OrderedSub α]
      (a b c : α), a - (b + c) = a - b - c :=
  by sorry

This theorem states that for any set `α` of elements that is a partially ordered set, an additive commutative semigroup, and has a subtraction operation that respects the order, the subtraction of the sum `(b + c)` from `a` is equivalent to the subtraction of `c` from the result of subtracting `b` from `a`. In mathematical terms, this theorem states that `a - (b + c) = a - b - c` for all elements `a`, `b`, and `c` in `α`.

For any additive commutative semigroup `α` with a subtraction operation respecting the order, the subtraction of `c` from `a - b` equals `a - (b + c)`.


theorem CategoryTheory.BraidedCategory.braiding_tensor_left :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      [inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : C),
      (β_ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z).hom =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X (β_ Y Z).hom)
            (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Z Y).inv
              (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (β_ X Z).hom Y)
                (CategoryTheory.MonoidalCategory.associator Z X Y).hom))) :=
  by sorry

This theorem is part of the Category Theory and it states that, for any braided monoidal category `C` and any three objects `X`, `Y`, and `Z` in `C`, the braiding morphism from the tensor product of `X` and `Y` with `Z` to `Z` tensor `X` tensor `Y` is equal to the composition of several other morphisms.

Specifically, the composition starts with the associator from `X` tensor `Y` tensor `Z` to `X` tensor `(Y tensor Z)`, then applies the braiding morphism from `Y` tensor `Z` to `Z` tensor `Y` (which is 'whiskered' with `X`), reverses the associator from `X` tensor `Z` tensor `Y` to `(X tensor Z) tensor Y`, applies the braiding morphism from `X` tensor `Z` to `Z` tensor `X` (which is 'whiskered' with `Y`), and finally applies the associator from `Z` tensor `X` tensor `Y` to `(Z tensor X) tensor Y`.

In mathematical terms, this means that the braiding operation is compatible with the tensor product and the associativity of the category, making it a key property of the structure of braided monoidal categories.

In a braided monoidal category, the braiding morphism between any three objects is equal to the composition of the associator and the braiding morphisms in reverse order, followed by the reversed associator.


PartialHomeomorph.EqOnSource.symm'

/-- If two partial homeomorphisms are equivalent, so are their inverses.  -/
theorem PartialHomeomorph.EqOnSource.symm' :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e e' : PartialHomeomorph X Y}, e ≈ e' → PartialHomeomorph.symm e ≈ PartialHomeomorph.symm e' :=
  by sorry

The theorem `PartialHomeomorph.EqOnSource.symm'` states the following: for any two types `X` and `Y` equipped with topological space structures, and any two partial homeomorphisms `e` and `e'` between `X` and `Y`, if `e` is equivalent to `e'`, then the inverse of `e` is equivalent to the inverse of `e'`. In other words, the equivalence of two partial homeomorphisms implies the equivalence of their inverses.

If partial homeomorphisms `e` and `e'` between topological spaces `X` and `Y` are equivalent, then their inverses are equivalent.


theorem Real.toNNReal_eq_zero : ∀ {r : ℝ}, Real.toNNReal r = 0 ↔ r ≤ 0 := by sorry

This theorem states that for every real number `r`, the function `Real.toNNReal` applied to `r` equals 0 if and only if `r` is less than or equal to 0. In other words, it asserts that `Real.toNNReal`, which converts a real number to a non-negative real number by returning `0` if the input is less than `0`, yields `0` precisely when the input real number is non-positive.

For every real number `r`, `Real.toNNReal r = 0 <--> r <= 0`.


theorem WithZero.coe_le_coe : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, ↑a ≤ ↑b ↔ a ≤ b := by sorry

This theorem states that for any type `α` with a preorder (a mathematical structure where all elements are comparable), the order of two elements `a` and `b` of type `α` remains the same when they are lifted (i.e., ↑ denotes lifting) into the `WithZero` type (which adds a zero element to the type `α` if it doesn't already exist). In other words, `a` is less than or equal to `b` in the original type if and only if `a` is less than or equal to `b` in the `WithZero` type.

For any type `α` with a preorder and any elements `a` and `b` of type `α`, `a ≤ b` if and only if `↑a ≤ ↑b` in the `WithZero` type extension of `α`.


theorem Hyperreal.infinitePos_iff_infinitesimal_inv_pos :
    ∀ {x : ℝ*}, Hyperreal.InfinitePos x ↔ Hyperreal.Infinitesimal x⁻¹ ∧ 0 < x⁻¹ := by sorry

This theorem states that for any hyperreal number 'x', 'x' is infinitely positive if and only if the inverse of 'x' is infinitesimal and is greater than zero. In simpler terms, a hyperreal number is larger than all real numbers if only its reciprocal is infinitesimally small (closer to zero) and is positive.

A hyperreal number is infinitely positive if and only if its reciprocal is an infinitesimal and is positive.


theorem Nat.gcd_mul_right : ∀ (m n k : ℕ), Nat.gcd (m * n) (k * n) = Nat.gcd m k * n := by sorry

This theorem states that for any three natural numbers `m`, `n`, and `k`, the greatest common divisor (gcd) of the product of `m` and `n`, and the product of `k` and `n`, is equal to the product of the gcd of `m` and `k`, and `n`. That means, in mathematical terms, we have $\gcd(mn, kn) = \gcd(m, k) \cdot n$ for all natural numbers `m`, `n`, `k`.

The theorem asserts that the greatest common divisor of the products of two natural numbers with a common factor is equal to the product of their greatest common divisor and the common factor. In other words, $\gcd(mn, kn) = \gcd(m, k) \cdot n$.


theorem Complex.arg_mul_cos_add_sin_mul_I :
    ∀ {r : ℝ},
      0 < r →
        ∀ {θ : ℝ},
          θ ∈ Set.Ioc (-Real.pi) Real.pi → Complex.arg (↑r * (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I)) = θ :=
  by sorry

This theorem states that for any real number `r` that is greater than zero and any real number `θ` that lies in the open-closed interval from `-π` to `π`, the argument of the complex number obtained by multiplying `r` with the sum of `cos(θ)` and `sin(θ)` times the imaginary unit `I` is equal to `θ`. In other words, it proves that the formula for converting from polar to rectangular coordinates in complex number theory holds true.

For any real number `r > 0` and `θ` in `(-π, π]`, the argument of `r * (cos(θ) + sin(θ) * I)` equals `θ` in complex numbers.


/-- Assumes left covariance.
The lemma assuming right covariance is `Right.add_pos_of_pos_of_nonneg`. -/
theorem Left.add_pos_of_pos_of_nonneg :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}, 0 < a → 0 ≤ b → 0 < a + b :=
  by sorry

This theorem, `Left.add_pos_of_pos_of_nonneg`, assumes left covariance. Given a type `α` that has an addition operation, an order operation, and satisfies the covariance property, the theorem states that for any elements `a` and `b` of this type, if `a` is positive (i.e., `0 < a`) and `b` is nonnegative (i.e., `0 ≤ b`), then the sum of `a` and `b` is also positive (i.e., `0 < a + b`). Note that this theorem assumes left covariance, and a corresponding lemma for the case of right covariance is `Right.add_pos_of_pos_of_nonneg`.

If `α` is an additive type with a total order such that `0 < a` and `0 ≤ b`, then `0 < a + b`. (Assumes left covariance.)


theorem Algebra.top_toSubmodule :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
      Subalgebra.toSubmodule ⊤ = ⊤ :=
  by sorry

This theorem states that, for any commutative semiring `R` and any semiring `A` with a given algebra structure, the top `Subalgebra` of `A` over `R`, when mapped through the forgetful function `Subalgebra.toSubmodule`, gives the top `Submodule` of `A` over `R`. In other words, the largest subalgebra (the whole algebra) corresponds to the largest submodule under the forgetful map from `Subalgebra` to `Submodule`.

The top subalgebra of an algebra over a commutative semiring, when mapped through the forgetful function to submodules, equals the top submodule.


theorem MeasureTheory.Measure.WeaklyRegular.innerRegular_measurable :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] {μ : MeasureTheory.Measure α}
      [inst_2 : MeasureTheory.Measure.WeaklyRegular μ],
      MeasureTheory.Measure.InnerRegularWRT μ IsClosed fun s => MeasurableSet s ∧ ↑↑μ s ≠ ⊤ :=
  by sorry

This theorem states that for any measurable and topological space `α` and any weakly regular measure `μ` on `α`, `μ` is inner regular with respect to closed sets and sets which are measurable and not of infinite measure. In other words, for any set `U` which is measurable and not of infinite measure, and any real number `r` less than the measure of `U`, there exists a closed subset `K` of `U` such that the measure of `K` is greater than `r`. This is a property of weakly regular measures and is useful in several proofs about properties of measures.

For any measurable and weakly regular measure `μ` on a measurable space `α`, and for any measurable set `U` of finite measure, there exists a closed subset `K` of `U` such that `μ(K) > μ(U) - r` for any real number `r` with `0 < r < μ(U)`.


/-- **Alias** of `sub_add_cancel_right`. -/
theorem sub_add_cancel'' : ∀ {G : Type u_3} [inst : AddGroup G] (a b : G), a - (b + a) = -b := by sorry

This theorem, `sub_add_cancel''`, states that for any type `G` that forms an additive group, for any elements `a` and `b` of `G`, subtracting `b + a` from `a` results in `-b`. In mathematical terms, this can be denoted as `a - (b + a) = -b` for any `a, b` in `G`. Essentially, it's an alias for the theorem `sub_add_cancel_right` and it describes one of the properties of subtraction in additive groups.

For any additive group `G` and elements `a, b` in `G`, `a - (b + a) = -b`.


theorem Asymptotics.isBigO_self_const_mul' :
    ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] {c : R},
      IsUnit c → ∀ (f : α → R) (l : Filter α), f =O[l] fun x => c * f x :=
  by sorry

This theorem states that for any type `α`, any seminormed ring `R`, any element `c` of `R` that is a unit (i.e., has a multiplicative inverse), any function `f` from `α` to `R`, and for any filter `l` on `α`, `f` is "big O" of `c * f` at the filter `l`. In terms of asymptotic analysis, this means that `f` grows no faster than `c * f` under the filter `l`, considering `c` as a constant factor.

For any type `α`, any seminormed ring `R` with unit `c`, and any function `f` from `α` to `R`, if `l` is a filter on `α`, then `f` is big O of `c * f` at `l`.


theorem mul_eq_mul_right_iff :
    ∀ {M₀ : Type u_2} [inst : CancelMonoidWithZero M₀] {a b c : M₀}, a * c = b * c ↔ a = b ∨ c = 0 := by sorry

This theorem states that, for a given type `M₀` which is a CancelMonoidWithZero, and for any three elements `a`, `b`, and `c` of this type, the equality `a * c` equals `b * c` is equivalent to `a` equals `b` or `c` equals zero. In other words, if the product of `a` and `c` equals the product of `b` and `c`, then either `a` is equal to `b`, or `c` is zero.

For any CancelMonoidWithZero type `M₀` and elements `a`, `b`, and `c` in `M₀`, `a * c = b * c` implies `a = b` or `c = 0`.


theorem UniqueFactorizationMonoid.irreducible_of_normalized_factor :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
      [inst_2 : UniqueFactorizationMonoid α] {a : α},
      ∀ x ∈ UniqueFactorizationMonoid.normalizedFactors a, Irreducible x :=
  by sorry

This theorem states that for any type `α` that has the structure of a `CancelCommMonoidWithZero`, a `NormalizationMonoid`, and a `UniqueFactorizationMonoid`, and for any element `a` of that type `α`, every element `x` in the multiset of normalized factors of `a` is irreducible. In mathematical terms, this corresponds to the fact that in any unique factorization domain, the prime factors of an element (after being normalized) are irreducible.

In a type `α` equipped with the structures of a `CancelCommMonoidWithZero`, a `NormalizationMonoid`, and a `UniqueFactorizationMonoid`, every normalized factor of any element `a` is irreducible.


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

The theorem `PartialHomeomorph.symm_symm` asserts that for any Partial Homeomorphism `e` from a topological space `X` to another topological space `Y`, applying the `symm` operation twice (taking the inverse of the inverse) returns the original Partial Homeomorphism `e`. This essentially states that taking the inverse of the inverse of a Partial Homeomorphism is an identity operation.

For any Partial Homeomorphism `e` from topological space `X` to `Y`, `e.symm.symm = e`.


theorem le_partialSups : ∀ {α : Type u_1} [inst : SemilatticeSup α] (f : ℕ → α), f ≤ ⇑(partialSups f) := by sorry

The theorem `le_partialSups` states that for any type `α` which forms a semilattice with a supremum operation and any sequence `f` of elements of type `α` indexed by natural numbers, the element `f(n)` of the sequence is less than or equal to the `n`-th element of the sequence of partial supremums of `f`. In other words, for each natural number `n`, the `n`-th element of `f` is less than or equal to the supremum of the `f(m)` for `m ≤ n`.

For any semilattice `α` with supremum operation and sequence `f` of elements from `α` indexed by natural numbers, `f(n) ≤ sup {f(m) | m ≤ n}` for all natural numbers `n`.


theorem Matrix.diagonal_zero :
    ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α], (Matrix.diagonal fun x => 0) = 0 := by sorry

The theorem `Matrix.diagonal_zero` states that for any type `n` and any type `α` which has an instance of `DecidableEq` for `n` and `Zero` for `α`, the diagonal matrix constructed by mapping all elements of `n` to zero is equal to the zero matrix. In other words, if we create a square matrix such that the diagonal elements are all zeros (and off-diagonal elements are also zeros because of the `Matrix.diagonal` definition), then this matrix is precisely the zero matrix.

For any square matrix constructed by mapping all its diagonal elements to zero and assuming `n` has a decidable equality and `α` has a zero instance, this matrix is equal to the zero matrix.


theorem MeasureTheory.MeasurePreserving.integral_comp :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} {β : Type u_7} {x : MeasurableSpace β} {f : α → β} {ν : MeasureTheory.Measure β},
      MeasureTheory.MeasurePreserving f μ ν →
        MeasurableEmbedding f → ∀ (g : β → G), ∫ (x : α), g (f x) ∂μ = ∫ (y : β), g y ∂ν :=
  by sorry

The theorem states that for any two types `α` and `β`, a normed additively commutative group `G`, a normed space over the real numbers `ℝ` and `G`, and a measurable space `m` associated with `α`. Given a measure `μ` on `α`, another measurable space `x` associated with `β`, a function `f` from `α` to `β`, and a measure `ν` on `β`, if the function `f` preserves measure from `μ` to `ν` and is a measurable embedding, then for any function `g` from `β` to `G`, the integral of `g` composed with `f` with respect to `μ` is equivalent to the integral of `g` with respect to `ν`. In mathematical notation, this is expressed as: if `f` is a measure-preserving measurable embedding, then `∫ g(f(x)) dμ = ∫ g(y) dν`.

If `f: α → β` is a measure-preserving measurable embedding between measurable spaces `(α, μ)` and `(β, ν)`, and `g: β → G` is a function from `β` to a normed additively commutative group `G`, then the integral of `g ∘ f` with respect to `μ` is equal to the integral of `g` with respect to `ν`.


theorem ciSup_of_empty :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] [inst_1 : IsEmpty ι] (f : ι → α),
      ⨆ i, f i = ⊥ :=
  by sorry

This theorem states that for any given type `α` that has a conditionally complete linear order with a least element, and an empty type `ι`, any function `f` from `ι` to `α` will have its supremum equal to the least element of `α` (denoted by `⊥`). Essentially, if we're trying to find the supremum of an empty set in a conditionally complete ordered set, the result is the least element of the set.

For any conditionally complete linearly ordered type `α` with a least element `⊥`, the supremum of the empty function domain is equal to `⊥`.


theorem isCoatomic_dual_iff_isAtomic :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α], IsCoatomic αᵒᵈ ↔ IsAtomic α := by sorry

This theorem states that for any type `α` with a partial order and a bottom element, `α` is coatomic in the dual order if and only if `α` is atomic. In mathematical terms, a poset (partially ordered set) is said to be atomic if every element greater than the bottom element is the least upper bound of some set of atomic elements. Similarly, a poset is coatomic if every element less than the top element is the greatest lower bound of some set of coatomic elements. The dual order is the inverse of the original order.

A type `α` with a partial order and a bottom element is coatomic in the dual order if and only if it is atomic.


theorem Mathlib.Data.Set.Basic._auxLemma.83 : ∀ {α : Type u} {s : Set α}, (sᶜ = Set.univ) = (s = ∅) := by sorry

The theorem `Mathlib.Data.Set.Basic._auxLemma.83` states that for any type `α` and any set `s` of this type, the complement of `s` is equal to the universal set if and only if `s` itself is the empty set. Here, `Set.univ` stands for the universal set (i.e., the set containing all elements of the type `α`), `sᶜ` represents the complement of a set `s`, and `∅` represents the empty set. The theorem basically emphasizes the set theory principle that the complement of an empty set is the universal set, and vice versa.

For any type α, the complement of an empty set is the universal set, and the empty set is the complement of the universal set.


theorem Mathlib.Data.Set.Basic._auxLemma.22 : ∀ {α : Type u} {s t u : Set α}, (s ∪ t ⊆ u) = (s ⊆ u ∧ t ⊆ u) := by sorry

The theorem states that for any type `α` and any three sets `s`, `t`, and `u` of type `α`, the union of `s` and `t` is a subset of `u` if and only if both `s` and `t` are subsets of `u`. In other words, all elements of `s` and `t` are in `u` if and only if every element of `s` is in `u` and every element of `t` is in `u`. This theorem captures a fundamental property of set theory.

For any set `α` and sets `s`, `t`, and `u` of type `α`, `s ∪ t ⊆ u` if and only if `s ⊆ u` and `t ⊆ u`.


theorem Mathlib.Data.Set.Basic._auxLemma.30 : ∀ {α : Type u} {s t : Set α}, (s ∩ t = t) = (t ⊆ s) := by sorry

This theorem states that for any two sets `s` and `t` of a certain type `α`, the intersection of `s` and `t` being equal to `t` is equivalent to `t` being a subset of `s`. In other words, `t` is a subset of `s` if and only if every element in `t` also belongs to `s`, resulting in the intersection of `s` and `t` to be `t` itself.

For sets `s` and `t` of type `α`, `s` contains `t`, i.e., `t ⊆ s`, if and only if the intersection of `s` and `t` equals `t`, i.e., `s ∩ t = t`.


theorem div_neg_eq_neg_div :
    ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] (a b : K), b / -a = -(b / a) := by sorry

This theorem states that for any division monoid `K` that also supports negation, and for any two elements `a` and `b` in `K`, the result of dividing `b` by `-a` is the same as the negative of dividing `b` by `a`. In mathematical notation, it says that for all `a` and `b` in `K`, `b / -a = -(b / a)`.

For any division monoid `K` with negation, the quotient of an element by its additive inverse equals the additive inverse of the quotient: `b / -a = -(b / a)`.


theorem Ideal.map_comap_of_surjective :
    ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] (f : F), Function.Surjective ⇑f → ∀ (I : Ideal S), Ideal.map f (Ideal.comap f I) = I :=
  by sorry

The theorem `Ideal.map_comap_of_surjective` states that for any semirings `R` and `S`, and for any function `f` of type `F` that behaves like a function from `R` to `S` and is a ring homomorphism, if `f` is also surjective, then for any ideal `I` in `S`, the ideal obtained by first mapping `I` under `f` and then taking the preimage (or comap) of `f` is the same as the original ideal `I`. In other words, for a surjective ring homomorphism, mapping and then comapping an ideal results in the original ideal.

For any surjective ring homomorphism `f` between semirings `R` and `S`, the ideal `f''(I)` obtained by mapping an ideal `I` in `S` under `f` and then taking the preimage under `f` is equal to `I`.


/-- **Alias** of the forward direction of `measurable_iff_comap_le`. -/
theorem Measurable.comap_le :
    ∀ {α : Type u_1} {β : Type u_2} {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β},
      Measurable f → MeasurableSpace.comap f m₂ ≤ m₁ :=
  by sorry

The theorem `Measurable.comap_le` states that for any types `α` and `β`, and for any measurable spaces `m₁` of type `α` and `m₂` of type `β`, and for any function `f` from `α` to `β`, if `f` is a measurable function, then the measurable space obtained by taking the reverse image of `m₂` under `f` (i.e., `MeasurableSpace.comap f m₂`) is a sub-measurable space of `m₁`. This essentially implies that the preimages of the measurable sets in `m₂` under `f` are also measurable sets in `m₁`.

If `f` is a measurable function from the measurable space `(α, m₁)` to the measurable space `(β, m₂)`, then `MeasurableSpace.comap f m₂` is a sub-measurable space of `m₁`.


/-- Polynomial evaluation commutes with `Finset.prod`
 -/
theorem Polynomial.eval_prod :
    ∀ {R : Type u} [inst : CommSemiring R] {ι : Type u_1} (s : Finset ι) (p : ι → Polynomial R) (x : R),
      Polynomial.eval x (Finset.prod s fun j => p j) = Finset.prod s fun j => Polynomial.eval x (p j) :=
  by sorry

The theorem `Polynomial.eval_prod` states that for any commutative semiring `R`, any finite set `s` of a certain type `ι`, any function `p` from `ι` to polynomials over `R`, and any element `x` from `R`, evaluating `x` on the product of the polynomials `p j` for each `j` in `s` is the same as the product of the evaluations of `x` on each individual polynomial `p j`. In other words, polynomial evaluation at a point `x` commutes with the operation of taking the product over a finite set of polynomials.

For any commutative semiring R, finite set ι, function p from ι to polynomials over R, and element x in R, the evaluation of the product of polynomials p j for j in ι at x is equal to the product of the evaluations of x at each polynomial p j.