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

This theorem, `Set.diff_subset_iff`, states that for all types `α` and for all sets `s`, `t`, and `u` of type `α`, the set difference `s \ t` is a subset of `u` if and only if `s` is a subset of the union of `t` and `u`. In other words, all elements of `s` that are not in `t` belong to `u` if and only if all elements of `s` belong to either `t`, `u`, or both. This theorem is a fundamental result in set theory and forms an essential part of the lattice structure on the power set of a given set.

For sets `s`, `t`, and `u` in type `α`, `s \ t` is a subset of `u` if and only if `s` is a subset of `t ∪ u`.


theorem Real.Angle.neg_pi_div_two_ne_zero : ↑(-Real.pi / 2) ≠ 0 := by sorry

This theorem states that the negative half of the real number π, when coerced (converted) to an angle, is not equal to zero. In mathematical terms, −π/2 is not zero when we consider it as an angle. This theorem is important as it helps in ensuring the uniqueness and non-zero nature of angle values in mathematical proofs and computations.

The theorem asserts that the angle representation of the negative half of π is not equal to 0. That is, -π/2 ≠ 0.


theorem Complex.one_re : 1.re = 1 := by sorry

This theorem states that the real part of the complex number 1 is 1. In the context of complex numbers, each number is composed of a real and an imaginary part. In this case, the number being considered is 1 which is purely real, hence its real part is 1.

The real part of the complex number 1 is equal to 1.


theorem Function.support_zero' : ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M], Function.support 0 = ∅ := by sorry

This theorem states that for any types `α` and `M` where `M` is equipped with a zero, the support of the zero function (a function always returning zero) is the empty set. In other words, there are no elements `x` from `α` such that `0(x) ≠ 0`, since the zero function always returns `0` for any `x`, making its support set empty.

For any type `α` and zeroed type `M`, the support of the zero function is empty.


theorem Real.arcsin_eq_of_sin_eq :
    ∀ {x y : ℝ}, Real.sin x = y → x ∈ Set.Icc (-(Real.pi / 2)) (Real.pi / 2) → Real.arcsin y = x := by sorry

The theorem states that for any real numbers `x` and `y`, if `y` is the sine of `x` and `x` lies in the closed interval from negative half pi to half pi (i.e., `-π / 2 ≤ x ≤ π / 2`), then the arcsine of `y` is `x`. In other words, it establishes the reversibility of the sine function within its principal domain of `[-π/2, π/2]` under the arcsine function.

For any real numbers `x` and `y`, if `y = sin(x)` and `-π/2 ≤ x ≤ π/2`, then `x = arcsin(y)`.


theorem Polynomial.monic_one : ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 1 := by sorry

The theorem `Polynomial.monic_one` states that for any type `R` that has a semiring structure, the polynomial `1` is `Monic`. In other words, the polynomial with constant term `1` is considered `Monic` in any semiring, since its leading coefficient is indeed `1`.

In any semiring, the constant polynomial 1 is monic.


theorem Finsupp.support_neg :
    ∀ {α : Type u_1} {G : Type u_9} [inst : AddGroup G] (f : α →₀ G), (-f).support = f.support := by sorry

This theorem, `Finsupp.support_neg`, states that for any type `α` and an additive group `G`, the support of the negation of a function `f` from `α` to `G` is equal to the support of `f` itself. Here, "support" refers to the set of elements from `α` that the function `f` maps to non-zero elements in `G`. The negation of the function `f` is simply the function that maps each element to the additive inverse of its image under `f`.

For any function `f` from type `α` to an additive group `G`, the support of `f` and the support of the negation of `f` are equal.


RelIso.ext

theorem RelIso.ext :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} ⦃f g : r ≃r s⦄,
      (∀ (x : α), f x = g x) → f = g :=
  by sorry

This theorem states that for any two types `α` and `β`, any relations `r` on `α` and `s` on `β`, and any two relation-preserving isomorphisms `f` and `g` from `r` to `s`, if for every element `x` of type `α`, `f(x)` is equal to `g(x)`, then `f` is equal to `g`. In other words, if two relation-preserving isomorphisms between the same pairs of relations agree on every input, then they are the same isomorphism.

If two relation-preserving isomorphisms between the same pairs of relations agree on every input, then they are equal.


theorem Set.Icc_diff_Ioo_same :
    ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a ≤ b → Set.Icc a b \ Set.Ioo a b = {a, b} := by sorry

The theorem `Set.Icc_diff_Ioo_same` states that for any type `α` that is ordered with a partial order, given any two elements `a` and `b` from `α` such that `a` is less than or equal to `b`, the difference between the closed interval [a, b] and the open interval (a, b) is the set containing only the elements `a` and `b`. In terms of mathematics, this corresponds to the following set difference: `[a, b] \ (a, b) = {a, b}`.

For any ordered type `α` and elements `a ≤ b` in `α`, the set difference between the closed interval `[a, b]` and the open interval `(a, b)` equals the singleton set `{a, b}`.


theorem Nat.sqrt_le : ∀ (n : ℕ), Nat.sqrt n * Nat.sqrt n ≤ n := by sorry

This theorem states that for any natural number `n`, the square of its integer square root (calculated using the `Nat.sqrt` function) is less than or equal to `n` itself. In other words, for all `n` in the set of natural numbers, the inequality $(\text{Nat.sqrt } n)^2 \leq n$ holds. This is a property of integer square roots, reflecting the fact that they are the largest whole number whose square does not exceed the original number.

For all natural numbers `n`, the square of their integer square root (obtained from `Nat.sqrt`) is less than or equal to `n`. In mathematical notation: `(sqrt n)^2 ≤ n`.


theorem Polynomial.comp_X : ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.comp p Polynomial.X = p :=
  by sorry

This theorem, named `Polynomial.comp_X`, states that for any type `R` that is a semiring, and any polynomial `p` over `R`, the composition of `p` with the polynomial variable `X` (also known as the indeterminate) is just `p` itself. In other words, if you substitute `X` into the polynomial `p`, you get `p` back. This is similar to the mathematical notion that for any function `f(x)`, `f(x)` composed with `x` is just `f(x)`.

For any semiring `R` and polynomial `p` over `R`, the composition of `p` with the polynomial variable `X` is equal to `p` itself.


theorem Set.prod_eq_empty_iff : ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
  by sorry

The theorem `Set.prod_eq_empty_iff` states that for any types `α` and `β`, and any sets `s` of type `α` and `t` of type `β`, the Cartesian product of `s` and `t` is empty if and only if either `s` or `t` is empty. In other words, a Cartesian product of two sets is empty if at least one of those sets is empty.

The Cartesian product of two sets is empty if and only if one of the sets is empty.


theorem Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic._auxLemma.2 :
    ∀ {R : Type u} [inst : CommSemiring R] (x : PrimeSpectrum R) (s : Set R),
      (x ∈ PrimeSpectrum.zeroLocus s) = (s ⊆ ↑x.asIdeal) :=
  by sorry

The theorem, `Mathlib.AlgebraicGeometry.PrimeSpectrum.Basic._auxLemma.2`, states that for any commutative semiring `R`, given a prime spectrum `x` of `R` and a set `s` of elements of `R`, `x` is in the zero locus of `s` if and only if `s` is a subset of the ideal associated with `x`. In other words, a prime spectrum `x` is among the zero points of all the elements in `s` exactly when every element of `s` belongs to the ideal represented by `x`.

A prime spectrum is in the zero locus of a set of elements if and only if that set is contained in the ideal represented by the spectrum.


theorem Nat.succ_sub : ∀ {m n : ℕ}, n ≤ m → Nat.succ m - n = Nat.succ (m - n) := by sorry

This theorem states that for all natural numbers `m` and `n`, if `n` is less than or equal to `m`, then subtracting `n` from the successor of `m` (i.e., `m` plus one, or `Nat.succ m`) is equal to the successor of `m - n`. In mathematical terms, the theorem can be expressed as ∀m, n ∈ ℕ, n ≤ m → (m+1) - n = (m - n) + 1.

For all natural numbers `m` and `n`, if `n` lever equals `m`, then `(m + 1) - n = (m - n) + 1`.


theorem isOpen_set_pi :
    ∀ {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {i : Set ι} {s : (a : ι) → Set (π a)},
      Set.Finite i → (∀ a ∈ i, IsOpen (s a)) → IsOpen (Set.pi i s) :=
  by sorry

The theorem `isOpen_set_pi` states that for any type `ι`, any function `π` mapping `ι` to a type, a topological space on each type `π i`, a set `i` of type `ι`, and a family of sets `s` indexed by `ι` and mapping to each type `π a`, if the set `i` is finite and each set `s a` is open for all `a` in `i`, then the set of all dependent functions `f` such that `f a` belongs to `s a` for all `a` in `i`, denoted as `Set.pi i s`, is also an open set. In other words, the cartesian product of a finite number of open sets is an open set in the product topology.

For a finite index type `ι`, a function `π : ι → Type`, a topological space on each `π i`, a set `i` of type `ι`, and a family `s : ∀ a, π a → Set`, if each `s a` is an open set in the subspace topology on `π a`, then `Set.pi i s` is an open set in the product topology on `Π a, s a`.


LT.lt.asymm

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

This theorem, also known as the alias of `lt_asymm`, states that for any type `α` with a preorder relation, given two elements `a` and `b` of that type, if `a` is less than `b`, then it cannot be the case that `b` is less than `a`. This theorem expresses the asymmetry of the 'less than' relation in a preordered set.

If `a` is less than `b` in a preordered type `α`, then it is not the case that `b` is less than `a`.


HasMFDerivAt.mfderiv

theorem HasMFDerivAt.mfderiv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {x : M} [Is : SmoothManifoldWithCorners I M] [I's : SmoothManifoldWithCorners I' M']
      {f' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)}, HasMFDerivAt I I' f x f' → mfderiv I I' f x = f' :=
  by sorry

This theorem states that for a function `f` mapping one smooth manifold `M` to another `M'`, under the conditions established by certain structures (such as `NontriviallyNormedField`, `NormedAddCommGroup`, `NormedSpace`, `TopologicalSpace`, `ModelWithCorners`, `ChartedSpace`, `SmoothManifoldWithCorners`), if `f` has a manifold derivative `f'` at a point `x` in `M` (expressed as `HasMFDerivAt`), then the manifold derivative of `f` at `x` (expressed as `mfderiv`) equals `f'`. In other words, if `f` has a certain manifold derivative at a point, that derivative is the manifold derivative at that point.

Given a smooth manifold function `f : M → M'` between two smooth manifolds `M` and `M'`, if `f` has a manifold derivative `HasMFDerivAt f x` at a point `x ∈ M`, then the manifold derivative `mfderiv f x` of `f` at `x` equals `f'`.


theorem continuous_bot : ∀ {α : Type u} {β : Type v} {f : α → β} {t : TopologicalSpace β}, Continuous f := by sorry

This theorem states that for any two types `α` and `β`, and for any function `f` from `α` to `β`, and for any topology `t` on `β`, the function `f` is continuous. In mathematical terms, this corresponds to the definition that a function is continuous if the preimage of every open set is open, for all types and all functions between them, regardless of the topology on the codomain.

For any types `α` and `β`, and any function `f` from `α` to `β`, if `t` is a topology on `β`, then `f` is continuous with respect to `t` if and only if the preimage of every open set in `β` under `f` is open in `α`.


theorem Finset.subset_singleton_iff : ∀ {α : Type u_1} {s : Finset α} {a : α}, s ⊆ {a} ↔ s = ∅ ∨ s = {a} := by sorry

This theorem states that for any type `α`, any finite set `s` of `α`, and any element `a` of `α`, the set `s` is a subset of the singleton set `{a}` if and only if `s` is either the empty set or it is equal to the singleton set `{a}`.

For any type `α` and any finite set `s` of `α`, `s` is a subset of the singleton set `{a}` if and only if `s` is the empty set or `s` = {`a`}.


theorem variationOnFromTo.eq_of_le :
    ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] (f : α → E) (s : Set α)
      {a b : α}, a ≤ b → variationOnFromTo f s a b = (eVariationOn f (s ∩ Set.Icc a b)).toReal :=
  by sorry

This theorem states that for any type `α` with a linear order, any pseudo-emetric space `E`, any function `f` from `α` to `E`, and any set `s` of `α`, and for any `a` and `b` in `α` where `a` is less than or equal to `b`, the signed variation of `f` on the interval `[a, b]` (inclusive) intersected with the set `s` is equal to the real value conversion of the extended real-valued variation of `f` on the intersection of set `s` and the interval `[a, b]`. This is essentially expressing a property about how the function's variation behaves on a specific interval when the order of the endpoints is certain.

For any linear order `α`, pseudo-metric space `E`, function `f` from `α` to `E`, set `s` of `α`, and `a ≤ b` in `α`, the signed variation of `f` on the interval `[a, b]` intersected with `s` equals the real value conversion of the extended real-valued variation of `f` on `s ∩ [a, b]`.


/-- Alias for `Or.inl`.  -/
theorem Or.intro_left : ∀ {a : Prop} (b : Prop), a → a ∨ b := by sorry

This theorem, named `Or.intro_left`, is an alias for `Or.inl` and is used to introduce the "or" logical operator (`∨`). It states that for any two propositions `a` and `b`, if `a` is true, then the proposition " `a ∨ b` " is also true. In other words, it's a way to confirm that if you have a proof of `a`, you can use that to create a proof of `a ∨ b`, regardless of whether `b` is true or not.

If `a` is a proposition, then `a ∨ b` holds. (Assumes `b` is arbitrary.)


theorem Polynomial.ne_zero_of_natDegree_gt :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ}, n < Polynomial.natDegree p → p ≠ 0 := by sorry

The theorem `Polynomial.ne_zero_of_natDegree_gt` states that for any semiring `R`, and for any polynomial `p` with coefficients in `R`, if there exists a natural number `n` which is less than the natural degree of `p` (`Polynomial.natDegree p`), then `p` cannot be the zero polynomial. In other words, a polynomial with a degree greater than zero is not the zero polynomial.

A polynomial over a semiring with natural degree greater than zero is not the zero polynomial.


theorem Filter.map_eq_bot_iff : ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β}, Filter.map m f = ⊥ ↔ f = ⊥ := by
  sorry

This theorem states that for any types `α` and `β`, any filter `f` of type `α`, and any mapping `m` from `α` to `β`, the forward map of the filter `f` under the mapping `m` is equal to the bottom element (the empty filter), if and only if the original filter `f` is also the bottom element. In other words, the operation of mapping a filter through a function results in an empty filter if and only if the original filter was empty.

For any filters $f$ on type $\alpha$ and any function $m:\alpha \to \beta$, $m(f) = \bot$ if and only if $f = \bot$.


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

This theorem, `inf_inf_inf_comm`, states that for all types `α` that form a semilattice under the infimum operation (notated as `⊓`), for any four elements `a`, `b`, `c`, and `d` of type `α`, the infimum of `a`, `b`, and the infimum of `c`, `d` is equal to the infimum of `a`, `c`, and the infimum of `b`, `d`. In other words, written in mathematical notation, regardless of the specific elements, the property $a \land b \land (c \land d) = a \land c \land (b \land d)$ holds for any semilattice.

For all semilattices α and elements a, b, c, d of type α, the infimum of a, b and the infimum of c, d equals the infimum of a, c and the infimum of b, d. In other words, a ⊓ b ⊓ (c ⊓ d) = a ⊓ c ⊓ b ⊓ d.


theorem Polynomial.sub_comp :
    ∀ {R : Type u} [inst : Ring R] {p q r : Polynomial R},
      Polynomial.comp (p - q) r = Polynomial.comp p r - Polynomial.comp q r :=
  by sorry

This theorem states that for any type `R` that forms a ring, and for any three polynomials `p`, `q`, and `r` over `R`, the composition of the difference of `p` and `q` with `r` equals to the difference of the compositions of `p` and `q` with `r` respectively. In mathematical terms, this can be written as `(p - q) ∘ r = p ∘ r - q ∘ r`, where `∘` denotes the composition of polynomials.

For any rings `R` and polynomials `p`, `q`, and `r` over `R`, the composition of `p - q` with `r` equals the difference of the compositions of `p` and `q` with `r`. In other words, `(p - q) ∘ r = p ∘ r - q ∘ r`.


theorem closure_subset_iff_isClosed :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], closure s ⊆ s ↔ IsClosed s := by sorry

This theorem states that for all types `X` and for all sets `s` of type `X` in a given topological space, the closure of `s` is a subset of `s` if and only if `s` is a closed set. In other words, within the constraints of a particular topology, any set `s` is considered closed if and only if every point in its closure is also a point in `s`.

A set `s` in a topological space is closed if and only if its closure is a subset of `s`.


theorem CategoryTheory.MonoidalCategory.whisker_exchange :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {W X Y Z : C}
      (f : W ⟶ X) (g : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft W g)
          (CategoryTheory.MonoidalCategory.whiskerRight f Z) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f Y)
          (CategoryTheory.MonoidalCategory.whiskerLeft X g) :=
  by sorry

The theorem `CategoryTheory.MonoidalCategory.whisker_exchange` states that, given a category `C` which is also a monoidal category, and morphisms `f` from `W` to `X` and `g` from `Y` to `Z` (where `W`, `X`, `Y`, `Z` are objects in the category `C`), the composition of whisker-left operation applied to `W` and `g`, followed by the whisker-right operation applied to `f` and `Z`, is equal to the composition of the whisker-right operation applied to `f` and `Y`, followed by the whisker-left operation applied to `X` and `g`.

In other words, in a monoidal category, you can exchange the order of the whiskering operations, as long as you adjust the objects appropriately. This is an important property in category theory, particularly in the context of monoidal categories.

In a monoidal category, the composition of whisker-left on object W with morphism g, followed by whisker-right on f and Z, equals the composition of whisker-right on f and object Y with whisker-left on X and morphism g.


theorem normalize_eq_normalize :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {a b : α},
      a ∣ b → b ∣ a → normalize a = normalize b :=
  by sorry

This theorem, `normalize_eq_normalize`, states that for any type `α` that has a `CancelCommMonoidWithZero` and a `NormalizationMonoid` instance, and for any two elements `a` and `b` of this type, if `a` divides `b` and `b` divides `a`, then the normalized form of `a` is equal to the normalized form of `b`.

In mathematical terms, `a` divides `b` and `b` divides `a` means that `a` and `b` are associate elements. The `normalize` function is defining a canonical representative from each associate class, by multiplying each element by the `normUnit` of the element. The theorem is essentially saying that if two elements are associates, they have the same canonical representative.

For any type `α` with `CancelCommMonoidWithZero` and `NormalizationMonoid` instances, if `a` and `b` are associates, then their normalized forms are equal.


Primrec.ite

theorem Primrec.ite :
    ∀ {α : Type u_1} {σ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Prop}
      [inst_2 : DecidablePred c] {f g : α → σ},
      PrimrecPred c → Primrec f → Primrec g → Primrec fun a => if c a then f a else g a :=
  by sorry

The theorem `Primrec.ite` states that for any types `α` and `σ` with instances of `Primcodable`, any decidable predicate `c : α → Prop`, and any two functions `f, g : α → σ`, if `c` is a primitive recursive predicate and `f` and `g` are primitive recursive functions, then the function which maps an element `a : α` to `f a` if `c a` holds and to `g a` otherwise is also primitive recursive. This corresponds to the primitive recursion of an if-then-else construct where the condition and both branches are primitive recursive.

Given types `α` and `σ` with decidable and primitive recursive predicate `c : α → Prop` and primitive recursive functions `f, g : α → σ`, the function `x ↦ if h : c x then f x else g x` is primitive recursive.


theorem ConvexBody.hausdorffEdist_ne_top :
    ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] {K L : ConvexBody V},
      EMetric.hausdorffEdist ↑K ↑L ≠ ⊤ :=
  by sorry

The theorem `ConvexBody.hausdorffEdist_ne_top` states that for any type `V` which is a seminormed additive commutative group and a real normed space, the Hausdorff edistance between the underlying sets of any two convex bodies `K` and `L` in `V` is never equal to positive infinity. Here, the Hausdorff edistance between two sets is defined as the smallest `r` such that each set is contained in the `r`-neighborhood of the other one.

The Hausdorff distance between any two convex bodies in a seminormed additive commutative group and real normed space is finite.


theorem imp_iff_not_or : ∀ {a b : Prop}, a → b ↔ ¬a ∨ b := by sorry

This theorem states that for any two propositions `a` and `b`, the implication `a → b` is logically equivalent to `¬a ∨ b`. In other words, "if `a` then `b`" is the same as "either `a` is not true, or `b` is true". This is a principle from propositional logic.

The logical equivalence of `a → b` and `¬a ∨ b` holds in propositional logic.


theorem IsScalarTower.algebraMap_smul :
    ∀ {R : Type u} (A : Type w) {M : Type v₁} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : MulAction A M] [inst_4 : SMul R M] [inst_5 : IsScalarTower R A M] (r : R) (x : M),
      (algebraMap R A) r • x = r • x :=
  by sorry

The theorem `IsScalarTower.algebraMap_smul` states that for any commutative semiring `R`, semiring `A`, and type `M`, given that `A` is an algebra over `R`, `M` is a module over `A`, `R` acts by scalar multiplication on `M`, and `R`, `A`, and `M` form a scalar tower, then scalar multiplication by an element `r` of `R` on an element `x` of `M`, when `r` is first mapped to `A` via the algebra structure, is the same as direct scalar multiplication by `r` on `x`. In mathematical terms, this can be written as $(\phi(r)) \cdot x = r \cdot x$ where $\phi : R \to A$ is the algebra structure map.

For any commutative semiring R, algebra A over R, A-module M, scalar action of R on M, and scalar tower (R, A, M), the algebra map of R to A commutes with scalar multiplication on M: $\phi(r) \cdot x = r \cdot x$.


/-- The **Heine–Borel theorem**: In a proper space, a closed bounded set is compact.  -/
theorem Metric.isCompact_of_isClosed_isBounded :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} [inst_1 : ProperSpace α],
      IsClosed s → Bornology.IsBounded s → IsCompact s :=
  by sorry

The **Heine-Borel theorem** states that in a proper space - a space where every closed ball is compact - if a set is both closed and bounded, it is also compact. In other words, for any type `α` equipped with a pseudometric space structure and for any set `s` of type `α` in a proper space, if `s` is closed and `s` is bounded with respect to the bornology on `α` (meaning that it is not larger than any given set in the bornology), then `s` is compact. A set is compact if, for every nontrivial filter that contains the set, there exists a point in the set such that every set in the filter intersects with every neighborhood of that point.

In a proper metric space, a bounded and closed set is compact.


theorem CategoryTheory.MorphismProperty.id_mem :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
      [inst_1 : CategoryTheory.MorphismProperty.ContainsIdentities W] (X : C), W (CategoryTheory.CategoryStruct.id X) :=
  by sorry

This theorem states that for any category `C` and for any `MorphismProperty` `W` that contains identity morphisms, the identity morphism of any object `X` in `C` is an element of `W`. In other words, if `W` is a property that all identity morphisms possess in the category `C`, then the identity morphism on any object `X` in `C` has the property `W`.

In any category `C` and for any morphism property `W` containing identity morphisms, the identity morphism of every object `X` in `C` belongs to `W`.


padicValRat.one

/-- `padicValRat p 1` is `0` for any `p`.  -/
theorem padicValRat.one : ∀ {p : ℕ}, padicValRat p 1 = 0 := by sorry

The theorem `padicValRat.one` states that for any natural number `p`, the p-adic valuation of the rational number 1 is equal to 0. Here, the p-adic valuation is defined as the difference of the valuations of the numerator and the denominator of the rational number. In this case, since both the numerator and denominator are 1, their p-adic valuations are the same, hence their difference is 0.

The p-adic valuation of the rational number 1 is 0.


theorem Matrix.det_apply :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n R),
      Matrix.det M = Finset.sum Finset.univ fun σ => Equiv.Perm.sign σ • Finset.prod Finset.univ fun i => M (σ i) i :=
  by sorry

The theorem `Matrix.det_apply` states that for any square matrix `M` with entries in a commutative ring `R`, and whose rows and columns are indexed by a type `n` that has decidable equality and is finite, the determinant of `M` is equal to the sum, over all permutations `σ`, of the product of the sign of `σ` and the product, over all indices `i`, of the `i`-th row and `σ(i)`-th column entry of `M`. It essentially expresses the determinant of a matrix in terms of the Leibniz formula.

The determinant of a square matrix over a commutative ring with decidable equality and finite index type is equal to the sum, over all permutations, of the sign of the permutation times the product of the corresponding row-column entries.


theorem Finset.sup_biUnion :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {f : β → α}
      [inst_2 : DecidableEq β] (s : Finset γ) (t : γ → Finset β),
      Finset.sup (Finset.biUnion s t) f = Finset.sup s fun x => Finset.sup (t x) f :=
  by sorry

The theorem `Finset.sup_biUnion` states that for all types `α`, `β`, and `γ` with `α` being a semilattice with least element (`OrderBot α`), given a function `f` from `β` to `α`, a decision procedure for equality of `β` elements (`DecidableEq β`), a finite set `s` of elements of type `γ`, and a function `t` from `γ` to finite sets of `β`, then the supremum (greatest element) of the union of all `t x` (for each `x` in `s`) under the function `f` is equal to the supremum of the set `s` under the function which maps `x` to the supremum of `t x` under `f`. In other words, we can either first form the union of all sets `t x` and then find the supremum, or we can first find the supremum of each `t x` and then find the supremum of these supremums, and the result will be the same. This is a property of the function `sup` applied to the union of finite sets in the context of semilattices.

For any semilattice `α` with least element, given a function `f : β -> α`, a decision procedure for equality of `β`, a finite set `s : γ`, and a function `t : γ -> Finset β`, the supremum of `f` applied to the union of `t x` for all `x` in `s` equals the supremum of `f` applied to the supremum of each `t x`.


theorem Int.negSucc_eq : ∀ (n : ℕ), Int.negSucc n = -(↑n + 1) := by sorry

This theorem, `Int.negSucc_eq`, states that for any natural number `n`, the function `Int.negSucc n` is equivalent to the negation of the sum of the natural number `n` and one. In mathematical terms, this can be written as `Int.negSucc n = -(n + 1)`, where `n` is a natural number.

The theorem `Int.negSucc_eq` asserts that `Int.negSucc n = -(n + 1)` for all natural numbers `n`.


theorem Real.arcsin_zero : Real.arcsin 0 = 0 := by sorry

This theorem states that the arcsine of 0 is 0. In mathematical terms, this would be written as arcsin(0) = 0. Arcsine is the inverse function of sine, and this theorem is saying that when you apply the arcsine function to 0, you get a result of 0.

The theorem asserts that the value of the inverse sine function is zero for input zero: arcsin(0) = 0.


theorem Profinite.NobelingProof.continuous_projRestrict :
    ∀ {I : Type u} (C : Set (I → Bool)) (J : I → Prop) [inst : (i : I) → Decidable (J i)],
      Continuous (Profinite.NobelingProof.ProjRestrict C J) :=
  by sorry

The theorem `Profinite.NobelingProof.continuous_projRestrict` asserts that for any type `I`, any set `C` of Boolean-valued functions on `I`, and any property `J` of the elements of `I`, given that we can decide for each `i` in `I` whether `J i` holds, the restriction of the projection `Proj` to a subset and mapping to its image (represented by the function `Profinite.NobelingProof.ProjRestrict C J`) is continuous.

Given a type `I`, a set `C` of Boolean-valued functions on `I`, and a property `J` of elements in `I`, if we can decide for each `i` in `I` whether `J(i)` holds, then the continuous restriction of the projection `Proj` to a subset and mapping to its image (`Profinite.NobelingProof.ProjRestrict C J`) is a continuous function.


theorem List.Perm.cons_inv :
    ∀ {α : Type u_1} {a : α} {l₁ l₂ : List α}, List.Perm (a :: l₁) (a :: l₂) → List.Perm l₁ l₂ := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, if a list `l₁` with `a` prefixed is a permutation of another list `l₂` with `a` prefixed, then `l₁` is a permutation of `l₂`. In other words, if two lists are permutations of each other once an identical item is added to the start of each, then they were permutations of each other even before that item was added.

If two lists `l₁` and `l₂`, each containing an element `a`, are permutations of each other, then `l₁` is a permutation of `l₂`.


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

This theorem states that for any type `α`, any permutation `f` on `α`, and any two elements `x` and `y` of type `α`, `x` and `y` being in the same cycle of permutation `f` is equivalent to `y` and `x` being in the same cycle of permutation `f`. In other words, the "same cycle" relation under a given permutation is symmetric: if `x` can be transformed into `y` by applying the permutation a certain number of times, then `y` can be transformed into `x` by applying the permutation a certain number of times.

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


theorem Mathlib.FieldTheory.RatFunc._auxLemma.4 :
    ∀ {K : Type u} [inst : CommRing K] (p q : FractionRing (Polynomial K)),
      { toFractionRing := p } * { toFractionRing := q } = { toFractionRing := p * q } :=
  by sorry

This theorem states that for any commutative ring `K` and any two elements `p` and `q` in the fraction ring of the polynomial ring over `K` (denoted as `FractionRing (Polynomial K)`), the product of `p` and `q` in this fraction ring is the same as if we multiplied `p` and `q` as polynomials first and then put them in the fraction ring. This essentially tells us that the fraction ring operation is compatible with the multiplication operation in the ring.

For any commutative ring K, the multiplication in the fraction ring of polynomials over K agrees with the quotient of their multiplication as polynomials.


Function.Surjective.nontrivial

/-- Pullback a `Nontrivial` instance along a surjective function.  -/
theorem Function.Surjective.nontrivial :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Nontrivial β] {f : α → β}, Function.Surjective f → Nontrivial α := by sorry

The theorem `Function.Surjective.nontrivial` states that for any two types `α` and `β`, given that `β` is nontrivial (i.e., there are at least two distinct elements in `β`), and given a function `f` from `α` to `β` that is surjective (i.e., for every element `b` in `β`, there is some element `a` in `α` such that `f(a)` equals `b`), then `α` is also nontrivial. In other words, if we have a surjective function from `α` to a nontrivial type `β`, then `α` must be nontrivial as well.

If `β` is a nontrivial type and `f` is a surjective function from `α` to `β`, then `α` is also a nontrivial type.


theorem Valuation.ne_zero_iff :
    ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommMonoidWithZero Γ₀]
      [inst_2 : Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K}, v x ≠ 0 ↔ x ≠ 0 :=
  by sorry

The theorem `Valuation.ne_zero_iff` states that for every division ring `K` and every non-trivial, linearly ordered commutative monoid with zero `Γ₀`, for a valuation `v` from `K` to `Γ₀`, a non-zero value `x` in `K` is associated with a non-zero value in `Γ₀` under the valuation `v`. In other words, `v` of `x` is not equal to zero if and only if `x` is not equal to zero.

For every division ring K and non-trivial, linearly ordered commutative monoid with zero Γ₀, a valuation v from K to Γ₀ maps non-zero elements in K to non-zero elements in Γ₀.


theorem continuous_sub_left :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G] (a : G),
      Continuous fun x => a - x :=
  by sorry

This theorem states that for any type `G` that has a topological structure (i.e., `G` is a topological space), a subtraction operation (`Sub G`), and the subtraction operation is continuous (`ContinuousSub G`), then for any given element `a` of type `G`, the function that subtracts each element `x` in `G` from `a` is a continuous function. This essentially says that subtraction from a fixed element in a topological group with continuous subtraction is a continuous operation.

If `G` is a topological space with a continuous subtraction operation, then for any `a` in `G`, the function `x ↦ a - x` is a continuous function from `G` to `G`.


theorem CategoryTheory.Sieve.pullback_monotone :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X),
      Monotone (CategoryTheory.Sieve.pullback f) :=
  by sorry

This theorem states that for any category `C`, and any morphism `f` from an object `Y` to another object `X` in `C`, the pullback operation (which assigns to each sieve on `X` a sieve on `Y` that is the inverse image of the original sieve under the morphism `f`) is monotone. In other words, if a sieve `S` is "less than or equal to" a sieve `T` (in the sense that every morphism in `S` is also in `T`), then the pullback of `S` under `f` is "less than or equal to" the pullback of `T` under `f`. This property is crucial in many constructions involving categories and functors.

Given any category `C`, any morphism `f` from object `Y` to `X`, and sieves `S` and `T` on `X` with `S ⊆ T`, the pullback of `S` under `f` is contained in the pullback of `T` under `f`.


NNRat.ext

theorem NNRat.ext : ∀ {p q : NNRat}, ↑p = ↑q → p = q := by sorry

This theorem, `NNRat.ext`, states that for any two nonnegative rational numbers `p` and `q`, if these numbers are equal when coerced to their underlying rational numbers (i.e., `↑p = ↑q`), then `p` and `q` themselves are also equal. It is essentially stating that the equality in the universe of nonnegative rational numbers (`NNRat`) is consistent with the equality in the universe of all rational numbers.

For any nonnegative rational numbers `p` and `q`, if `↑p = ↑q`, then `p = q`.


theorem not_isMax_iff : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, ¬IsMax a ↔ ∃ b, a < b := by sorry

The theorem `not_isMax_iff` states that for any type `α` that has a preorder (a binary relation that is reflexive and transitive), an element `a` is not a maximal element if and only if there exists an element `b` such that `a` is strictly less than `b`. In other words, `a` is not the greatest element in `α` if we can find another element `b` in `α` that is bigger than `a`.

For any preordered type `α` and element `a` in `α`, `a` is not a maximal element if and only if there exists `b` in `α` such that `a` is strictly preceded by `b` in the preorder relation.


/-- Any linear map on a finite dimensional space over a complete field is continuous.  -/
theorem LinearMap.continuous_of_finiteDimensional :
    ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
      [inst_2 : TopologicalSpace E] [inst_3 : TopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
      [inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : TopologicalAddGroup F']
      [inst_9 : ContinuousSMul 𝕜 F'] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : FiniteDimensional 𝕜 E]
      (f : E →ₗ[𝕜] F'), Continuous ⇑f :=
  by sorry

This theorem states that any linear map `f` from a vector space `E` to another space `F'`, where both `E` and `F'` are over the same complete field `𝕜`, is continuous. The vector space `E` is assumed to be finite-dimensional, topological, and a topological add group with continuous scalar multiplication. The space `F'` is also assumed to be topological and a topological add group with continuous scalar multiplication. The field `𝕜` is assumed to be a complete space with nontrivial norms.

Any finite-dimensional linear map between topological vector spaces over a complete field with continuous scalar multiplication is continuous.


theorem Mathlib.Logic.Equiv.PartialEquiv._auxLemma.2 :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {x : α}, x ∈ e.source → (↑e x ∈ e.target) = True := by sorry

This theorem from the `Mathlib.Logic.Equiv.PartialEquiv` module states that for any given partial equivalence `e` between two types `α` and `β`, if an element `x` of type `α` is in the source of `e`, then the result of applying `e` to `x`, denoted by `↑e x`, is in the target of `e`. This is always true. In other words, the partial equivalence `e` maps elements from its source to its target.

If `e` is a partial equivalence between types `α` and `β`, then for all `x ∈ α`, `↑e x ∈ β`.


theorem Filter.nhds_eq : ∀ {α : Type u_2} (l : Filter α), nhds l = Filter.lift' l (Set.Iic ∘ Filter.principal) := by
  sorry

This theorem states that for any type α and any filter `l` on α, the neighborhood filter of `l` is equivalent to the filter obtained by applying the lift' operation to `l` with the function that maps each set to the set of all those elements which are less than or equal to all elements of the principal filter of the set. In other words, the filter of all neighborhoods (sets containing an open subset) at a given point `l` in a topological space is equal to the filter generated by mapping `l` through a process that first generates the principal filter (the collection of all supersets) of a set and then collects all elements that are less than or equal to any element in that principal filter.

The neighborhood filter of a filter on a type is equivalent to the filter generated by applying the lift' operation and taking the set of elements less than or equal to each principal filter.


theorem Multiset.toFinset_zero : ∀ {α : Type u_1} [inst : DecidableEq α], Multiset.toFinset 0 = ∅ := by sorry

The theorem `Multiset.toFinset_zero` states that for any type `α` that has decidable equality (meaning, we can definitively determine whether any two elements of type `α` are equal or not), the operation of transforming an empty multiset (denoted by `0`) into a finset (a set with no duplicates) results in an empty finset (denoted by `∅`). In other words, the finset version of an empty multiset is also empty, regardless of the type of its elements.

The theorem asserts that the conversion of an empty multiset to a finset results in the empty finset, for types with decidable equality.


theorem WittVector.coeff_frobenius_charP :
    ∀ (p : ℕ) {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] [inst_1 : CharP R p] (x : WittVector p R)
      (n : ℕ), (WittVector.frobenius x).coeff n = x.coeff n ^ p :=
  by sorry

This theorem, `WittVector.coeff_frobenius_charP`, states that, for any natural number `p`, any type `R` which is a commutative ring, and any Witt vector `x` in the ring `R`, if `R` has characteristic `p` and `p` is prime, then the `n`-th coefficient of the Frobenius endomorphism of `x` is equal to the `p`-th power of the `n`-th coefficient of `x`. In mathematical terms, if $\text{coeff}_{\text{frobenius}}(x,n) = \text{coeff}(x,n)^p$. This theorem is crucial in the field of number theory, particularly in the exploration of p-adic numbers and their applications.

For any prime number p and Witt vector x in a commutative ring R of characteristic p, the n-th coefficient of the Frobenius endomorphism of x equals the p-th power of the n-th coefficient of x.


Thunk.ext

theorem Thunk.ext : ∀ {α : Type u} {a b : Thunk α}, Thunk.get a = Thunk.get b → a = b := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of the type `Thunk α`, if the result of the `Thunk.get` function applied to `a` equals the result of the `Thunk.get` function applied to `b`, then `a` equals `b`. In other words, two thunk objects are equal if and only if they produce the same value when their contained functions are invoked.

For all types `α` and elements `a` and `b` of `Thunk α`, if `Thunk.get a = Thunk.get b`, then `a = b`.


theorem DFunLike.ext'_iff :
    ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, f = g ↔ ⇑f = ⇑g := by sorry

This theorem states that for any two functions `f` and `g` of a type `F` that behaves like a dependent function (this behavior is captured by `DFunLike F α β`), `f` is equal to `g` if and only if the application of `f` and `g` to any arguments yield the same results. Here, `α` is the sort of the argument, `β` is a function from `α` to a sort, defining the result type of the function depending on the argument, and `F` is a sort that behaves like such a dependent function. In other words, two such dependent functions are identical if they produce the same output for every possible input.

For functions `f` and `g` of sort `F` with dependent types `α` and `β`, `f = g` if and only if `f α = g α` for all `α`.


theorem List.kerase_cons_eq :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Sigma β} {l : List (Sigma β)},
      a = s.fst → List.kerase a (s :: l) = l :=
  by sorry

The theorem `List.kerase_cons_eq` states that for any type `α` that has decidable equality, any type function `β` from `α` to some type, any value `a` of type `α`, any pair `s` in the sigma type of `β`, and any list `l` of pairs in the sigma type of `β`, if `a` is equal to the first element of the pair `s`, then removing the first pair in the list `l` whose first element is `a` from the list that has `s` added to the front of `l` results in the original list `l`. In other words, if `a` is the key of the first pair in the list, then removing the first pair with key `a` will result in the rest of the list.

For any decidably equal type `α`, if `a` equals the first element of pair `s` in the sigma type of a type function `β` and `l` is a list of such pairs, then removing the first pair `s` from `l` and adding it to the front of `l` results in the original list `l` without the pair containing `a`.


theorem EuclideanDomain.gcd_dvd_right :
    ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] (a b : R), EuclideanDomain.gcd a b ∣ b := by
  sorry

The theorem `EuclideanDomain.gcd_dvd_right` states that for any type `R` that forms a Euclidean Domain and has decidable equality, for any two elements `a` and `b` in `R`, the greatest common divisor (gcd) of `a` and `b` divides `b`. This means there exists some element in `R` such that multiplying that element by the gcd of `a` and `b` yields `b`.

For any Euclidean Domain `R` with decidable equality, the greatest common divisor of elements `a` and `b` in `R` divides `b`. In other words, `gcd a b | b` in `R`.


theorem List.kerase_cons_ne :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Sigma β} {l : List (Sigma β)},
      a ≠ s.fst → List.kerase a (s :: l) = s :: List.kerase a l :=
  by sorry

The theorem `List.kerase_cons_ne` states that for any type `α`, type `β` that is a function of `α`, a decidable equality instance for `α`, and given an element `a` of type `α`, a pair `s` of type `Sigma β`, and a list `l` of pairs of type `Sigma β`, if `a` is not equal to the first element of the pair `s`, then the operation of key erasure `List.kerase` on `a` from the list that is the result of appending `s` and `l`, is equal to the list that is the result of appending `s` and the list obtained by applying `List.kerase` on `a` from `l`. In other words, if `a` is not the key of the pair at the head of the list, it is not removed and the `List.kerase` operation continues on the rest of the list.

For any type `α`, function type `β -> α`, decidable equality instance for `α`, element `a` of `α`, pair `s` of type `Σβ`, and list `l` of pairs of type `Σβ`, if `a ≠ fst s`, then `List.kerase a (s :: l) = s :: List.map (λ x => (fst x, List.kerase (fst x) (snd x :: l))) l`.


theorem Multiset.gcd_cons :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α) (s : Multiset α),
      Multiset.gcd (a ::ₘ s) = gcd a (Multiset.gcd s) :=
  by sorry

The theorem `Multiset.gcd_cons` states that for any type `α` that has the structure of a cancel commutative monoid with zero and also has the structure of a normalized greatest common divisor (GCD) monoid, and for any element `a` of type `α` and any multiset `s` of type `α`, the greatest common divisor of the multiset obtained by adding `a` to `s` is equal to the greatest common divisor of `a` and the greatest common divisor of `s`. This is similar to the property of the GCD operation in number theory context, where the GCD of a number and the GCD of a set of numbers is the same as the GCD of the set obtained by adding the number to the set.

Given a cancel commutative monoid with zero and normalized GCD structure, the greatest common divisor of an element and a multiset is equal to the greatest common divisor of the element and the multiset's existing elements.


theorem padicValNat.eq_zero_of_not_dvd : ∀ {p n : ℕ}, ¬p ∣ n → padicValNat p n = 0 := by sorry

This theorem states that for any two natural numbers `p` and `n`, if `p` does not divide `n`, then the `p`-adic valuation of `n` is zero. In mathematical terms, if `p` is not a divisor of `n`, denoted as ¬(p ∣ n), then the largest natural number `k` such that `p^k` divides `n` is zero, i.e., `padicValNat p n = 0`. This is because there's no power of `p` that can divide `n` when `p` itself doesn't divide `n`.

If a prime number `p` does not divide a natural number `n`, then the `p`-adic valuation of `n` is zero.


theorem Quotient.lift_mk :
    ∀ {α : Sort u_1} {β : Sort u_2} [s : Setoid α] (f : α → β) (h : ∀ (a b : α), a ≈ b → f a = f b) (x : α),
      Quotient.lift f h ⟦x⟧ = f x :=
  by sorry

The theorem `Quotient.lift_mk` states that, for any types `α` and `β`, any setoid `s` on `α`, any function `f` from `α` to `β` that respects the equivalence relation `≈` of this setoid, and any element `x` of `α`, applying the `Quotient.lift` function to `f`, the proof `h` that `f` respects `≈`, and the equivalence class of `x` (denoted by `⟦x⟧`) is equal to the value of `f` at `x`. In other words, `f` can be "lifted" to a function on the quotient of `α` by `≈`, and this lifted function behaves the same way as `f` on the representatives of the equivalence classes.

Given a setoid `s` on type `α`, a function `f` from `α` to `β` respecting `≈`, and an element `x` of `α`, `Quotient.lift f h (⟨x⟩s) = f x`, where `h` is the proof of `f` respecting `≈`.


Orthonormal.linearIndependent

/-- An orthonormal set is linearly independent.  -/
theorem Orthonormal.linearIndependent :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {ι : Type u_4} {v : ι → E}, Orthonormal 𝕜 v → LinearIndependent 𝕜 v :=
  by sorry

This theorem states that for any orthonormal set of vectors in an inner product space, the set is also linearly independent. More specifically, given a field `𝕜` and a normed additive commutative group `E` that forms an inner product space, any function `v` from an index set `ι` to `E` which forms an orthonormal set is also linearly independent over the field `𝕜`. In other words, no vector in the orthonormal set can be expressed as a linear combination of the others.

In an inner product space, every orthonormal set of vectors is linearly independent.


theorem ContDiffBump.support_eq :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E] {c : E}
      (f : ContDiffBump c), Function.support ↑f = Metric.ball c f.rOut :=
  by sorry

This theorem, `ContDiffBump.support_eq`, states that for any Type `E` that is a Normed Additive Commutative Group and a Normed Space over the real numbers, and that also has a bump function that is continuously differentiable (`HasContDiffBump E`), for any point `c` in `E`, and a continuously differentiable bump function `f` centered at `c`, the support of the function is exactly the same as the metric ball centered at `c` with radius corresponding to the outer radius of the bump function. In other words, the set of all points where the bump function `f` is nonzero corresponds precisely to the set of points within a certain distance (`f.rOut`) of `c`.

For any Normed Additive Commutative Group and Normed Space `E` over the real numbers with a continuously differentiable bump function, the support of a continuously differentiable bump function `f` centered at a point `c` in `E` equals the metric ball centered at `c` with radius `f.rOut`.


IntermediateField.adjoin.finrank

theorem IntermediateField.adjoin.finrank :
    ∀ {K : Type u} [inst : Field K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L] {x : L},
      IsIntegral K x → FiniteDimensional.finrank K ↥K⟮x⟯ = Polynomial.natDegree (minpoly K x) :=
  by sorry

The theorem `IntermediateField.adjoin.finrank` states that for any fields `K` and `L`, where `L` is an algebra over `K`, and any element `x` in `L` that is integral over `K`, the rank of the field resulting from adjoining `x` to `K` (denoted by `K⟮x⟯`), when considered as a module over `K`, equals the natural degree of the minimal polynomial of `x` over `K` (i.e., the smallest degree of any polynomial with coefficients in `K` that `x` is a root of). In other words, for a given integral element `x`, the dimension of `K⟮x⟯` as a vector space over `K` is equal to the degree of `x`'s minimal polynomial.

The rank of the field extension K⟮x⟯ as a K-module equals the degree of the minimal polynomial of x over K.


Equiv.Perm.IsCycle.orderOf

theorem Equiv.Perm.IsCycle.orderOf :
    ∀ {α : Type u_2} {f : Equiv.Perm α} [inst : DecidableEq α] [inst_1 : Fintype α],
      Equiv.Perm.IsCycle f → orderOf f = (Equiv.Perm.support f).card :=
  by sorry

This theorem states that for any type `α`, given a permutation `f` of `α` which forms a cycle, the order of `f` (i.e., the smallest positive integer `n` such that `f^n` is the identity function, if such an `n` exists, otherwise `0`) is equal to the number of elements in the `f`'s support set. The support set of a permutation is the set of points not fixed by the permutation. This holds true when `α` has decidable equality and is a finite type.

For any finite type `α` with decidable equality, the order of a permutation `f` on `α` equals the cardinality of its support set.


theorem Set.diff_union_of_subset : ∀ {α : Type u} {s t : Set α}, t ⊆ s → s \ t ∪ t = s := by sorry

The theorem `Set.diff_union_of_subset` states that for any type `α` and for any two sets `s` and `t` of type `α`, if `t` is a subset of `s` then the union of the set difference `s \ t` and the set `t` equals the set `s` itself. In mathematical notation, this would be rendered as if `t ⊆ s` then `(s \ t) ∪ t = s`.

If `s` contains `t` (i.e., `t ⊆ s`), then `(s \ t) ∪ t = s`.


spectrum.nonempty

/-- In a (nontrivial) complex Banach algebra, every element has nonempty spectrum.  -/
theorem spectrum.nonempty :
    ∀ {A : Type u_2} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] [inst_2 : CompleteSpace A]
      [inst_3 : Nontrivial A] (a : A), Set.Nonempty (spectrum ℂ a) :=
  by sorry

This theorem states that in a nontrivial complex Banach algebra, the spectrum of any element is always nonempty. In more detail, for any given type `A` which is a normed ring and also a normed algebra over the complex numbers, and which additionally is a complete space (i.e., a Banach algebra), and is nontrivial (i.e., it consists of more than one element), then for any element `a` of `A`, the spectrum of `a` (as defined in the complex numbers) is a nonempty set. The spectrum of an element in this context is the set of complex numbers for which subtracting the element times 1 from the number does not yield a unit of the algebra.

In a complex Banach algebra that is a nontrivial normed ring and algebra, the spectrum of any element is a nonempty set of complex numbers.


theorem Nat.card_pi :
    ∀ {α : Type u_1} {β : α → Type u_3} [inst : Fintype α],
      Nat.card ((a : α) → β a) = Finset.prod Finset.univ fun a => Nat.card (β a) :=
  by sorry

This theorem, `Nat.card_pi`, states that for any types `α` (which must be a finite type) and `β` (which is dependent on `α`), the cardinality of the function type `(a : α) → β a`, which is a function from `α` to `β a`, is equal to the product of the cardinalities of `β a` for each `a` in the universal finite set of `α`. In other words, the number of all possible functions from `α` to `β a` is the product of the numbers of possible values of `β a` for each element `a` of `α`.

The cardinality of the type of functions from a finite type `α` to a dependent type `β a` is equal to the product of the cardinalities of `β a` for each `a` in `α`.


theorem DFinsupp.card_Icc :
    ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → DecidableEq (α i)]
      [inst_2 : (i : ι) → PartialOrder (α i)] [inst_3 : (i : ι) → Zero (α i)]
      [inst_4 : (i : ι) → LocallyFiniteOrder (α i)] (f g : Π₀ (i : ι), α i),
      (Finset.Icc f g).card =
        Finset.prod (DFinsupp.support f ∪ DFinsupp.support g) fun i => (Finset.Icc (f i) (g i)).card :=
  by sorry

The theorem `DFinsupp.card_Icc` states that for any types `ι` and `α` (where `α` is indexed by `ι`), given decidable equality on `ι` and each `α i`, a partial order on each `α i`, a zero for each `α i`, and a locally finite order on each `α i`, for any two functions `f` and `g` that map from `ι` to `α i`, the cardinality of the finset of elements between `f` and `g` (inclusive) equals the product, as `i` ranges over the union of the support of `f` and the support of `g`, of the cardinality of the finset of elements between `f i` and `g i` (inclusive).

In other words, the size of the set of elements between two functions `f` and `g` can be computed as a product of sizes of sets between their corresponding elements.

For functions between indexed types with decidable equality, partial order, zero, and locally finite order structures, the cardinality of their elements between the functions is equal to the product of cardinalities of elements between corresponding functions.


theorem Function.Periodic.int_mul_sub_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c x : α} [inst : Ring α],
      Function.Periodic f c → ∀ (n : ℤ), f (↑n * c - x) = f (-x) :=
  by sorry

The theorem `Function.Periodic.int_mul_sub_eq` states that for any type `α` that forms a ring and any function `f` from `α` to another type `β`, if `f` is periodic with period `c`, then for every integer `n` and every value `x` in `α`, the value of `f` at `n * c - x` is the same as the value of `f` at `-x`. In other words, if a function is periodic, then scaling the period by an integer and subtracting any number from it results in a value that is the same as when the original number is negated.

If `f` is a periodic function from a ring `α` to another type `β` with period `c`, then for all integers `n` and elements `x` in `α`, `f(n * c - x) = f(-x)`.


/-- Any open set is the union of the basis sets contained in it.  -/
theorem TopologicalSpace.IsTopologicalBasis.open_eq_sUnion' :
    ∀ {α : Type u} [t : TopologicalSpace α] {B : Set (Set α)},
      TopologicalSpace.IsTopologicalBasis B → ∀ {u : Set α}, IsOpen u → u = ⋃₀ {s | s ∈ B ∧ s ⊆ u} :=
  by sorry

This theorem states that for any type `α` and any topological space `t` on `α`, if `B` is a collection of sets that forms a topological basis of `t`, then any open set `u` in this topological space can be expressed as the union of basis sets that are contained in `u`. In other words, if we have a topological basis, every open set is just a union of these basic open sets.

For any topological space `(α, t)` and topological basis `B` of `t`, every open set `u` in `t` can be written as a union of sets in `B` that are contained in `u`.


theorem nhds_def :
    ∀ {X : Type u_3} [inst : TopologicalSpace X] (x : X), nhds x = ⨅ s ∈ {s | x ∈ s ∧ IsOpen s}, Filter.principal s :=
  by sorry

This theorem, `nhds_def`, states that for any type `X` with a topological space structure and any element `x` of `X`, the neighborhood filter of `x` (denoted by `nhds x`) is defined as the infimum (or greatest lower bound) of the set of all principal filters of sets `s` which contain `x` and are open in `X`. In simpler terms, the neighborhood filter of a point in a topological space is a collection of all sets that contain an open set around the point. The theorem provides a precise description of this collection in terms of principal filters, which are filters comprising of all supersets of a given set.

The neighborhood filter of a point in a topological space is the infimum of the set of open, principal filters containing that point.


theorem embedding_of_embedding_compose :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      Continuous f → Continuous g → Embedding (g ∘ f) → Embedding f :=
  by sorry

This theorem states that for all types `X`, `Y`, and `Z`, given functions `f: X → Y` and `g: Y → Z` and considering `X`, `Y` and `Z` are topological spaces, if both `f` and `g` are continuous and the composition of `g` and `f` (i.e., `g ∘ f`) is an embedding, then `f` is also an embedding. In topology, an embedding is a function that is both injective (i.e., maps distinct points in the domain to distinct points in the codomain) and continuous, with its image being a topologically meaningful copy of its domain.

If `f: X → Y` and `g: Y → Z` are continuous functions between topological spaces `X`, `Y`, and `Z` with `g ∘ f` being an embedding, then `f` is an embedding.


theorem Metric.closedBall_subset_closedBall :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε₁ ε₂ : ℝ},
      ε₁ ≤ ε₂ → Metric.closedBall x ε₁ ⊆ Metric.closedBall x ε₂ :=
  by sorry

This theorem states that for any type `α` that is a pseudometric space, and for any point `x` of type `α`, if `ε₁` is less than or equal to `ε₂` (both are real numbers), then the closed ball centered at `x` with radius `ε₁` is a subset of the closed ball centered at `x` with radius `ε₂`. In other words, if one ball has a smaller or equal radius compared to another, all points in the smaller (or equally-sized) ball are also contained in the larger ball.

For any pseudometric space `α` and point `x` in `α`, the closed ball `{y : α | d(x, y) ≤ ε₁}` around `x` with radius `ε₁` is a subset of the closed ball `{y : α | d(x, y) ≤ ε₂}` around `x` with radius `ε₂`, when `ε₁` is less than or equal to `ε₂`.


theorem CategoryTheory.Limits.prod.map_id_id :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y],
      CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id Y) =
        CategoryTheory.CategoryStruct.id (X ⨯ Y) :=
  by sorry

This theorem, `CategoryTheory.Limits.prod.map_id_id`, states that for any type `C` which is a category and any objects `X`, `Y` in `C` that have a binary product, the product map induced by the identity morphisms on `X` and `Y` is equal to the identity morphism on the binary product of `X` and `Y`. In other words, it asserts the identity law for the product functor in a category, saying that mapping the identity transformations of `X` and `Y` under the product map gives the identity transformation of the binary product `X ⨯ Y`.

For any category `C` and objects `X` and `Y` with a product, the product map of the identity morphisms on `X` and `Y` is equal to the identity morphism on their product `X ⨯ Y`.


theorem one_half_lt_one : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α], 1 / 2 < 1 := by sorry

This theorem states that for any type `α` which is a Linear Ordered Semifield (a structure that generalizes both fields and ordered rings), the fraction 1/2 is less than 1. This is an example of a basic inequality property that holds in any such mathematical structure.

For any Linear Ordered Semifield `α`, we have `1 / 2 < 1`.


theorem Partrec.nat_iff : ∀ {f : ℕ →. ℕ}, Partrec f ↔ Nat.Partrec f := by sorry

The theorem `Partrec.nat_iff` states that for any function `f` from natural numbers to partial natural numbers (i.e., the function may not necessarily return a value for all input natural numbers), `f` is partial recursive (`Partrec`) if and only if `f` is partial recursive according to the natural numbers definition (`Nat.Partrec`). In other words, the function `f` is partial recursive in the context of the general definition of partial recursive functions if it is also partial recursive when considered specifically over the domain of natural numbers.

The theorem `Partrec.nat_iff` asserts that a function from natural numbers to partial natural numbers is partial recursive according to the general definition if and only if it is partial recursive when considered over the domain of natural numbers according to the specific definition.


theorem Set.snd_image_prod :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, Set.Nonempty s → ∀ (t : Set β), Prod.snd '' s ×ˢ t = t := by sorry

The theorem `Set.snd_image_prod` states that for any types `α` and `β`, given a set `s` of type `α` which is nonempty, and any set `t` of type `β`, the image under the second projection function (`Prod.snd`) of the cartesian product of `s` and `t` is equal to `t`. In other words, if we take each pair in the cartesian product of `s` and `t` and map it to its second element, we get the set `t` back. It is a statement about the property and behavior of the second projection function (`Prod.snd`) when acting on the cartesian product of two sets, where one of the sets is nonempty.

For any nonempty set `s` and set `t`, the image of the cartesian product `s × t` under the second projection function `Prod.snd` is equal to `t`.


theorem le_compl_compl : ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α}, a ≤ aᶜᶜ := by sorry

This theorem states that for all types `α` that form a Heyting algebra, and for any element `a` of that type, `a` is less than or equal to its double complement (`aᶜᶜ`). In the context of Heyting algebras, the double complement of an element can be interpreted as the "approximation" of that element within the logic system; this theorem asserts that the original element is never greater than this approximation.

For all types `α` in a Heyting algebra and for all elements `a` in `α`, `a ≤ aᶜᶜ` holds.


theorem Ctop.Realizer.mem_nhds :
    ∀ {α : Type u_1} [T : TopologicalSpace α] (F : Ctop.Realizer α) {s : Set α} {a : α},
      s ∈ nhds a ↔ ∃ b, a ∈ F.F.f b ∧ F.F.f b ⊆ s :=
  by sorry

This theorem states that for any type `α` with a given topological space structure `T`, a topological space realizer `F`, a set `s` of elements of `α`, and an element `a` of `α`, the set `s` is a neighborhood of `a` (i.e., `s` is in the neighborhood filter of `a`) if and only if there exists an element `b` such that `a` is in the realization of `b` with respect to the functor `F.F` and the realization of `b` with respect to the functor `F.F` is a subset of `s`.

In short, this theorem characterizes neighborhoods in terms of a topological space realizer: a set is a neighborhood of a point if and only if it contains the realization of some element with respect to the realizer's functor, and that realization is contained within the set.

A set is a neighborhood of a point in a topological space with respect to a given topological space realizer if and only if it contains the realization of some element and is contained in the realization's subset.


List.Subset.trans

theorem List.Subset.trans : ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, l₁ ⊆ l₂ → l₂ ⊆ l₃ → l₁ ⊆ l₃ := by sorry

This theorem states that for any three lists `l₁`, `l₂`, and `l₃` of any type `α`, if `l₁` is a subset of `l₂` and `l₂` is a subset of `l₃`, then `l₁` is a subset of `l₃`. This is a formal encoding of the transitive property of subset relationships in the context of lists.

If `l₁ ⊆ l₂` and `l₂ ⊆ l₃`, then `l₁ ⊆ l₃` (`l₁` is a subset of `l₃`).


theorem linearIndependent_empty :
    ∀ (R : Type u_2) (M : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      LinearIndependent R fun (x : ↑∅) => ↑x :=
  by sorry

The theorem `linearIndependent_empty` asserts that for any semiring `R` and any additive commutative monoid `M` that is also an `R`-module, the empty set of vectors is linearly independent over `R`. Essentially, this means there are no nontrivial linear combinations among the vectors in the empty set, which is trivially true as there are no vectors in the set.

In any semiring `R` and additive commutative monoid `M` that is an `R`-module, the empty set of vectors is linearly independent over `R`.


/-- Either `f = ⊥` or `Filter.NeBot f`. This is a version of `eq_or_ne` that uses `Filter.NeBot`
as the second alternative, to be used as an instance.  -/
theorem Filter.eq_or_neBot : ∀ {α : Type u} (f : Filter α), f = ⊥ ∨ Filter.NeBot f := by sorry

This theorem states that for any filter `f` of an arbitrary type `α`, either `f` is equal to the bottom filter (denoted as `⊥`), or `f` is not the bottom filter (`Filter.NeBot f`). This is a version of the equality or inequality law (`eq_or_ne`) which uses `Filter.NeBot` as the second alternative option, and it is intended to be used as an instance.

For any filter `f` on type `α`, either `f = ⊥` or `f ≠ ⊥`.


theorem WCovBy.covBy_of_lt : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⩿ b → a < b → a ⋖ b := by sorry

This theorem states that for any type `α` equipped with a preorder, given two elements `a` and `b` of type `α`, if `a` is covered by `b` (denoted `a ⩿ b`) and `a` is less than `b` (denoted `a < b`), then `a` is strictly covered by `b` (denoted `a ⋖ b`). In other words, in the context of a preorder, if one element is covered by and less than another, then it is also strictly covered by that other element.

If `α` is a type with a preorder such that `a ⩿ b` and `a < b`, then `a ⋖ b`.


theorem Dioph.eq_dioph :
    ∀ {α : Type} {f g : (α → ℕ) → ℕ}, Dioph.DiophFn f → Dioph.DiophFn g → Dioph fun v => f v = g v := by sorry

This theorem states that for any two functions `f` and `g` from `α → ℕ` to `ℕ`, if both `f` and `g` are Diophantine (i.e., the set of natural numbers which can be represented by some polynomial equation), then the set of natural number sequences where `f` equals `g` is also Diophantine. In other words, the set of natural number sequences for which `f` and `g` yield the same result can also be represented by a polynomial equation.

If `f` and `g` are Diophantine functions from `α` to `ℕ`, then the set `{n : ℕ | f(n) = g(n)}` is also Diophantine.


theorem Ordinal.lsub_le :
    ∀ {ι : Type u_4} {f : ι → Ordinal.{max u_5 u_4}} {a : Ordinal.{max u_5 u_4}},
      (∀ (i : ι), f i < a) → Ordinal.lsub f ≤ a :=
  by sorry

This theorem states that for any type `ι` and any function `f` from `ι` to the type of ordinals, and any ordinal `a`, if every ordinal in the image of `f` is less than `a`, then the least strict upper bound of the ordinals obtained from `f` (which is denoted as `Ordinal.lsub f`) is less than or equal to `a`. Essentially, this theorem is saying if all elements of a set of ordinals are less than a given ordinal `a`, then the smallest ordinal that is larger than all elements of the set (if it exists) is also less than or equal to `a`. This is a formalization of a basic property of upper bounds in the setting of ordinals.

For any type `ι` and function `f` from `ι` to the type of ordinals, if every image `f(x)` is less than an ordinal `a`, then `Ordinal.lsup f` (the least upper bound of `f` if it exists) is less than or equal to `a`.


theorem NNReal.abs_eq : ∀ (x : NNReal), |↑x| = ↑x := by sorry

This theorem states that for every nonnegative real number `x` (denoted as `NNReal`), the absolute value of `x` (expressed as `|↑x|`) is equal to `x` itself (expressed as `↑x`). In mathematical terms, it would be stated as "For all x in the set of nonnegative real numbers, the absolute value of x equals x". This is expected because, by the definition of nonnegative real numbers, `x` is always greater than or equal to 0, so its absolute value is just `x` itself.

For all non-negative real numbers x, |x| = x holds.


theorem CategoryTheory.ProjectiveResolution.exact_succ :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ),
      CategoryTheory.ShortComplex.Exact
        (CategoryTheory.ShortComplex.mk (P.complex.d (n + 2) (n + 1)) (P.complex.d (n + 1) n) ⋯) :=
  by sorry

This theorem states that for any category `C` (with `C` being a type), given that `C` has zero objects and zero morphisms, and for any object `Z` in `C` and a projective resolution `P` of `Z`, the short complex made from the differential maps `d` at positions `n+2` to `n+1` and `n+1` to `n` in the complex `P` is an exact sequence. In category theory, an exact sequence is a sequence of objects and morphisms between them such that the image of one morphism is equal to the kernel of the next.

Given a category `C` with zero objects and morphisms, for any projective resolution `P` of an object `Z` in `C`, the sequence obtained by considering the differential maps from positions `n+2` to `n+1` and `n+1` to `n` forms an exact sequence in `C`.


theorem CategoryTheory.Limits.biproduct.ι_π_assoc :
    ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : DecidableEq J] (f : J → C)
      [inst_3 : CategoryTheory.Limits.HasBiproduct f] (j j' : J) {Z : C} (h : f j' ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.π f j') h) =
        CategoryTheory.CategoryStruct.comp (if h : j = j' then CategoryTheory.eqToHom ⋯ else 0) h :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.ι_π_assoc`, states that in a category `C` (which is assumed to have zero morphisms and a biproduct for a certain function `f` from a type `J` to `C`), for any two objects `j` and `j'` from `J` and any morphism `h` from `f j'` to another object `Z` in `C`, the composition of the `ι` morphism for `j` and the composition of the `π` morphism for `j'` and `h` is equal to the composition of an equality morphism or zero (depending on whether `j` equals `j'`) and `h`. The `ι` and `π` morphisms here are the inclusion and projection morphisms for a summand of a biproduct, respectively. The equality check between `j` and `j'` is assumed to be decidable.

For any category with zero morphisms and biproducts, the composition of the inclusion morphism for one summand and the composition of the projection morphism for another summand with any morphism between them is equal to the morphism between the summands if they are equal, and zero otherwise.


theorem SetTheory.PGame.not_lf : ∀ {x y : SetTheory.PGame}, ¬SetTheory.PGame.LF x y ↔ y ≤ x := by sorry

This theorem states that for any two pre-games `x` and `y` in Set Theory, the negation of the less or fuzzy relation `SetTheory.PGame.LF x y` holds if and only if `y` is less than or equal to `x`. In other words, if `y` is not strictly better for the first player than `x` (that is, the first player cannot win `y` when `x` is played), then `y` is less than or equal to `x`.

The theorem asserts that for all pre-games x and y in Set Theory, the negation of x having a strict less or fuzzy relation to y holds if and only if y is less than or equal to x.


theorem closure_prod_eq :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} {t : Set Y},
      closure (s ×ˢ t) = closure s ×ˢ closure t :=
  by sorry

The theorem `closure_prod_eq` states that for all types `X` and `Y` with topological space structures, and for any two sets `s` of type `X` and `t` of type `Y`, the closure of the Cartesian product of `s` and `t` is equal to the Cartesian product of the closures of `s` and `t`. In mathematical notation, this is saying that for any two sets `s` and `t` in topological spaces `X` and `Y` respectively, `cl(s x t) = cl(s) x cl(t)`, where `cl` denotes the topological closure operation and `x` denotes the Cartesian product of two sets.

For any topological spaces X and Y, and sets s in X and t in Y, the closure of their Cartesian product s × t is equal to the Cartesian product of the closures of s and t, i.e., cl(s × t) = cl(s) × cl(t).


/-- In any concrete category, surjective morphisms are epimorphisms.  -/
theorem CategoryTheory.ConcreteCategory.epi_of_surjective :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.ConcreteCategory C] {X Y : C}
      (f : X ⟶ Y), Function.Surjective ⇑f → CategoryTheory.Epi f :=
  by sorry

In the context of any concrete category, the theorem states that if a morphism `f` from object `X` to object `Y` is surjective, then this morphism is an epimorphism. Here, surjective implies that for every element in the codomain `Y`, there exists at least one element in the domain `X` such that the function `f` maps this element from `X` to that particular element in `Y`. An epimorphism, in category theory, is a morphism which has the property that any two morphisms from its codomain to any other object that are equal after composition with the epimorphism are already equal.

In any concrete category, a surjective morphism is an epimorphism.


theorem multiplicity.pow_dvd_of_le_multiplicity :
    ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α} {k : ℕ},
      ↑k ≤ multiplicity a b → a ^ k ∣ b :=
  by sorry

The theorem named `multiplicity.pow_dvd_of_le_multiplicity` states that for any type `α` that forms a monoid, and any decidable relation defined by divisibility between two elements of type `α`, along with elements `a` and `b` of this type, and a natural number `k`, if `k` is less than or equal to the multiplicity of `a` in `b`, then `a` to the power of `k` divides `b`.

In mathematical terms, given a monoid with elements `a` and `b`, and a natural number `k`, if `k` is less than or equal to the highest power of `a` that divides `b` (the multiplicity), then `a^k` is a divisor of `b`.

If `α` is a monoid with decidable divisibility, `a`, `b` are elements of `α`, and `k` is a natural number less than or equal to the multiplicity of `a` in `b`, then `a^k` divides `b`.


IsConnected.image

/-- The image of a connected set is connected as well.  -/
theorem IsConnected.image :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α},
      IsConnected s → ∀ (f : α → β), ContinuousOn f s → IsConnected (f '' s) :=
  by sorry

This theorem states that if a set is connected in a topological space, then the image of this set under a continuous function is also connected in its respective topological space. In other words, for any topological spaces `α` and `β`, any connected set `s` in `α`, and any function `f: α → β` that is continuous on `s`, the image of `s` under `f` (denoted as `f '' s`) is also connected in `β`. This highlights the preserving nature of continuous functions with respect to the property of connectedness.

If `s` is a connected subset of a topological space `α`, and `f: α → β` is a continuous function, then `f '' s` is a connected subset of `β`.


/-- **Alias** of `Decidable.byContradiction`. -/
theorem Decidable.by_contradiction : ∀ {p : Prop} [dec : Decidable p], (¬p → False) → p := by sorry

This theorem, called `Decidable.by_contradiction`, is essentially an alias for `Decidable.byContradiction`. It states that for any proposition `p`, given that `p` is decidable (i.e., it is either true or false), if assuming `¬p` (the negation of `p`) leads to a contradiction (represented by `False`), then `p` must be true. This theorem represents the classic principle of proof by contradiction in logic.

If `p` is a decidable proposition and assuming `¬p` leads to a contradiction, then `p` is true.


theorem iInf_of_empty :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] [inst_1 : IsEmpty ι] (f : ι → α), iInf f = ⊤ := by sorry

The theorem `iInf_of_empty` states that for any type `α` forming a complete lattice, and for any function `f` mapping from an empty type `ι` to `α`, the indexed infimum (`iInf`) of `f` is the top element (`⊤`) of the lattice. In other words, when the domain of a function is an empty set, the infimum over the range of that function in a complete lattice is the greatest element in the lattice.

For any complete lattice `α` and empty type `ι`, the indexed infimum of the empty function from `ι` to `α` is the top element of `α`.


theorem IsLinearMap.with_bound :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
      IsLinearMap 𝕜 f → ∀ (M : ℝ), (∀ (x : E), ‖f x‖ ≤ M * ‖x‖) → IsBoundedLinearMap 𝕜 f :=
  by sorry

This theorem, `IsLinearMap.with_bound`, states that for any nontrivial normed field `𝕜`, any normed additively commutative group `E` over `𝕜`, any normed additively commutative group `F` over `𝕜`, and any function `f` from `E` to `F`, if `f` is a linear map and there exists a real number `M` such that the norm of `f(x)` does not exceed `M` times the norm of `x` for any `x` in `E`, then `f` is a bounded linear map.

In other words, it asserts that a linear map is guaranteed to be a bounded linear map if each input's magnitude is expanded by no more than a constant factor after the map.

A linear map from one normed additive commutative group to another, over a nontrivial normed field, is bounded if there exists a constant such that the norm of the image is less than or equal to the norm of the input multiplied by the constant for all inputs.


theorem Mathlib.RingTheory.RootsOfUnity.Basic._auxLemma.1 :
    ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ+) (ζ : Mˣ), (ζ ∈ rootsOfUnity k M) = (ζ ^ ↑k = 1) := by sorry

This theorem states that for any type `M` with a commutative monoid structure, any positive natural number `k`, and any element `ζ` of the multiplicative group of `M`, `ζ` is in the roots of unity of `k` in `M` if and only if `ζ` to the power of `k` equals 1. In mathematical notation, this is saying that for any ζ in the multiplicative group of a commutative monoid M and a positive integer k, ζ is a k-th root of unity in M if and only if ζ^k = 1.

A commutative monoid element ζ is a root of unity of order k if and only if ζ^k = 1.


theorem CauSeq.le_of_exists :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {f g : CauSeq α abs}, (∃ i, ∀ j ≥ i, ↑f j ≤ ↑g j) → f ≤ g := by sorry

This theorem asserts that, for any two Cauchy sequences `f` and `g` of elements from a linearly ordered field `α`, if there exists an index `i` such that for all indices `j` greater than or equal to `i`, the `j`-th term of `f` is less than or equal to the `j`-th term of `g`, then `f` is less than or equal to `g`. The function `abs` is used here to define the absolute value on the field `α`.

If two Cauchy sequences in a linearly ordered field have `f(i) ≤ g(i)` for all `i` greater than some index, then `f ≤ g`.


theorem Path.extend.proof_1 : 0 ≤ 1 := by sorry

This theorem, `Path.extend.proof_1`, simply states that 0 is less than or equal to 1. In mathematical notation, this is expressed as \(0 \leq 1\). This is a fundamental and universal truth in the context of real numbers or integers.

The theorem `Path.extend.proof_1` asserts that 0 is less than or equal to 1 (0 ≤ 1) in Lean 4.


theorem Function.iterate_zero_apply : ∀ {α : Type u} (f : α → α) (x : α), f^[0] x = x := by sorry

This theorem states that for any function `f` that maps a type `α` to itself and any value `x` of type `α`, applying the function `f` zero times to `x` (denoted as `f^[0] x`) yields `x` itself. In other words, it formalizes the intuitive idea that not applying a function at all leaves the input unchanged.

For any function `f` from type `α` to itself, `f^[0] x = x` for all `x : α`.


theorem Continuous.inv₀ :
    ∀ {α : Type u_1} {G₀ : Type u_3} [inst : Zero G₀] [inst_1 : Inv G₀] [inst_2 : TopologicalSpace G₀]
      [inst_3 : HasContinuousInv₀ G₀] {f : α → G₀} [inst_4 : TopologicalSpace α],
      Continuous f → (∀ (x : α), f x ≠ 0) → Continuous fun x => (f x)⁻¹ :=
  by sorry

This theorem states that for any type `α`, and a type `G₀` that has a structure of a topological space, a zero element and an inverse operation, if a function `f` from `α` to `G₀` is continuous and never equals zero, then the function that maps `x` to the inverse of `f(x)` is also continuous. This is under the condition that the inverse operation is continuous at every non-zero point in `G₀`.

If `f` is a continuous function from type `α` to a topological space `G₀` with a zero element, an inverse operation, and the inverse operation is continuous at every non-zero point, then the function that maps `x` to the inverse of `f(x)` is continuous.


theorem EuclideanGeometry.mem_sphere :
    ∀ {P : Type u_2} [inst : MetricSpace P] {p : P} {s : EuclideanGeometry.Sphere P},
      p ∈ s ↔ dist p s.center = s.radius :=
  by sorry

This theorem states that for any point `p` and any `Sphere s` in a metric space of type `P`, `p` is in `s` if and only if the distance from `p` to the center of `s` is equal to the radius of `s`. In other words, a point is inside a sphere according to Euclidean Geometry only when its distance from the sphere's center is exactly the sphere's radius.

A point is in a sphere in a metric space if and only if the distance from the point to the sphere's center equals the sphere's radius.


theorem Primrec.vector_head : ∀ {α : Type u_1} [inst : Primcodable α] {n : ℕ}, Primrec Vector.head := by sorry

The theorem `Primrec.vector_head` asserts that for any type `α` that has an instance of `Primcodable` and for any natural number `n`, the function `Vector.head`, which retrieves the first element of a vector, is primitive recursive. This means that `Vector.head` can be computed using simple arithmetic operations, conditional statements, and bounded loops or recursion after encoding its input and output as natural numbers, which is the definition of a primitive recursive function.

The theorem asserts that the function `Vector.head` on types `α` with `Primcodable` instance and natural numbers is primitive recursive.


theorem Mathlib.Data.Ordmap.Ordset._auxLemma.7 : ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) := by sorry

This theorem, `Mathlib.Data.Ordmap.Ordset._auxLemma.7`, asserts that for any three propositions `a`, `b`, and `c`, the proposition "`a` and `b` are both true, and also `c` is true" is logically equivalent to the proposition "`a` is true, and both `b` and `c` are true". In other words, the logical conjunction operator (`∧`) is associative, so the grouping of `a`, `b`, and `c` in `(a ∧ b) ∧ c` and `a ∧ (b ∧ c)` does not matter.

The theorem `Mathlib.Data.Ordmap.Ordset._auxLemma.7` in Lean 4 states that the logical conjunction `(a ∧ b) ∧ c` is logically equivalent to `a ∧ (b ∧ c)` for any propositions `a`, `b`, and `c`. In other words, the logical conjunction operator is associative in Lean.


theorem Finset.sum_range_zero :
    ∀ {β : Type u_4} [inst : AddCommMonoid β] (f : ℕ → β), (Finset.sum (Finset.range 0) fun k => f k) = 0 := by sorry

The theorem `Finset.sum_range_zero` states that for all type `β` which has an `AddCommMonoid` instance, and for any function `f` from natural numbers to the type `β`, the sum of the function `f` over the range 0 (i.e., the set of natural numbers less than 0) equals to 0. Since there are no natural numbers less than 0, the sum is over an empty set and is therefore 0, as per the default property of addition in an `AddCommMonoid`.

For any type `β` with an `AddCommMonoid` instance and any function `f : ℕ -> β`, the sum of `f` over the empty natural number set is 0.


theorem Nonneg.coe_one : ∀ {α : Type u_1} [inst : OrderedSemiring α], ↑1 = 1 := by sorry

The theorem `Nonneg.coe_one` states that for any type `α` which forms an ordered semiring, the coersion of the integer 1 (notated as `↑1`) is equal to the semiring's unity (notated as `1`). In other words, in any ordered semiring, the coersion of the integer 1 remains as 1.

In an ordered semiring, the conversion of the integer 1 to the semiring's type is equal to the semiring's unity.


theorem MeasureTheory.map_eq_withDensity_pdf :
    ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} (X : Ω → E)
      (ℙ : MeasureTheory.Measure Ω) (μ : autoParam (MeasureTheory.Measure E) _auto✝) [hX : MeasureTheory.HasPDF X ℙ μ],
      MeasureTheory.Measure.map X ℙ = μ.withDensity (MeasureTheory.pdf X ℙ μ) :=
  by sorry

The theorem `MeasureTheory.map_eq_withDensity_pdf` states that for any measure spaces `Ω` and `E`, any random variable `X : Ω → E`, any measure `ℙ` on `Ω`, and any (automatically determined) measure `μ` on `E`, if `X` has a Probability Density Function (PDF) with respect to measures `ℙ` and `μ`, then the push-forward measure of `ℙ` along `X` is equal to the measure `μ` weighted by the PDF of `X`.

 If random variable X from measure space Ω to E has a Probability Density Function (PDF) with respect to measures ℙ on Ω and μ on E, then X�#{ℙ} = μ ∘ X ∘ #.

Here, X�#{ℙ} denotes the push-forward measure of ℙ along X, and #. represents the function composition symbol.


SetCoe.forall

theorem SetCoe.forall :
    ∀ {α : Type u} {s : Set α} {p : ↑s → Prop},
      (∀ (x : ↑s), p x) ↔ ∀ (x : α) (h : x ∈ s), p { val := x, property := h } :=
  by sorry

This theorem, named `SetCoe.forall`, asserts that for all types `α` and for all sets `s` of type `α`, and any predicate `p` that applies to elements of the set `s`, it is equivalent to say that the predicate `p` holds for all elements of `s` and to say that for all elements `x` of type `α`, if `x` is in the set `s`, then the predicate `p` holds for `x` with the evidence that `x` is in `s`. Essentially, it is expressing the property of universal quantification over the elements of a set in two different ways.

For any type `α`, set `s` of `α`, and predicate `p` on `α`, the statements "for all `x` in `s`, `p(x)` holds" and "for all `x` in `α` with `x` in `s`, `p(x)` holds" are equivalent.


theorem convexHull_singleton :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E] (x : E),
      (convexHull 𝕜) {x} = {x} :=
  by sorry

The theorem `convexHull_singleton` states that for any given type `𝕜`, which is an ordered semiring, and any type `E`, which is an additive commutative monoid and a module over `𝕜`, the convex hull of a singleton set `{x}` in `E` is the set itself, `{x}`. In more intuitive terms, this means that if we have a set consisting of only one element (singleton set), the smallest convex set that contains this element is the set containing the element itself.

For any ordered semiring `𝕜` and additive commutative monoid `E` being a `𝕜`-module, the convex hull of a singleton set in `E` equals the set itself.


theorem right_div_gcd_ne_zero :
    ∀ {R : Type u_1} [inst : EuclideanDomain R] [inst_1 : GCDMonoid R] {p q : R}, q ≠ 0 → q / gcd p q ≠ 0 := by sorry

This theorem states that for any type `R` that is an instance of the `EuclideanDomain` and `GCDMonoid` typeclasses, and any elements `p` and `q` of `R`, if `q` is not equal to zero, then the result of dividing `q` by the greatest common divisor (gcd) of `p` and `q` is also not equal to zero. In other words, in a Euclidean Domain, the division of a non-zero element by its gcd with any other element will never yield zero.

In a Euclidean Domain, the quotient of any non-zero element by its greatest common divisor with another element is a non-zero element.


theorem OrderIso.map_mem_minimals :
    ∀ {β : Type u_2} {α : Type u_1} [inst : LE α] [inst_1 : LE β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t) {x : α}
      (hx : x ∈ minimals (fun x x_1 => x ≤ x_1) s),
      ↑(f { val := x, property := ⋯ }) ∈ minimals (fun x x_1 => x ≤ x_1) t :=
  by sorry

The theorem `OrderIso.map_mem_minimals` states that for any two types `α` and `β` with preorder relations, and any two sets `s` of type `α` and `t` of type `β`, if there exists an order isomorphism `f` from `s` to `t`, then for any element `x` in `s` that belongs to the minimal elements of `s` under the order relation `≤`, the image of `x` under `f` belongs to the minimal elements of `t` under the same order relation. Here, the minimal elements of a set are those for which there are no other elements in the set that are strictly less than them.

If `f` is an order isomorphism from a set `s` with minimal elements `x` under relation `≤` to a set `t`, then the image `f(x)` is a minimal element in `t` under the same relation `≤`.


AlgebraicIndependent.injective

theorem AlgebraicIndependent.injective :
    ∀ {ι : Type u_1} {R : Type u_3} {A : Type u_5} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
      [inst_2 : Algebra R A], AlgebraicIndependent R x → ∀ [inst : Nontrivial R], Function.Injective x :=
  by sorry

This theorem states that, for every type `ι`, every type `R` being a commutative ring, every type `A` being a commutative ring with an algebra structure over `R`, and every function `x` from `ι` to `A`, if the function `x` is algebraically independent over `R` (i.e., the canonical map from the multivariable polynomial ring in the elements of `x` to `A` is injective), then, under the assumption that `R` is nontrivial, the function `x` itself is injective. In other words, no two distinct elements in the domain `ι` map to the same value in `A` under `x` when `x` is algebraically independent and `R` is nontrivial.

If `R` is a nontrivial commutative ring, `A` is a commutative `R`-algebra, `x : ι → A` is an algebraically independent function, then `x` is injective.


SameRay.rfl

theorem SameRay.rfl :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {x : M}, SameRay R x x :=
  by sorry

The theorem `SameRay.rfl` states that for any type `R` that is a strict ordered commutative semiring, and any type `M` that is an additive commutative monoid and also a module over `R`, any vector `x` from `M` is in the same ray as itself. This essentially states the reflexivity property of the `SameRay` relation in the context of vectors in a module over a semiring, i.e., every vector is in the same direction as itself.

For any strict ordered commutative semiring `R` and any additive commutative monoid `M` that is an `R`-module, every vector `x` in `M` is in the same ray as `x` regarding the `SameRay` relation.


theorem BoundedSMul.of_norm_smul_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedAddCommGroup β] [inst_2 : Module α β],
      (∀ (r : α) (x : β), ‖r • x‖ ≤ ‖r‖ * ‖x‖) → BoundedSMul α β :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` is a seminormed ring, `β` is a seminormed additive commutative group, and `β` is a module over `α`, if for every `r` in `α` and `x` in `β`, the norm of the product `r • x` is less than or equal to the product of the norms `‖r‖` and `‖x‖`, then `α` and `β` have the property `BoundedSMul`. In other words, if the norm of the scaled vector doesn't exceed the product of the norms of the scaler and the vector, then scalar multiplication is bounded in the vector space `β` with scalars from `α`.

If `α` is a seminormed ring and `β` is a seminormed additive commutative group that is a module over `α`, then `α` and `β` have the property `BoundedSMul` if and only if for all `r` in `α` and `x` in `β`, `‖r • x‖ ≤ ‖r‖ * ‖x‖`.


theorem ConjClasses.mk_eq_mk_iff_isConj :
    ∀ {α : Type u} [inst : Monoid α] {a b : α}, ConjClasses.mk a = ConjClasses.mk b ↔ IsConj a b := by sorry

The theorem `ConjClasses.mk_eq_mk_iff_isConj` states that for all monoids `α`, and any two elements `a` and `b` from this monoid, the canonical quotient map from `α` into the conjugacy classes of `α` applied to `a` equals the same map applied to `b` if and only if `a` is conjugate to `b`. Here, `a` is considered conjugate to `b` if there exists some unit `c` such that `c * a * c⁻¹ = b`.

For all monoids α and elements a, b ∈ α, the canonical quotient map maps a to the same conjugacy class as b if and only if a is conjugate to b.


theorem Finsupp.mapDomain_apply :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α → β},
      Function.Injective f → ∀ (x : α →₀ M) (a : α), (Finsupp.mapDomain f x) (f a) = x a :=
  by sorry

The theorem `Finsupp.mapDomain_apply` states that for every types `α`, `β`, and `M`, where `M` is endowed with an additive commutative monoid structure, and given an injective function `f` from `α` to `β`, and every finitely supported function `x` from `α` to `M`, and for every element `a` of `α`, applying the function `f` to `a` and then applying the finitely supported function obtained from `mapDomain` applied to `f` and `x`, results in the same value as applying `x` directly to `a`. Essentially, it means that `mapDomain` preserves the values of the original function at each point when the domain mapping function is injective.

For an injective function `f:` α --> β, and a finitely supported function `x:` α --> M with an additive commutative monoid structure, the application of `x` to `a` is equal to the application of `(mapDomain f x)` to `(f a)` for every `a` in α.


theorem Int.floor_mono : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], Monotone Int.floor := by
  sorry

The theorem `Int.floor_mono` states that for any type `α` that is equipped with a linear ordered ring structure and a floor ring structure, the `Int.floor` function is monotone. This means that if `a` and `b` are two elements of `α` such that `a ≤ b`, then the greatest integer less than or equal to `a` is also less than or equal to the greatest integer less than or equal to `b`. In mathematical notation, this is equivalent to saying that if `a ≤ b`, then `⌊a⌋ ≤ ⌊b⌋`, where `⌊x⌋` denotes the floor of `x`.

If `α` is a type equipped with a linear ordered ring structure and a floor ring structure, then the floor function `Int.floor` is monotone, that is, `⌊a⌋ ≤ ⌊b⌋` for all `a ≤ b` in `α`.


theorem Rat.neg_def : ∀ {a b : ℤ}, -Rat.divInt a b = Rat.divInt (-a) b := by sorry

The theorem `Rat.neg_def` states that for any two integers `a` and `b`, the negation of the quotient of `a` by `b` is equal to the quotient of the negation of `a` and `b`. In other words, it asserts that the operation of negation commutes with the division operation for integers (casted to rational numbers), i.e., we have `- (a / b) = (-a) / b` for all integers `a` and `b`.

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