theorem gc_nhds : ∀ {α : Type u} (a : α), GaloisConnection (nhdsAdjoint a) fun t => nhds a := by sorry

The theorem `gc_nhds` states that for any type `α` and any element `a` of that type, there exists a Galois connection between the function `nhdsAdjoint a` and the function `t => nhds a`. In other words, for every `a` in `α`, the function which assigns a topological space to each filter on `α` using `nhdsAdjoint a`, and the function which sends each topological space to the neighborhood filter at `a`, satisfy the properties of a Galois connection. In terms of order theory, this means that for all filters and topological spaces in their respective orders, the value of `nhdsAdjoint a` on a filter is less than or equal to a topological space if and only if the filter is less than or equal to the value of `nhds a` on the topological space.

For every type `α` and element `a` in `α`, the functions `nhdsAdjoint a` and `nhds a` form a Galois connection between filters on `α` and topological spaces over `α`.


theorem div_eq_zero_iff : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, a / b = 0 ↔ a = 0 ∨ b = 0 := by sorry

This theorem states that for any type `G₀` equipped with a group with zero structure (denoted `[inst : GroupWithZero G₀]`), and any elements `a` and `b` of this type, the fraction `a / b` is equal to zero if and only if `a` is equal to zero or `b` is equal to zero. In terms of mathematics, it reads: For any elements `a` and `b` in a group with zero, the statement "the division of `a` by `b` is zero" is equivalent to the statement "either `a` is zero or `b` is zero".

In a group with zero, the division of two elements is zero if and only if one of them is zero.


theorem PrimeSpectrum.vanishingIdeal_zeroLocus_eq_radical :
    ∀ {R : Type u} [inst : CommSemiring R] (I : Ideal R),
      PrimeSpectrum.vanishingIdeal (PrimeSpectrum.zeroLocus ↑I) = Ideal.radical I :=
  by sorry

The theorem `PrimeSpectrum.vanishingIdeal_zeroLocus_eq_radical` states that for any commutative semiring `R` and any ideal `I` of `R`, the vanishing ideal of the zero locus of `I` is equal to the radical of `I`. In other words, the ideals consisting of all elements that vanish on the set of prime ideals where `I` becomes zero, is the same as the ideal formed by those elements in `I` whose some power belongs to `I`.

The theorem asserts that for any commutative semiring `R` and ideal `I`, the vanishing ideal of `I`'s zero locus equals the radical of `I`.


theorem Fin.val_mk : ∀ {m n : ℕ} (h : m < n), ↑{ val := m, isLt := h } = m := by sorry

This theorem, `Fin.val_mk`, states that for any two natural numbers `m` and `n` where `m` is less than `n`, the value of a `Fin n` instance created with `m` as the value and a proof `h` of `m < n` is equal to `m`. In other words, it's ensuring that the `val` field of a `Fin` object correctly reflects the value that was used to construct the object.

For all natural numbers `m` and `n` with `m < n`, the value of a `Fin n` instance created with `m` is equal to `m`.


/-- A subset of a monoid is contained in the submonoid it generates.  -/
theorem Monoid.subset_closure : ∀ {M : Type u_1} [inst : Monoid M] {s : Set M}, s ⊆ Monoid.Closure s := by sorry

This theorem states that for any given monoid `M` and a subset `s` of this monoid, the subset `s` is contained within the submonoid generated by `s` itself. In other words, every element in the subset `s` also belongs to the submonoid created by taking the closure of `s` under the monoid operations. This property holds true for all monoids and their subsets.

For any monoid M and subset s of M, s is contained in the submonoid generated by s.


theorem Mathlib.Data.Int.Basic._auxLemma.2 : ∀ {R : Type u_1} [inst : Ring R] (n : ℤ) (m : ℕ), ↑n ^ m = ↑(n ^ m) := by
  sorry

This theorem states that for any type `R` that forms a Ring, for an integer `n` and a natural number `m`, the `m`-th power of the coerced `n` in `R` is the same as the coerced `m`-th power of `n`. This essentially shows the compatibility of power operation with type coercion from integers to any ring.

For any ring `R` and integers `n` and `m`, the power `n^m` in `R` of the coerced integer `n` is equal to the coerced `m`-th power of the integer `n`. In mathematical notation: `(coe (n : R) : R)^m = coe (n^m : int)`.


theorem Mathlib.Data.Fin.Basic._auxLemma.11 : ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) := by sorry

This theorem, `Mathlib.Data.Fin.Basic._auxLemma.11`, states that for any natural number `n` and any two elements `a` and `b` of the finite set of size `n` (denoted as `Fin n` in Lean), the equality of `a` and `b` is equivalent to the equality of their respective "coerced" or "promoted" values. In Lean, the `↑` symbol is used to denote the coercion of a term from one type to another, so `↑a` and `↑b` are the natural number representations of `a` and `b` respectively.

For any natural number `n` and elements `a` and `b` in `Fin n`, the equality of `a` and `b` is equivalent to the equality of their coerced natural number representations, i.e., `↑a = ↑b`.


theorem inf_left_comm : ∀ {α : Type u} [inst : SemilatticeInf α] (a b c : α), a ⊓ (b ⊓ c) = b ⊓ (a ⊓ c) := by sorry

This is a theorem about the infimum (greatest lower bound) operation in semilattices. For any semilattice of type α and for any three elements a, b, and c of this semilattice, the infimum of a and the infimum of b and c is the same as the infimum of b and the infimum of a and c. In mathematical terms, this can be written as $a \wedge (b \wedge c) = b \wedge (a \wedge c)$. This theorem thus expresses a property of left-commutativity for the infimum operation in any semilattice.

In any semilattice, the infimum of a and the infimum of b commute, that is, $a \wedge (b \wedge c) = b \wedge (a \wedge c)$.


theorem Real.rpow_def_of_nonneg :
    ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), x ^ y = if x = 0 then if y = 0 then 1 else 0 else Real.exp (Real.log x * y) := by
  sorry

This theorem provides a definition for raising a non-negative real number `x` to any real power `y`. It states that for every real number `x` that is greater than or equal to 0, and any real number `y`, `x` raised to the power `y` equals to the exponential of the real logarithm of `x` multiplied by `y`, unless `x` equals to 0. If `x` is 0, then the result will be 1 if `y` is also 0, and 0 for any other value of `y`.

For non-negative real numbers `x` and `y`, `x^y` equals `exp(y * log(x))` if `x` is not 0, and equals 1 if both `x` and `y` are 0.


theorem Set.piecewise_preimage :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) [inst : (j : α) → Decidable (j ∈ s)] (f g : α → β) (t : Set β),
      Set.piecewise s f g ⁻¹' t = Set.ite s (f ⁻¹' t) (g ⁻¹' t) :=
  by sorry

The theorem `Set.piecewise_preimage` states that for any sets `s` of type `α` and `t` of type `β`, and any functions `f` and `g` from `α` to `β`, the preimage of `t` under the piecewise function defined by `s`, `f`, and `g` is the "if-then-else" combination of the preimages of `t` under `f` and `g`, respectively. Specifically, this means that each element in the domain that is mapped into `t` by the piecewise function comes either from `s` and is mapped there by `f`, or from the complement of `s` and is mapped there by `g`.

For sets $S \subseteq \alpha$ and $T \subseteq \beta$, and functions $f, g : \alpha \to \beta$, the preimage of $T$ under the piecewise function $x \mapsto if h x \in S then f x else g x$ is $f^{-1}(T) \cup g^{-1}(T)$, where $h : \alpha \to \texttt{Prop}$ is any decidable relation such that $x \in S$ if and only if $h x$.


theorem CategoryTheory.Equivalence.invFunIdAssoc_hom_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (e : C ≌ D) (F : CategoryTheory.Functor D E) (X : D),
      (CategoryTheory.Equivalence.invFunIdAssoc e F).hom.app X = F.map (e.counit.app X) :=
  by sorry

This theorem is about category theory and deals with the concept of functors and equivalence between categories. Specifically, for any categories `C`, `D`, and `E`, and for any equivalence `e` between `C` and `D`, and any functor `F` from `D` to `E`, and any object `X` in `D`, the application of the homomorphism of the functor obtained by associating the inverse of the functor `F` with the identity functor on the equivalence `e` to the object `X` is equal to the mapping of the counit of the equivalence `e` at `X` under the functor `F`. This theorem establishes a relationship between the operations of the functor and the equivalence in the context of category theory.

For any categories `C`, `D`, `E`, equivalence `e` between `C` and `D`, functor `F` from `D` to `E`, and object `X` in `D`, the application of the right adjoint of `F` along `e` to `X` is equal to the composition of `F` with the inverse of the counit of `e` at `X`.


theorem Monotone.le_map_iSup :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] {s : ι → α} [inst_1 : CompleteLattice β]
      {f : α → β}, Monotone f → ⨆ i, f (s i) ≤ f (iSup s) :=
  by sorry

This theorem states that for any complete lattices `α` and `β`, any mapping `s` from some sort `ι` to `α`, and any function `f` from `α` to `β`, if `f` is monotone (that is, `f` preserves the ordering, i.e., if `a ≤ b`, then `f(a) ≤ f(b)`), then the supremum (indexed by `ι`) of the function `f` applied to `s` is less than or equal to the function `f` applied to the supremum of `s`. In other words, the supremum of the image under `f` is less than or equal to the image of the supremum under `f` as long as `f` is a monotone function.

For any complete lattices α and β, any map s from sort ι to α, and monotone function f from α to β, the supremum of f(s) is less than or equal to f(sup s).


theorem Finset.insert_subset_iff :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t := by sorry

The theorem `Finset.insert_subset_iff` states that for any given type `α`, where `α` has a decidable equality relation, and for any given finite sets `s` and `t` of type `α`, along with an element `a` of type `α`, the insertion of `a` into `s` is a subset of `t` if and only if `a` is an element of `t` and `s` is a subset of `t`. In other words, it says that the action of inserting an element into a set and then testing for subset inclusion is equivalent to checking if the element is in the target set and the original set is a subset of the target set.

For any type `α` with decidable equality and finite sets `s`, `t` of `α` and element `a` of `α`, `a ∈ t` and `s ⊆ t` are equivalent.


theorem List.foldlM_cons :
    ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (b : β) (a : α)
      (l : List α),
      List.foldlM f b (a :: l) = do
        let init ← f b a
        List.foldlM f init l :=
  by sorry

The theorem `List.foldlM_cons` states that for any monad `m`, any types `β` and `α`, any function `f : β → α → m β`, any initial value `b : β`, any value `a : α`, and any list `l : List α`, applying the monadic fold operation `List.foldlM` on the list that has `a` at its head and `l` as its tail, with `f` as the folding function and `b` as the initial accumulator, is equivalent to applying the function `f` on `b` and `a` to get a new initial value, and then applying `List.foldlM` on the rest of the list `l` with this new initial value. This is a generalization of the property of associativity of reduce/fold operations to the context of monadic operations.

For any monad `m`, any types `β` and `α`, and any function `f : β → α → m β`, the monadic fold operation `List.foldlM` of a list `l : List α` with `f` as the folding function, `b : β` as the initial accumulator, and `a : α` as the head of the list, is equivalent to applying `f` to `b` and `a` to get a new initial value, and then performing the monadic fold operation on the remaining list `l` with the new initial value.


theorem UFModel.Models.parent_eq :
    ∀ {α : Type u_1} {arr : Array (UFNode α)} {n : ℕ} {m : UFModel n},
      UFModel.Models arr m →
        ∀ (i : ℕ) (h₁ : i < Array.size arr) (h₂ : i < n), arr[i].parent = ↑(m.parent { val := i, isLt := h₂ }) :=
  by sorry

The theorem `UFModel.Models.parent_eq` states that for any type `α`, any array `arr` of `UFNode α`, any natural number `n`, and any `UFModel n` `m`, if `arr` models `m`, then for any natural number `i` such that `i` is less than the size of the array `arr` and `i` is less than `n`, the parent of the `i`-th element of `arr` is equal to the parent of the `i`-th element of `m`. This theorem essentially says that when a `UFModel` is modeled by an array of `UFNode`, the parent relationships within the array and the model are consistent.

For any array `arr` of `UFNode` modeling `UFModel` `m`, and for all `i` less than the size of `arr` and `n`, the parent of the `i`-th element in `arr` equals the parent of the `i`-th element in `m`.


theorem Module.Free.of_equiv :
    ∀ {R : Type u} {M : Type v} {N : Type z} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      [inst_3 : Module.Free R M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N], (M ≃ₗ[R] N) → Module.Free R N :=
  by sorry

The theorem `Module.Free.of_equiv` states that for any semiring `R` and any two types `M` and `N` that have the structure of an `R`-module, if `M` is a free `R`-module and there is a linear equivalence (a bijective, linear map) between `M` and `N`, then `N` is also a free `R`-module. This means that the property of being a free module is preserved under linear equivalences.

If `M` and `N` are `R`-modules with `M` free and there exists a linear equivalence between them, then `N` is also a free `R`-module.


theorem Set.preimage_neg_Iio : ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a : α), -Set.Iio a = Set.Ioi (-a) := by
  sorry

This theorem states that for any type `α` that forms an Ordered Additive Commutative Group, the preimage of the left-infinite, right-open interval under negation, `-Set.Iio a`, is equal to the left-open right-infinite interval at `-a`, `Set.Ioi (-a)`. In other words, if you take all elements less than a certain value `a` in this ordered group, negate them, you will get a set of all elements greater than `-a`.

For any Ordered Additive Commutative Group `α`, the set of all elements negated from elements in the left-open right-infinite interval `Set.Ioi (-a)` is equal to the preimage of the left-infinite, right-open interval `-Set.Iio a` under negation.


theorem Algebra.discr_def :
    ∀ (A : Type u) {B : Type v} {ι : Type w} [inst : DecidableEq ι] [inst_1 : CommRing A] [inst_2 : CommRing B]
      [inst_3 : Algebra A B] [inst_4 : Fintype ι] (b : ι → B),
      Algebra.discr A b = Matrix.det (Algebra.traceMatrix A b) :=
  by sorry

The theorem `Algebra.discr_def` asserts that for any type `A`, with types `B` and `ι`, where `A` and `B` are commutative rings, `A` is an algebra over `B` and `ι` is a finite type, and a function `b` from `ι` to `B`, the discriminator of `A` with respect to `b` is equal to the determinant of the trace matrix of `A` with respect to `b`. In mathematical terms, the discriminator is determined by the determinant of the trace matrix, where the `(i, j)`-th element of the trace matrix is given by the trace of the product of the `i`-th and `j`-th elements of the `ι`-indexed family of elements of `B`.

For any commutative rings A with types B and ι, where A is an algebra over B and ι is a finite type, the discriminator of A with respect to a function b from ι to B equals the determinant of the matrix whose (i, j)-th element is the trace of the product of the i-th and j-th elements of the ι-indexed family in B.


theorem Ideal.IsPrime.mul_le :
    ∀ {R : Type u} [inst : CommSemiring R] {I J P : Ideal R}, Ideal.IsPrime P → (I * J ≤ P ↔ I ≤ P ∨ J ≤ P) := by sorry

This theorem, "Ideal.IsPrime.mul_le", states that for any commutative semiring `R`, and for any ideals `I`, `J`, and `P` of `R`, if `P` is a prime ideal, then the product of `I` and `J` is contained in `P` if and only if either `I` is contained in `P` or `J` is contained in `P`. This is a formalization of the algebraic property that characterizes prime ideals in the context of ring theory.

In a commutative semiring, if ideal `P` is prime, then `I J ⊆ P` if and only if `I ⊆ P` or `J ⊆ P`.


theorem edist_eq_coe_nnnorm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] (x : E), edist x 0 = ↑‖x‖₊ := by sorry

This theorem states that for any seminormed add group `E` and any element `x` in `E`, the extended distance (`edist`) between `x` and the zero element is equal to the non-negative real number equivalent (`↑‖x‖₊`) of the norm of `x`. In other words, in a seminormed add group, the distance from any point to the origin is precisely the norm of that point.

For any seminormed add group `E` and its element `x`, the extended distance from `x` to the zero element equals the norm of `x`. (edist x 0 = ‖x‖₊)


theorem ZMod.nat_cast_mod : ∀ (a n : ℕ), ↑(a % n) = ↑a := by sorry

This theorem states that for any two natural numbers `a` and `n`, the natural number casting of the modulus of `a` and `n` is equal to the natural number casting of `a`. In mathematical terms, this can be expressed as `(a mod n) = a` for all natural numbers `a` and `n`.

For all natural numbers `a` and `n`, the cast of `a` to natural numbers is equal to the cast of `(a mod n)`. In other words, `(cast nat a) = (cast nat (a % n))`.


theorem rank_self : ∀ (R : Type u) [inst : Ring R] [inst_1 : StrongRankCondition R], Module.rank R R = 1 := by sorry

This theorem, `rank_self`, states that for any type `R` which satisfies the conditions of being a ring (`Ring R`) and having a strong rank condition (`StrongRankCondition R`), the rank of the module over itself (`Module.rank R R`) is equal to 1. In mathematical terms, it's asserting that the rank of a ring as a module over itself is always 1, given that the ring satisfies the strong rank condition.

For any ring `R` satisfying the strong rank condition, the rank of the `R`-module `R` is equal to 1.


Primrec.cond

theorem Primrec.cond :
    ∀ {α : Type u_1} {σ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Bool} {f g : α → σ},
      Primrec c → Primrec f → Primrec g → Primrec fun a => bif c a then f a else g a :=
  by sorry

The theorem `Primrec.cond` states that for all types `α` and `σ`, if `α` and `σ` are both primitive encodable, then for any functions `c : α → Bool`, `f : α → σ`, and `g : α → σ`, if `c`, `f`, and `g` are all primitive recursive (i.e., their input and output can be encoded as natural numbers), then the function which maps `a` in `α` to `f(a)` if `c(a)` is true and to `g(a)` if `c(a)` is false, is also primitive recursive. This essentially says that the "if-then-else" construction preserves primitive recursiveness.

If `α` and `σ` are primitive encodable types, and `c : α → Bool`, `f : α → σ`, and `g : α → σ` are primitive recursive functions, then the function `x ↦ if h x then f x else g x` is also primitive recursive, for any `h : α → Bool`.


theorem MeasureTheory.SimpleFunc.monotone_eapprox :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (f : α → ENNReal), Monotone (MeasureTheory.SimpleFunc.eapprox f) := by
  sorry

This theorem states that for any type `α` equipped with a measurable space instance and for any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), the sequence of simple functions that approximate `f` (obtained using `MeasureTheory.SimpleFunc.eapprox`) is monotone. In other words, if `n ≤ m` then `MeasureTheory.SimpleFunc.eapprox f n` is less than or equal to `MeasureTheory.SimpleFunc.eapprox f m` for all elements of `α`. Here, the term "less than or equal to" is understood in the sense of pointwise comparison of functions, i.e., for each point in the domain the value of the first function is less than or equal to the value of the second function.

For any measurable space `(α, Σ, μ)` and measurable function `f : α → ENNReal`, the sequence of simple function approximations `MeasureTheory.SimpleFunc.eapprox f n` is monotone increasing, i.e., `n ≤ m` implies `MeasureTheory.SimpleFunc.eapprox f n ≤ MeasureTheory.SimpleFunc.eapprox f m` pointwise.


theorem spectrum.mem_iff :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
      r ∈ spectrum R a ↔ ¬IsUnit ((algebraMap R A) r - a) :=
  by sorry

This theorem states that for any commutative semiring `R`, any ring `A`, and an algebra structure over `R` and `A`, for any elements `r` of `R` and `a` of `A`, `r` is in the spectrum of `a` if and only if the difference between the image of `r` under the algebra map from `R` to `A` and `a` is not a unit in the algebra. In other words, it describes a property of a ring element's spectrum in terms of unit elements. The spectrum here refers to the set of elements for which subtracting the given element gives a non-unit element in the algebra.

For any commutative semiring `R`, ring `A`, and algebra structure over `R` and `A`, an element `r` in `R` is in the spectrum of an element `a` in `A` if and only if the image of `r` under the algebra map from `R` to `A` minus `a` is not a unit in `A`.


theorem MeasureTheory.Measure.restrict_singleton :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) (a : α),
      μ.restrict {a} = ↑↑μ {a} • MeasureTheory.Measure.dirac a :=
  by sorry

This theorem states that for any type `α` with a measurable space structure, any measure `μ` on `α`, and any element `a` of `α`, the restriction of `μ` to the singleton set `{a}` is equal to `{a}` under `μ` times the Dirac measure at `a`. In other words, when we restrict a measure to a single point, it behaves just like the Dirac measure at that point, scaled by the measure of the point under the original measure.

For any measurable space `(α, Σ)`, measure `μ`, and `Σ-`measurable `a ∈ α`, the restriction of `μ` to the singleton set `{a}` is equal to the Dirac measure `δ_a` multiplied by the measure `μ({a})`. In Lean notation, `μ {a} = δ_a ⊤ (μ ∘ iCarrier a)`.


theorem Filter.Tendsto.inv_tendsto_atTop :
    ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : LinearOrderedField 𝕜] [inst_1 : TopologicalSpace 𝕜]
      [inst_2 : OrderTopology 𝕜] {l : Filter α} {f : α → 𝕜},
      Filter.Tendsto f l Filter.atTop → Filter.Tendsto f⁻¹ l (nhds 0) :=
  by sorry

The theorem `Filter.Tendsto.inv_tendsto_atTop` states that for any linearly ordered field 𝕜, with a corresponding topological structure and order topology, and any filter `l` on an arbitrary type α, if a function `f` from α to 𝕜 tends to infinity (i.e., for every neighborhood of infinity, the pre-image of that neighborhood under `f` is a neighborhood in `l`), then the reciprocal of the function `f`, denoted by `f⁻¹`, tends to 0 (i.e., for every neighborhood of 0, the pre-image of this neighborhood under `f⁻¹` is a neighborhood in `l`).

If a function from an arbitrary type to a linearly ordered field tends to infinity with respect to a filter, then the reciprocal function tends to 0 with respect to the same filter.


theorem AddMonoidHom.map_finsum :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_6} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {f : α → M}
      (g : M →+ N), Set.Finite (Function.support f) → g (finsum fun i => f i) = finsum fun i => g (f i) :=
  by sorry

The `AddMonoidHom.map_finsum` theorem states that for any two types `α` and `M`, and another type `N`, all of which are under the context of additive commutative monoids, given a function `f` from `α` to `M`, and an additive monoid homomorphism `g` from `M` to `N`, if the support of the function `f` is finite, then the sum of the function `f` over its support, after being mapped by `g`, is equal to the sum, over the same support, of `f` mapped by `g`. In other words, the operation of summing over a finite support commutes with the operation of applying an additive monoid homomorphism. This can be represented in mathematical notation as: if the set $\{x | f(x) \neq 0\}$ is finite, then $g(\sum f(i)) = \sum g(f(i))$.

Given a function from a finite set to an additive commutative monoid, and an additive monoid homomorphism, the sum of the function mapped by the homomorphism is equal to the homomorphism of the sum of the function.


theorem ne_zero_of_dvd_ne_zero : ∀ {α : Type u_1} [inst : MonoidWithZero α] {p q : α}, q ≠ 0 → p ∣ q → p ≠ 0 := by sorry

This theorem states that for any type `α` which is a 'MonoidWithZero', if we have two elements `p` and `q` of this type such that `q` is not zero and `p` divides `q`, then `p` cannot be zero. In mathematical terms, for all `p` and `q` in a monoid with zero, if `q` is non-zero and `p` is a divisor of `q`, then `p` must also be non-zero.

In a monoid with zero, if a non-zero element has a divisor, then that divisor is non-zero.


/-- Being filtered is preserved by equivalence of categories.  -/
theorem CategoryTheory.IsFiltered.of_equivalence :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFiltered C] {D : Type u₁}
      [inst_2 : CategoryTheory.Category.{v₁, u₁} D], (C ≌ D) → CategoryTheory.IsFiltered D :=
  by sorry

This theorem states that the property of being filtered is preserved by equivalence of categories. More concretely, given two types `C` and `D` with their respective categories and an equivalence of categories between `C` and `D`, if `C` is filtered, then `D` is also filtered. This means, in the context of category theory, that any finite diagram in `D` has a cocone, based on the fact that the corresponding finite diagram in `C` (due to the category equivalence) has a cocone because `C` is filtered.

Given an equivalence of categories between filtered categories `C` and `D`, `D` is filtered.


theorem Complex.hasStrictDerivAt_const_cpow :
    ∀ {x y : ℂ}, x ≠ 0 ∨ y ≠ 0 → HasStrictDerivAt (fun y => x ^ y) (x ^ y * Complex.log x) y := by sorry

This theorem states that for any complex numbers `x` and `y`, where either `x` or `y` is non-zero, the function `f(y) = x^y` is strictly differentiable at the point `y`. The derivative of this function at `y` is `x^y * Complex.log x`, where `Complex.log x` denotes the complex logarithm of `x`. In other words, the change in `x^y` with respect to `y` at any point `y` is described by the function `x^y * Complex.log x`, given that either `x` or `y` is not zero.

For complex numbers `x` and `y` with `x` or `y` non-zero, the function `f(y) = x^y` is strictly differentiable with derivative `x^y * log(x)`, where `log(x)` denotes the complex logarithm of `x`.


theorem uniformContinuous_mul :
    ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : Group α] [inst_2 : UniformGroup α],
      UniformContinuous fun p => p.1 * p.2 :=
  by sorry

The theorem `uniformContinuous_mul` states that for any type `α` that has a uniform space structure, a group structure, and a uniform group structure, the multiplication operation is uniformly continuous. In other words, if two pairs of elements from `α` are arbitrarily close to each other, then their products are also arbitrarily close to each other, regardless of their actual location in `α`.

For any uniform, grouped type `α`, the multiplication operation is uniformly continuous.


theorem MeasureTheory.Measure.singularPart_le :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α), μ.singularPart ν ≤ μ := by sorry

This theorem states that for any type `α` and any measurable space `m` on `α`, the singular part of a measure `μ` with respect to another measure `ν` is always less than or equal to `μ`. Here, the singular part of a measure is a concept from measure theory, which intuitively captures the part of a measure that is 'unaccounted for' by another measure.

For any measurable spaces `α` and measures `μ` and `ν` on `α`, the singular part of `μ` with respect to `ν` is less than or equal to `μ`.


theorem Ideal.span_singleton_le_span_singleton :
    ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, Ideal.span {x} ≤ Ideal.span {y} ↔ y ∣ x := by sorry

This theorem states that for any commutative semiring `α` and for any two elements `x` and `y` of `α`, the ideal generated by the singleton set `{x}` is a subset of the ideal generated by the singleton set `{y}` if and only if `y` divides `x`. In terms of mathematical notation, if `α` is a commutative semiring, for all `x, y` in `α`, the condition that the ideal of `{x}` is less than or equal to the ideal of `{y}` is equivalent to `y` dividing `x`.

For any commutative semiring `α`, the ideal generated by `{x}` is contained in the ideal generated by `{y}` if and only if `y` divides `x`.


/-- **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold eventually for the filter.  -/
theorem tendsto_of_tendsto_of_tendsto_of_le_of_le' :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] {f g h : β → α}
      {b : Filter β} {a : α},
      Filter.Tendsto g b (nhds a) →
        Filter.Tendsto h b (nhds a) →
          (∀ᶠ (b : β) in b, g b ≤ f b) → (∀ᶠ (b : β) in b, f b ≤ h b) → Filter.Tendsto f b (nhds a) :=
  by sorry

This is the **Squeeze Theorem**, also known as the **Sandwich Theorem**, in the context of filters. Given a topological space `α` with a preorder and an order topology, and three functions `f`, `g`, and `h` from `β` to `α`, and a filter `b` on `β` and a point `a` in `α`, if `g` and `h` both tend to `a` as defined by the filter `b`, and if `g(b)` is eventually less than or equal to `f(b)` and `f(b)` is eventually less than or equal to `h(b)` under the filter `b`, then `f` also tends to `a` under the filter `b`. In simpler terms, if `f` is squeezed between `g` and `h` for values in `b` and both `g` and `h` approach the same limit `a`, then `f` also approaches `a`.

If functions `f`, `g`, and `h` satisfy `g(x) ≤ f(x) ≤ h(x)` for all `x` in a filter `b` and `g` and `h` both tend to a limit `a` in a topological space with order topology, then `f` also tends to `a` in the filter `b`.


theorem LinearMap.range_comp :
    ∀ {R : Type u_1} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_9} {M₂ : Type u_12} {M₃ : Type u_13}
      [inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M]
      [inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid M₃] [inst_6 : Module R M] [inst_7 : Module R₂ M₂]
      [inst_8 : Module R₃ M₃] {τ₁₂ : R →+* R₂} {τ₂₃ : R₂ →+* R₃} {τ₁₃ : R →+* R₃}
      [inst_9 : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃] [inst_10 : RingHomSurjective τ₁₂] [inst_11 : RingHomSurjective τ₂₃]
      [inst_12 : RingHomSurjective τ₁₃] (f : M →ₛₗ[τ₁₂] M₂) (g : M₂ →ₛₗ[τ₂₃] M₃),
      LinearMap.range (LinearMap.comp g f) = Submodule.map g (LinearMap.range f) :=
  by sorry

The theorem `LinearMap.range_comp` states that for any three semirings `R`, `R₂`, and `R₃`, and any three additive commutative monoids `M`, `M₂`, and `M₃`, and any three ring homomorphisms `τ₁₂`, `τ₂₃`, and `τ₁₃` such that `τ₁₂`, `τ₂₃`, and `τ₁₃` form a ring homomorphism triple and are surjective, if `f` is a linear map from `M` to `M₂` and `g` is a linear map from `M₂` to `M₃`, then the range of the composition of `g` and `f` is the same as the image of the range of `f` under `g`. In other words, composing two linear maps and then taking the range gives the same result as first taking the range of the first map, and then mapping it through the second map.

For any surjective ring homomorphisms τ₁₂, τ₂₃, and τ₁₃ between semirings R, R₂, and R₃, and any linear maps f : M → M₂ and g : M₂ → M₃ between additive commutative monoids M, M₂, and M₃, the range of g ∘ f is equal to the image of the range of f under g.


theorem Monoid.Coprod.mk_eq_mk :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {w₁ w₂ : FreeMonoid (M ⊕ N)},
      Monoid.Coprod.mk w₁ = Monoid.Coprod.mk w₂ ↔ (Monoid.coprodCon M N) w₁ w₂ :=
  by sorry

This theorem, `Monoid.Coprod.mk_eq_mk`, states that for all types `M` and `N` that have a `MulOneClass` instance (i.e., they are monoids), and for all elements `w₁` and `w₂` of the free monoid over the coproduct of `M` and `N`, the application of the `Monoid.Coprod.mk` function to `w₁` and `w₂` results in the same output if and only if `w₁` and `w₂` are connected by the congruence relation `Monoid.coprodCon M N`. In simpler terms, it asserts that two elements of the free monoid are mapped to the same element in the coproduct monoid if and only if they are equivalent under the defining relation of the coproduct.

For all monoids M and N, the elements w₁ and w₂ of the free monoid over M ⊕ N are mapped to the same element in the coproduct monoid M ⊕\_* N if and only if they are related by the congruence relation of Monoid.coprod on M and N.


theorem Matrix.mul_add :
    ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalNonAssocSemiring α]
      [inst_1 : Fintype n] (L : Matrix m n α) (M N : Matrix n o α), L * (M + N) = L * M + L * N :=
  by sorry

This theorem, `Matrix.mul_add`, states that for any types `m`, `n`, `o`, and any type `α` that forms a NonUnitalNonAssocSemiring, and given that `n` is a Fintype, if `L` is a matrix with entries of type `α` and dimensions indexed by `m` and `n`, and `M` and `N` are matrices also with entries of type `α` and dimensions indexed by `n` and `o`, then the result of matrix multiplication `L` with the sum of `M` and `N` (`L * (M + N)`) is equal to the sum of the result of `L` multiplied by `M` and `L` multiplied by `N` (`L * M + L * N`). That is, it verifies the distributivity of matrix multiplication over matrix addition.

For matrices `L` of dimensions `m x n`, `M` and `N` of dimensions `n x o`, and type `α` forming a NonUnitalNonAssocSemiring, the distributivity of matrix multiplication over matrix addition holds: `L * (M + N) = L * M + L * N`.


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

This theorem states that for any real numbers `a` and `b`, any function `f` from the real numbers to a normed additive commutative group `E` which is also a normed space over the real numbers, and any measure `μ` on the real numbers, the integral over the interval from `a` to `b` of the negation of `f` (i.e., `-f(x)`) with respect to `μ` is equal to the negation of the integral over the same interval of `f` with respect to `μ`. In more mathematical terms, the theorem says that ∫_{a}^{b} -f(x) dμ = -∫_{a}^{b} f(x) dμ. This theorem asserts the linearity property of the integral with respect to scalar multiplication.

For any real numbers `a` and `b`, any function `f` from the real numbers to a normed additive commutative group `E` which is also a normed space over the real numbers, and any measure `μ` on the real numbers, the integral of `-f(x)` with respect to `μ` over the interval [`a`, `b`] is equal to the negative of the integral of `f(x)` with respect to `μ` over the same interval.


theorem Nat.testBit_bitwise :
    ∀ {f : Bool → Bool → Bool},
      f false false = false →
        ∀ (x y i : ℕ), Nat.testBit (Nat.bitwise f x y) i = f (Nat.testBit x i) (Nat.testBit y i) :=
  by sorry

This theorem states that for any boolean function `f`, given that `f` returns false when both its arguments are false, and for any natural numbers `x`, `y`, and `i`, the `(i+1)` least significant bit of the bitwise operation `f` applied to `x` and `y` is equal to the function `f` applied to the `(i+1)` least significant bits of `x` and `y`. In simple terms, it says that the `(i+1)` least significant bit of the result of a bitwise operation on two numbers is determined by applying the operation to the `(i+1)` least significant bits of the two numbers.

For any boolean function `f` with the property that `f(false, false) = false, and for all natural numbers `x`, `y`, the `(i+1)`-th bit of the bitwise operation `f(x ⊔ y)` is equal to `f(x(i) ⊔ y(i))`, where `x(i)` and `y(i)` are the `(i+1)`-th bits of `x` and `y`, respectively.


/-- The edist is antitone with respect to inclusion.  -/
theorem EMetric.infEdist_anti :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s t : Set α},
      s ⊆ t → EMetric.infEdist x t ≤ EMetric.infEdist x s :=
  by sorry

The theorem `EMetric.infEdist_anti` states that for any type `α` equipped with a `PseudoEMetricSpace` structure, and given any point `x` of type `α` and any two sets `s` and `t` of type `α`, if `s` is a subset of `t`, then the infimum extended distance from `x` to `t` is less than or equal to the infimum extended distance from `x` to `s`. In other words, the minimal extended distance from a point to a set is anti-monotonic with respect to the inclusion of the set.

For any pseudo-metric space `(α, d)`, and point `x ∈ α`, if `s ⊆ t` are subsets of `α`, then `inf (d x i : i ∈ s) ≤ inf (d x j : j ∈ t)`.


theorem lipschitzWith_smul :
    ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
      [inst_2 : SMulZeroClass α β] [inst_3 : BoundedSMul α β] (s : α), LipschitzWith ‖s‖₊ fun x => s • x :=
  by sorry

The theorem `lipschitzWith_smul` states that for any seminormed add groups `α` and `β` (which are types `u_1` and `u_2` respectively) that also have a multiplication operation with zero (`SMulZeroClass α β`), and the multiplication operation is bounded (`BoundedSMul α β`), for any element `s` of `α`, the function that maps `x` to `s • x` (the multiplication of `s` and `x`) is Lipschitz continuous with Lipschitz constant equal to the seminorm of `s` (`‖s‖₊`). In other words, the distance (in the sense of the edistance) between `s • x` and `s • y` is at most the seminorm of `s` times the distance between `x` and `y`, for any `x, y` in `α`.

For any seminormed add groups `α` and `β` with multiplication operation and zero, and a bounded multiplication, the function `x mapsto s • x` is Lipschitz continuous with constant `‖s‖₊` on `α`.


theorem Associates.out_dvd_iff :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (a : α) (b : Associates α),
      Associates.out b ∣ a ↔ b ≤ Associates.mk a :=
  by sorry

The theorem `Associates.out_dvd_iff` states a property relating the division operation in a `CancelCommMonoidWithZero` and the order operation in the `Associates` of the monoid. For any `CancelCommMonoidWithZero` α and `NormalizationMonoid` α, and any element `a` of α and `b` of `Associates` α, the normalized element of `b`'s associate class divides `a` if and only if `b` is less than or equal to the quotient map of `a` into `Associates` α. In other words, there is a correspondence between the divisibility in the monoid and the order in the quotient by the `Associated` relation.

For any `CancelCommMonoidWithZero` α and `NormalizationMonoid` α, the normalized associate of `b` divides `a` in α if and only if `b` is less than or equal to the quotient of `a` modulo the `Associates` relation in α.


theorem Nat.mod_two_of_bodd : ∀ (n : ℕ), n % 2 = bif Nat.bodd n then 1 else 0 := by sorry

This theorem states that for any natural number `n`, the remainder when `n` is divided by 2 is determined by whether `n` is odd or not. Specifically, if `n` is odd (as indicated by the function `Nat.bodd n` returning `true`), then `n` modulo 2 is 1. Otherwise, if `n` is even (i.e., `Nat.bodd n` returns `false`), then `n` modulo 2 is 0. This is essentially the definition of odd and even numbers in terms of division by 2.

For any natural number `n`, `n` modulo 2 is 1 if `n` is odd, and 0 if `n` is even.


theorem star_le_star_iff :
    ∀ {R : Type u} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarOrderedRing R] {x y : R},
      star x ≤ star y ↔ x ≤ y :=
  by sorry

This theorem states that for any type `R` that has the structure of a non-unital semiring, is partially ordered, and also a star ordered ring, the star of `x` is less than or equal to the star of `y` if and only if `x` is less than or equal to `y`. Here, `x` and `y` are elements of `R`. In terms of mathematics, it can be represented as: ∀x, y ∈ R, star(x) ≤ star(y) iff x ≤ y.

For any non-unital semiring `R` with a partial order and star order, `x ≤ y` implies `star(x) ≤ star(y)` and vice versa.


theorem zero_zpow : ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] (z : ℤ), z ≠ 0 → 0 ^ z = 0 := by sorry

This theorem, `zero_zpow`, states that for all integers `z` that are not equal to zero, zero raised to the power of `z` is equal to zero. Here, `G₀` is any type that forms a group with zero, which means it satisfies certain mathematical properties such as associativity and the existence of a zero element.

For any non-zero integer `z` in a group `G₀` with identity element 0, 0 raised to the power of `z` equals 0.


theorem Ideal.comap_comap :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {T : Type u_3} [inst_2 : Semiring T]
      {I : Ideal T} (f : R →+* S) (g : S →+* T), Ideal.comap f (Ideal.comap g I) = Ideal.comap (RingHom.comp g f) I :=
  by sorry

The theorem `Ideal.comap_comap` states that for any three semirings `R`, `S`, and `T`, and for any ideal `I` in `T`, the preimage of the preimage of `I` under ring homomorphism `g` from `S` to `T` and then ring homomorphism `f` from `R` to `S` is equal to the preimage of `I` under the composition of `g` and `f`. In other words, taking the preimage of an ideal under a ring homomorphism is a process that can be composed, and the order of operations does not matter.

For any semirings R, S, T and ideal I in T, the preimage of I under the composition of homomorphisms f: R -> S and g: S -> T equals the preimage of I under g and then f.


theorem Bornology.le_cofinite : ∀ (α : Type u_4) [inst : Bornology α], Bornology.cobounded α ≤ Filter.cofinite := by
  sorry

The theorem `Bornology.le_cofinite` asserts that for any type `α` equipped with a Bornology structure, the filter of cobounded sets in that Bornology is a sub-filter of the cofinite filter. In other words, every cobounded set in the Bornology is also a set whose complement is finite. Thus the filter of all cobounded sets includes all sets whose complement is finite.

The filter of cobounded sets in a Bornology is a sub-filter of the cofinite filter.


theorem MeasureTheory.Content.outerMeasure_opens :
    ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : R1Space G]
      (U : TopologicalSpace.Opens G),
      ↑(MeasureTheory.Content.outerMeasure μ) ↑U = MeasureTheory.Content.innerContent μ U :=
  by sorry

This theorem states that for any topological space `G`, given a measure content `μ` and an open set `U` in `G`, the outer measure of `U` under `μ` is equal to the inner content of `μ` on `U`. In other words, it is a property of measure theory content saying that the outer measure, which is defined by extending a content on compact sets to all sets, when applied on an open set, equals to the inner content, which is defined as the supremum of the content of all compact subsets of the open set. This holds true under the condition that the topological space `G` is also an `R1Space`, a specific kind of topological space.

For any `R1Space` `G` with measure content `μ`, the outer measure of an open set `U` equals the inner content of `μ` on `U`.


theorem Cardinal.ofENat_strictMono : StrictMono Cardinal.ofENat := by sorry

The theorem `Cardinal.ofENat_strictMono` states that the function `Cardinal.ofENat`, which maps elements of `ℕ∞` (extended natural numbers including `⊤`) to cardinals, is strictly monotone. In other words, if `a` and `b` are elements of `ℕ∞` and `a` is strictly less than `b`, then the cardinal number corresponding to `a` is strictly less than the cardinal number corresponding to `b`. Therefore, this function strictly preserves the order from the extended natural numbers to cardinal numbers.

The function `Cardinal.ofENat` maps strictly smaller extended natural numbers to strictly smaller cardinal numbers.


theorem Set.Icc_subset_uIcc : ∀ {α : Type u_1} [inst : Lattice α] {a b : α}, Set.Icc a b ⊆ Set.uIcc a b := by sorry

This theorem states that for any type `α` equipped with a lattice structure, and for any two elements `a` and `b` in `α`, the interval `Set.Icc a b` is a subset of the interval `Set.uIcc a b`. Here, `Set.Icc a b` represents the set of elements lying between `a` and `b`, inclusive, in the given order, whereas `Set.uIcc a b` represents a set of elements lying between the minimum (`a ⊓ b`) and the maximum (`a ⊔ b`) of `a` and `b`, inclusive. This theorem essentially asserts that any element that lies between `a` and `b` in the specified order will also lie between the minimum and maximum of `a` and `b`, inclusive.

For any lattice `α` and elements `a` and `b` in `α`, `Set.Icc a b` is included in `Set.uIcc a b`. That is, all elements between `a` and `b` in order are also between their minimum and maximum in the lattice.


theorem Set.union_subset_iff : ∀ {α : Type u} {s t u : Set α}, s ∪ t ⊆ u ↔ s ⊆ u ∧ t ⊆ u := by sorry

This theorem, `Set.union_subset_iff`, states that for any type `α` and any sets `s`, `t`, and `u` of type `α`, the set `s` union with the set `t` is a subset of set `u` if and only if both sets `s` and `t` are subsets of `u`. In mathematical terms, we would express this as $s \cup t \subseteq u \Leftrightarrow (s \subseteq u) \land (t \subseteq u)$. It means that the union of two sets is contained within another set precisely when both of the constituent sets are contained within that other set.

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


theorem Order.covBy_succ_of_not_isMax :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, ¬IsMax a → a ⋖ Order.succ a := by sorry

The theorem `Order.covBy_succ_of_not_isMax` states that for any type `α` that has a preorder structure and a successor order, given any element `a` of type `α` that is not a maximal element, `a` is covered by its successor. In other words, there is no element of type `α` that is strictly greater than `a` and strictly less than the successor of `a`. Symbolically, if `a` is not a maximal element, then `a ⋖ Order.succ a`, where `⋖` denotes the covering relation.

If `α` is a preordered type with a successor order and `a` is not a maximal element of `α`, then there is no element strictly between `a` and the successor of `a`.


theorem sub_le_sub_iff_left :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {b c : α} (a : α),
      a - b ≤ a - c ↔ c ≤ b :=
  by sorry

This theorem states that for any type `α` that has an addition group structure, a partial ordering (`LE`), and satisfies two covariance properties (one for addition and one for its swapped version), the following inequality holds: subtracting `b` from `a` is less than or equal to subtracting `c` from `a` if and only if `c` is less than or equal to `b`. Here, `a`, `b`, and `c` are elements of the type `α`. In other words, for all real numbers `a`, `b`, and `c`, `a - b ≤ a - c` is equivalent to `c ≤ b`.

For any type `α` with an additive structure, a partial ordering `LE`, and the covariance properties for addition and its swapped version, `a LE b` if and only if `c LE b` implies `a - c LE a - b`.


theorem Partrec.to₂ :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α × β →. σ}, Partrec f → Partrec₂ fun a b => f (a, b) :=
  by sorry

The theorem `Partrec.to₂` states that for any types `α`, `β`, and `σ` that are Primcodable (i.e., they can be encoded as natural numbers), if a function `f` from a pair of type `α` and `β` to a partial function on `σ` is partially recursive (defined by `Partrec`), then this function `f` can be treated as a function of two variables (defined by `Partrec₂`). This essentially means that the partial recursion property is preserved when we treat a function of a pair as a function of two variables.

If `f` is a partially recursive function from `α × β` to the partial functions on `σ`, where `α`, `β`, and `σ` are Primcodable types, then `f` is equivalent to a function `g` of two variables, defined by `Partrec₂`, such that the application of `g` to arguments `(a, b)` is equal to the application of `f` to the pair `(a, b)`.


theorem PosNum.add_one : ∀ (n : PosNum), n + 1 = PosNum.succ n := by sorry

The theorem `PosNum.add_one` states that for every positive number `n`, the result of adding 1 to `n` is the same as the successor of `n`. In other words, it formalizes the common arithmetic property that adding one to any positive number results in its next consecutive number. The successor function is defined in such a way that it extends the positive numbers to include `PosNum.one` (for 1), `PosNum.bit0 n` (for even numbers), and `PosNum.bit1 n` (for odd numbers).

For every positive number `n`, `1 + n` equals the successor of `n`.


theorem List.mem_pmap :
    ∀ {α : Type u} {β : Type v} {p : α → Prop} {f : (a : α) → p a → β} {l : List α} {H : ∀ a ∈ l, p a} {b : β},
      b ∈ List.pmap f l H ↔ ∃ a, ∃ (h : a ∈ l), f a ⋯ = b :=
  by sorry

This theorem, `List.mem_pmap`, states that for any two types `α` and `β`, a predicate `p` over `α`, a function `f` from `α` and a proof of `p a` to `β`, a list `l` of type `α`, a proof `H` that for all `a` in `l`, `p a` holds, and a value `b` of type `β`, `b` is in the list produced by applying `f` to each element of `l` (along with the proof that the predicate holds for that element), if and only if there exists an `a` in `l` such that `f` applied to `a` and the proof that `p a` holds is equal to `b`. In other words, `b` is an element of the `pmap` of `f` over `l` if and only if `b` is the result of `f` applied to some `a` in `l`.

For any types `α` and `β`, predicate `p` over `α`, function `f` from `α` to `β`, list `l` of type `α`, proof `H` that `p a` holds for all `a` in `l`, and value `b` of type `β`, `b` is in the image of `pmap(f)(l)` if and only if there exists an `a` in `l` such that `b = f(a) * p(a)`.


theorem Nat.findGreatest_eq_iff :
    ∀ {m k : ℕ} {P : ℕ → Prop} [inst : DecidablePred P],
      Nat.findGreatest P k = m ↔ m ≤ k ∧ (m ≠ 0 → P m) ∧ ∀ ⦃n : ℕ⦄, m < n → n ≤ k → ¬P n :=
  by sorry

The theorem `Nat.findGreatest_eq_iff` states that for any natural numbers `m` and `k`, and any predicate `P` in natural numbers that is decidable, `Nat.findGreatest P k` is equal to `m` if and only if the following conditions are met: `m` is less than or equal to `k`, if `m` is not zero then `P m` holds, and for every natural number `n` greater than `m` but less than or equal to `k`, `P n` does not hold. In other words, `m` is the greatest natural number less than or equal to `k` for which the predicate `P` holds.

For any decidable predicate P on natural numbers and natural numbers m and k with m <= k and P(m) holding if m is non-zero, m is the greatest natural number less than or equal to k satisfying P if and only if no natural number n between m and k satisfies P.


/-- See also `Nat.card_addSubgroupZPowers`.  -/
theorem Fintype.card_zpowers :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] {x : G}, Fintype.card ↥(Subgroup.zpowers x) = orderOf x := by
  sorry

The theorem `Fintype.card_zpowers` states that for any group `G` that is also a finite type and any element `x` of `G`, the number of elements in the subgroup generated by `x` is equal to the order of `x`. In mathematical terms, if `G` is a group and `x` is an element of `G`, the size (or cardinality) of the subgroup of `G` generated by the powers of `x` is equal to the smallest positive integer `n` such that `x^n = 1` (this `n` is called the order of `x`). If no such `n` exists, which means `x` has infinite order, then by convention, the order of `x` is defined to be `0`, and this theorem states that the subgroup generated by `x` is infinite.

The order of a finite group element equals the cardinality of the subgroup generated by its powers.


theorem Rat.cast_inv : ∀ {α : Type u_3} [inst : DivisionRing α] [inst_1 : CharZero α] (n : ℚ), ↑n⁻¹ = (↑n)⁻¹ := by sorry

This theorem states that for any rational number `n`, the reciprocal of the cast of `n` to a division ring `α` (where `α` is of characteristic zero) is equal to the cast of the reciprocal of `n` to `α`. In other words, taking the reciprocal then casting is the same operation as casting then taking the reciprocal. This theorem is valid for any type `α` as long as `α` forms a division ring and its characteristic is zero.

For any rational number `n` and any division ring `α` of characteristic zero, the cast of the reciprocal of `n` to `α` equals the reciprocal of the cast of `n` to `α`.


theorem Set.sUnion_range : ∀ {β : Type u_2} {ι : Sort u_4} (f : ι → Set β), ⋃₀ Set.range f = ⋃ x, f x := by sorry

This theorem states that for any type `β` and any sort `ι`, given a function `f` that maps from `ι` to a set of `β`, the union of the sets in the range of `f` is equal to the union of the sets `f x` for every `x`. In mathematical terms, it states that the union over the range of a function `f` (i.e., ⋃₀ Set.range f) is the same as the union over all `x` of `f(x)` (i.e., ⋃ x, f x).

For any function `f` from sort `ι` to a set of type `β`, the set union over the range of `f` equals the set union of `f(x)` for all `x` in `ι`. In Lean notation, `⋃₀ Set.range f = ⋃ x, f x`.


theorem CategoryTheory.ShortComplex.homologyι_naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ)
          (CategoryTheory.ShortComplex.homologyι S₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyι S₁)
          (CategoryTheory.ShortComplex.opcyclesMap φ) :=
  by sorry

This theorem states that given any category `C` with zero morphisms, and two short complexes `S₁` and `S₂` in `C`, for any morphism `φ` from `S₁` to `S₂`, the composition of the homology map of `φ` and the homology insertion of `S₂` is equal to the composition of the homology insertion of `S₁` and the cycles map of `φ`. This essentially showcases the naturality of the homology insertion in the context of short complexes in a category.

Given any category with zero morphisms, for short complexes $S\_1$ and $S\_2$, and a morphism $\varphi$ from $S\_1$ to $S\_2$, the homology insertion of $S\_2$ and the homology map of $\varphi$ are naturally equal to the homology insertion of $S\_1$ and the cycles map of $\varphi$.


Composition.ext

theorem Composition.ext : ∀ {n : ℕ} (x y : Composition n), x.blocks = y.blocks → x = y := by sorry

This theorem, named `Composition.ext`, states that for any natural number `n`, given two compositions `x` and `y` of `n`, if the `blocks` of `x` and `y` are equal, then `x` and `y` are equal. In other words, the equality of two compositions is determined solely by the equality of their respective `blocks`.

If two compositions of a natural number have equal blocks, then they are equal.


Function.Injective.noZeroDivisors

/-- Pull back a `NoZeroDivisors` instance along an injective function.  -/
theorem Function.Injective.noZeroDivisors :
    ∀ {M₀ : Type u_1} {M₀' : Type u_3} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : Mul M₀'] [inst_3 : Zero M₀']
      (f : M₀ → M₀'),
      Function.Injective f →
        f 0 = 0 → (∀ (x y : M₀), f (x * y) = f x * f y) → ∀ [inst_4 : NoZeroDivisors M₀'], NoZeroDivisors M₀ :=
  by sorry

The theorem `Function.Injective.noZeroDivisors` states that for any two types `M₀` and `M₀'` with multiplication and zero, if there exists a function `f` that is injective (meaning that equal outputs imply equal inputs), maps zero to zero and preserves multiplication (i.e., `f` of the product of two elements is equal to the product of `f` of the individual elements), then if `M₀'` has the property of having no zero divisors (no pair of nonzero elements multiply to zero), `M₀` also has this property. This theorem essentially shows that the property of having no zero divisors is preserved under injective, zero-preserving, multiplicative maps.

If `f` is an injective function from a commutative monoid `(M₀, ∗, 0)` to another commutative monoid `(M₀', ∗', 0')` that preserves multiplication and maps zero to zero, and `M₀'` has no zero divisors, then `M₀` also has no zero divisors.


theorem Set.compl_empty_iff : ∀ {α : Type u} {s : Set α}, sᶜ = ∅ ↔ s = Set.univ := by sorry

This theorem states that for any type `α` and a set `s` of type `α`, the complement of `s` is empty if and only if `s` is the universal set. In other words, a set `s` is the universal set (meaning it contains all elements of the type `α`) precisely when its complement (the set of all elements not in `s`) is empty. This is a formalization of a basic principle from set theory.

A set is the universal set if and only if its complement is empty.


Measurable.eval

theorem Measurable.eval :
    ∀ {α : Type u_1} {δ : Type u_4} {π : δ → Type u_6} [inst : MeasurableSpace α]
      [inst_1 : (a : δ) → MeasurableSpace (π a)] {a : δ} {g : α → (a : δ) → π a},
      Measurable g → Measurable fun x => g x a :=
  by sorry

The theorem `Measurable.eval` states that for any types `α`, `δ`, and `π`, where `α` and `π a` for some `a : δ` have measurable spaces, and there is a function `g : α → (a : δ) → π a`, if `g` is a measurable function, then the function that takes an element `x` from `α` and returns `g x a` is also a measurable function. This means that the preimage of every measurable set under this function is also a measurable set.

If `α`, `δ`, and `π` are measurable spaces, `a : δ`, and `g : α → (a : δ) → π a` is a measurable function, then the function `x ↦ g x a` is also a measurable function.


theorem normalize_zero :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α], normalize 0 = 0 := by sorry

This theorem states that for any type `α` that is a member of the classes `CancelCommMonoidWithZero` and `NormalizationMonoid`, the normalization of zero is zero. In more mathematical terms, if we have a cancel commutative monoid with zero (a structure with zero where multiplication is commutative and cancellative) and a normalization monoid (a structure with a function that returns 'normalized' elements) then the normalization operation applied to zero will always return zero.

For any type `α` that is a cancel commutative monoid with zero and a normalization monoid, the normalization of zero is zero.


/-- The first projection in a product is `C^∞`.  -/
theorem contDiff_fst :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞},
      ContDiff 𝕜 n Prod.fst :=
  by sorry

The theorem `contDiff_fst` states that for any non-trivial normed field `𝕜`, and any normed additive commutative groups `E` and `F` that are also normed spaces over `𝕜`, the first projection function, `Prod.fst`, is infinitely differentiable (`C^∞`). This applies for every smoothness class `n`, represented as a natural number or infinity (`ℕ∞`).

For any non-trivial normed field `𝕜` and normed additive commutative groups `E` and `F` over `𝕜` that are normed spaces, the first projection function `Prod.fst` from `E × F` to `E` is infinitely differentiable.


theorem Ordinal.toPGame_moveLeft' :
    ∀ {o : Ordinal.{u_1}} (i : SetTheory.PGame.LeftMoves (Ordinal.toPGame o)),
      SetTheory.PGame.moveLeft (Ordinal.toPGame o) i = Ordinal.toPGame ↑(Ordinal.toLeftMovesToPGame.symm i) :=
  by sorry

The theorem `Ordinal.toPGame_moveLeft'` states that for any ordinal 'o' and any valid move 'i' for the player Left in the positional game corresponding to 'o', making the move 'i' in this game results in a game that corresponds to a smaller ordinal. Specifically, the ordinal it corresponds to is the one that the move 'i' maps to under the inverse of the function `Ordinal.toLeftMovesToPGame`, which converts ordinals less than 'o' into moves for the game corresponding to 'o'.

For any ordinal o and valid move i for player Left in the positional game of ordinal o, making move i results in a game corresponding to an ordinal less than o.


theorem Finset.sum_dite_eq' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] [inst_1 : DecidableEq α] (s : Finset α) (a : α)
      (b : (x : α) → x = a → β), (Finset.sum s fun x => if h : x = a then b x h else 0) = if a ∈ s then b a ⋯ else 0 :=
  by sorry

This theorem is about the sum of a function over a finite set in Lean. It states that for any given type `α`, type `β` that is an additive commutative monoid, a finite set `s` of elements of type `α`, and any specific element `a` of type `α`, when we have a function `b` that maps an element `x` and a proof that `x = a` to `β`, the sum of function values over set `s` where each function value is determined by an if-then-else expression (`b x h` if `x = a` otherwise `0`) is equal to the value of `b a` if `a` belongs to the set `s` and `0` otherwise. This theorem is particularly useful when we want to compute the sum of a function at a specific point in a finite set, effectively isolating the contribution of a particular element to the sum.

For any additive commutative monoid type `β`, finite set `s` of type `α`, and function `b : α → β`, the sum of `b x <| x ∈ s` equals `b a` if `a ∈ s`, and `0` otherwise.


Set.Countable.measurableSet

theorem Set.Countable.measurableSet :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] {s : Set α},
      Set.Countable s → MeasurableSet s :=
  by sorry

The theorem `Set.Countable.measurableSet` states that for any type `α` equipped with a measurable space structure and a measurable singleton class, if we have a set `s` of this type which is countable (i.e., there exists an injective map from `s` to the set of natural numbers `ℕ`), then `s` is a measurable set in the ambient measurable space on `α`.

If `α` is a type with a measurable space structure and a measurable singleton class, and `s` is a countable (injectively mappeable to `ℕ`) subset of `α`, then `s` is a measurable set in the ambient measurable space on `α`.


theorem Function.uncurry_curry :
    ∀ {α : Type u₁} {β : Type u₂} {φ : Type u₃} (f : α × β → φ), Function.uncurry (Function.curry f) = f := by sorry

The theorem `Function.uncurry_curry` states that for all types `α`, `β`, and `φ`, and for any function `f` which takes a pair of elements (one from `α` and one from `β`) and returns an element of `φ`, if we first curry this function `f` (transform it into a function that takes two arguments separately) and then uncurry it (transform it back into a function that takes a pair of arguments), we get the original function `f`. This theorem thus asserts the consistency of the curry and uncurry operations; currying followed by uncurrying a function always brings us back to the original function.

For any function `f : α × β → φ`, the functions `(λ x y => f (x, y))` and `λ p => f p.fst p.snd` are equal. (Here, `α × β` denotes the Cartesian product of types `α` and `β`, `p` is a pair, `p.fst` is the first component of the pair, and `p.snd` is the second component of the pair.)


theorem Mathlib.Order.Synonym._auxLemma.5 :
    ∀ {α : Type u_1} {p : αᵒᵈ → Prop}, (∀ (a : αᵒᵈ), p a) = ∀ (a : α), p (OrderDual.toDual a) := by sorry

The theorem `Mathlib.Order.Synonym._auxLemma.5` states that for any type `α` and any property `p` that takes as input elements of the order dual of `α` (symbolized as `αᵒᵈ`), saying that "the property `p` holds for all elements `a` of `αᵒᵈ`" is equivalent to stating "for all elements `a` of `α`, the property `p` holds for `a` when it is transformed into its order dual using the function `OrderDual.toDual`". In essence, it shows the property preservation under the transformation to the order dual.

The theorem `Mathlib.Order.Synonym._auxLemma.5` asserts that for any property `p` on the order dual `αᵒᵈ` of a type `α`, `p` holds for all elements `a` in `αᵒᵈ` if and only if it holds for the order duals `OrderDual.toDual a` of all elements `a` in `α`.


theorem UpperSet.coe_iInf :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → UpperSet α), ↑(⨅ i, f i) = ⋃ i, ↑(f i) := by sorry

This theorem, `UpperSet.coe_iInf`, states that for any type `α` and any sort `ι`, given a certain less-or-equals relationship on `α`, and a function `f` from `ι` to the set of upper sets of `α`, the intersection over all `ι` of the co-domain of `f` is equivalent to the union over all `ι` of the individual co-domains of `f`. In other words, in this context, intersecting all `f i` and then taking the upper set is the same as taking the upper set of each `f i` and then uniting them all.

For any type `α` and sort `ι`, if `f : ι → upperSets α` satisfies `∀ i, ∀ x ∈ i, x ≤ x' → f i x ∩ f i x' = f i x ∪ f i x'`, then `⋂ i, f i = ⋃ i, f i`.


theorem Real.arctan_mem_Ioo : ∀ (x : ℝ), Real.arctan x ∈ Set.Ioo (-(Real.pi / 2)) (Real.pi / 2) := by sorry

The theorem `Real.arctan_mem_Ioo` states that for any real number `x`, the inverse tangent of `x`, denoted as `Real.arctan x`, is always within the open interval `( -π/2 , π/2 )`. Here, `Set.Ioo` refers to a left-open right-open interval, meaning both ends of the range are not included. Therefore, the theorem asserts that the value of `arctan(x)` is strictly greater than `-π/2` and strictly less than `π/2` for any real `x`.

The theorem `Real.arctan_mem_Ioo` asserts that for all real numbers `x`, `Real.arctan x` lies in the open interval `(-\pi/2, \pi/2)`.


theorem AlgebraicTopology.DoldKan.PInfty_f_idem :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} (n : ℕ),
      CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.PInfty.f n) (AlgebraicTopology.DoldKan.PInfty.f n) =
        AlgebraicTopology.DoldKan.PInfty.f n :=
  by sorry

This theorem states that for any category `C` (which is of some type `u_1`, and is preadditive), and any simplicial object `X` in this category, the morphism `AlgebraicTopology.DoldKan.PInfty.f` is idempotent for any natural number `n`. In other words, composing `AlgebraicTopology.DoldKan.PInfty.f` with itself (using `CategoryTheory.CategoryStruct.comp`) results in the original morphism `AlgebraicTopology.DoldKan.PInfty.f`. This property is crucial in the study of algebraic topology, particularly in the exploration of Dold-Kan correspondences.

For any preadditive category `C` and simplicial object `X` in `C`, the Dold-Kan morphism `AlgebraicTopology.DoldKan.PInfty.f` is idempotent.


theorem ZMod.val_add : ∀ {n : ℕ} [inst : NeZero n] (a b : ZMod n), ZMod.val (a + b) = (ZMod.val a + ZMod.val b) % n :=
  by sorry

This theorem, `ZMod.val_add`, states that for every natural number `n` that is not zero, and for any two integers `a` and `b` modulo `n` (`ZMod n`), the value (`ZMod.val`) of the sum of `a` and `b` is equal to the remainder of the sum of the values of `a` and `b` when divided by `n`. In mathematical notation, it can be represented as: for all `n ≠ 0`, `a`, `b` in `ZMod n`, we have `val(a + b) = (val(a) + val(b)) mod n`. This theorem essentially states a property of modular arithmetic where the value of the sum of two numbers modulo `n` can be computed by adding the numbers first and then taking the modulus.

For all natural numbers `n` not equal to zero and integers `a`, `b` in `ZMod n`, the sum `a + b` in `ZMod n` equals the remainder of `(val(a) + val(b))` when divided by `n`.


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

The theorem `Equiv.Perm.sameCycle_apply_left` states that for any type `α`, any permutation `f` of `α`, and any two elements `x` and `y` of `α`, `x` and `y` are in the same cycle of the permutation `f` if and only if the image of `x` under `f` and `y` are also in the same cycle of `f`. In other words, applying the permutation `f` to `x` does not change whether it is in the same cycle as `y` under the permutation `f`.

For any type `α`, permutation `f` of `α`, and elements `x` and `y` of `α`, `x` and `y` are in the same cycle of `f` if and only if `f(x)` and `y` are in the same cycle of `f`.


/-- **Alias** of the reverse direction of `measurable_iff_le_map`. -/
theorem Measurable.of_le_map :
    ∀ {α : Type u_1} {β : Type u_2} {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β},
      m₂ ≤ MeasurableSpace.map f m₁ → Measurable f :=
  by sorry

This theorem, also known as the reverse direction of `measurable_iff_le_map`, states that for any two types `α` and `β`, and measurable spaces `m₁` and `m₂` on `α` and `β` respectively, and a function `f` mapping `α` to `β`, if `m₂` is less than or equal to the forward image of `m₁` under `f` (i.e., `m₂ ≤ MeasurableSpace.map f m₁`), then `f` is a measurable function. In other words, if the preimage of every set in `m₂` under `f` is a measurable set in `m₁`, then `f` is a measurable function.

If a function between measurable spaces satisfies the preimage of every measurable set under the function being measurable in the domain space, then the function is measurable.


theorem Int.ceil_intCast : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (z : ℤ), ⌈↑z⌉ = z := by
  sorry

This theorem states that for any integer `z`, when cast to a type `α`, which is a linear ordered ring and a floor ring, the ceiling operation on the cast value will equal the original integer `z`. In essence, the ceiling of an integer, when it's cast to a certain type, is the integer itself.

For any integer `z`, the ceiling function of `z` when considered as an element of a linear ordered ring and a floor ring `α` is equal to `z` itself.


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

This theorem from Category Theory in mathematics, states that for any objects `W, X, Y, Z` in a category, and morphisms `f : W ⟶ X`, `g : X ⟶ Y`, `h : Y ⟶ Z`, the composition of the morphisms is associative. In other words, composing `f` with the result of composing `g` and `h` is the same as composing the result of composing `f` and `g` with `h`. This is written in mathematical notation as `(f ∘ (g ∘ h)) = ((f ∘ g) ∘ h)`, where `∘` represents the composition of morphisms.

In any category, the order of composing morphisms does not matter, that is, `(f ∘ g) ∘ h = f ∘ (g ∘ h)` for morphisms `f : W ⟶ X`, `g : X ⟶ Y`, and `h : Y ⟶ Z`.


theorem Bool.not_eq_false : ∀ (b : Bool), (¬b = false) = (b = true) := by sorry

This theorem states that for any boolean value `b`, the statement "not `b` equals false" is equivalent to the statement "`b` equals true". In other words, if the negation of a boolean value is false, then the original boolean value must have been true, and vice versa.

The negation of a boolean value is logically equivalent to its complement. That is, `not b` is equivalent to `b = false <rv> b = true`.


theorem IsCompl.of_eq :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x y : α}, x ⊓ y = ⊥ → x ⊔ y = ⊤ → IsCompl x y := by
  sorry

This theorem, `IsCompl.of_eq`, states that for any types `α` (where `α` is a lattice and a bounded order), and any elements `x` and `y` of `α`, if the infimum (greatest lower bound) of `x` and `y` equals the bottom element (`⊥`), and the supremum (least upper bound) of `x` and `y` equals the top element (`⊤`), then `x` and `y` are said to be complements of each other (denoted as `IsCompl x y`).

If `α` is a lattice and bounded order type, `x`, `y` ∈ `α`, `⊥ = inf (x, y)`, and `⊤ = sup (x, y)`, then `x` and `y` are complements of each other (`IsCompl x y`).


Option.forall

theorem Option.forall :
    ∀ {α : Type u_1} {p : Option α → Prop}, (∀ (x : Option α), p x) ↔ p none ∧ ∀ (x : α), p (some x) := by sorry

This theorem states that for any type `α` and a property `p` that applies to `Option α`, the property `p` holds for all elements of `Option α` if and only if `p` holds for `none` and `p` holds for all elements `x` of `α` when wrapped in `some`. In other words, in terms of optional values, if a property is true for all possible optional values, it must be true both for the value `none` and for any value `x` wrapped in `some`.

For any property `p` on `Option α`, `p` holds for all `Option α` if and only if `p(none)` and `∀x ∈ α, p(some x)` hold.


theorem Matrix.transpose_zero : ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Zero α], Matrix.transpose 0 = 0 :=
  by sorry

This theorem states that the transpose of a zero matrix, for any given types `m`, `n`, and `α`, where `α` is a type with a zero element, is also a zero matrix. In other words, transposing a matrix that consists solely of zero entries results in another matrix that also consists solely of zero entries. This is true regardless of the dimensions or types of the original zero matrix.

For any types `m`, `n`, and `α` with a zero element, the transpose of a zero `m x n` matrix over `α` is also a zero `n x m` matrix over `α`.


theorem AdjoinRoot.aeval_eq :
    ∀ {R : Type u} [inst : CommRing R] {f : Polynomial R} (p : Polynomial R),
      (Polynomial.aeval (AdjoinRoot.root f)) p = (AdjoinRoot.mk f) p :=
  by sorry

This theorem states that for any commutative ring `R` and any polynomial `f` over `R`, and given any polynomial `p` over `R`, applying the algebra homomorphism `Polynomial.aeval` at the adjoined root of `f` to the polynomial `p` is equivalent to applying the ring homomorphism `AdjoinRoot.mk` at `f` to the polynomial `p`. In other words, the `Polynomial.aeval` function, when evaluated at the root adjoined to `f`, and the `AdjoinRoot.mk` function, when evaluated at `f`, are the same when applied to any polynomial `p` in `R`.

For any commutative ring `R`, polynomial `f` over `R`, and polynomial `p` in `R`, `Polynomial.aeval (AdjoinRoot.mk f r) p = p.substRoot r f`, where `r` is the root adjoined to `f`.


Cauchy.mono

theorem Cauchy.mono :
    ∀ {α : Type u} [uniformSpace : UniformSpace α] {f g : Filter α} [hg : Filter.NeBot g],
      Cauchy f → g ≤ f → Cauchy g :=
  by sorry

The theorem `Cauchy.mono` states that for any uniform space `α` and any two filters `f` and `g` on `α` (where `g` is guaranteed not to be the bottom filter), if `f` is a Cauchy filter and `g` is a subset of `f`, then `g` is also a Cauchy filter. To put it simply, this theorem shows that the Cauchy property of a filter is preserved under taking subsets. The preservation of the Cauchy property is important because it ensures that when we restrict our attention to a smaller filter, we can still make the same conclusions about the closeness of the elements of the filter.

If `α` is a uniform space, `f` is a Cauchy filter on `α`, and `g` is a subset of `f` not equal to the bottom filter, then `g` is also a Cauchy filter.


theorem List.coe_toFinset : ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), ↑(List.toFinset l) = {a | a ∈ l} := by
  sorry

The theorem `List.coe_toFinset` states that for any given type `α` that has decidable equality (`DecidableEq α`), and for any list `l` of type `α`, the conversion of `l` to a finset (`List.toFinset l`) and then applying the coercion function `↑` to this finset results in a set which contains exactly the elements that are in `l`. In other words, it establishes that the process of converting a list to a finset and then coercing it back to a set simply gives us a set of unique elements from the original list, effectively removing any duplicate elements.

For any type `α` with decidable equality and any list `l` of `α`, the set obtained by converting `l` to a finset and then coercing it back to a set equals the set of unique elements in `l`.


CategoryTheory.MonoidalNatTrans.ext

theorem CategoryTheory.MonoidalNatTrans.ext :
    ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
      {D : Type u₂} {inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory D}
      {F G : CategoryTheory.LaxMonoidalFunctor C D} (x y : CategoryTheory.MonoidalNatTrans F G),
      x.app = y.app → x = y :=
  by sorry

This theorem is a statement about category theory, specifically monoidal categories and natural transformations. It states that for any two categories `C` and `D`, where `C` and `D` are both monoidal categories, and for any two lax monoidal functors `F` and `G` from `C` to `D`, if we have two monoidal natural transformations `x` and `y` from `F` to `G`, then if the application function (`app`) of `x` is equal to the application function of `y`, `x` and `y` must be the same. In other words, a monoidal natural transformation is determined by its application function.

If `F` and `G` are lax monoidal functors between monoidal categories `C` and `D`, and `x` and `y` are monoidal natural transformations from `F` to `G` with equal application functions, then `x = y`.


/-- Adding a vector to a point in a subspace produces a point in the subspace if and only if the
vector is in the direction.  -/
theorem AffineSubspace.vadd_mem_iff_mem_direction :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s : AffineSubspace k P} (v : V) {p : P},
      p ∈ s → (v +ᵥ p ∈ s ↔ v ∈ AffineSubspace.direction s) :=
  by sorry

The theorem `AffineSubspace.vadd_mem_iff_mem_direction` states that for any ring `k`, additive commutative group `V`, module over `k` with `V`, and add torsor `V` for `P`, and given an affine subspace `s` of `P`, a vector `v` in `V`, and a point `p` in `P` that belongs to the subspace `s`, adding the vector `v` to the point `p` results in a point that is in the subspace `s` if and only if the vector `v` is in the direction of the subspace `s`.

In simpler terms, this theorem says that in an affine subspace, you can add a vector to a point to get another point in the subspace, but only if the vector is along the direction of the subspace. The 'direction' of a subspace is defined as the set of all possible vectors that can be achieved by subtracting any two points within the subspace.

For an affine subspace of a module over a ring and a point in the subspace, a vector belongs to the subspace if and only if it is in the direction of the subspace, i.e., is obtained by subtracting any two points in the subspace.


theorem MeasureTheory.SimpleFunc.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      (f : MeasureTheory.SimpleFunc α β), MeasureTheory.AEStronglyMeasurable (↑f) μ :=
  by sorry

This theorem states that for all simple functions `f` from a measurable space `α` to a topological space `β`, `f` is "almost everywhere strongly measurable" with respect to any measure `μ` on `α`. Here, a function is said to be "almost everywhere strongly measurable" if it is almost everywhere equal to the limit of a sequence of simple functions.

A simple function `f` from a measurable space `α` to a topological space `β` is almost everywhere equal to the limit of a sequence of simple functions with respect to any measure `μ` on `α`.


theorem mem_nhdsWithin :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {t : Set α} {a : α} {s : Set α},
      t ∈ nhdsWithin a s ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t :=
  by sorry

This theorem states that for any type `α`, with a given topological structure, and any sets `t` and `s` from `α` and an element `a` from `α`, `t` is in the neighborhood within `s` of `a` if and only if there exists a set `u` such that `u` is open, `a` is in `u`, and the intersection of `u` and `s` is a subset of `t`. In other words, a set is in the neighborhood within another set of a certain point if and only if it contains the intersection of that other set with some open set containing the point.

For any topological space `(α, τ)`, point `a` in `α`, and sets `t, s` in `α`, `t` is a neighborhood of `a` within `s` if and only if there exists an open set `u` containing `a` such that `t` is a subset of `u ∩ s`.


theorem Units.continuous_val : ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Monoid M], Continuous Units.val :=
  by sorry

This theorem states that for any type `M`, given that `M` has a topological space structure and a monoid structure, the value function on units of `M` (which retrieves the underlying value in the base monoid) is continuous. This essentially means that the elements of `M` behave nicely under the operation of monoid in the topological sense, that is, the 'closeness' relations in `M` are preserved under the monoid operation.

If `M` is a type with both a topological space and a monoid structure, then the value function on units of `M` is continuous.


theorem MvPolynomial.aeval_C :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
      [inst_2 : Algebra R S₁] (f : σ → S₁) (r : R), (MvPolynomial.aeval f) (MvPolynomial.C r) = (algebraMap R S₁) r :=
  by sorry

The theorem `MvPolynomial.aeval_C` states that for any types `R`, `S₁`, `σ` where `R` is a commutative semiring, `S₁` is a commutative semiring and an algebra over `R`, and `f` is a map from `σ` to `S₁`, and for any element `r` of `R`, applying the algebra homomorphism generated by `f` to the constant polynomial with value `r` is equivalent to applying the algebra embedding from `R` to `S₁` to `r`. In other words, evaluating the constant polynomial using a certain algebra homomorphism returns the same result as mapping the constant value via the algebra embedding.

For any commutative semirings R and S₁, algebra homomorphism f : σ -> S₁, and r ∈ R, we have f.(constant polynomial of value r) = algebra embedding of R into S₁ (r).


theorem sq_lt_sq : ∀ {α : Type u_1} [inst : LinearOrderedRing α] {a b : α}, a ^ 2 < b ^ 2 ↔ |a| < |b| := by sorry

The theorem `sq_lt_sq` states that for any type `α` that is a linear ordered ring, and for any two elements (`a` and `b`) of this type, `a` squared is less than `b` squared if and only if the absolute value of `a` is less than the absolute value of `b`. In mathematical terms, it is expressed as \(a^2 < b^2 \Leftrightarrow |a| < |b|\).

For any linear ordered ring type `α` and its elements `a` and `b`, `a`'s square is less than `b`'s square if and only if the absolute value of `a` is less than the absolute value of `b`. In mathematical notation, `a² < b² ↔ |a| < |b|`.


TensorProduct.lift.tmul

theorem TensorProduct.lift.tmul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : Module R P] {f : M →ₗ[R] N →ₗ[R] P} (x : M) (y : N), (TensorProduct.lift f) (x ⊗ₜ[R] y) = (f x) y :=
  by sorry

This theorem states that for any commutative semiring 'R', types 'M', 'N', and 'P' each with a commutative monoid addition and a 'R'-module structure, and a bilinear map 'f' from 'M' to 'N' into 'P', the 'lift' of 'f' applied to the tensor product of elements 'x' from 'M' and 'y' from 'N' is equal to the evaluation of 'f' at 'x' and 'y'. In other words, lifting a bilinear map to the tensor product space and applying it to a tensor is the same as applying the original map to the components of the tensor.

For any commutative semiring 'R', and bilinear map 'f' from a commutative monoid 'M' with 'R'-module structure to commutative monoids 'N' and 'P' with 'R'-module structures, the lifting of 'f' to the tensor product 'M ⊗ N' satisfies 'f (x ⊗ y) = f x ⊗ y' for all 'x' in 'M' and 'y' in 'N'.


unitInterval.nonneg

theorem unitInterval.nonneg : ∀ (x : ↑unitInterval), 0 ≤ ↑x := by sorry

The theorem `unitInterval.nonneg` states that for every element `x` in the set `unitInterval`, which represents the closed interval from 0 to 1 in ℝ (real numbers), `x` is greater than or equal to 0. In other words, all elements in the `unitInterval` are nonnegative real numbers.

For all x in the real numbers, if x is an element of the unit interval [0, 1], then x ≥ 0.


theorem Pretrivialization.proj_symm_apply' :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} (e : Pretrivialization F proj) {b : B} {x : F},
      b ∈ e.baseSet → proj (↑(PartialEquiv.symm e.toPartialEquiv) (b, x)) = b :=
  by sorry

The theorem `Pretrivialization.proj_symm_apply'` states that for any types `B`, `F`, and `Z`, with `B` and `F` having a topology, a function `proj` from `Z` to `B`, a pretrivialization `e` of `F` with respect to `proj`, a point `b` in `B`, and a point `x` in `F`, if `b` is in the base set of the pretrivialization `e`, then the projection of the inverse of the partial equivalence associated with `e`, applied to the pair `(b, x)`, is equal to `b`. In simpler terms, this means that the inverse operation of the pretrivialization takes us back to our original point in the base set.

For any pretrivialization `e` of a topological space `F` over a base space `B`, with `b` in the base set and `x` in `F`, if `b` is in the image of `e`, then `proj(e.equiv.symm.(apply e.equiv)(b, x)) = b`.


theorem Finset.card_insert_le :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (insert a s).card ≤ s.card + 1 := by sorry

This theorem states that for any type `α` with decidable equality (i.e., for any two elements `a` and `b` of `α`, it's possible to decide whether `a = b` or not), any element `a` of `α`, and any finite set `s` of `α`, the cardinality (size, or number of distinct elements) of the set resulting from inserting `a` into `s` is less than or equal to the cardinality of `s` plus one. This stems from the fact that if `a` is already in `s`, the size of the set does not increase when `a` is inserted; otherwise, it increases by one.

For any type `α` with decidable equality and any finite set `s` in `α`, the cardinality of `s` and the cardinality of `s.insert(a)` differ by at most 1, where `a` is any element of `α`.


theorem Stream'.Seq.destruct_eq_cons :
    ∀ {α : Type u} {s : Stream'.Seq α} {a : α} {s' : Stream'.Seq α},
      Stream'.Seq.destruct s = some (a, s') → s = Stream'.Seq.cons a s' :=
  by sorry

This theorem, `Stream'.Seq.destruct_eq_cons`, states that for any type `α`, and for any sequences `s` and `s'` of type `α`, and for any element `a` of type `α`, if the destruct operation on sequence `s` yields `some` tuple consisting of `a` and `s'`, then the sequence `s` is equal to the sequence obtained by prepending `a` to `s'`. In other words, if destructing a sequence gives us an element and another sequence, this original sequence must have been constructed by consing (adding at the beginning) that element onto the second sequence.

If two sequences `s` and `s'` of type `α`, and an element `a` of type `α`, satisfy `s = some (a, s')` from the destruct operation on `s`, then `s` is equal to the sequence obtained by appending `a` to `s'`.


theorem Mathlib.Order.MinMax._auxLemma.1 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (c ≤ min a b) = (c ≤ a ∧ c ≤ b) := by sorry

This theorem states that for any type `α` that has a linear order, and for any three elements `a`, `b`, and `c` of type `α`, `c` is less than or equal to the minimum of `a` and `b` if and only if `c` is less than or equal to `a` and `c` is less than or equal to `b`. In LaTeX mathematics, this would be expressed as $c \leq \min(a, b) \iff (c \leq a \land c \leq b)$.

For any linear order type `α` and elements `a`, `b`, `c` of type `α`, `c` is the minimum of `a` and `b` if and only if `c` is less than or equal to both `a` and `b`.


theorem Nat.mod_eq_zero_of_dvd : ∀ {m n : ℕ}, m ∣ n → n % m = 0 := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `m` divides `n` (denoted as `m ∣ n`), then the remainder of `n` divided by `m` (`n % m`) is zero. Essentially, what this implies is that `n` is a multiple of `m` such that there is no remainder left when `n` is divided by `m`.

If `m` divides `n`, then the remainder of `n` divided by `m` is zero. (i.e., `m ∣ n` implies `n % m = 0`).


CompositionSeries.step

theorem CompositionSeries.step :
    ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] (s : CompositionSeries X) (i : Fin s.length),
      JordanHolderLattice.IsMaximal (s.series (Fin.castSucc i)) (s.series (Fin.succ i)) :=
  by sorry

The theorem `CompositionSeries.step` states that for any type `X` that forms a Lattice and a Jordan-Hölder Lattice, and for any composition series `s` of `X`, at every index `i` of the series (represented as a `Fin` type), the element at the index `i` cast to `Fin (n + 1)` (denoted by `Fin.castSucc i`) and the successor of the index `i` (denoted by `Fin.succ i`) in the series form a maximal pair as per the definition of maximality in Jordan-Hölder Lattice. In simpler terms, for each consecutive pair of elements in the composition series, the first element is less than the second, and there are no elements between them in the lattice structure.

For any composition series `s` of a type `X` that forms a Lattice and a Jordan-Hölder Lattice, the consecutive pairs of elements `(X.n i) (Fin.castSucc i)` in `s` satisfy `X.n i < X.n (Fin.succ i)` and there are no elements between them in the lattice structure.


theorem MeasureTheory.pdf_def :
    ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {x : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω}
      {μ : MeasureTheory.Measure E} {X : Ω → E}, MeasureTheory.pdf X ℙ μ = (MeasureTheory.Measure.map X ℙ).rnDeriv μ :=
  by sorry

The theorem `MeasureTheory.pdf_def` describes the relationship between the probability density function (pdf) and the Radon-Nikodym derivative of the push-forward measure. Specifically, for any measurable spaces `Ω` and `E`, a measure `ℙ` on `Ω`, a measure `μ` on `E`, and a random variable `X` from `Ω` to `E`, the pdf of `X` with respect to measures `ℙ` and `μ` is equal to the Radon-Nikodym derivative of the push-forward measure of `ℙ` along `X` with respect to `μ`. In simpler terms, this theorem provides a theoretical framework for calculating the probability distribution of a transformed random variable in terms of the original random variable and its transformation.

The pdf of a random variable with respect to two measures is equal to the Radon-Nikodym derivative of the push-forward measure of the first measure along the random variable with respect to the second measure.


theorem Filter.blimsup_eq_limsup :
    ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop},
      Filter.blimsup u f p = Filter.limsup u (f ⊓ Filter.principal {x | p x}) :=
  by sorry

The theorem `Filter.blimsup_eq_limsup` asserts that for any type `α` that forms a conditionally complete lattice, any filter `f` of type `β`, any function `u` from `β` to `α`, and any predicate `p` on `β`, the bounded limit superior (`blimsup`) of the function `u` along the filter `f`, bounded by the predicate `p`, is equal to the limit superior (`limsup`) of the function `u` along the infimum of the filter `f` and the principal filter of the set of elements satisfying the predicate `p`. In other words, it states that the infimum of all upper bounds `a` that are eventually reached by `u` at points where `p` holds, is the same as the infimum of all upper bounds that are eventually reached by `u` along the set of points where `p` is true.

For any conditionally complete lattice α, filter f on β, function u from β to α, and predicate p on β, the bounded limit superior of u along f, bounded by p, equals the limit superior of u along the infimum of f and the principal filter of elements satisfying p.


/-- A closed interval in a densely ordered conditionally complete linear order is preconnected.  -/
theorem isPreconnected_Icc :
    ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a b : α}, IsPreconnected (Set.Icc a b) :=
  by sorry

This theorem states that for any type `α` that has a ConditionallyCompleteLinearOrder, a TopologicalSpace, an OrderTopology, and is DenselyOrdered, any closed interval `(Set.Icc a b)` is preconnected. In mathematical terms, it means that for any closed interval in a densely ordered conditionally complete linear order, there is no non-trivial open partition. Specifically, given any two open sets `u` and `v`, if the interval is a subset of the union `u ∪ v` and the interval intersects both `u` and `v`, then it must also intersect the intersection `u ∩ v`.

In a densely ordered, conditionally complete linear order with a topology making it an order topology, every closed interval is preconnected, meaning that for any open sets `u` and `v` intersecting an interval, their intersection also intersects the interval.


theorem exists_ge_ge :
    ∀ {α : Type u} [inst : LE α] [inst_1 : IsDirected α fun x x_1 => x ≤ x_1] (a b : α), ∃ c, a ≤ c ∧ b ≤ c := by sorry

This theorem, `exists_ge_ge`, states that for any type `α` that has a less-than-or-equal-to (`≤`) operation and for which a direction can be determined (i.e., it can be decided whether one element is less than or equal to another), given any two elements `a` and `b` of `α`, there exists a third element `c` such that both `a` and `b` are less than or equal to `c`. In mathematical terms, this can be expressed as `∀a, b ∈ α, ∃c ∈ α, a ≤ c ∧ b ≤ c`. This theorem embodies one of the properties of directed sets in order theory.

For any type `α` with a decidable `≤` relation, there exists an element `c` such that `a ≤ c` and `b ≤ c` for all `a, b ∈ α`.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.17 : ∀ {V : Type u} (v w : V), ⊤.Adj v w = (v ≠ w) := by sorry

This theorem from Mathlib's combinatorics about simple graphs states that for any type `V` and any two elements `v` and `w` of that type, `v` and `w` are adjacent in the complete graph on `V` if and only if `v` is not equal to `w`. In graph theory, a complete graph is a simple undirected graph in which every pair of distinct vertices is connected by a unique edge. Here, ⊤ is used to denote the complete graph.

In the complete graph on type `V`, elements `v` and `w` are adjacent if and only if they are distinct.


theorem aemeasurable_const :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {b : β}, AEMeasurable (fun _a => b) μ :=
  by sorry

The theorem `aemeasurable_const` states that for any type `α`, measurable space `m` over `α`, type `β`, measurable space over `β`, measure `μ` over `α`, and element `b` of type `β`, the function which assigns `b` to every element of `α` is almost everywhere measurable with respect to `μ`. In other words, a constant function is almost everywhere measurable.

For any measurable spaces (α, m) and (β, ν) over types α and β, and any measure μ over (α, m) and constant function f : α → β, the function f is almost everywhere measurable with respect to μ.


theorem List.dedup_cons_of_mem :
    ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α}, a ∈ l → List.dedup (a :: l) = List.dedup l := by sorry

This theorem states that for any type `α` with decidable equality, given an element `a` of the type `α` and a list `l` of type `List α`, if `a` is an element of the list `l`, then the operation of removing duplicates from the list obtained by prepending `a` to `l` (`a :: l`) results in the same list as simply removing duplicates from the original list `l`. In other words, if the list already contains `a`, adding another `a` at the beginning doesn't change the list after removing duplicates.

For any type `α` with decidable equality and list `l` of `α`, if `a ∈ l`, then removing duplicates from `a :: l` equals removing duplicates from `l`.


theorem Finset.sup'_eq_sup :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} (H : s.Nonempty)
      (f : β → α), Finset.sup' s H f = Finset.sup s f :=
  by sorry

The theorem `Finset.sup'_eq_sup` states that for any types `α` and `β`, where `α` is a join-semilattice and also has a bottom element, any nonempty finite set `s` of type `β`, and any function `f` from `β` to `α`, the supremum of the image of `s` under `f` calculated with `Finset.sup'` (which requires a proof of non-emptiness of `s`) is equal to the supremum calculated with `Finset.sup` (which does not require `s` to be nonempty due to presence of a bottom element in `α`). In other words, if `s` is not empty, these two methods for calculating the supremum of the image of `s` under `f` are equivalent.

For any join-semilattice `α` with a bottom element, nonempty finite set `s` of type `β`, and function `f` from `β` to `α`, `Finset.sup' (f '' s) = Finset.sup (f '' s)`.


theorem CategoryTheory.ShortComplex.quasiIso_iff :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂] (φ : S₁ ⟶ S₂),
      CategoryTheory.ShortComplex.QuasiIso φ ↔ CategoryTheory.IsIso (CategoryTheory.ShortComplex.homologyMap φ) :=
  by sorry

This theorem states that for any two short complexes `S₁` and `S₂` in a category `C`, which possesses zero morphisms, and for any morphism `φ` from `S₁` to `S₂`, the short complex `φ` is a quasi-isomorphism if and only if the homology map of `φ` is an isomorphism. Essentially, this theorem is revealing a connection between the concepts of quasi-isomorphism in the domain of short complexes and isomorphism in the domain of homology maps.

A morphism between short complexes in a category with zero morphisms is a quasi-isomorphism if and only if its induced homology map is an isomorphism.