theorem ENNReal.smul_def : ∀ {M : Type u_1} [inst : MulAction ENNReal M] (c : NNReal) (x : M), c • x = ↑c • x := by
  sorry

This theorem states that for any type `M` with a multiplication action defined on it by the extended nonnegative real numbers (`ENNReal`), and given a nonnegative real number (`NNReal`) `c` and an element `x` of type `M`, the scalar multiplication operation `c • x` is equivalent to the scalar multiplication of the coerced value of `c` to `ENNReal` and `x`, written as `↑c • x`. In simpler terms, it shows that for any nonnegative real number and an element of a particular type, you can perform scalar multiplication as though the nonnegative real number was an extended nonnegative real number.

For any type `M` with multiplication action by nonnegative real numbers, and for any nonnegative real number `c` and element `x` of `M`, `c • x` is equal to `↑c • x`, where `↑c` is the coerced value of `c` to `ENNReal`.


Dense.mono

theorem Dense.mono : ∀ {X : Type u} {s₁ s₂ : Set X} [inst : TopologicalSpace X], s₁ ⊆ s₂ → Dense s₁ → Dense s₂ := by
  sorry

The theorem `Dense.mono` states that for any type `X`, and for any two sets `s₁` and `s₂` of `X` under a given topology, if `s₁` is a subset of `s₂` and `s₁` is dense in the topological space, then `s₂` is also dense in the same topological space. In other words, the denseness property of a set is preserved under taking supersets in the same topology.

If `s₁ ⊆ s₂` and `s₁` is dense in the topological space `X`, then `s₂` is also dense in `X`.


theorem Nat.mul_div_cancel_left : ∀ (m : ℕ) {n : ℕ}, 0 < n → n * m / n = m := by sorry

This theorem states that for any two natural numbers `m` and `n`, where `n` is greater than zero, if you multiply `n` and `m` together and then divide the result by `n`, you will get back `m`. It essentially asserts the fundamental property of division and multiplication being inverse operations with respect to each other, in the context of natural numbers.

For all natural numbers `m` and `n` (`n` > 0), `m * (1 / n) = n * m`.


BoxIntegral.Integrable.hasIntegral

theorem BoxIntegral.Integrable.hasIntegral :
    ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
      {l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
      BoxIntegral.Integrable I l f vol → BoxIntegral.HasIntegral I l f vol (BoxIntegral.integral I l f vol) :=
  by sorry

The theorem `BoxIntegral.Integrable.hasIntegral` asserts that for any given types `ι`, `E`, and `F`, together with instances of `E` and `F` as normed add commutative groups and normed spaces over real numbers, an integrable box `I` of type `ι`, a finite type instance for `ι`, an integration parameter `l`, a function `f` mapping `ι → ℝ` to `E`, and a volume `vol` represented as a box additive map from `ι` to `E →L[ℝ] F`, if the function `f` is integrable over the box `I` with respect to the volume `vol` and the integration parameter `l`, then the integral of the function `f` over the box `I` is well-defined, i.e., `f` has an integral over `I` with respect to `vol` and `l`, and this integral is equal to the box integral of `f` over `I` with respect to `vol` and `l`.

For any integrable function `f` from a box `I` to the normed space `E` over real numbers, with respect to a normed additive group `ι`, a finite type instance for `ι`, a normed space `F`, an integration parameter `l`, and a box additive map `vol` from `ι` to `E →ℝ[ℝ] F`, the integral of `f` over `I` with respect to `vol` and `l` exists and equals the box integral of `f` over `I` with respect to `vol` and `l`.


/-- `Fintype.sum_equiv` is a specialization of `Finset.sum_bij` that
automatically fills in most arguments.

See `Equiv.sum_comp` for a version without `h`. -/
theorem Fintype.sum_equiv :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid α]
      (e : ι ≃ κ) (f : ι → α) (g : κ → α),
      (∀ (x : ι), f x = g (e x)) → (Finset.sum Finset.univ fun x => f x) = Finset.sum Finset.univ fun x => g x :=
  by sorry

The theorem `Fintype.sum_equiv` states that for any two types `ι` and `κ`, both having a `Fintype` instance, and for any type `α` with an `AddCommMonoid` instance, given an equivalence `e` between `ι` and `κ`, a function `f` from `ι` to `α`, and a function `g` from `κ` to `α`, if for each element `x` of `ι`, `f x` equals `g` of the image of `x` under `e`, then the sum of `f x` for all `x` in the universal finite set of `ι` equals the sum of `g x` for all `x` in the universal finite set of `κ`. This theorem shows that the sum of the elements of a function over a finite set remains the same after a bijective transformation.

Given types `ι` and `κ` with `Fintype` instances, an equivalence `e` between them, and functions `f: ι → α` and `g: κ → α` such that `f x = g (e x)` for all `x`, the sum of `f` over the universal finite set of `ι` equals the sum of `g` over the universal finite set of `κ`.


theorem add_neg_eq_zero : ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a + -b = 0 ↔ a = b := by sorry

This theorem states that for any type `G` that forms an additive group, and any two elements `a` and `b` of `G`, the sum of `a` and the additive inverse of `b` is zero if and only if `a` and `b` are equal. In other words, in any additive group, the condition that `a` added to the negative of `b` equals zero is equivalent to `a` being equal to `b`.

In an additive group, for all elements `a` and `b`, `a + (-b) = 0` if and only if `a = b`.


/-- A function is interval integrable with respect to a given measure `μ` on `a..b` if and
only if it is integrable on `uIoc a b` with respect to `μ`. This is an equivalent
definition of `IntervalIntegrable`.  -/
theorem intervalIntegrable_iff :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {f : ℝ → E} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
      IntervalIntegrable f μ a b ↔ MeasureTheory.IntegrableOn f (Ι a b) μ :=
  by sorry

The theorem states that for a given function `f` mapping real numbers to an element of a normed additive commutative group `E`, and a measure `μ`, the function is interval integrable with respect to `μ` on the interval `a..b` if and only if it is integrable on the interval `Ι a b` with respect to `μ`. This provides an alternative definition of interval integrability. The interval `Ι a b` represents the interval from min(a,b) to max(a,b). In essence, this theorem allows us to state that the concept of interval integrability is equivalent to the function being integrable over the interval from min(a,b) to max(a,b).

For a real-valued function `f` on a normed additive commutative group `E` and a measure `μ`, the function `f` is interval integrable with respect to `μ` on the interval `a..b` if and only if it is integrable on the interval `I a b` with respect to `μ`, where `I a b = {x : Real | min a b ≤ x ≤ max a b}`.


theorem Int.ofNat_inj : ∀ {m n : ℕ}, ↑m = ↑n ↔ m = n := by sorry

This theorem, `Int.ofNat_inj`, states that for any two natural numbers `m` and `n`, the assertion that the integer representation of `m` is equal to the integer representation of `n` is equivalent to the assertion that `m` is equal to `n`. In other words, coercing (or converting) natural numbers to integers preserves uniqueness. This is a statement about the injective property of the function that maps natural numbers to integers.

The theorem `Int.ofNat_inj` asserts that for all natural numbers m and n, the equality of their integer representations implies the equality of m and n.


theorem Set.image2_empty_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α}, Set.image2 f s ∅ = ∅ := by sorry

This theorem states that for any set `s` of elements of type `α` and function `f` of type `α → β → γ`, the image of `f` with respect to `s` and an empty set of type `β` is an empty set of type `γ`. In other words, if the second set in the function `Set.image2` is empty, then the resultant set will also be empty, no matter what the first set or the binary function is. In mathematical terms, this is expressed as: if `s` is a set and `f` is a function from `α × β` to `γ`, then the image of `f` applied to `s` and an empty set is an empty set.

For any set `s` and function `f`: if `s` is a set and `f` maps `α × β` to `γ`, then `Set.image2 s empty set` is an empty set.


IsConnected.nonempty

theorem IsConnected.nonempty : ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsConnected s → Set.Nonempty s :=
  by sorry

This theorem, named `IsConnected.nonempty`, states that for any set `s` of a certain type `α` in a topological space, if `s` is a connected set, then `s` is not empty. In other words, the theorem asserts that a connected set must contain at least one element. It can be seen as a property of connected sets in the context of topology.

In a topological space, a connected set is non-empty.


theorem Matroid.Indep.subset_ground : ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → I ⊆ M.E := by sorry

This theorem states that for any type `α`, any Matroid `M` defined over this type, and any Set `I` of elements of this type, if `I` is an independent set in the Matroid `M` (denoted by `M.Indep I`), then `I` is a subset of the ground set of the Matroid `M` (denoted by `M.E`). In other words, all independent sets in a matroid are subsets of the matroid's ground set.

For any matroid M and its ground set E, any independent set I of M is a subset of E.


theorem inner_self_eq_zero :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {x : E}, ⟪x, x⟫_𝕜 = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any type `𝕜` which behaves like a ring, and any normed add commutative group `E` which is also an inner product space over `𝕜`, the inner product of a vector `x` with itself is zero if and only if the vector `x` itself is the zero vector. This is a fundamental property in the context of inner product spaces.

For any normed add commutative `𝕜`-module `E` (where `𝕜` is a ring) being an inner product space, the inner product of a vector `x` with itself equals zero if and only if `x` is the zero vector.


theorem LinearEquiv.map_zero :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂), e 0 = 0 :=
  by sorry

This theorem states that for any linear equivalence `e` between two modules `M` and `M₂` over rings `R` and `S` respectively, the image of the zero element of `M` under `e` is the zero element of `M₂`. Here, the linear equivalence is defined with respect to two ring homomorphisms `σ` and `σ'` that form inverse pairs, i.e., the composition in each direction is the identity function on the respective ring.

Given linear equivalences `e : M ≃ M₂` between modules `M` over ring `R` and `M₂` over ring `S`, and ring homomorphisms `σ : R → S` and `σ' : S → R` forming inverse pairs, the image of the zero element of `M` under `e` is the zero element of `M₂`.


theorem Nat.Primrec'.of_eq :
    ∀ {n : ℕ} {f g : Vector ℕ n → ℕ}, Nat.Primrec' f → (∀ (i : Vector ℕ n), f i = g i) → Nat.Primrec' g := by sorry

This theorem states that for any natural number `n`, and for two functions `f` and `g` that map a `Vector` of length `n` with elements of type `ℕ` to `ℕ`, if `f` is a primitive recursive function (`Nat.Primrec' f`) and if `f` and `g` are equal for every `Vector` of natural numbers of length `n` (i.e., `∀ (i : Vector ℕ n), f i = g i`), then `g` is also a primitive recursive function (`Nat.Primrec' g`). In simpler terms, this theorem establishes that the property of being primitive recursive is preserved under equation for functions from vectors of natural numbers to natural numbers.

If `f` is a primitive recursive function mapping vectors of length `n` of natural numbers to natural numbers, and `f` equals `g` for all such vectors, then `g` is also a primitive recursive function.


theorem Set.image2_empty_left :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {t : Set β}, Set.image2 f ∅ t = ∅ := by sorry

This theorem states that for all types `α`, `β`, and `γ`, and for any binary function `f` from `α` and `β` to `γ`, and any set `t` of type `β`, the image of `f` when the first set is the empty set and the second set is `t`, is the empty set. In other words, when we take a binary function and apply it to pairs of elements where the first element is from an empty set, the result is always an empty set, regardless of what the second set is.

For all types `α`, `β`, and `γ`, and for any binary function `f` from `α` to `β`, the image of `f` applied to the empty set is an empty set.


/-- **Bézout's lemma**: given `x y : ℕ`, `gcd x y = x * a + y * b`, where `a = gcd_a x y` and
`b = gcd_b x y` are computed by the extended Euclidean algorithm.
 -/
theorem Nat.gcd_eq_gcd_ab : ∀ (x y : ℕ), ↑(Nat.gcd x y) = ↑x * Nat.gcdA x y + ↑y * Nat.gcdB x y := by sorry

**Bézout's Lemma**: For any two natural numbers `x` and `y`, the greatest common divisor (gcd) of `x` and `y` can be expressed as a linear combination of `x` and `y`, such that `gcd x y = x * a + y * b`. Here `a` and `b` are the coefficients obtained from the extended Euclidean algorithm, represented by the functions `gcdA x y` and `gcdB x y` respectively.

The greatest common divisor of natural numbers `x` and `y` can be expressed as a linear combination of `x` and `y`, i.e., `gcd x y = x * a + y * b` for some integers `a` and `b`.


theorem Set.insert_diff_singleton : ∀ {α : Type u} {a : α} {s : Set α}, insert a (s \ {a}) = insert a s := by sorry

This theorem states that for any type `α`, any element `a` of that type, and any set `s` of elements of that type, the set obtained by inserting `a` into the difference between `s` and the singleton set containing `a` is the same as the set obtained by simply inserting `a` into `s`. In other words, if you remove `a` from `s` and then add it back, you end up with the same set as if you just added `a` to `s`, even if `a` was already in `s`. This is expressed mathematically as ∀ {α : Type u} {a : α} {s : Set α}, insert a (s \ {a}) = insert a s.

For any type `α`, set `s` of elements, and element `a` in `α`, adding `a` to the set difference `s \ {a}` yields the same result as simply adding `a` to `s`. In mathematical notation: `insert a (s \ {a}) = insert a s`.


theorem neg_mem_iff :
    ∀ {S : Type u_5} {G : Type u_6} [inst : InvolutiveNeg G] {x : SetLike S G} [inst_1 : NegMemClass S G] {H : S}
      {x_1 : G}, -x_1 ∈ H ↔ x_1 ∈ H :=
  by sorry

This theorem states that for any set-like structure `S`, `H`, that is a subset of `G`, where `G` is a type endowed with the property of involutive negation, and any element `x_1` from `G`, the element `x_1` is in `H` if and only if its negation is in `H`. In other words, `H` contains an element and its negation simultaneously. Here, `InvolutiveNeg` refers to the property where the negation of a negation brings you back to the original element (like in the case of numbers), and `NegMemClass` is a class that relates `S` and `G`, suggesting that negation of elements in `S` results in elements in `G`.

For any set-like structure `S` subset of the involutively negated type `G`, an element `x_1` in `G` belongs to `H` if and only if its negation belongs to `H`.


theorem PartialHomeomorph.extend_source :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H),
      (PartialHomeomorph.extend f I).source = f.source :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed addition commutative group `E`, normed space `𝕜 E`, and topological spaces `H` and `M`, given a partial homeomorphism `f` from `M` to `H` and a model with corners `I` on `𝕜 E H`, the source of the extended partial homeomorphism `f` through `I` is equal to the source of `f`. In other words, extending a partial homeomorphism via a model with corners doesn't change its source.

For any non-trivially normed field `𝕜`, normed addition commutative group `E`, normed space `𝕜 E`, topological spaces `H` and `M`, a partial homeomorphism `f` from `M` to `H`, and a model with corners `I` on `𝕜 E H`, the source of the extended partial homeomorphism `f` through `I` equals the source of `f`.


/-- **Alias** of `congrFun₂`. -/
theorem congr_fun₂ :
    ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {f g : (a : α) → (b : β a) → γ a b},
      f = g → ∀ (a : α) (b : β a), f a b = g a b :=
  by sorry

This theorem, referred to as an alias of `congrFun₂`, states that for any two functions `f` and `g` that map an element `a` of type `α` and an element `b` of a dependent type `β a` to an element of a dependent type `γ a b`, if `f` and `g` are equal, then for any specific `a` and `b` (where `b` is of type `β a`), `f a b` is equal to `g a b`. Essentially, it asserts that if two functions are equal, their outcomes are equal for each possible pair of input.

If two functions `f` and `g` from `α × β (α)` to `γ (α) (β (α))` are equal, then for all `a : α` and `b : β a`, `f a b` is equal to `g a b`.


theorem mul_inv_eq_iff_eq_mul : ∀ {G : Type u_3} [inst : Group G] {a b c : G}, a * b⁻¹ = c ↔ a = c * b := by sorry

This theorem states that for any type `G` that forms a Group, given any three elements `a`, `b`, and `c` of the group, the equality `a * b⁻¹ = c` is equivalent to `a = c * b`. Here, `*` denotes the group multiplication operation and `b⁻¹` is the inverse of `b` in the group. In other words, multiplying `a` by the inverse of `b` gives `c` if and only if `a` equals `c` multiplied by `b`.

For any group `G` and elements `a, b, c` in `G`, `a * b⁻¹ = c` if and only if `a = c * b`.


theorem IsUnit.ne_zero :
    ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Nontrivial M₀] {a : M₀}, IsUnit a → a ≠ 0 := by sorry

This theorem states that for any nontrivial monoid with zero (`MonoidWithZero`), which is a monoid that has an additional zero element distinct from the identity, any element `a` of this monoid that is a unit (i.e., has a two-sided inverse), is not equal to zero. In other words, in such a monoid, all unit elements are nonzero.

In a `MonoidWithZero`, every unit is non-zero.


theorem Ideal.ne_top_iff_one : ∀ {α : Type u} [inst : Semiring α] (I : Ideal α), I ≠ ⊤ ↔ 1 ∉ I := by sorry

This theorem states that for any type `α` equipped with a semiring structure, and any ideal `I` of that semiring, the ideal `I` is not the entire semiring (represented by `⊤`) if and only if the multiplicative identity `1` does not belong to `I`. So, in the context of ring theory, an ideal is different from the total ring if it doesn't contain the number one.

A semiring ideal is not the entire semiring if and only if its multiplicative identity does not belong to it.


theorem Complex.re_ofReal_mul : ∀ (r : ℝ) (z : ℂ), (↑r * z).re = r * z.re := by sorry

This theorem states that for any real number `r` and any complex number `z`, the real part of the product of `r` (converted to a complex number) and `z` is equal to `r` multiplied by the real part of `z`. In terms of mathematical notation, this would be represented as Re(rz) = rRe(z) where `Re` represents the real part of a complex number.

The real part of the product of a real number and a complex number is equal to the real number times the real part of the complex number. In Lean notation, Re(r * z) = r * Re(z).


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

This theorem states that for any type `R` which is a semiring and any polynomial `p` of type `R`, the composition of the polynomial `p` with the constant polynomial 1 is equal to the constant polynomial 1. In other words, it asserts that if you substitute polynomial `p` into the polynomial `1`, you get back the polynomial `1`. This theorem is a property of the composition operation on polynomials defined over a semiring.

For any semiring `R` and polynomial `p` of type `R`, `p` composed with the constant polynomial 1 equals the constant polynomial 1. In Lean 4 notation, `(p : R → R) ∘ const 1 = const 1`.


theorem pure_le_nhdsWithin :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, a ∈ s → pure a ≤ nhdsWithin a s := by sorry

This theorem states that for any type `α` that has a topological space structure (indicated by `[TopologicalSpace α]`), for any element `a` of `α` and any set `s` of `α`, if `a` is an element of `s` (expressed as `a ∈ s`), then the pure filter of `a` is less than or equal to the "neighborhood within" filter of `a` within `s` (expressed as `pure a ≤ nhdsWithin a s`). Here, the "neighborhood within" filter of `a` within `s` refers to the intersection of `s` and a neighborhood of `a`.

For any topological space `α` and element `a` in `α`, if `a` belongs to a set `s`, then the pure filter of `a` is contained in the neighborhood filter of `a` within `s`.


/-- Given two elements `a`, `b` of a commutative `CancelMonoidWithZero` and a nonzero
element `c`, `a*c` divides `b*c` iff `a` divides `b`.  -/
theorem mul_dvd_mul_iff_right :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] {a b c : α}, c ≠ 0 → (a * c ∣ b * c ↔ a ∣ b) := by sorry

This theorem states that for any commutative `CancelMonoidWithZero` type `α`, given two elements `a` and `b` of type `α` and a nonzero element `c` of the same type, `a` multiplied by `c` divides `b` multiplied by `c` if and only if `a` divides `b`. Here, `CancelMonoidWithZero` is a type of algebraic structure in which multiplication is commutative, 0 is the multiplicative identity, and multiplication by a nonzero element is cancellative (that is, if `ac = bc` and `c ≠ 0`, then `a = b`).

For any commutative `CancelMonoidWithZero` type `α` and nonzero `c` in `α`, `a * c |- b * c` if and only if `a |- b`, where `*` denotes multiplication and `|-` denotes divisibility.


theorem Finset.filter_union :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : DecidableEq α] (s₁ s₂ : Finset α),
      Finset.filter p (s₁ ∪ s₂) = Finset.filter p s₁ ∪ Finset.filter p s₂ :=
  by sorry

The theorem `Finset.filter_union` states that for any type `α`, any predicate `p` on `α` that is decidable, any two finite sets `s₁` and `s₂` of `α`, and given that equality in `α` is decidable, filtering the union of `s₁` and `s₂` with the predicate `p` is the same as taking the union of the filter of `s₁` with `p` and the filter of `s₂` with `p`. In other words, it asserts that the operation of filtering a finite set with a decidable predicate distributes over the operation of taking the union of two finite sets, much like how multiplication distributes over addition in basic arithmetic.

For any decidable predicate `p` on a type `α` and finite sets `s₁` and `s₂` of `α` with decidable equality, `(s₁ ∪ s₂).filter p = s₁.filter p ∪ s₂.filter p`.


theorem Finset.mem_ssubsets : ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, t ∈ Finset.ssubsets s ↔ t ⊂ s :=
  by sorry

This theorem states that for any two finite sets `s` and `t` of an arbitrary type `α` with decidable equality, `t` is a member of the set of strict subsets of `s` (i.e., `t` is in `Finset.ssubsets s`) if and only if `t` is a strict subset of `s` (denoted as `t ⊂ s`). In other words, `t` is considered a strict subset of `s` (meaning `t` is contained in `s` but `t` and `s` are not equal) exactly when `t` is in the collection of strict subsets of `s`. This theorem provides a characterization of the membership in the collection of all strict subsets of a given finite set.

For any finite sets `s` and `t` of type `α` with decidable equality, `t` is a strict subset of `s` if and only if `t` is an element of the set of strict subsets of `s` (`Finset.ssubsets s`).


theorem CategoryTheory.IsIso.Iso.inv_hom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ≅ Y), CategoryTheory.inv f.hom = f.inv :=
  by sorry

This theorem, `CategoryTheory.IsIso.Iso.inv_hom`, states that for any category `C`, and any two objects `X` and `Y` in that category, if we have an isomorphism `f` from `X` to `Y`, then the inverse of the morphism `f.hom` as computed by the function `CategoryTheory.inv` is equal to `f.inv`. In other words, the inverse of the morphism given by an isomorphism, as defined by the `CategoryTheory.inv` function, is the same as the inverse morphism in the isomorphism itself.

For any category C and isomorphism f : X ≈ Y in C, the inverse morphisms f^-1 and CategoryTheory.inv f agree: f^-1 = CategoryTheory.inv f.hom.


theorem FreeAbelianGroup.induction_on :
    ∀ {α : Type u} {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α),
      C 0 →
        (∀ (x : α), C (FreeAbelianGroup.of x)) →
          (∀ (x : α), C (FreeAbelianGroup.of x) → C (-FreeAbelianGroup.of x)) →
            (∀ (x y : FreeAbelianGroup α), C x → C y → C (x + y)) → C z :=
  by sorry

This theorem, called `FreeAbelianGroup.induction_on`, states that for any type `α` and any property `C` that holds for elements of the free Abelian group on `α`, if `C` holds for the zero element, for any element of `α` mapped into the free Abelian group, for the additive inverse of any such element, and is closed under addition in the free Abelian group (i.e., if it holds for any two elements, it also holds for their sum), then `C` holds for every element of the free Abelian group. This theorem provides a principle of induction for proving properties over all elements of the free Abelian group.

If a property `C` holds for the zero element and is closed under addition in a free Abelian group, then `C` holds for all elements if it holds for each element and its additive inverse.


/-- Note that as this lemma has an `if` in the statement, we include a `DecidableEq` argument.
This means you may not be able to `simp` using this lemma unless you `open scoped Classical`.  -/
theorem CategoryTheory.Limits.biproduct.ι_π :
    ∀ {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),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι f j)
          (CategoryTheory.Limits.biproduct.π f j') =
        if h : j = j' then CategoryTheory.eqToHom ⋯ else 0 :=
  by sorry

This theorem, `CategoryTheory.Limits.biproduct.ι_π`, states that for any type `J`, type `C`, an instance of `CategoryTheory.Category` for `C`, an instance of `CategoryTheory.Limits.HasZeroMorphisms` for `C`, an instance of `DecidableEq` for `J`, a function `f` from `J` to `C`, and an instance of `CategoryTheory.Limits.HasBiproduct` for `f`, along with two elements `j` and `j'` of `J`, the composition of the inclusion into a summand of a biproduct of `f` at `j` and the projection onto a summand of a biproduct of `f` at `j'` equals the morphism from `j` to `j'` if `j` equals `j'`, otherwise it equals zero. It is important to note that due to the presence of an `if` in the statement of the theorem, a `DecidableEq` argument is included, meaning you may not be able to use simplification (`simp`) with this theorem unless you open the classical logic scope (`open scoped Classical`).

For any functor `f` from a decidable category with biproducts `J` to a category `C`, and for any `j`, `j'` in `J`, the composition of the inclusion and projection morphisms of the biproduct of `f` at `j` and `j'` equals `f(j) = f(j')` if and only if `j = j'`, otherwise it is the zero morphism.


ClosedEmbedding.isClosedMap

theorem ClosedEmbedding.isClosedMap :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      ClosedEmbedding f → IsClosedMap f :=
  by sorry

The theorem states that for any types `X` and `Y`, and any function `f` from `X` to `Y`, given that `X` and `Y` have a topological space structure, if `f` is a closed embedding (meaning it's an embedding and its image is a closed set in `Y`), then `f` is a closed map. In other words, if a function `f` is such that it embeds `X` into `Y` and the image of `f` is closed in `Y`, it will also have the property that the image of any closed set in `X` under `f` is a closed set in `Y`.

If `f` is a closed embedding of topological spaces `X` into `Y`, then `f` is a closed map.


minpoly.dvd

/-- If an element `x` is a root of a polynomial `p`, then the minimal polynomial of `x` divides `p`.
See also `minpoly.isIntegrallyClosed_dvd` which relaxes the assumptions on `A` in exchange for
stronger assumptions on `B`.  -/
theorem minpoly.dvd :
    ∀ (A : Type u_1) {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B)
      {p : Polynomial A}, (Polynomial.aeval x) p = 0 → minpoly A x ∣ p :=
  by sorry

The theorem `minpoly.dvd` states that for any field `A`, ring `B`, algebra structure between `A` and `B`, and element `x` in `B`, if `x` is a root of a polynomial `p` over `A` (i.e., applying the algebra homomorphism from `A[X]` to `B` that sends `X` to `x` results in zero), then the minimal polynomial of `x` over `A` divides `p`. This result is also related to the theorem `minpoly.isIntegrallyClosed_dvd`, which has looser conditions on `A` but stricter ones on `B`.

If `x` is a root of a polynomial `p` over field `A` in ring `B` with an algebra structure from `A`, then the minimal polynomial of `x` over `A` divides `p`.


theorem Polynomial.derivative_mul :
    ∀ {R : Type u} [inst : Semiring R] {f g : Polynomial R},
      Polynomial.derivative (f * g) = Polynomial.derivative f * g + f * Polynomial.derivative g :=
  by sorry

The theorem `Polynomial.derivative_mul` states that for any type `R` that is a semiring and for any polynomials `f` and `g` over `R`, the derivative of the product of `f` and `g` is equal to the product of the derivative of `f` and `g` plus the product of `f` and the derivative of `g`. This is equivalent to the product rule in calculus, stated as `(f*g)' = f'*g + f*g'`.

The derivative of the product of two polynomials over a semiring is equal to the sum of the product of the derivatives of each polynomial and the other polynomial.


theorem CategoryTheory.Limits.initial.to_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasInitial C] {P Q : C}
      (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.initial.to P) f = CategoryTheory.Limits.initial.to Q :=
  by sorry

This theorem states that for any category `C` that has an initial object, and any two objects `P` and `Q` in `C`, with a morphism `f` from `P` to `Q`, the composition of the morphism from the initial object to `P` with `f` is equal to the morphism from the initial object to `Q`. This is essentially a specific instance of the universal property of the initial object, stating that there is a unique morphism from the initial object to any object in the category, which commutes with any other morphisms in the category.

For any category with an initial object, the unique morphism from the initial object to any object commutes with any morphism from that object to another.


theorem isOfFinOrder_of_finite :
    ∀ {G : Type u_1} [inst : LeftCancelMonoid G] [inst_1 : Finite G] (x : G), IsOfFinOrder x := by sorry

This theorem states that for any type `G`, given that `G` is a Left Cancelable Monoid and `G` is finite, every element `x` of `G` is of finite order. Here, an element `x` of `G` being of finite order means that there exists a positive integer `n` such that raising `x` to the power `n` equals the identity of the monoid, i.e., `x ^ n = 1`. A Left Cancelable Monoid is a monoid (an algebraic structure equipped with an associative binary operation and an identity element) with the additional property that for all elements `a`, `b`, and `c`, if `a * b = a * c`, then `b = c`. A finite `G` means that the type `G` has a finite number of elements.

In a finite, left cancelable monoid, every non-identity element has finite order.


theorem Set.biUnion_image :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set γ} {f : γ → α} {g : α → Set β},
      ⋃ x ∈ f '' s, g x = ⋃ y ∈ s, g (f y) :=
  by sorry

This theorem, `Set.biUnion_image`, states that for all types `α`, `β`, and `γ`, and for a given set `s` of type `γ`, a function `f` from `γ` to `α`, and a function `g` from `α` to a set of type `β`, the union over `x` in the image of `s` under `f` of `g(x)` is equal to the union over `y` in `s` of `g(f(y))`. In other words, it shows that the ordering of function application and set union operation can be swapped without changing the result. This theorem is a manifestation of the interchange between the operations of union and function application (image) in the context of set theory.

For any sets `α`, `β`, `γ`, a set `s` of type `γ`, and functions `f: γ → α` and `g: α → β`, the image of `s` under `f` followed by `g` is equal to the union of `g`'s images over the elements of `s`, i.e., `(∪ y ∈ s (g ∘ f) y) = ∪ x ∈ ∫ x ∈ s g (f x)`.


/-- An affine map on the result of adding a vector to a point produces
the same result as the linear map applied to that vector, added to the
affine map applied to that point.  -/
theorem AffineMap.map_vadd :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
      [inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
      [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] (f : P1 →ᵃ[k] P2) (p : P1) (v : V1),
      f (v +ᵥ p) = f.linear v +ᵥ f p :=
  by sorry

This theorem states that for any ring `k`, additively commutative groups `V1` and `V2`, modules `V1` and `V2` over `k`, additively commutative torsor `P1` over `V1` and `P2` over `V2`, and an affine map `f` from `P1` to `P2`, the result of applying the affine map `f` to the sum of a vector `v` from `V1` and a point `p` from `P1` is equivalent to the sum of the result of applying the linear part of `f` to `v` and the result of applying `f` to `p`.

For any ring `k`, additively commutative groups `V1` and `V2`, modules `V1` and `V2` over `k`, additively commutative torsors `P1` over `V1` and `P2` over `V2`, and an affine map `f` from `P1` to `P2`, we have `f(p + v) = f(p) + fⁱ(v)`, where `fⁱ` denotes the linear part of `f`.


MeasureTheory.IntegrableOn.mono

theorem MeasureTheory.IntegrableOn.mono :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s t : Set α}
      {μ ν : MeasureTheory.Measure α},
      MeasureTheory.IntegrableOn f t ν → s ⊆ t → μ ≤ ν → MeasureTheory.IntegrableOn f s μ :=
  by sorry

The theorem `MeasureTheory.IntegrableOn.mono` states that for any types `α` and `E`, with `α` having a `MeasurableSpace` instance and `E` having a `NormedAddCommGroup` instance, and given a function `f` from `α` to `E` and sets `s` and `t` of type `α`, if the function `f` is integrable over the set `t` with respect to measure `ν`, then if `s` is a subset of `t` and measure `μ` is less than or equal to `ν`, it follows that `f` is also integrable over the set `s` with respect to measure `μ`. In other words, this theorem states the monotonicity of the integrability of a function over a set with respect to a measure.

If `f` is a integrable function from a measurable space `(α, Σ, ν)` to a normed additive group `(E, +, ∥⋅∥)`, and `s ⊆ t` are sets in `α` with `μ(s) ≤ ν(t)`, then `f` is integrable over `s` with respect to measure `μ`.


theorem Set.disjoint_iff : ∀ {α : Type u} {s t : Set α}, Disjoint s t ↔ s ∩ t ⊆ ∅ := by sorry

The theorem `Set.disjoint_iff` states that, for any type `α` and any two sets `s` and `t` of type `α`, `s` and `t` are disjoint if and only if the intersection of `s` and `t` is a subset of the empty set. In other words, two sets are defined as disjoint when their intersection contains no elements, which is equivalent to saying their intersection is contained within the empty set.

Two sets of type `α` are disjoint if and only if their intersection is equal to the empty set.


theorem ofUnits_units_gc : ∀ {M : Type u_1} [inst : Monoid M], GaloisConnection Subgroup.ofUnits Submonoid.units := by
  sorry

The theorem `ofUnits_units_gc` states that for any type `M` that forms a monoid, there exists a Galois connection between the operation `Subgroup.ofUnits` and `Submonoid.units`. In other words, for every subgroup of units in `M`, there is a corresponding submonoid in `M` and vice versa. A Galois connection is a pair of operations related in such a way that an inequality involving one operation on one side implies and is implied by an inequality involving the other operation on the other side. This theorem thus provides a conceptual link between the structure of monoids and the structure of their associated unit groups.

For any monoid `M`, there exists a Galois connection between `Subgroup.ofUnits` and `Submonoid.units`.


IsCompact.measurableSet

theorem IsCompact.measurableSet :
    ∀ {α : Type u_1} {s : Set α} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α]
      [inst_2 : OpensMeasurableSpace α] [inst_3 : T2Space α], IsCompact s → MeasurableSet s :=
  by sorry

The theorem `IsCompact.measurableSet` asserts that for any set `s` of type `α`, under the conditions that `α` has a topological space structure, a measurable space structure, an open measurable space structure, and is a T2 space (also known as a Hausdorff space), if `s` is a compact set, then `s` is a measurable set. In other words, it guarantees measurability of compact sets in a Hausdorff topological space where the open sets are measurable.

In a Hausdorff topological space with a measurable structure where the open sets are measurable, a compact set is measurable.


theorem MonoidHom.ker_eq_bot_iff :
    ∀ {G : Type u_1} [inst : Group G] {M : Type u_7} [inst_1 : MulOneClass M] (f : G →* M),
      MonoidHom.ker f = ⊥ ↔ Function.Injective ⇑f :=
  by sorry

The theorem `MonoidHom.ker_eq_bot_iff` states that for any group `G` and any type `M` endowed with multiplication and an identity element, a monoid homomorphism `f: G → M` has a trivial kernel (the kernel of `f` is the trivial subgroup, denoted by `⊥`) if and only if `f` is injective. In other words, in the context of group theory, a monoid homomorphism between a group and a mul-one-class is injective exactly when the preimage of the identity element under the homomorphism is just the identity element of the group.

A monoid homomorphism from a group to a monoid with an identity is injective if and only if its kernel is the trivial subgroup.


theorem one_le_div : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b : α}, 0 < b → (1 ≤ a / b ↔ b ≤ a) := by
  sorry

This theorem, `one_le_div`, states that for any type `α` in the universe `u_2` which is a Linear Ordered Semifield, and for any `a` and `b` of type `α`, when `b` is greater than 0, the condition that `1` is less than or equal to the division of `a` over `b` holds if and only if `b` is less than or equal to `a`. In simpler terms, in a certain kind of ordered field, if `b` is positive, then `1` is less than or equal to `a` divided by `b` exactly when `b` is less than or equal to `a`.

In a Linear Ordered Semifield `α`, for all `a` and `b` of type `α` with `b > 0`, `1 ≤ a / b` if and only if `b ≤ a`.


theorem Finset.sup_insert :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α}
      [inst_2 : DecidableEq β] {b : β}, Finset.sup (insert b s) f = f b ⊔ Finset.sup s f :=
  by sorry

The theorem `Finset.sup_insert` states that for any types `α` and `β`, given a semilattice structure (where supremum operation is possible) on `α` and the bottom element of `α`, a finite set `s` of type `β`, and a function `f` mapping from `β` to `α`. If type `β` has decidable equality, and `b` is an element of type `β`, then the supremum of the set formed by inserting `b` into `s` mapped through `f` is equal to the supremum of `f(b)` and the supremum of the set `s` mapped through `f`. In simpler terms, adding an element to a finite set and then taking the supremum, is the same as taking the supremum of the original set and the new element separately.

Given a semilattice with bottom element, a finite set, and a function from the set to the semilattice with decidable equality, the supremum of the set with a new element inserted and mapped through the function equals the supremum of mapping the new element through the function and the original supremum.


LipschitzWith.lipschitzOnWith

theorem LipschitzWith.lipschitzOnWith :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → ∀ (s : Set α), LipschitzOnWith K f s :=
  by sorry

The theorem `LipschitzWith.lipschitzOnWith` states that for any set `s`, if a function `f` from a pseudometric space `α` to another pseudometric space `β` is Lipschitz continuous with a nonnegative real constant `K`, then `f` is also Lipschitz continuous on the set `s` with the same constant `K`. In other words, if the distance between the images of any two points under `f` is at most `K` times the distance between the points themselves, then this property still holds when those points are restricted to belong to a particular set `s`.

If `f:` `α` → `β` is a Lipschitz continuous function with constant `K` from the pseudometric space `α` to the pseudometric space `β`, then `f` is Lipschitz continuous on any set `s` ⊆ `α` with the same constant `K`.


theorem List.length_range' : ∀ (s step n : ℕ), List.length (List.range' s n step) = n := by sorry

The theorem `List.length_range'` asserts that for any natural numbers `s`, `step`, and `n`, the length of the list produced by the function `List.range'` with start point `s`, count `n`, and step size `step` is exactly `n`. In other words, when we create a list of natural numbers starting from `s`, with increments defined by `step`, and a total of `n` numbers, the length of this list will always be `n`, regardless of the values of `s` and `step`.

For any natural numbers `n`, `s`, and `step`, the length of the sequence `List.range' s (s + n - 1) step` equals `n`.


theorem UniqueFactorizationMonoid.factors_unique :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {f g : Multiset α},
      (∀ x ∈ f, Irreducible x) →
        (∀ x ∈ g, Irreducible x) → Associated (Multiset.prod f) (Multiset.prod g) → Multiset.Rel Associated f g :=
  by sorry

The theorem `UniqueFactorizationMonoid.factors_unique` states that for a given Type `α` which has a `CancelCommMonoidWithZero` and `UniqueFactorizationMonoid` structure, if we have two multisets `f` and `g`, where all elements in both multisets are irreducible, then if the product of all elements in `f` is associated with the product of all elements in `g` (meaning that one product can be gotten by multiplying the other by a unit), then each element in `f` is associated with an element in `g`, and vice versa. This is the uniqueness part of the unique factorization property in algebra, stating that every element in a unique factorization monoid can be uniquely factored into irreducible elements (up to association).

In a unique factorization monoid with cancellation, if two multisets of irreducible elements have the same product up to units, then each irreducible in one multiset is associated with exactly one irreducible in the other multiset.


theorem Homeomorph.comap_nhds_eq :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) (y : Y),
      Filter.comap (⇑h) (nhds y) = nhds ((Homeomorph.symm h) y) :=
  by sorry

The theorem `Homeomorph.comap_nhds_eq` states that for any topological spaces `X` and `Y`, and a homeomorphism `h` from `X` to `Y`, the result of applying the comap function to the neighborhood filter `nhds` at a point `y` in `Y` and the function defined by `h`, is equal to the neighborhood filter at the image of `y` under the inverse of `h`. In other words, precomposing the neighborhood filter of a point in `Y` with a homeomorphism gives the neighborhood filter of its preimage in `X`.

For any topological spaces X and Y and a homeomorphism h: X -> Y, the preimage of the neighborhood filter of y in Y under h is equal to the neighborhood filter of h\*(y) in X.


theorem Mathlib.Logic.IsEmpty._auxLemma.5 : ∀ {α : Sort u_1}, IsEmpty α = ¬Nonempty α := by sorry

This theorem states that for any kind `α` (which can be a type or a sort), `α` is empty if and only if it is not nonempty. In other words, the property of being empty for a type is logically equivalent to the negation of the property of being nonempty for that type. Here, `IsEmpty α` means that there are no elements of type `α`, and `Nonempty α` means that there exists at least one element of type `α`.

For any type `α`, `IsEmpty α` is equivalent to `∥α∥ = ∅`, where `∥_∥` denotes the size or the cardinality of a type. In other words, a type is empty if and only if it has no elements.


Cardinal.cantor

/-- **Cantor's theorem**  -/
theorem Cardinal.cantor : ∀ (a : Cardinal.{u}), a < 2 ^ a := by sorry

Cantor's theorem states that for any cardinal number `a`, `a` is strictly less than `2 ^ a`. In other words, the cardinality of any set is always less than the cardinality of the power set of that set. The power set of a set is the set of all of its subsets, and its cardinality (or size) is represented in Lean by `2 ^ a`. This theorem is a fundamental result in set theory and reveals the existence of different "sizes" of infinity in mathematics.

For any cardinal number `a`, the cardinality of a set is strictly less than the cardinality of its power set, `2 ^ a`.


theorem WithTop.range_coe : ∀ {α : Type u_1} [inst : Preorder α], Set.range WithTop.some = Set.Iio ⊤ := by sorry

This theorem states that for any type `α` that has a preorder relation, the set of all values that can be produced by the `WithTop.some` function (which maps each element of `α` to an element of the type `WithTop α`, essentially adding a "top" or maximal element to `α`) is exactly the same as the set of all values in `WithTop α` that are strictly less than the top element. In other words, every element in the type `WithTop α` except for the top element can be reached by applying `WithTop.some` to some element of `α`.

For any preordered type `α`, the image of `α` under `WithTop.some` is equal to the set of strictly smaller elements in `WithTop α`.


theorem Set.image2_subset_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t : Set β},
      s ⊆ s' → Set.image2 f s t ⊆ Set.image2 f s' t :=
  by sorry

The theorem `Set.image2_subset_right` states that for any types `α`, `β`, and `γ`, and a binary function `f` from `α` and `β` to `γ`, if a set `s` of type `α` is a subset of another set `s'` of type `α`, then the image of the function `f` when applied to the sets `s` and `t` (of type `β`) is a subset of the image of the function `f` when applied to the sets `s'` and `t`. In other words, this theorem enforces the property that the image of a smaller set under a function is a subset of the image of a larger set under the same function, when the function is applied to a fixed second set.

For any functions $f : \alpha \times \beta \rightarrow \gamma$ and sets $s \subseteq s' \subseteq \alpha$, we have $f(s \times t) \subseteq f(s' \times t)$ for all $t \in \beta$.


theorem MeasureTheory.integrable_congr :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f g : α → β},
      f =ᶠ[MeasureTheory.Measure.ae μ] g → (MeasureTheory.Integrable f μ ↔ MeasureTheory.Integrable g μ) :=
  by sorry

This theorem states that for any measurable space `α`, any measure `μ` on that space, and any two functions `f` and `g` from `α` to a normed additive commutative group `β`, if `f` and `g` are equal almost everywhere with respect to the measure `μ`, then `f` is integrable with respect to `μ` if and only if `g` is also integrable with respect to `μ`. Here, a function is deemed integrable if it is both measurable and has a finite integral.

If two measurable functions from a measurable space to a normed additive commutative group are equal almost everywhere with respect to a measure, then they are both integrable with respect to that measure.


theorem Polynomial.natDegree_neg :
    ∀ {R : Type u} [inst : Ring R] (p : Polynomial R), Polynomial.natDegree (-p) = Polynomial.natDegree p := by sorry

The theorem `Polynomial.natDegree_neg` states that for any type `R` equipped with a ring structure, and for any polynomial `p` of type `R`, the natural degree of the negation of `p` (`-p`) is equal to the natural degree of `p`. In other words, negating a polynomial does not change its natural degree.

The natural degree of the negation of a polynomial is equal to the natural degree of the polynomial in any commutative ring.


theorem Polynomial.eval_zero : ∀ {R : Type u} [inst : Semiring R] {x : R}, Polynomial.eval x 0 = 0 := by sorry

The theorem `Polynomial.eval_zero` states that for any given type `R` that forms a semiring, and for any element `x` of type `R`, the evaluation of the zero polynomial at `x` (i.e., `Polynomial.eval x 0`) is always zero. It essentially asserts the mathematical fact that if you substitute any number into the zero polynomial, the resulting value will be zero.

For any semiring `R` and its element `x`, the value of the zero polynomial evaluated at `x` is zero.


theorem Real.tan_eq_sin_div_cos : ∀ (x : ℝ), Real.tan x = Real.sin x / Real.cos x := by sorry

This theorem states that for all real numbers `x`, the value of the tangent of `x` is equal to the value of the sine of `x` divided by the cosine of `x`. In other words, `tan(x) = sin(x) / cos(x)`. This is a well-known identity from trigonometry which holds for all real numbers.

The tangent function is equal to the quotient of the sine and cosine functions for all real numbers. (tan(x) = sin(x) / cos(x))


theorem Finset.image_nonempty :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α},
      (Finset.image f s).Nonempty ↔ s.Nonempty :=
  by sorry

This theorem, `Finset.image_nonempty`, states for any two types `α` and `β` with a decidable equality on `β`, any function `f` from `α` to `β`, and any finite set `s` of type `α`, the forward image of `s` under `f` (represented by `Finset.image f s`) is nonempty if and only if `s` itself is nonempty. In other words, a finite set `s` has a nonempty image under a function `f` precisely when `s` is not empty.

For any decidably equalizable types `α` and `β`, function `f` from `α` to `β`, and finite set `s` of type `α`, the image `Finset.image f s` is nonempty if and only if `s` is nonempty.


theorem Polynomial.degree_add_eq_left_of_degree_lt :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.degree q < Polynomial.degree p → Polynomial.degree (p + q) = Polynomial.degree p :=
  by sorry

The theorem `Polynomial.degree_add_eq_left_of_degree_lt` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the degree of polynomial `q` is strictly less than the degree of polynomial `p`, then the degree of the sum of polynomial `p` and polynomial `q` equals the degree of polynomial `p`. In other words, when adding two polynomials, if one has a lower degree than the other, the degree of the resulting polynomial will be the same as the degree of the higher-degree polynomial.

For any semiring R and polynomials p and q over R with deg(q) < deg(p), the degree of p + q equals deg(p).


theorem Set.image_inter_preimage :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α) (t : Set β), f '' (s ∩ f ⁻¹' t) = f '' s ∩ t := by sorry

The theorem `Set.image_inter_preimage` states that for all types `α` and `β`, and a function `f` from `α` to `β`, the image of the intersection of a set `s` of type `α` and the preimage of a set `t` under `f` is equal to the intersection of the image of `s` under `f` and `t`. In mathematical terms, given a function `f : α → β`, a set `s ⊆ α`, and a set `t ⊆ β`, we have `f(s ∩ f⁻¹(t)) = f(s) ∩ t`. This theorem relates the concepts of image, intersection, and preimage in the context of sets and functions between them.

For all sets `s ⊆ α` and `t ⊆ β`, and function `f : α → β`, `f(s ∩ f⁻¹(t)) = f(s) ∩ t`.


theorem DFinsupp.single_injective :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)] {i : ι},
      Function.Injective (DFinsupp.single i) :=
  by sorry

The theorem `DFinsupp.single_injective` states that for any type ι, a type β dependent on ι, a decision procedure for equality on ι, and a zero element for each type β i, the function `DFinsupp.single i` is injective. In other words, if ι is a type, β is a type dependent on ι, there is a way to decide if two elements of ι are equal, and each type β i has a defined zero element, then for each element i of ι, no two different inputs to the function `DFinsupp.single i` produce the same output.

For any type ι, dependent type β, decision procedure for equality on ι, and zero elements for each β i, the function `DFinsupp.single i` maps distinct elements of ι to distinct outputs.


theorem Set.iUnion_iUnion_eq' :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → α} {g : α → Set β},
      ⋃ x, ⋃ y, ⋃ (_ : f y = x), g x = ⋃ y, g (f y) :=
  by sorry

This theorem, `Set.iUnion_iUnion_eq'`, states that for any types `α` and `β`, and an index type `ι`, given a function `f : ι → α` and another function `g : α → Set β`, the union over `x` of the union over `y` of the union over the condition that `f y = x` of `g x` is equal to the union over `y` of `g (f y)`. In other words, this theorem is about a change of order of set unions, where the function `f` maps the index `y` to an element `x`, and `g` maps this `x` to a set of `β` type elements: it guarantees that we can directly map `y` to the set of `β` elements via composition of `f` and `g`, and take the union over `y` instead of over `x`. This kind of reordering is often useful in mathematical proofs involving indexed families of sets.

For any types α and β, and an index type ι, given functions f : ι → α and g : α → Set β, the union over y of g (f y) is equal to the union over x of the union over y with f y = x of g x.


theorem Nat.gcd_zero_right : ∀ (n : ℕ), Nat.gcd n 0 = n := by sorry

This theorem, `Nat.gcd_zero_right`, states that for any natural number `n`, the greatest common divisor (gcd) of `n` and `0` is `n` itself. In other words, if you compute the gcd between any natural number and zero, you will always get the original natural number. This is a standard result in number theory and is represented mathematically as $\text{gcd}(n, 0) = n$ for any natural number $n$.

The greatest common divisor of a natural number `n` and zero is equal to `n`. In Lean, this is expressed as `Nat.gcd_zero_right n`.


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

The theorem `CategoryTheory.Limits.biprod.inl_desc` states that for any category `C` with zero morphisms, and any objects `W`, `X`, `Y` in `C` that form a binary biproduct, the composition of the inclusion into the first summand of the binary biproduct (`CategoryTheory.Limits.biprod.inl`) with the morphism (`CategoryTheory.Limits.biprod.desc`) that describes the biproduct in terms of maps `f : X ⟶ W` and `g : Y ⟶ W`, will always equal `f`. In other words, if you first include `X` into the biproduct and then apply the biproduct description, you get back the original morphism `f`. This theorem captures a fundamental property of binary biproducts in category theory.

For any category with zero morphisms and objects forming a binary biproduct, the inclusion into the first summand and the biproduct description morphism commute, i.e., `inl (desc X Y W f g) = f`.


theorem Complex.I_ne_zero : Complex.I ≠ 0 := by sorry

This theorem states that the imaginary unit (often denoted as 'i' in mathematical literature) in the field of complex numbers is not equal to zero. In other words, the complex number whose real part is zero and imaginary part is one, denoted as `Complex.I` in Lean 4, is not the same as the number zero.

The imaginary unit `Complex.I` in the field of complex numbers is distinct from the zero element.


theorem Mathlib.Order.Filter.Basic._auxLemma.2 : ∀ {α : Type u} {f : Filter α} {s : Set α}, (s ∈ f.sets) = (s ∈ f) := by
  sorry

The theorem "`Mathlib.Order.Filter.Basic._auxLemma.2`" states that for any type `α`, any filter `f` of type `α`, and any set `s` of type `α`, the predicate that `s` is in the set of `f`'s sets (written as `s ∈ f.sets`) is equivalent to the predicate that `s` is in `f` (written as `s ∈ f`). In other words, the two ways of expressing set membership in a filter are equivalent.

For any filter `f` on type `α`, the set `f.sets` contains a set `s` if and only if `s` is in the filter `f`. That is, `s ∈ f.sets` if and only if `s ∈ f`.


theorem Set.prod_univ : ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, s ×ˢ Set.univ = Prod.fst ⁻¹' s := by sorry

The theorem `Set.prod_univ` states that for any type `α` and `β`, and any set `s` of type `α`, the cartesian product of `s` and the universal set of `β` is precisely the preimage of `s` under the first projection function. In other words, if you take all pairs whose first element is in the set `s` and second element is in the universal set of `β`, this is equivalent to all elements in `s`. This theorem provides a useful identity in dealing with cartesian products involving the universal set.

For any type `α` and `β`, and set `s` of type `α`, the cartesian product `s × β` is equal to the preimage of `s` under the first projection function.


theorem List.length_range : ∀ (n : ℕ), List.length (List.range n) = n := by sorry

The theorem `List.length_range` states that for any natural number `n`, the length of the list generated by `List.range n` is equal to `n`. This means that the function `List.range` generates a list of natural numbers from `0` to `n` exclusive, and the size of this list is exactly `n`.

For any natural number n, the length of List.range n is equal to n.


theorem Complex.ofReal_im : ∀ (r : ℝ), (↑r).im = 0 := by sorry

This theorem states that the imaginary part of any real number `r` expressed as a complex number is always zero. In other words, when a real number is considered as a complex number (by being cast to a complex number via `(↑r)`), its imaginary component is always `0`. This theorem stands true for every real number `r`.

The real part of a real number, when considered as a complex number, is always equal to its real part and its imaginary part is always zero. (Or equivalently, the imaginary part of a real number as a complex number is always 0.)


theorem MeasureTheory.isStoppingTime_const :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] (f : MeasureTheory.Filtration ι m)
      (i : ι), MeasureTheory.IsStoppingTime f fun x => i :=
  by sorry

The theorem `MeasureTheory.isStoppingTime_const` asserts that for any measurable space `Ω`, any type `ι` equipped with a preorder, any filtration `f` on the measurable space indexed by `ι`, and any element `i` of `ι`, the function which assigns `i` to every element of `Ω` is a stopping time with respect to `f`. In other words, a function that maps every event in a measurable space to a fixed point in time is deemed a stopping time according to the given filtration, since the occurrence of the event can be determined at the fixed point in time.

For any measurable space Ω, preorder ι, filtration f on Ω indexed by ι, and i in ι, the constant function mapping every element of Ω to i is a stopping time with respect to f.


theorem MeasureTheory.set_integral_congr :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f g : X → E} {s : Set X} {μ : MeasureTheory.Measure X},
      MeasurableSet s → Set.EqOn f g s → ∫ (x : X) in s, f x ∂μ = ∫ (x : X) in s, g x ∂μ :=
  by sorry

The theorem `MeasureTheory.set_integral_congr` states that for any measurable space `X` and any normed additively commutative group `E` that is also a normed space over the real numbers, given two functions `f` and `g` from `X` to `E`, a set `s` of `X`, and a measure `μ` on `X`, if the set `s` is measurable and the functions `f` and `g` are equal on the set `s`, then the integral of the function `f` with respect to the measure `μ` over the set `s` is equal to the integral of the function `g` with respect to the measure `μ` over the set `s`. In other words, it asserts the equality of integrals of two functions over a measurable set, when the functions coincide on that set.

If `X` is a measurable space, `E` is a normed additively commutative group and normed space over the real numbers, `f` and `g` are measurable functions from `X` to `E`, `s` is a measurable subset of `X`, and `f` equals `g` on `s`, then the integrals of `f` and `g` with respect to a measure `μ` on `X` over `s` are equal.


theorem EReal.bot_lt_coe : ∀ (x : ℝ), ⊥ < ↑x := by sorry

This theorem states that for any real number `x`, the extended real number corresponding to negative infinity (represented here as ⊥) is less than the extended real number representation of `x`. In mathematical terms, it's stating that -∞ < `x` for any real number `x`.

For any real number `x`, negative infinity (⊥) is strictly smaller than `x`.


theorem EReal.coe_lt_top : ∀ (x : ℝ), ↑x < ⊤ := by sorry

This theorem states that for any real number `x`, the extended real number representation of `x` is always less than positive infinity. In mathematical terms, for every real number `x`, it holds that `x` is strictly less than positive infinity when `x` is interpreted in the extended real number system.

For every real number `x`, `x` is strictly less than positive infinity in the extended real number system.


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

This theorem states that for any two propositions `a` and `b`, if `a` implies `b` (denoted as `a → b`), then the statement "either `a` or `b` is true" is logically equivalent to the statement "`b` is true". In mathematical terms, this theorem asserts that whenever `a` implies `b`, the logical disjunction `a ∨ b` is equivalent to `b`.

If `a` implies `b`, then `a ∨ b` is logically equivalent to `b` in Lean 4 logic.


theorem Mathlib.Order.Filter.Basic._auxLemma.166 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
      Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, ∀ᶠ (x : α) in l₁, f x ∈ s :=
  by sorry

The theorem `Mathlib.Order.Filter.Basic._auxLemma.166` states that for any types `α` and `β`, and for any function `f` from `α` to `β`, and for any filters `l₁` on `α` and `l₂` on `β`, the statement "Filter `l₁` tends to filter `l₂` under function `f`" is equivalent to the statement "For every set `s` in the filter `l₂`, all elements `x` from the filter `l₁` eventually map under `f` into the set `s`. Here, `∀ᶠ (x : α) in l₁, f x ∈ s` is denoting the "eventually" quantifier, signifying that from some point onward in filter `l₁`, all elements `x` satisfy the condition `f x ∈ s`.

For filters \(l\_1\) on type \(\alpha\) and \(l\_2\) on type \(\beta\), and a function \(f : \alpha \rightarrow \beta\), the filters \(l\_1\) tends to \(l\_2\) under \(f\) if and only if for every set \(s \in l\_2\), all elements \(x \in l\_1\) eventually map under \(f\) into \(s\).


theorem CategoryTheory.Adjunction.left_triangle_components :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) (X : C),
      CategoryTheory.CategoryStruct.comp (F.map (adj.unit.app X)) (adj.counit.app (F.obj X)) =
        CategoryTheory.CategoryStruct.id (F.obj X) :=
  by sorry

This theorem, called `CategoryTheory.Adjunction.left_triangle_components`, states that for any categories `C` and `D`, with functors `F : C -> D` and `G : D -> C` forming an adjunction (denoted `F ⊣ G`), and any object `X` in `C`, the composition of `F.map (adj.unit.app X)` and `adj.counit.app (F.obj X)` is equal to the identity on `F.obj X`.

In simpler terms, this theorem is a part of the definition of an adjunction in category theory, more specifically, it is the statement of one of the conditions in the so-called "triangle identities". It says that if you start with an object in `C`, apply `F`, then apply the unit at `X`, then apply `F` again, then apply the counit at `F.obj X`, you end up back at `F.obj X`, i.e., doing all these operations is the same as doing nothing.

For any adjunction `F ⊣ G` between categories `C` and `D`, and for any object `X` in `C`, the diagram `F(X) ♂ adj.unit.app X ♂ F(X)` commutes, where `♂` denotes composition.


theorem NumberField.InfinitePlace.mk_embedding :
    ∀ {K : Type u_2} [inst : Field K] (w : NumberField.InfinitePlace K),
      NumberField.InfinitePlace.mk (NumberField.InfinitePlace.embedding w) = w :=
  by sorry

This theorem states that for any given number field `K` and an infinite place `w` of `K`, the infinite place constructed using the complex embedding associated with `w` (by the function `NumberField.InfinitePlace.mk`) is exactly `w` itself. In other words, the process of obtaining a complex embedding from an infinite place and then constructing an infinite place from that embedding is an identity operation on the set of infinite places of the number field.

For any number field `K` and its infinite place `w`, the complex embedding and subsequent construction of an infinite place from `w` yield the same result. In other words, `NumberField.InfinitePlace.mk (NumberField.complexEmbedding w) = w`.


theorem lcm_dvd :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : GCDMonoid α] {a b c : α},
      a ∣ b → c ∣ b → lcm a c ∣ b :=
  by sorry

This theorem states that for any type `α` that is a cancel commutative monoid with zero and a gcd monoid, and any elements `a`, `b`, `c` of that type, if `a` divides `b` and `c` divides `b`, then the least common multiple (lcm) of `a` and `c` also divides `b`. This theorem essentially captures one of the key properties of the least common multiple in the context of a gcd monoid.

If `α` is a cancel commutative monoid with zero and a gcd, then for all `a, b, c` in `α` with `a` dividing `b` and `c` dividing `b`, the least common multiple of `a` and `c` also divides `b`.


MeasureTheory.Integrable.mono'

theorem MeasureTheory.Integrable.mono' :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β} {g : α → ℝ},
      MeasureTheory.Integrable g μ →
        MeasureTheory.AEStronglyMeasurable f μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ ≤ g a) → MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.Integrable.mono'` states that for any measurable space `α`, any measure `μ` on `α`, any normed add commutative group `β`, and any two functions `f : α → β` and `g : α → ℝ`, if `g` is integrable with respect to measure `μ`, `f` is almost everywhere strongly measurable with respect to `μ`, and almost everywhere, the norm of `f` is less than or equal to `g`, then `f` is also integrable with respect to `μ`. In other words, if we have a function `g` that is integrable, and another function `f` that is almost everywhere equal to the limit of a sequence of simple functions and is pointwise bounded by `g`, then `f` is also integrable.

If a function `f : α → β` is almost everywhere strongly measurable, pointwise bounded by an integrable function `g : α → ℝ` (almost everywhere), then `f` is integrable.


theorem MeasureTheory.integral_nonneg_of_ae :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae μ] f → 0 ≤ ∫ (a : α), f a ∂μ :=
  by sorry

This theorem, `MeasureTheory.integral_nonneg_of_ae`, states that for any measurable space `α` and a measure `μ` on this space, if a function `f` from `α` to the real numbers is nonnegative almost everywhere (with respect to the measure `μ`), then the integral of `f` with respect to `μ` is also nonnegative. In more mathematical terms, it says that if `0 ≤ f` almost everywhere in the measure space `(α, μ)`, then `0 ≤ ∫ f dμ`.

If `f: α → ℝ` is a measurable and nonnegative almost everywhere function on the measurable space `(α, μ)`, then `∫ f dμ ≥ 0`.


theorem Set.pi_def :
    ∀ {α : Type u_1} {π : α → Type u_11} (i : Set α) (s : (a : α) → Set (π a)),
      Set.pi i s = ⋂ a ∈ i, Function.eval a ⁻¹' s a :=
  by sorry

This theorem, `Set.pi_def`, establishes the identity of the pi set of a function over a certain domain to an intersection of pre-images. More precisely, for any type `α` and a type-valued function `π` on `α`, and for any set `i` of `α` and a set-valued function `s` on `α`, the pi set of `i` and `s`, denoted `Set.pi i s`, is equal to the intersection of sets `Function.eval a ⁻¹' s a` for all `a` in `i`. In other words, `Set.pi i s` is the set of all functions `f` such that for each index `a` in `i`, `f(a)` is in the set `s a`. This theorem states that this set is equivalent to the intersection of all pre-images of `s a` under the function `Function.eval a`, as `a` ranges over `i`.

The pi set of a function's domain and a set-valued function is equal to the intersection of the pre-images of the set under the function evaluation at each index in the domain.


/-- Additive closure of an additive submonoid `S` equals `S` -/
theorem AddSubmonoid.closure_eq :
    ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M), AddSubmonoid.closure ↑S = S := by sorry

This theorem states that, for any additive submonoid `S` of a type `M` equipped with an addition operation and a zero element (represented by the `AddZeroClass M` instance), the additive closure of `S` equals `S` itself. In other words, if we take an additive submonoid and generate the smallest additive submonoid that contains it (the "additive closure of `S`"), we end up with the original submonoid `S`. This implies that `S` already contains all elements that can be obtained through repeated addition operations on its elements.

The additive closure of an additive submonoid equals the submonoid itself.


theorem Stream'.get_succ :
    ∀ {α : Type u} (n : ℕ) (s : Stream' α), Stream'.get s (Nat.succ n) = Stream'.get (Stream'.tail s) n := by sorry

The theorem `Stream'.get_succ` states that for any type `α`, natural number `n`, and stream `s` of type `α`, getting the `n+1`-th element of the stream `s` is the same as first getting the tail of the `s` and then getting its `n`-th element. In other words, the tail operation on a stream effectively reduces the index of each element by one. This is in alignment with the general understanding of the tail operation in the context of sequences or lists, where it usually refers to the remaining sequence after its first element has been removed.

For any type `α`, natural number `n`, and stream `s` of type `α`, the `(n + 1)`-th element of `s` equals the `n`-th element of the tail of `s`.


theorem tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {a : α} {l : Filter β} {s : Set α} (f : β → α),
      Filter.Tendsto f l (nhds a) → (∀ᶠ (x : β) in l, f x ∈ s) → Filter.Tendsto f l (nhdsWithin a s) :=
  by sorry

This theorem, `tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within`, states that for all types `α` and `β` with `α` being a type equipped with a topological space structure, given an element `a` of type `α`, a filter `l` on type `β`, a set `s` of elements of type `α`, and a function `f` mapping elements from `β` to `α`, if the function `f` tends to `nhds a` under the filter `l` (i.e., the limit of `f` as elements approach `a` exists and is defined by the neighbourhood filter at `a`) and all elements from `l` eventually fall into the set `s` (i.e., for all large enough elements), then `f` also tends to the neighbourhood within `s` of `a` under the filter `l`. In other words, the limit of `f` as elements approach `a` within the set `s` also exists and is defined by the intersection of `s` and a neighbourhood of `a`.

If a function `f` tends to the neighborhood filter of `a` in a topological space `α` under a filter `l`, and all elements in `l` eventually belong to a set `s`, then `f` tends to the neighborhood filter of `a` within `s` under `l`.


MeasureTheory.NullMeasurableSet.compl

theorem MeasureTheory.NullMeasurableSet.compl :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
      MeasureTheory.NullMeasurableSet s μ → MeasureTheory.NullMeasurableSet sᶜ μ :=
  by sorry

The theorem `MeasureTheory.NullMeasurableSet.compl` states that for any type `α`, measurable space `m0`, measure `μ`, and set `s`, if `s` is a null measurable set with respect to measure `μ`, then the complement of `s` (denoted by `sᶜ`) is also a null measurable set with respect to the same measure `μ`. In other words, the property of being a null measurable set is preserved under taking complements.

If a set `s` is null measurable with respect to measure `μ` in measurable space `m0`, then its complement `sᶜ` is also null measurable with respect to `μ` in `m0`.


theorem inv_lt_inv_iff :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x < x_1] {a b : α},
      a⁻¹ < b⁻¹ ↔ b < a :=
  by sorry

This theorem states that for any type `α` which forms a group and has a less-than (`<`) operation that is compatible with its multiplication, and where multiplication is covariant in both arguments, the inverse of an element `a` is less than the inverse of another element `b` if and only if `b` is less than `a`. In mathematical terms, for all `a` and `b` in the group `α`, `a⁻¹ < b⁻¹` is equivalent to `b < a`.

For any group `α` with a compatible `<` relation, where multiplication is covariant, the inverse of a smaller element is smaller than the inverse of a larger element: `a < b` if and only if `a⁻¹ > b⁻¹`. (Note: The original statement has been slightly adjusted for clarity and to use the more common notation of `<` for "less than" and `>` for "greater than" with respect to the inverse elements.)


theorem one_div_mul_cancel : ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, a ≠ 0 → 1 / a * a = 1 := by sorry

This theorem states that for any non-zero element `a` from a type `G₀` that forms a group with zero, the product of `1 / a` and `a` equals 1. In other words, in any mathematical structure that accommodates the concept of a group with zero, such as a field, the reciprocal of `a` times `a` always yields 1 provided that `a` is not zero. This corresponds to the well-known property in field theory that the product of a non-zero number and its reciprocal is always 1.

For any non-zero element `a` in a group with identity element `1` (i.e., `G₀` with `0`), `1 / a * a = 1`.


theorem Set.setOf_exists : ∀ {β : Type u_2} {ι : Sort u_4} (p : ι → β → Prop), {x | ∃ i, p i x} = ⋃ i, {x | p i x} := by
  sorry

This theorem, `Set.setOf_exists`, states that for any type `β` and any abstract sort `ι`, given a predicate `p : ι → β → Prop`, the set of elements `x` that satisfy the property "there exists an `i` such that `p i x` holds" is equal to the union over all `i` of the sets of `x` for which `p i x` holds. Essentially, this theorem expresses that you can interchange the order of quantification and set formation.

For any type `β` and abstract sort `ι` with predicate `p : ι → β → Prop`, the set of `x` such that there exists an `i` with `p i x` is equivalent to the union of the sets of `x` satisfying `p i x` for all `i`.


/-- For every open cover of a compact set, there exists a finite subcover.  -/
theorem IsCompact.elim_finite_subcover :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {ι : Type v},
      IsCompact s → ∀ (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ t, s ⊆ ⋃ i ∈ t, U i :=
  by sorry

This theorem states that for every open cover of a compact set in a topological space, there exists a finite subcover. More specifically, given any type `X` with a topological structure, a compact set `s` of type `X`, and an indexed family `U` of open sets in `X` such that `s` is a subset of the union of these sets (i.e., `s` is covered by `U`), there exists a finite subset `t` of the index type such that `s` is also a subset of the union of the sets in `U` indexed by `t`. This is a formalization of the standard concept of compactness in topology.

Every compact set in a topological space can be covered by a finite number of open sets from the cover.


theorem Set.mem_image_equiv :
    ∀ {α : Type u_1} {β : Type u_2} {S : Set α} {f : α ≃ β} {x : β}, x ∈ ⇑f '' S ↔ f.symm x ∈ S := by sorry

This theorem states that for any types `α` and `β`, any set `S` of elements of type `α`, any bijection `f` from `α` to `β`, and any element `x` of type `β`, the element `x` is in the image of the set `S` under the function `f` if and only if the inverse of `x` under `f` is in the set `S`. In mathematical terms, we can say $x \in f(S) \iff f^{-1}(x) \in S$. This is a basic property about the interaction between function application, inverse functions, and set membership.

For any sets S of type α, bijection f from α to β, and element x of type β, x is in the image of S under f if and only if the inverse image of x under f is in S. In symbolic form: x ∈ f(S) ↔ f⁻¹(x) ∈ S.


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

The theorem `Set.image_preimage_eq_iff` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any set `s` of type `β`, the image of the preimage of `s` under `f` is equal to `s` if and only if `s` is a subset of the range of `f`. In other words, for every element in `s`, there exists an element in the domain of `f`, such that the function `f` maps that element to `s`. The terms `f '' (f ⁻¹' s)` and `s ⊆ Set.range f` can be translated into mathematical language as $f(f^{-1}(s)) = s$ and $s \subseteq Range(f)$ respectively.

For any function $f: \alpha \rightarrow \beta$ and set $s \subseteq \beta$, $f(f^{-1}(s)) = s$ if and only if $s \subseteq \text{Range}(f)$.


theorem zsmul_mem :
    ∀ {M : Type u_5} {S : Type u_6} [inst : SubNegMonoid M] [inst_1 : SetLike S M] [hSM : AddSubgroupClass S M] {K : S}
      {x : M}, x ∈ K → ∀ (n : ℤ), n • x ∈ K :=
  by sorry

This theorem, `zsmul_mem`, states that for any type `M` which is a sub-negative monoid, any type `S` which is a set-like structure over `M`, and any `S` that is also an additive subgroup of `M`, if we have an element `x` from an instance `K` of `S`, then the integer-multiple (denoted by `n • x`) of `x` is also an element of `K`. In mathematical terms, if `x` is in a subgroup `K`, then for any integer `n`, `n` times `x` is also in the subgroup `K`.

If `x` is an element of a subgroup `K` of a sub-negative monoid `M`, then for any integer `n`, `n` times `x` is also an element of `K`.


Multiset.leInductionOn

theorem Multiset.leInductionOn :
    ∀ {α : Type u_1} {C : Multiset α → Multiset α → Prop} {s t : Multiset α},
      s ≤ t → (∀ {l₁ l₂ : List α}, List.Sublist l₁ l₂ → C ↑l₁ ↑l₂) → C s t :=
  by sorry

This theorem, called `Multiset.leInductionOn`, states that for any type `α` and any property `C` that can relate two multisets of type `α`, if one multiset `s` is less than or equal to another multiset `t` (in terms of a multiset inequality), then under the condition that the property `C` holds for any two lists `l₁` and `l₂` (of type `α`) such that `l₁` is a sublist of `l₂`, the property `C` also holds for the multisets `s` and `t`. Essentially, this theorem allows us to generalize a property from lists to multisets.

Given a type `α` and a property `C` relating multisets of `α`, if `C` holds for all sublists `l₁` and `l₂` and `s ⊇ s'` implies `∀ l₁ ⊆ l₂, C(l₁, l₂) → C(s, s')`, then `C` holds for all multisets `s` and `t` with `s �leq t`.


StarAlgHom.ext

theorem StarAlgHom.ext :
    ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] {f g : A →⋆ₐ[R] B},
      (∀ (x : A), f x = g x) → f = g :=
  by sorry

This theorem states that for all types `R`, `A`, `B` where `R` is a commutative semiring, `A` is a semiring, `B` is a semiring, `A` is an `R`-algebra, `B` is an `R`-algebra, `A` has a star operation, and `B` has a star operation, if `f` and `g` are star-algebra homomorphisms from `A` to `B`, then if for all elements `x` in `A`, `f(x)` equals `g(x)`, it follows that `f` and `g` are equal.

If `f` and `g` are star-algebra homomorphisms from a commutative semiring `A`, which is an `R`-algebra with a star operation, to another commutative semiring `B`, also an `R`-algebra with a star operation, such that `f(x) = g(x)` for all `x` in `A`, then `f` equals `g`.


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

The theorem `Polynomial.le_natDegree_of_ne_zero` states that for any semiring `R`, natural number `n`, and polynomial `p` with coefficients in `R`, if the coefficient of `X^n` in `p` is not zero, then `n` is less than or equal to the natural degree of `p`. The natural degree of a polynomial is a forced version of the degree of the polynomial into natural numbers, where the degree of the zero polynomial is defined to be zero.

If a polynomial `p` of degree `n` over a semiring `R` has a non-zero coefficient for `X^k` with `k = n`, then `k` is the natural degree of `p`.


theorem induced_inf :
    ∀ {α : Type u_1} {β : Type u_2} {t₁ t₂ : TopologicalSpace α} {g : β → α},
      TopologicalSpace.induced g (t₁ ⊓ t₂) = TopologicalSpace.induced g t₁ ⊓ TopologicalSpace.induced g t₂ :=
  by sorry

The theorem `induced_inf` states that for any two topological spaces `t₁` and `t₂` over a type `α`, and for any function `g` from a type `β` to `α`, the topology induced on `β` by the intersection of `t₁` and `t₂` (denoted `t₁ ⊓ t₂`) under the function `g` is the same as the intersection of the topologies induced by `t₁` and `t₂` separately under the same function `g`. In other words, the order of intersection and topology induction does not matter.

For topological spaces $t\_1$, $t\_2$ over type $\alpha$ and a function $g:\beta\to\alpha$, the topology induced by $t\_1 \cap t\_2$ on $\beta$ via $g$ equals the intersection of the topologies induced by $t\_1$ and $t\_2$ on $\beta$ via $g$.


theorem Set.compl_eq_univ_diff : ∀ {α : Type u} (s : Set α), sᶜ = Set.univ \ s := by sorry

The theorem `Set.compl_eq_univ_diff` states that for any set `s` of a certain type `α`, the complement of `s` (denoted `sᶜ`) is equal to the difference between the universal set of type `α` and `s`. In other words, the complement of a set `s` includes all elements belonging to the universal set that are not in `s`.

The complement of a set `s` in type `α` is equal to the universal set of `α` minus `s`.


theorem Filter.tendsto_atTop_mono' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄,
      f₁ ≤ᶠ[l] f₂ → Filter.Tendsto f₁ l Filter.atTop → Filter.Tendsto f₂ l Filter.atTop :=
  by sorry

The theorem `Filter.tendsto_atTop_mono'` states that, given an arbitrary filter `l` and two functions `f₁` and `f₂` from the type `α` to an ordered type `β`, if `f₁` is almost everywhere less than or equal to `f₂` with respect to the filter `l`, and if the function `f₁` tends to infinity (`Filter.atTop`) as the filter `l` tends to infinity, then the function `f₂` also tends to infinity as the filter `l` tends to infinity. This theorem essentially says that if `f₁` is smaller or equal to `f₂` and `f₁` tends to infinity, then `f₂` must also tend to infinity.

If a filter converges to infinity for a function `f_1` that is pointwise less than or equal to another function `f_2`, then `f_2` also converges to infinity with respect to that filter.


theorem Complex.tan_periodic : Function.Periodic Complex.tan ↑Real.pi := by sorry

The theorem `Complex.tan_periodic` states that the complex tangent function, defined as the ratio of the sine to the cosine of a complex number, is periodic with a period of π (pi, the ratio of a circle's circumference to its diameter). This means that for any complex number `z`, `tan(z + π) = tan(z)`.

The complex tangent function is periodic with a period of pi, i.e., tan(z + pi) = tan(z) for all complex numbers z.


theorem Subtype.map.proof_1 :
    ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (f : α → β),
      (∀ (a : α), p a → q (f a)) → ∀ (x : Subtype p), q (f ↑x) :=
  by sorry

This theorem states that for any two types `α` and `β`, predicates `p` on `α` and `q` on `β`, and a function `f` from `α` to `β`, if for all elements `a` of type `α` the property `p a` implies the property `q` on `f a`, then for all subtypes `x` of type `α` satisfying the property `p`, the property `q` holds on `f` applied to `x`. In other words, the theorem ensures that if `f` maps elements of `α` satisfying `p` to elements of `β` satisfying `q`, then `f` also maps elements of the subtype of `α` defined by `p` to elements of `β` satisfying `q`.

If `f: α → β`, `p` is a predicate on `α`, `q` is a predicate on `β`, and for all `a: α` with `p a`, `q (f a)` holds, then `q` holds for `f` applied to every subtype `x` of `α` satisfying `p`.


theorem Nat.mul_lt_mul_of_pos_left : ∀ {n m k : ℕ}, n < m → k > 0 → k * n < k * m := by sorry

This theorem states that for any three natural numbers `n`, `m`, and `k`, if `n` is less than `m` and `k` is greater than 0, then the product of `k` and `n` (i.e., `k * n`) is less than the product of `k` and `m` (i.e., `k * m`). The theorem asserts the preservation of ordering under multiplication by a positive factor in the context of natural numbers.

For any natural numbers `n` < `m` and `k` > 0, `k * n` < `k * m`.


theorem Mathlib.Order.Lattice._auxLemma.2 : ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (b ≤ a ⊔ b) = True := by
  sorry

This theorem, `Mathlib.Order.Lattice._auxLemma.2`, states that for any type `α` that forms a semilattice under the supremum operation, and any two elements `a` and `b` from this type `α`, `b` is always less than or equal to the supremum of `a` and `b`. In terms of mathematical notation, it asserts that $\forall a, b \in \alpha : b \leq a \vee b$ is always true in a semilattice.

In any semilattice, for all elements `a` and `b`, `b` is less than or equal to the supremum of `a` and `b`. In mathematical notation, $\forall a, b : a \sqcup b \geq b$, where $\sqcup$ denotes the supremum operation.


theorem LinearIsometry.norm_map :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
      [inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) (x : E), ‖f x‖ = ‖x‖ :=
  by sorry

This theorem states that for any semiring R, other semiring R₂, types E and E₂, a semiring homomorphism σ₁₂ from R to R₂, and given that E and E₂ are seminormed additive commutative groups and also modules over R and R₂ respectively, a linear isometry `f` (which is a linear map preserving distances) from E to E₂ preserves the norm. In other words, the norm of the image of any element `x` of E under `f` is equal to the norm of `x` itself.

Given semiring homomorphisms σ₁₂ : R → R₂, seminormed additive commutative groups and R-modules E and E₂, and a linear isometry f : E → E₂ between them, the norm of f(x) equals the norm of x for all x in E.


theorem HomologicalComplex.comp_f :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ C₃ : HomologicalComplex V c}
      (f : C₁ ⟶ C₂) (g : C₂ ⟶ C₃) (i : ι),
      (CategoryTheory.CategoryStruct.comp f g).f i = CategoryTheory.CategoryStruct.comp (f.f i) (g.f i) :=
  by sorry

The theorem `HomologicalComplex.comp_f` says that for any category `V` that has zero morphisms, and for any complex shape `c`, if we have three homological complexes `C₁`, `C₂`, and `C₃` over the category `V` with the complex shape `c`, and if `f` is a morphism from `C₁` to `C₂` and `g` is a morphism from `C₂` to `C₃`, then the composition of `f` and `g` at an index `i` is the same as the composition of `f` at index `i` and `g` at index `i`. In other words, the composition operation for morphisms in a homological complex is compatible with the indexing operation.

For any homological complexes $C\_1$, $C\_2$, $C\_3$ over a category with zero morphisms and complex shape $c$, and morphisms $f : C\_1 \to C\_2$ and $g : C\_2 \to C\_3$ in degree $i$, we have $g \circ f = f \circ_i g$, where $f \circ_i g$ denotes the composition of $f$ and $g$ at index $i$.


MonotoneOn.dual

/-- **Alias** of the reverse direction of `monotoneOn_dual_iff`. -/
theorem MonotoneOn.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      MonotoneOn f s → MonotoneOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s :=
  by sorry

The theorem `MonotoneOn.dual` states that for any set `s` of some type `α` and any function `f` from `α` to some type `β`, if `f` is monotone on `s` (meaning that for all `a, b` in `s`, if `a ≤ b`, then `f(a) ≤ f(b)`), then the function composed of applying `f` to the dual order of `α` (i.e., applying the function `OrderDual.toDual` after `f` and then applying `OrderDual.ofDual`) is also monotone on `s`. The dual order is simply the original order reversed.

If `f` is a monotone function from a set `s` to type `β`, then the composition of `f` with the dual order on `α` is also a monotone function on `s`.


theorem nhdsWithin_union :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (s t : Set α),
      nhdsWithin a (s ∪ t) = nhdsWithin a s ⊔ nhdsWithin a t :=
  by sorry

This theorem states that for any given topological space `α`, any point `a` in that space, and any two sets `s` and `t` in that space, the neighborhood within the union of `s` and `t` at the point `a` is equal to the supremum (join) of the neighborhood within `s` at `a` and the neighborhood within `t` at `a`. In other words, it's describing how the "nearness" to a point in a union of two sets can be described in terms of the "nearness" to that point in each of the individual sets. This is a property of neighborhoods in a topological space.

For any topological space `α`, point `a` in `α`, and sets `s` and `t` in `α`, the neighborhood of `a` in `s ∪ t` is equal to the join (supremum) of the neighborhood of `a` in `s` and the neighborhood of `a` in `t`.


theorem List.Pairwise.of_cons :
    ∀ {α : Type u_1} {a : α} {l : List α} {R : α → α → Prop}, List.Pairwise R (a :: l) → List.Pairwise R l := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, any list `l` of type `α`, and any relation `R` defined over `α`, if the list composed of `a` followed by `l` satisfies the pairwise property with respect to `R`, then the list `l` also satisfies the pairwise property with respect to `R`. The pairwise property implies that for every pair of distinct elements in the list, the relation `R` holds.

If a list `l` of type `α` satisfies the pairwise property of relation `R` with respect to its head `a` and the tail of the list, then `l` itself satisfies the pairwise property of relation `R`.


theorem List.sum_replicate :
    ∀ {M : Type u_5} [inst : AddMonoid M] (n : ℕ) (a : M), List.sum (List.replicate n a) = n • a := by sorry

The theorem `List.sum_replicate` asserts that for any type `M` that forms an Additive Monoid, any natural number `n`, and any element `a` of type `M`, the sum of a list that is created by replicating `a` `n` times (i.e., `List.replicate n a`) is equal to `n` times `a` (denoted by `n • a` in Lean notation). In other words, it states that summing `n` copies of an element `a` in an additive monoid is the same as scaling `a` by `n`.

For any additive monoid type `M`, natural number `n`, and element `a` in `M`, the sum of replicating `a` in a list of length `n` equals `n` times `a`.


/-- The closure of the open interval `(a, b)` is the closed interval `[a, b]`.  -/
theorem closure_Ioo :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a b : α}, a ≠ b → closure (Set.Ioo a b) = Set.Icc a b :=
  by sorry

The theorem `closure_Ioo` states that for any type `α` that has a topology, a linear order, an order topology, and is densely ordered, and for any two distinct elements `a` and `b` of this type, the closure of the open interval `(a, b)` is equal to the closed interval `[a, b]`. In mathematical terms, this means that the smallest closed set that contains all the elements `x` such that `a < x < b` is the set of all elements `x` such that `a ≤ x ≤ b`. This theorem is a formalization of a well-known result in real analysis.

For any densely ordered type `α` with a topology and order topology, the closure of the open interval `(a, b)` equals the closed interval `[a, b]` for all distinct `a` and `b` in `α`.


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

This theorem states that for any type `α`, where `α` has an equality comparison and that comparison is lawful, if an element `a` of type `α` is not a member of a list `l` of elements of type `α`, then the operation of inserting `a` into `l` using the `List.insert` function results in the list that starts with `a` followed by the elements of `l`.

For any type `α` with lawful equality and list `l` of elements from `α`, if `a ≠ ∃ x, x ∈ l`, then `List.insert a l = a :: l`.


theorem nsmul_le_nsmul_right :
    ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass M M (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : M},
      a ≤ b → ∀ (i : ℕ), i • a ≤ i • b :=
  by sorry

The theorem `nsmul_le_nsmul_right` states that for any type `M` which is an additive monoid and a preorder, and if it satisfies the covariant properties for addition and ordering, then for any two elements `a` and `b` of `M` such that `a` is less than or equal to `b`, the scalar multiplication of `a` by any natural number `i` is also less than or equal to the scalar multiplication of `b` by the same natural number `i`. More intuitively, this means that if an element `a` is less than or equal to an element `b` in this type `M`, then any 'multiple' of `a` is also less than or equal to the corresponding 'multiple' of `b`.

For any additive monoid and preorder type `M` with covariant properties for addition and ordering, if `a ≤ b` in `M`, then for all natural numbers `i`, `i*a ≤ i*b`.


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

This theorem states that for any natural number `a`, the minimum value between `0` and `a` is `0`. In other words, when you compare zero with any natural number using the `min` function, the result will always be zero.

 For any natural number `a`, `0` is the minimum value. (or)
The minimum value of `0` and any natural number `a` is `0`.


theorem Bool.not_not : ∀ (b : Bool), (!!b) = b := by sorry

This theorem, `Bool.not_not`, states that for all boolean values `b`, applying the boolean negation operator twice (`!!b`) will yield the original boolean value `b`. This is equivalent to saying that double negation in boolean logic returns the original value, which is a standard principle in classical logic.


theorem mem_primitiveRoots :
    ∀ {R : Type u_4} {k : ℕ} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R},
      0 < k → (ζ ∈ primitiveRoots k R ↔ IsPrimitiveRoot ζ k) :=
  by sorry

The theorem `mem_primitiveRoots` asserts that for any type `R` that is a commutative ring and an integral domain, and any natural number `k` that is greater than 0, an element `ζ` belongs to the set of `k`-th primitive roots of unity in `R` if and only if `ζ` is a primitive `k`-th root of unity. In mathematical terms, this theorem establishes that an element is a primitive `k`-th root of unity in an integral domain if it satisfies the properties defined in `IsPrimitiveRoot ζ k`.

In an integral domain R, an element ζ is a k-th primitive root of unity if and only if it is a primitive k-th root of unity in R.


theorem Nat.add_sub_assoc : ∀ {m k : ℕ}, k ≤ m → ∀ (n : ℕ), n + m - k = n + (m - k) := by sorry

This theorem, `Nat.add_sub_assoc`, states that for all natural numbers `m`, `k`, and `n`, if `k` is less than or equal to `m`, then adding `n` to `m` and then subtracting `k` is the same as first subtracting `k` from `m` and then adding `n`. In other words, it expresses the associative property of addition and subtraction for natural numbers when the condition `k ≤ m` is met. In terms of mathematical notation, it says that for every `m`,`k` and `n` in the set of natural numbers, if `k ≤ m` then `n + m - k = n + (m - k)`.

For all natural numbers `m`, `k`, and `n`, if `k` is less than or equal to `m`, then `(m + n) - k` is equal to `m - k + n`.