/-- A measure on a finite product space equals the product measure if they are equal on
rectangles.  -/
theorem MeasureTheory.Measure.pi_eq :
    ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
      {μ : (i : ι) → MeasureTheory.Measure (α i)} [inst_2 : ∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
      {μ' : MeasureTheory.Measure ((i : ι) → α i)},
      (∀ (s : (i : ι) → Set (α i)),
          (∀ (i : ι), MeasurableSet (s i)) →
            ↑↑μ' (Set.pi Set.univ s) = Finset.prod Finset.univ fun i => ↑↑(μ i) (s i)) →
        MeasureTheory.Measure.pi μ = μ' :=
  by sorry

This theorem states that for a measure on a finite product space, it equals the product measure if they coincide on rectangles. Specifically, given an index set `ι`, a family of measurable spaces `α i` for each `i` in `ι`, a family of measures `μ i` for each `i` in `ι`, and a measure `μ'` on the product space, if for every family of sets `s i` such that each `s i` is measurable, the measure `μ'` of the set of all functions from `ι` to `α i` that map each `i` to an element of `s i` equals the product (over all `i` in `ι`) of the measures `μ i` of `s i`, then the product measure of the `μ i` is equal to `μ'`. In mathematical terms, given $s_i \subseteq \alpha_i$ for all $i \in \mathbb{I}$, if $\mu'(\prod_{i \in \mathbb{I}} s_i) = \prod_{i \in \mathbb{I}} \mu_i(s_i)$, then the measure on the product space induced by the $\mu_i$ equals $\mu'$.

If for all families of sets {Si : i ∈ I} with each Si measurable, the product measure of the family {Mi : i ∈ I} of measures and the measure of their product in the product space coincide, then the product measure of the family equals the given measure on the product space.


theorem Codisjoint.eq_top :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b → a ⊔ b = ⊤ := by sorry

This theorem states that for any type `α` with a semilattice structure and a top element, if two elements `a` and `b` of this type are codisjoint (meaning that for any `x` in `α` such that `a` and `b` are both less than or equal to `x`, the top element `⊤` is less than or equal to `x`), then the supremum of `a` and `b` is exactly `⊤` (the top element). In mathematical terms, this can be written as: if `a` and `b` are codisjoint, then `a ⊔ b = ⊤`.

If `α` is a type with a semilattice structure and a top element, and `a` and `b` are codisjoint elements of `α`, then their supremum equals the top element, i.e., `a ⊔ b = ⊤`.


theorem Nat.abs_cast : ∀ {α : Type u_1} [inst : LinearOrderedRing α] (a : ℕ), |↑a| = ↑a := by sorry

This theorem states that for any natural number `a` and for any type `α`, which is a linear ordered ring, the absolute value of the cast of `a` to `α` is equal to the cast of `a` to `α`. In other words, it establishes that the absolute value operation doesn't affect natural numbers after being casted to a type that is a linear ordered ring.

For any natural number `a` and any linear ordered ring `α`, the absolute value of `a` in `α` equals the cast of `a` to `α`.


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

The theorem `Int.floor_intCast` states that for any integer `z`, when it is cast into a type `α` (which is assumed to be a linearly ordered ring and a floor ring), the floor function applied to the cast value equals `z`. In simpler terms, the theorem states that when you take an integer, turn it into a decimal number and then round down to the nearest integer, you'll end up with the original integer.

For any integer `z` and any linearly ordered ring `α`, the floor function applied to the cast of `z` to `α` equals `z`.


theorem codisjoint_hnot_right : ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a : α}, Codisjoint a (￢a) := by sorry

The theorem `codisjoint_hnot_right` states that for any type `α` that forms a Coheyting algebra, any element `a` of this type is codisjoint from its complement `￢a`. In other words, for any element `a` and its complement `￢a` in the Coheyting algebra `α`, any element `x` in `α` that is greater than or equal to both `a` and `￢a` must be the top element `⊤` of `α`.

In a Coheting algebra, for all elements `a` and their complements `¬a`, any element `x` greater than or equal to both `a` and `¬a` is the top element `⊤`.


theorem isOfFinAddOrder_of_finite :
    ∀ {G : Type u_1} [inst : AddLeftCancelMonoid G] [inst_1 : Finite G] (x : G), IsOfFinAddOrder x := by sorry

The theorem `isOfFinAddOrder_of_finite` states that for any type `G`, given an additive left-cancelable monoid structure and a finiteness condition on `G`, any element `x` of `G` is of finite additive order. In other words, for every `x` in `G`, there exists a positive integer `n` such that `n • x = 0`. In this context, "left-cancelable" means that for all `a, b, c` in `G`, if `a + b = a + c`, then `b = c`.

Given a type `G` equipped with an additive monoid structure and a finite element `x` in `G`, `x` has finite additive order.


theorem AffineMap.apply_lineMap :
    ∀ {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₀ p₁ : P1) (c : k),
      f ((AffineMap.lineMap p₀ p₁) c) = (AffineMap.lineMap (f p₀) (f p₁)) c :=
  by sorry

The theorem `AffineMap.apply_lineMap` states that for any ring `k`, any additive commutative groups `V1` and `V2`, any `k`-modules `V1` and `V2`, and any affine spaces `P1` and `P2` over `V1` and `V2` respectively, and for any affine map `f` from `P1` to `P2`, any points `p₀` and `p₁` in `P1`, and any scalar `c` in `k`, applying `f` to the result of the affine line map from `k` to `P1` at `c`, which sends `0` to `p₀` and `1` to `p₁`, is equal to the result of the affine line map from `k` to `P2` at `c`, which sends `0` to `f p₀` and `1` to `f p₁`. In other words, the diagram commutes, meaning that the order in which we apply the affine map and the line map does not matter.

For any affine maps `f` and affine line maps `λ_p0` and `λ_p1` with base points `p0` and `p1` respectively, the diagram commutes, that is, `λ_p1(c) ∘ f = f ∘ λ_p0(c)` for all scalars `c`.


theorem List.mem_range : ∀ {m n : ℕ}, m ∈ List.range n ↔ m < n := by sorry

This theorem states that for any natural numbers `m` and `n`, `m` is an element of the list generated by `List.range n` if and only if `m` is strictly less than `n`. In other words, `List.range n` generates a list of natural numbers from `0` to `n-1`, and a number `m` can only be in this list if it is less than `n`.

For natural numbers `m` and `n`, `m` is in the range `[0, n)` if and only if `m < n`.


theorem Matrix.transpose_mul :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : AddCommMonoid α] [inst_1 : CommSemigroup α]
      [inst_2 : Fintype n] (M : Matrix m n α) (N : Matrix n l α),
      Matrix.transpose (M * N) = Matrix.transpose N * Matrix.transpose M :=
  by sorry

The theorem `Matrix.transpose_mul` states that for any two matrices `M` and `N` with entries in a type `α` that forms a commutative semigroup under multiplication and a commutative monoid under addition, the transpose of the product of `M` and `N` is equal to the product of the transpose of `N` and the transpose of `M`. Here `M` is a matrix where rows are indexed by `m` and columns are indexed by `n`, and `N` is a matrix where rows are indexed by `n` and columns are indexed by `l`. The theorem assumes that the type `n` is finite, i.e., there are only finitely many elements of type `n`. This theorem essentially describes the property of transposition with respect to matrix multiplication, which is a well-known result in linear algebra.

For matrices M and N with finite index size, over a commutative semigroup for multiplication and commutative monoid for addition, the transposes of their product are equal: (M · N)^T = N^T · M^T.


theorem Set.mem_of_subset_of_mem : ∀ {α : Type u} {s₁ s₂ : Set α} {a : α}, s₁ ⊆ s₂ → a ∈ s₁ → a ∈ s₂ := by sorry

This theorem states that for any type `α` and any two sets `s₁` and `s₂` of type `α`, along with any element `a` of type `α`, if `s₁` is a subset of `s₂`, and if `a` is an element of `s₁`, then `a` is also an element of `s₂`. This is essentially the property of subset, stating that all elements of a subset must also be elements of the set that contains it.

If `s₁` is a subset of `s₂` and `a` is an element of `s₁`, then `a` is an element of `s₂`.


theorem CategoryTheory.MorphismProperty.RespectsIso.arrow_mk_iso_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.RespectsIso P →
        ∀ {W X Y Z : C} {f : W ⟶ X} {g : Y ⟶ Z},
          (CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g) → (P f ↔ P g) :=
  by sorry

This theorem states that for any category `C` and a morphism property `P` that respects isomorphisms, if we have four objects `W`, `X`, `Y`, and `Z` in `C` and two morphisms `f: W ⟶ X` and `g: Y ⟶ Z`, then if the arrows created by `f` and `g` (i.e., `CategoryTheory.Arrow.mk f` and `CategoryTheory.Arrow.mk g`) are isomorphic, then `P f` holds if and only if `P g` holds. In other words, if `f` and `g` give rise to isomorphic objects in the arrow category, then `f` and `g` either both have the property `P` or both do not have the property `P`.

If morphisms `f: W ⟶ X` and `g: Y ⟶ Z` in a category `C` with isomorphism-respecting property `P` have isomorphic arrows, then `P(f)` if and only if `P(g)`.


theorem SetTheory.PGame.turnBound_ne_zero_of_right_move :
    ∀ {S : Type u} [inst : SetTheory.PGame.State S] {s t : S},
      t ∈ SetTheory.PGame.State.r s → SetTheory.PGame.State.turnBound s ≠ 0 :=
  by sorry

This theorem states that for any type 'S' that is a state in set theoretic game theory, and for any states 's' and 't' in this set, if 't' belongs to the right moves from state 's', then the turn bound of state 's' must not be zero. In other words, if there's a right move possible from a state in a positional game, then the number of turns allowed in the game from that state can't be zero.

In set theoretic game theory, if state 's' has a successor state 't' with a right move, then the turn bound of state 's' is non-zero.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.19 :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α},
      (a + b ≤ a) = (b ≤ 0) :=
  by sorry

This theorem, from the Mathlib library in the Algebra, Order, Monoid section, states that for any type `α` that has an `AddZeroClass` structure (meaning it has addition and zero element) and a lesser-than-or-equal-to (`LE`) order, and assuming that the addition operation is both covariant and contravariant (mathematical terms referring to how a function behaves under transformations), then for any elements `a` and `b` of `α`, `a + b` being less than or equal to `a` is equivalent to `b` being less than or equal to zero.

For any type `α` with an `AddZeroClass` structure and an `LE` order, if addition is both covariant and contravariant, then `a + b <= a` if and only if `b <= 0`.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.25 :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α) {b : α},
      (a < b + a) = (0 < b) :=
  by sorry

This theorem, named `Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.25`, states that for any type `α` that is an additive zero class, has a less than operation, and satisfies both the covariant and contravariant properties with respect to the swap function involving addition and less than operation, for any element `a` of type `α` and any other element `b` of type `α`, the inequality `a` is less than `b + a` holds if and only if `0` is less than `b`.

For any additive zero class type `α` with a total order satisfying the covariant and contravariant properties, `a` is less than `b + a` if and only if `0` is less than `b`.


theorem RingHom.id_apply : ∀ {α : Type u_2} {x : NonAssocSemiring α} (x_1 : α), (RingHom.id α) x_1 = x_1 := by sorry

The theorem `RingHom.id_apply` states that for any type `α` that forms a non-associative semiring and any element `x_1` of `α`, applying the identity ring homomorphism `RingHom.id α` to `x_1` results in `x_1` itself. In other words, the identity ring homomorphism does not change the value of an element in the semiring.

For any semiring `α` and its identity homomorphism `RingHom.id α`, `RingHom.id α x_1 = x_1` for all `x_1 ∈ α`.


theorem Cardinal.mk_eq_one : ∀ (α : Type u) [inst : Unique α], Cardinal.mk α = 1 := by sorry

The theorem `Cardinal.mk_eq_one` states that for any type `α`, if `α` is unique, i.e., it has exactly one element, then the cardinality of `α` is 1. Here, `Cardinal.mk α` is a function that returns the cardinal number of type `α`, and `Unique α` is a typeclass assumption indicating that there is exactly one element of type `α`. In mathematical terms, this theorem is saying that the cardinality of a singleton set is 1.

If a type `α` has exactly one element, then the cardinality of `α` is 1.


theorem himp_bot : ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), a ⇨ ⊥ = aᶜ := by sorry

This theorem, `himp_bot`, states that for any type `α` that forms a Heyting algebra, the Heyting implication of any element `a` towards the bottom element (representing "false" or "zero" in the algebra) is equal to the logical complement (or negation) of `a`. In terms of logic, it essentially states that "if `a` implies `false`, then `a` must be false", hence `a` is not true, or `a`'s complement.

For any element `a` in a Heyting algebra, `a → ⊥ = ⊢(a)`, where `⊥` denotes the bottom element, `⊢` is the logical complement, and `→` denotes Heyting implication.


theorem List.length_drop : ∀ {α : Type u_1} (i : ℕ) (l : List α), List.length (List.drop i l) = List.length l - i := by
  sorry

The theorem `List.length_drop` states that for any list `l` of elements of some type `α`, and for any natural number `i`, the length of the list obtained by dropping the first `i` elements from `l` is equal to the length of the original list `l` minus `i`. This applies to all types and lists, and it reflects the intuitive idea that dropping elements from a list reduces its length by the number of elements dropped.

For any list `l` of length `n` and any natural number `i`, the length of `l.drop i` equals `n - i`.


theorem Polynomial.coeff_eq_zero_of_degree_lt :
    ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R},
      Polynomial.degree p < ↑n → Polynomial.coeff p n = 0 :=
  by sorry

The theorem `Polynomial.coeff_eq_zero_of_degree_lt` states that for any semiring `R`, natural number `n`, and polynomial `p` of type `R`, if the degree of `p` (the highest power of `X` that appears in `p`) is less than `n`, then the coefficient of `X^n` in `p` is zero. In other words, there are no terms in `p` with `X` to the power of `n` or greater.

For any semiring `R`, natural number `n`, and polynomial `p` over `R` in one variable `X` of degree less than `n`, the coefficient of `X^n` in `p` is equal to zero.


Set.Finite.preimage

theorem Set.Finite.preimage :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β}, Set.InjOn f (f ⁻¹' s) → Set.Finite s → Set.Finite (f ⁻¹' s) :=
  by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β`, if `f` is injective on the preimage of a set `s` under `f`, and if the set `s` is finite, then the preimage of `s` under `f` is also finite.

In other words, if we have a function that does not map different elements to the same value within the preimage of a set, and if that set has a finite number of elements, then the preimage of the set (i.e., all the elements in the domain that map to elements in the set) must also have a finite number of elements.

If `f : α → β` is a function, `s ⊆ β` is finite, and the restriction of `f` to the preimage of `s` is injective, then the preimage of `s` under `f` is also finite.


Matroid.Indep.subset

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

This theorem states that for any type `α` and for any Matroid `M` of type `α`, if `J` and `I` are sets from the type `α`, and if `J` is an independent set in the matroid `M`, then if `I` is a subset of `J`, `I` is also an independent set in the matroid `M`. Here, `M.Indep J` and `M.Indep I` refer to the independence of the sets `J` and `I` in the matroid `M` respectively, and `I ⊆ J` denotes that `I` is a subset of `J`.

If `M` is a matroid over type `α`, `J` is an independent set in `M`, and `I ⊆ J`, then `I` is also an independent set in `M`.


theorem algebraMap_smul :
    ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A] {M : Type u_3}
      [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (r : R)
      (m : M), (algebraMap R A) r • m = r • m :=
  by sorry

This theorem, `algebraMap_smul`, states that for any commutative semiring `R`, semiring `A`, commutative monoid `M`, provided that `M` is a module over both `R` and `A`, and also `R` forms a scalar tower over `A` and `M`, then the action of scalar multiplication by `r` in `R` on `m` in `M` is the same whether we consider `r` as an element of `R` or as an element of `A` through the embedding given by the algebra structure. In other words, the scalar multiplication operation is consistent across the scalar tower.

For any commutative semirings R and A, commutative monoid M being an R-A module with R forming a scalar tower over A, the scalar multiplication by r in R on m equals the scalar multiplication by r in A, for all r in R and m in M.


/-- If a monoid homomorphism `f` between two `GroupWithZero`s maps `0` to `0`, then it maps `x^n`,
`n : ℤ`, to `(f x)^n`.  -/
theorem map_zpow₀ :
    ∀ {F : Type u_8} {G₀ : Type u_9} {G₀' : Type u_10} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
      [inst_2 : FunLike F G₀ G₀'] [inst_3 : MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ),
      f (x ^ n) = f x ^ n :=
  by sorry

This theorem states that if we have a monoid homomorphism `f` between two `GroupWithZero`s (which are groups with an additional zero element) and this homomorphism maps `0` to `0`, then for any integer `n` and any element `x` of the original `GroupWithZero`, the result of applying `f` to `x` raised to power `n` is equal to the result of first applying `f` to `x` and then raising the result to power `n`. In other words, the homomorphism `f` preserves exponentiation for integer exponents.

If `f` is a homomorphism between two `GroupWithZero`s mapping `0` to `0`, then for all integers `n` and elements `x` in the original `GroupWithZero`, `f(x^n) = (f(x))^n`.


theorem ofAddUnits_addUnits_gc :
    ∀ {M : Type u_1} [inst : AddMonoid M], GaloisConnection AddSubgroup.ofAddUnits AddSubmonoid.addUnits := by sorry

The theorem `ofAddUnits_addUnits_gc` asserts that for any type `M` having an additive monoid structure, there exists a Galois connection between the function `AddSubgroup.ofAddUnits` and the function `AddSubmonoid.addUnits`. In other words, for all members `a` of the additive subgroup of additive units and all members `b` of the additive submonoid `M`, the condition that `AddSubgroup.ofAddUnits a` is less than or equal to `b` is logically equivalent to the condition that `a` is less than or equal to `AddSubmonoid.addUnits b`. This states a special kind of duality between certain operations on additive subgroups of additive units and additive submonoids.

The theorem `ofAddUnits_addUnits_gc` states that for any additive monoid `M`, the function `AddSubgroup.ofAddUnits` and `AddSubmonoid.addUnits` form a Galois connection, i.e., for all `a` in the additive subgroup of additive units and `b` in `M`, `AddSubgroup.ofAddUnits a ≤ b` if and only if `a ≤ AddSubmonoid.addUnits b`.


theorem refl_mem_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α] {x : α} {s : Set (α × α)}, s ∈ uniformity α → (x, x) ∈ s := by sorry

This theorem states that for any type `α` endowed with a `UniformSpace` structure, any point `x` in `α`, and any set `s` of pairs of elements of `α` that is in the uniformity of `α`, the pair `(x, x)` belongs to `s`. In more mathematical terms, it says that if `s` is a set in the uniformity (i.e., a set of "sufficiently close" pairs of points) in a uniform space, then every point of the space is "sufficiently close" to itself according to `s`. This is a formalization of one of the basic properties of uniform spaces: reflexivity of the underlying relation.

In any uniform space, every point is reflexive with respect to its uniformity, i.e., for any point `x` and any set `s` in the uniformity of `α`, the pair `(x, x)` belongs to `s`.


theorem MeasureTheory.map_mul_left_eq_self :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Mul G] (μ : MeasureTheory.Measure G)
      [inst_2 : MeasureTheory.Measure.IsMulLeftInvariant μ] (g : G), MeasureTheory.Measure.map (fun x => g * x) μ = μ :=
  by sorry

The theorem `MeasureTheory.map_mul_left_eq_self` states that for any type `G` with a measurable space structure and a multiplication operation, any measure `μ` on `G` that is left invariant under multiplication, and any element `g` of `G`, the measure obtained by pushing forward `μ` along the function that multiplies by `g` on the left is equal to `μ` itself. In other words, left multiplication by `g` does not change the measure `μ` if `μ` is left invariant under multiplication.

For any measurable space `(G, Σ, μ)` with a left multiplication-invariant measure `μ`, the pushforward measure of `μ` under left multiplication by any element `g` in `G` is equal to `μ` itself.


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

The theorem `le_neg` states that for any type `α` which forms an additive group and has a less than or equal to (`≤`) relation, such that this `≤` relation is preserved under addition and swapping arguments of the addition (these properties are captured by the `CovariantClass` requirements), then for any two elements `a` and `b` from `α`, `a` is less than or equal to the negation of `b` if and only if `b` is less than or equal to the negation of `a`.

For any additive group type `α` equipped with a covariant `≤` relation preserving addition and swapping arguments, `a ≤ -b` if and only if `b ≤ -a`.


theorem ENNReal.lt_add_right : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ 0 → a < a + b := by sorry

The theorem `ENNReal.lt_add_right` states that for all extended nonnegative real numbers `a` and `b`, if `a` is not equal to positive infinity and `b` is not zero, then `a` is less than the sum of `a` and `b`. This is a formalization of the common mathematical property that a real number is always less than the sum of itself and a positive number.

For all extended nonnegative real numbers `a` and `b` not equal to positive infinity with `b` nonzero, `a < a + b`.


theorem Function.support_subset_iff' :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α → M} {s : Set α},
      Function.support f ⊆ s ↔ ∀ x ∉ s, f x = 0 :=
  by sorry

The theorem `Function.support_subset_iff'` states that for any types `α` and `M`, given a zero instance for `M`, a function `f` from `α` to `M`, and a set `s` of `α`, the support of the function `f` is a subset of the set `s` if and only if for all elements `x` not in the set `s`, the function `f` evaluated at `x` equals `0`. Here, the support of a function `f` is defined as the set of points `x` such that `f(x)` is not equal to `0`.

For functions from type `α` to type `M` with a zero element `0_M`, the support of the function equals the subset of domain `α` where the function does not equal `0_M`. That is, `support(f) ⊆ s` if and only if for all `x ∈ α \ s`, `f(x) = 0_M`.


theorem Set.mk_mem_prod :
    ∀ {α : Type u} {β : Type v} {a : α} {b : β} {s : Set α} {t : Set β}, a ∈ s → b ∈ t → (a, b) ∈ s ×ˢ t := by sorry

This theorem states that for any types `α` and `β`, any elements `a` from `α` and `b` from `β`, and any sets `s` of type `α` and `t` of type `β`, if `a` is an element of set `s` and `b` is an element of set `t`, then the pair `(a, b)` is an element of the cartesian product of sets `s` and `t`. In mathematical terms, if $a \in s$ and $b \in t$, then $(a, b) \in s \times t$.

For any sets `s` and `t`, and for all `a in s` and `b in t`, `(a, b) in s × t`.


Pointed.Hom.ext

theorem Pointed.Hom.ext : ∀ {X Y : Pointed} (x y : Pointed.Hom X Y), x.toFun = y.toFun → x = y := by sorry

This theorem, `Pointed.Hom.ext`, states that for any two pointed spaces `X` and `Y`, and any two morphisms `x` and `y` from `X` to `Y` in the category of pointed spaces, if the underlying functions of `x` and `y` are equal, then `x` and `y` themselves are equal. In other words, in the category of pointed spaces, morphisms are determined entirely by their underlying functions.

In the category of pointed spaces, two morphisms between pointed spaces with equal underlying functions are equal.


Continuous.intervalIntegrable

/-- A continuous function on `ℝ` is `IntervalIntegrable` with respect to any locally finite measure
`ν` on ℝ.  -/
theorem Continuous.intervalIntegrable :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure ℝ}
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] {u : ℝ → E},
      Continuous u → ∀ (a b : ℝ), IntervalIntegrable u μ a b :=
  by sorry

The theorem states that for any continuous function `u` mapping real numbers to a normed additively commutative group `E`, and for any locally finite measure `μ` on the real numbers, the function `u` is interval integrable with respect to the measure `μ` on any unordered interval `a..b`. In other words, the function is integrable on both intervals `(a, b]` and `(b, a]`. In mathematical terms, it's equivalent to saying that the function `u` is integrable on the interval `(min a b, max a b]`.

For any continuous function from real numbers to a normed additively commutative group and any locally finite measure on real numbers, the function is interval integrable with respect to the measure on any unordered interval, equivalently integrable on the interval with minimum and maximum endpoints.


theorem Nat.log_zero_right : ∀ (b : ℕ), Nat.log b 0 = 0 := by sorry

The theorem `Nat.log_zero_right` states that for any natural number `b`, the logarithm of `0` in base `b` is `0`. In other words, regardless of what the base `b` is, log base `b` of `0` always equals `0`.

For all natural numbers b, log base b of 0 equals 0.


theorem Nat.min_eq_left : ∀ {a b : ℕ}, a ≤ b → min a b = a := by sorry

This theorem, `Nat.min_eq_left`, states that for any two natural numbers `a` and `b`, if `a` is less than or equal to `b`, then the minimum of `a` and `b` is `a`. The theorem is essentially describing one of the properties of the minimum function in the context of natural numbers.

For all natural numbers `a` and `b`, if `a` ≤ `b`, then `min a b` = `a`.


theorem MeasureTheory.lintegral_indicator :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) {s : Set α},
      MeasurableSet s → ∫⁻ (a : α), Set.indicator s f a ∂μ = ∫⁻ (a : α) in s, f a ∂μ :=
  by sorry

The theorem `MeasureTheory.lintegral_indicator` states that for any measurable space `α`, any measure `μ` on that space, any function `f` from `α` to the extended nonnegative real numbers `ENNReal`, and any measurable set `s`, the Lebesgue integral over the whole space of the function `f` where it is multiplied by the indicator function of the set `s` (making it zero outside `s`) is equal to the Lebesgue integral of `f` over the set `s`. In other words, integrating a function over a whole space, but with the function's value being zero outside a particular set, is the same as integrating the function over that set itself. In LaTeX mathematics, it is represented as:

∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) {s : Set α}, MeasurableSet s → ∫⁻ (a : α), Set.indicator s f a ∂μ = ∫⁻ (a : α) in s, f a ∂μ

For any measurable space, measure, function, and measurable set, the Lebesgue integral of the function's indicator multiplication over the whole space equals the integral over the set itself.


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

This theorem, `inv_le_inv_iff`, is a statement about inverse elements in a group with a certain type of order relation. Specifically, consider a group `α` equipped with a multiplication operation and a "less than or equal to" (`≤`) relation. Assume that `α` is covariant, which means that the multiplication operation and the order relation interact in a certain way: if `x` and `y` are elements of the group and `x ≤ y`, then for any other element `z`, we have `z * x ≤ z * y`. Also assume that this covariance holds when the multiplication is done in the opposite order: if `x ≤ y`, then `z * x ≤ z * y` for any `z`. Then, the theorem states that for any two elements `a` and `b` in our group, the inverse of `a` is less than or equal to the inverse of `b` if and only if `b` is less than or equal to `a`.

In a covariant group equipped with a multiplication operation and a covariant "less than or equal to" relation, the inverse of an element is less than or equal to the inverse of another element if and only if the other element is less than or equal to the first.


theorem ENNReal.nat_ne_top : ∀ (n : ℕ), ↑n ≠ ⊤ := by sorry

This theorem states that, for any natural number `n`, the real number equivalent of `n` is not equal to infinity. In other words, the real number representation of any natural number will never be infinity.

For all natural numbers `n`, the real number representation `n` is finite.


theorem Metric.uniformContinuous_iff :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      UniformContinuous f ↔ ∀ ε > 0, ∃ δ > 0, ∀ {a b : α}, dist a b < δ → dist (f a) (f b) < ε :=
  by sorry

The theorem `Metric.uniformContinuous_iff` provides a criterion for checking the uniform continuity of a function between two pseudometric spaces. Specifically, it states that for all types `α` and `β` that are pseudometric spaces, a function `f : α → β` is uniformly continuous if and only if for every positive real number `ε`, there exists a positive real number `δ` such that for all points `a` and `b` in `α`, if the distance between `a` and `b` is less than `δ`, then the distance between `f(a)` and `f(b)` is less than `ε`. In simpler terms, no matter where we are in `α`, if two points are sufficiently close together (within `δ`), their images under `f` are also close together (within `ε`).

A function between two pseudometric spaces is uniformly continuous if and only if for every ε > 0, there exists δ > 0 such that d(a, b) < δ implies d(f(a), f(b)) < ε, where d denotes the respective pseudometric.


MulChar.ext

/-- Extensionality. Since `MulChar`s always take the value zero on non-units, it is sufficient
to compare the values on units.  -/
theorem MulChar.ext :
    ∀ {R : Type u} [inst : CommMonoid R] {R' : Type v} [inst_1 : CommMonoidWithZero R'] {χ χ' : MulChar R R'},
      (∀ (a : Rˣ), χ ↑a = χ' ↑a) → χ = χ' :=
  by sorry

The theorem `MulChar.ext` is a statement about extensionality in the context of multiplication characters (MulChar). Given two types `R` and `R'`, where `R` is a commutative monoid and `R'` is a commutative monoid with zero, and two multiplication characters `χ` and `χ'` from `R` to `R'`, if those characters coincide on the multiplicative units (`Rˣ`) of `R`, then the characters `χ` and `χ'` are equal. This comes from the fact that multiplication characters always map non-units to zero, so you only need to compare the values on units to determine if two multiplication characters are the same.

If two multiplication characters from a commutative monoid to a commutative monoid with zero have the same value on the multiplicative units, then they are equal.


theorem Finset.card_eq_sum_ones : ∀ {α : Type u_3} (s : Finset α), s.card = Finset.sum s fun x => 1 := by sorry

The theorem `Finset.card_eq_sum_ones` states that for any finite set `s` of type `α`, the cardinality of `s` (i.e., the number of elements in `s`) is equal to the sum of `1` for each element in `s`. In other words, if you were to take each element in the finite set `s` and map it to the number `1`, then add up all those ones, you would get the same count as the total number of elements in the set `s`.

For any finite set `s` of type `α`, the cardinality of `s` equals the sum of ones over its elements.


theorem Set.eq_empty_of_subset_empty : ∀ {α : Type u} {s : Set α}, s ⊆ ∅ → s = ∅ := by sorry

This theorem states that for any set `s` of type `α`, if `s` is a subset of the empty set `∅`, then `s` must be the empty set. In other words, the only set that can be a subset of the empty set is the empty set itself. This is in line with the mathematical principle that the empty set is a subset of every set, including itself.

If a set `s` is a subset of the empty set `∅`, then `s` is the empty set.


theorem Int.add_left_neg : ∀ (a : ℤ), -a + a = 0 := by sorry

This theorem, `Int.add_left_neg`, states that for any integer `a`, the sum of `-a` (the negation of `a`) and `a` equals 0. In other words, when you add an integer and its negative counterpart, you always get zero. This is a formal restatement of a fundamental property of integers in Lean 4.


theorem orderOf_dvd_iff_pow_eq_one : ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, orderOf x ∣ n ↔ x ^ n = 1 := by
  sorry

The theorem `orderOf_dvd_iff_pow_eq_one` states that for any type `G` equipped with the structure of a monoid and for any element `x` of `G` and natural number `n`, the order of element `x` divides `n` if and only if `x` raised to the power `n` equals the multiplicative identity element `1`. In other words, the exponent at which `x` gives `1` is a divisor of `n` if and only if the `n`-th power of `x` is `1`.

For any monoid `G` and `x` in `G` and natural number `n`, `x` raised to the power `n` equals the identity element `1` if and only if the order of `x` divides `n`.


theorem mul_inv_cancel_right₀ :
    ∀ {G₀ : Type u} [inst : GroupWithZero G₀] {b : G₀}, b ≠ 0 → ∀ (a : G₀), a * b * b⁻¹ = a := by sorry

This theorem states that for any type `G₀` that forms a group with zero, given any non-zero element `b` of `G₀` and any other element `a` of `G₀`, the formula `a * b * b⁻¹` simplifies to `a`. Here, `b⁻¹` denotes the multiplicative inverse of `b`. This is a property of groups where multiplying an element by its inverse results in the identity, thereby canceling the effect of `b` and `b⁻¹` in the multiplication.

In any group with an identity element, for all `a, b` in the group with `b` non-zero, `a * b * b⁻¹ = a`.


theorem LieSubmodule.subset_lieSpan :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] {s : Set M}, s ⊆ ↑(LieSubmodule.lieSpan R L s) :=
  by sorry

This theorem states that for any types `R`, `L`, and `M` where `R` is a commutative ring, `L` is a Lie ring, `M` is an additive commutative group that is also a module over `R` and a Lie ring module over `L`, and given a set `s` of elements from `M`, the set `s` is a subset of the Lie span of `s`. In mathematical terms, if we consider `M` as a Lie submodule, then for any subset `s` of `M`, all elements of `s` are also elements of the smallest possible Lie submodule that contains `s` (the Lie span of `s`).

For any commutative ring `R`, Lie ring `L`, and an additive commutative group `M` that is an `R`-module and a Lie ring module over `L`, every subset `s` of `M` is contained in the Lie span of `s`.


theorem Set.Ioo_eq_empty : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, ¬a < b → Set.Ioo a b = ∅ := by sorry

This theorem states that for any type `α` equipped with a preorder, the left-open right-open interval `(a, b)` (represented as `Set.Ioo a b`) is empty if `a` is not less than `b`. In other words, if `a` is greater than or equal to `b`, then there are no elements `x` such that `a < x < b`. This is a very intuitive result, since it simply says that in a given ordered set, there cannot be elements between two points if the first point is not strictly less than the second one.

For any type `α` with a preorder, the left-open right-open interval `(a, b)` is empty when `a ≥ b`.


theorem Polynomial.degree_le_natDegree :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.degree p ≤ ↑(Polynomial.natDegree p) := by sorry

The theorem `Polynomial.degree_le_natDegree` states that for any semiring `R` and any polynomial `p` from this semiring, the degree of `p` (which could be undefined or `⊥`) is always less than or equal to the natural degree of `p` (which is always defined and is a natural number). Here, the degree of a polynomial is the highest power of `X` that appears in it, and the natural degree is a forced version of the degree, where the degree of the zero polynomial is defined to be zero.

For any semiring R and polynomial p over R, the degree of p is less than or equal to its natural degree.


Primrec.succ

theorem Primrec.succ : Primrec Nat.succ := by sorry

The theorem `Primrec.succ` states that the successor function on natural numbers, denoted `Nat.succ`, is primitive recursive. In other words, for the function that takes a natural number and returns its successor (i.e., increases the number by one), this function can be computed by a process that is "primitive recursive". This means that the function can be computed by a procedure that involves only basic mathematical operations and recursion.

The successor function on natural numbers is primitive recursive.


/-- Alias of `Nat.cast_le` specialized to `PartENat` - -/
theorem PartENat.coe_le_coe : ∀ {x y : ℕ}, ↑x ≤ ↑y ↔ x ≤ y := by sorry

This theorem states that for any two natural numbers `x` and `y`, the statement "the partial extended natural number corresponding to `x` is less than or equal to the partial extended natural number corresponding to `y`" is equivalent to "x is less than or equal to y". In other words, the partial extended natural number representation of a number preserves the order of natural numbers.

The theorem asserts that for all natural numbers x and y, x ≤ y if and only if the partial extended natural number representing x is less than or equal to the partial extended natural number representing y.


theorem contDiffWithinAt_univ :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {n : ℕ∞}, ContDiffWithinAt 𝕜 n f Set.univ x ↔ ContDiffAt 𝕜 n f x :=
  by sorry

This theorem, named `contDiffWithinAt_univ`, states that for any nontrivially normed field `𝕜`, any normed additive commutative group `E` and `F` over `𝕜`, any function `f` from `E` to `F`, any point `x` in `E`, and any natural number or infinity `n`, the function `f` is continuously differentiable within the universal set at point `x` if and only if `f` is continuously differentiable at point `x`. In other words, if a function is continuously differentiable at a point in the whole space, it is also continuously differentiable at that point when restricting to any open subset, and vice versa.

For any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F` over `𝕜`, function `f` from `E` to `F`, point `x` in `E`, and natural number or infinity `n`, `f` is continuously differentiable within the universal set at `x` if and only if it is continuously differentiable at `x`.


theorem Polynomial.mem_nthRoots :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {n : ℕ},
      0 < n → ∀ {a x : R}, x ∈ Polynomial.nthRoots n a ↔ x ^ n = a :=
  by sorry

The theorem `Polynomial.mem_nthRoots` states that for any commutative ring `R` that is also a domain, any natural number `n` that is greater than zero, and any elements `a` and `x` from `R`, `x` is a solution to the equation `x^n = a` if and only if `x` is in the multiset of `n`-th roots of `a`. In other words, it provides a characterization of the `n`-th roots of `a` in terms of the solutions to the polynomial equation `x^n = a`.

For any commutative domain R, natural number n > 0, and elements a and x in R, x is an n-th root of a if and only if x is a solution to the equation x^n = a.


theorem Set.injOn_iff_injective :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.InjOn f s ↔ Function.Injective (Set.restrict s f) := by
  sorry

This theorem states that for any type `α`, type `β`, a set `s` of type `α`, and a function `f` from `α` to `β`, the function `f` is injective on the set `s` if and only if the restriction of the function `f` to the set `s` is injective. Here, a function is said to be injective (or one-to-one) if it assigns a unique output to each unique input. In other words, if two values in the domain of the function map to the same value in the codomain, these two values must be the same. The theorem links the concept of injectivity to the concept of injectivity on a subset, asserting these are equivalent when considering a function restricted to a subset.

For any function \(f : \alpha \rightarrow \beta\) and set \(s \subseteq \alpha\), \(f\) is injective on \(s\) if and only if the restriction \(f|_s : s \rightarrow \beta\) is injective.


theorem Polynomial.toFinsupp_injective : ∀ {R : Type u} [inst : Semiring R], Function.Injective Polynomial.toFinsupp :=
  by sorry

The theorem `Polynomial.toFinsupp_injective` asserts that for any type `R` equipped with a semiring structure, the function `Polynomial.toFinsupp` is injective. In other words, if we have two polynomials (from the type `R`) and the `toFinsupp` function maps them to the same element of the additive monoid algebra, then those two polynomials must be the same. It is a statement about the uniqueness of the representation of polynomials in the additive monoid algebra.

The theorem asserts that the `Polynomial.toFinsupp` function maps distinct polynomials over a semiring to distinct elements in the additive monoid algebra.


theorem Filter.comap_map :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β},
      Function.Injective m → Filter.comap m (Filter.map m f) = f :=
  by sorry

This theorem states that for all types `α` and `β`, for any filter `f` on the type `α`, and for any injective function `m` from `α` to `β`, the composition of the comap of `m` and the map of `m` applied to `f` is equal to `f` itself. In simpler terms, it says that if you first map a filter `f` from `α` to `β` using an injective function and then comap it back to `α` using the same function, you end up with the original filter `f`. This is similar to the mathematical concept that the composition of a function and its inverse results in the identity function, in this case, the filter remains unchanged.

For all filters $f$ on type $\alpha$, and for any injective function $m:\alpha \rightarrow \beta$, the composition of $m \circ \map(m)(f)$ equals $f$.


Measurable.sub

theorem Measurable.sub :
    ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : Sub G] {m : MeasurableSpace α} {f g : α → G}
      [inst_2 : MeasurableSub₂ G], Measurable f → Measurable g → Measurable fun a => f a - g a :=
  by sorry

The theorem `Measurable.sub` states that for any type 'G' equipped with a measurable space structure and a subtraction operation, and any measurable space 'α', if 'f' and 'g' are two measurable functions from 'α' to 'G' and if 'G' has a defined measurable subtraction operation, then the function that maps each value in 'α' to the difference of the corresponding values in 'f' and 'g' is also a measurable function. This essentially means that the subtraction of two measurable functions is again a measurable function.

If 'f' and 'g' are measurable functions from a measurable space 'α' to a measurable group 'G' with a defined measurable subtraction operation, then their pointwise difference is also a measurable function from 'α' to 'G'.


theorem MeasureTheory.lintegral_mono' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} ⦃μ ν : MeasureTheory.Measure α⦄,
      μ ≤ ν → ∀ ⦃f g : α → ENNReal⦄, f ≤ g → ∫⁻ (a : α), f a ∂μ ≤ ∫⁻ (a : α), g a ∂ν :=
  by sorry

The theorem `MeasureTheory.lintegral_mono'` states that for any measurable space `α` and two measures `μ` and `ν` on that space, if `μ` is less than or equal to `ν` and `f` and `g` are two functions from `α` to the extended nonnegative real numbers (`ENNReal`), such that `f` is less than or equal to `g`, then the integral from `f` with respect to `μ` is less than or equal to the integral from `g` with respect to `ν`. In mathematical notation, this is written as: if `μ ≤ ν` and `f ≤ g`, then `∫⁻ (a : α), f a ∂μ ≤ ∫⁻ (a : α), g a ∂ν`. This theorem is a fundamental property of measures and integrals in measure theory.

If `μ` is a measure less than or equal to `ν` on the measurable space `α`, and `f` is a measurable function with `f ≤ g` pointwise, then the integral of `f` with respect to `μ` is less than or equal to the integral of `g` with respect to `ν`.


theorem add_sub : ∀ {G : Type u_3} [inst : SubNegMonoid G] (a b c : G), a + (b - c) = a + b - c := by sorry

This theorem, named `add_sub`, states that for all types `G` that form a subtractable negated monoid (as indicated by `SubNegMonoid G`), for any three elements `a`, `b`, and `c` of `G`, the result of adding `a` and the difference between `b` and `c` (`a + (b - c)`) is equal to the result of subtracting `c` from the sum of `a` and `b` (`a + b - c`). This is essentially the statement of the distributive property of subtraction over addition within a subtractable negated monoid structure.

For any subtractable negated monoid type `G`, the distributive property holds: `a + (b - c) = a + b - c` for all elements `a, b, c` of `G`.


theorem Finset.mem_map :
    ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, b ∈ Finset.map f s ↔ ∃ a ∈ s, f a = b := by
  sorry

The theorem `Finset.mem_map` states that for any types `α` and `β`, any embedding `f` from `α` to `β`, any finite set `s` of type `α`, and any element `b` of type `β`, `b` is in the image of the finite set `s` under the embedding `f` if and only if there exists an element `a` in `s` such that `f(a) = b`. In other words, an element is in the image of a finite set under an embedding if and only if it is the image of some element in the original set under the embedding.

For any finite set $S \subseteq \alpha$, embedding $f : \alpha \to \beta$, and $\beta$-element $b$, $b \in \operatorname{image}(f(S))$ if and only if $\exists a \in S. \, f(a) = b$.


theorem Polynomial.natDegree_mul' :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.leadingCoeff p * Polynomial.leadingCoeff q ≠ 0 →
        Polynomial.natDegree (p * q) = Polynomial.natDegree p + Polynomial.natDegree q :=
  by sorry

The theorem `Polynomial.natDegree_mul'` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the product of the leading coefficients of `p` and `q` is nonzero, then the natural degree of the product of `p` and `q` is equal to the sum of the natural degrees of `p` and `q`. Here, the "leading coefficient" of a polynomial is the coefficient of the highest power of `X` in the polynomial, and the "natural degree" of a polynomial forces the degree of the polynomial to ℕ by defining the natural degree of 0 as 0.

If `R` is a semiring and `p(X)` and `q(X)` are polynomials over `R` with nonzero product of leading coefficients, then the natural degree of `p(X) * q(X)` equals the sum of the natural degrees of `p(X)` and `q(X)`.


theorem Complex.conj_I : (starRingEnd ℂ) Complex.I = -Complex.I := by sorry

This theorem states that the complex conjugate of the imaginary unit in complex numbers, denoted as `Complex.I`, is equal to the negative of the imaginary unit. In mathematical terms, the complex conjugate of `i` (i.e., the imaginary unit) is `-i`. This is represented in Lean 4 as `(starRingEnd ℂ) Complex.I = -Complex.I`.

The complex conjugate of `Complex.I` equals `-Complex.I` in the complex number field.


List.Nodup.sublist

theorem List.Nodup.sublist : ∀ {α : Type u} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.Nodup l₂ → List.Nodup l₁ := by
  sorry

The theorem `List.Nodup.sublist` states that for all types `α` and for any two lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂` and if `l₂` has no duplicates (expressed as `List.Nodup l₂`), then `l₁` also has no duplicates (expressed as `List.Nodup l₁`). In other words, if a list has no duplicate items, then any sublist of that list also has no duplicate items.

If `l₁` is a sublist of `l₂` and `List.Nodup l₂`, then `List.Nodup l₁`.


theorem Cardinal.card_ord : ∀ (c : Cardinal.{u_3}), Ordinal.card (Cardinal.ord c) = c := by sorry

The theorem `Cardinal.card_ord` states that for any cardinal number `c`, the cardinality of the ordinal number corresponding to `c` (obtained via the function `Cardinal.ord`), is `c` itself. In other words, the cardinality function `Ordinal.card` and the ordinal function `Cardinal.ord` are inverses of each other when applied to a cardinal number `c`.

For any cardinal number `c`, the ordinal number obtained from `Cardinal.ord(c)` has cardinality `c`. In other words, `Cardinal.ord` and `Ordinal.card` are inverses of each other when applied to cardinal numbers.


theorem Nat.sub_succ : ∀ (n m : ℕ), n - Nat.succ m = Nat.pred (n - m) := by sorry

The theorem `Nat.sub_succ` is a statement about subtraction and the predecessor function on natural numbers. For all natural numbers `n` and `m`, the difference between `n` and the successor of `m` (`Nat.succ m` which represents `m+1`) is the same as the predecessor (`Nat.pred`) of the difference between `n` and `m`. In other words, if we subtract `m+1` from `n`, it's the same as first subtracting `m` from `n` and then taking the predecessor of that result. This theorem formalizes one of the basic properties of subtraction on natural numbers.

For all natural numbers `n` and `m`, `n - Nat.succ m = Nat.pred (n - m)`.


theorem Nat.div_self : ∀ {n : ℕ}, 0 < n → n / n = 1 := by sorry

This theorem states that for any natural number 'n', if 'n' is greater than zero, then the result of dividing 'n' by itself is 1. Put simply, it formalizes the common mathematical fact that any non-zero number divided by itself equals one.

For any natural number n greater than zero, n / n = 1.


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

This theorem, `MeasureTheory.Measure.smul_apply`, states that for any types `α` and `R`, where `R` is a type that can be scaled (multiplied) with the extended nonnegative real numbers (`ENNReal`), given a measurable space of type `α`, a scalar `c` of type `R`, a measure `μ` on that measurable space, and a set `s` of elements of type `α`, the measure of the set `s` under the scaled measure `c • μ` is equal to the scalar `c` scaled with the measure of the set `s` under the original measure `μ`. This establishes a property of scalar multiplication in the context of measures, essentially stating that scaling a measure and then applying it is the same as applying the measure and then scaling the result.

For any measurable space `(α, Σ, μ)`, scalar `c` in a type `R` with scalar multiplication `•`, and measurable set `s` in `α`, `c • μ(s) = μ(s) • c`.


theorem CategoryTheory.Limits.limit.isoLimitCone_hom_π :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F]
      (t : CategoryTheory.Limits.LimitCone F) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limit.isoLimitCone t).hom (t.cone.π.app j) =
        CategoryTheory.Limits.limit.π F j :=
  by sorry

The theorem `CategoryTheory.Limits.limit.isoLimitCone_hom_π` states that for any category `J` with a functor `F` from `J` to a category `C`, if `C` has a limit for functor `F` and `t` is a limit cone of the functor `F`, then composing the morphism from the limit of `F` to the limit cone `t` with the projection from the limit cone `t` to a value `j` in `J` is equal to the projection from the limit of `F` to the value `j` through the functor `F`.

In other words, this theorem guarantees the commutativity of a specific diagram in the category theory, which relates the limit of a functor, limit cones, and the values of the functor.

For any limit cone `t` and limit `l` of a functor `F` from a category `J` to a category `C`, the composition of the morphism from `l` to `t` and the projection `t` to an object `j` in `J` equals the projection `l` to `j` through `F`.


/-- `zeroLocus` and `vanishingIdeal` form a galois connection.  -/
theorem ProjectiveSpectrum.gc_ideal :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
      (𝒜 : ℕ → Submodule R A) [inst_3 : GradedAlgebra 𝒜],
      GaloisConnection (fun I => ProjectiveSpectrum.zeroLocus 𝒜 ↑I) fun t =>
        HomogeneousIdeal.toIdeal (ProjectiveSpectrum.vanishingIdeal t) :=
  by sorry

The theorem `ProjectiveSpectrum.gc_ideal` states that for any commutative semiring `R`, commutative ring `A`, and an algebra `A` over `R`, given a function `𝒜` that maps natural numbers to submodules of `A` over `R` (under the condition that `𝒜` forms a `GradedAlgebra`), the functions `zeroLocus` and `vanishingIdeal` form a Galois connection. In this context, `zeroLocus` takes a homogeneous ideal and produces its zero locus in the projective spectrum, and `vanishingIdeal` takes a subset of the projective spectrum and produces the homogeneous ideal of functions that vanish on it. The Galois connection property ensures a specific kind of correspondence between the set of homogeneous ideals and the subsets of the projective spectrum: for a homogeneous ideal `I` and a subset `t` of the projective spectrum, the zero locus of `I` is contained in `t` if and only if `I` is contained in the vanishing ideal of `t`.

The `ProjectiveSpectrum.gc_ideal` theorem in Lean 4 states that the functions `zeroLocus` and `vanishingIdeal` form a Galois connection between graded submodules of a commutative ring `A` over a commutative semiring `R` and subsets of the projective spectrum of `A`, such that the zero locus of a homogeneous ideal is contained in a subset if and only if the ideal is contained in the vanishing ideal of the subset.


theorem Mathlib.Data.ENNReal.Inv._auxLemma.5 : ∀ {a : ENNReal}, (a⁻¹ = ⊤) = (a = 0) := by sorry

This theorem states that for all extended nonnegative real numbers 'a', 'a' inverted is equal to infinity if and only if 'a' is equal to zero. In other words, the reciprocal of any extended nonnegative real number is infinity exactly when the original number is zero.

For all extended nonnegative real numbers $a$, $a^{-1} = \infty$ if and only if $a = 0$.


theorem min_le_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, min a b ≤ c ↔ a ≤ c ∨ b ≤ c := by sorry

This theorem states that for a given linear ordering of some type `α`, the minimum of two elements `a` and `b` is less than or equal to a third element `c` if and only if either `a` is less than or equal to `c` or `b` is less than or equal to `c`. In mathematical terms, this theorem expresses that `min(a, b) ≤ c` is equivalent to `a ≤ c ∨ b ≤ c`.

For all linear order types `α`, the minimum of two elements `a` and `b` is less than or equal to a third element `c` if and only if `a` is less than or equal to `c` or `b` is less than or equal to `c`. In mathematical notation: `min(a, b) ≤ c ↔ a ≤ c ∨ b ≤ c`.


/-- If matrix A is left invertible, then its inverse equals its left inverse.  -/
theorem Matrix.inv_eq_left_inv :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] {A B : Matrix n n α},
      B * A = 1 → A⁻¹ = B :=
  by sorry

This theorem states that for any type `n` that is a finite type with decidable equality and any commutative ring `α`, if a matrix `A` of type `Matrix n n α` (a matrix with entries in `α` and both rows and columns indexed by `n`) has a left inverse `B` (i.e., `B * A` equals the identity matrix), then the inverse of `A` is equal to `B`. In more mathematical terms, if $BA = I$ for matrices $A$ and $B$ over a commutative ring, then $A^{-1} = B$.

If `A` is a finite type with decidable equality and `α` is a commutative ring such that `A` has a left inverse `B` over `α`, then `B` is the right inverse (and hence the inverse) of `A`.


theorem Mathlib.Algebra.Divisibility.Basic._auxLemma.3 :
    ∀ {α : Type u_1} [inst : CommSemigroup α] (a b : α), (a ∣ b * a) = True := by sorry

This theorem, `Mathlib.Algebra.Divisibility.Basic._auxLemma.3`, states that for any type `α` that has the structure of a commutative semigroup, given any two elements `a` and `b` of that type, `a` divides the product of `b` and `a`. In other words, for all `a` and `b` in a commutative semigroup, `a` is a divisor of `b` multiplied by `a`.

For any commutative semigroup type `α`, and any of its elements `a` and `b`, `a` is a divisor of the product `b * a`.


/-- Given a MonoidHom `f : M →* N` and Submonoid `S ⊆ M` such that `f(S) ⊆ Nˣ`, for all
`w, z : N` and `y ∈ S`, we have `w * (f y)⁻¹ = z ↔ w = f y * z`.  -/
theorem Submonoid.LocalizationMap.mul_inv_left :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {f : M →* N}
      (h : ∀ (y : ↥S), IsUnit (f ↑y)) (y : ↥S) (w z : N),
      w * ↑((IsUnit.liftRight (MonoidHom.restrict f S) h) y)⁻¹ = z ↔ w = f ↑y * z :=
  by sorry

This theorem states that for a given monoid homomorphism `f` mapping from monoid `M` to `N`, and a submonoid `S` of `M` such that the image of `S` under `f` is contained in `Nˣ` (the group of units in `N`), for all `w, z` in `N` and `y` in `S`, the equality `w * (f(y))⁻¹ = z` holds if and only if `w = f(y) * z`. This theorem allows us to simplify expressions involving the inverse of the image of an element under a monoid homomorphism.

For a monoid homomorphism `f` from monoid `M` to `N` with image of a submonoid `S` of `M` contained in `Nˣ`, the equation `w * (f(y))⁻¹ = z` holds if and only if `w = f(y) * z` for all `w, z` in `N` and `y` in `S`.


theorem Finset.prod_empty :
    ∀ {α : Type u_3} {β : Type u_4} {f : α → β} [inst : CommMonoid β], (Finset.prod ∅ fun x => f x) = 1 := by sorry

This theorem states that for any types `α` and `β`, and any function `f` from `α` to `β` under the condition that `β` forms a commutative monoid, the product of `f x` as `x` ranges over the elements of an empty set is equal to the identity element of the monoid, which is 1. This is akin to saying that the product of an empty list of numbers is 1, in the sense of multiplication of numbers.

For any commutative monoid type `β` and function `f` from type `α` to `β`, the empty product of `f x` over an empty set equals the identity element of `β`.


theorem Mathlib.Topology.Separation._auxLemma.47 :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : T1Space X] {l : Filter Y}
      [inst_2 : Filter.NeBot l] {c d : X}, Filter.Tendsto (fun x => c) l (nhds d) = (c = d) :=
  by sorry

The theorem `Mathlib.Topology.Separation._auxLemma.47` states that for any two points `c` and `d` in a T1 topological space `X`, and for a non-bottom filter `l` on some type `Y`, the function that is constantly `c` tends to `d` with respect to the filter `l` if and only if `c` equals `d`. In other words, a constant function at `c` has a limit of `d` with respect to filter `l` if and only if `c` equals `d`. This limit is considered in the filter-topology framework, where the limit of the function is defined by the `Filter.Tendsto` predicate.

In a T1 topological space, a constant function with respect to two points `c` and `d` has a limit converging to `d` with respect to a non-bottom filter `l` if and only if `c` equals `d`.


theorem Nat.pow_right_injective : ∀ {a : ℕ}, 2 ≤ a → Function.Injective fun x => a ^ x := by sorry

The theorem `Nat.pow_right_injective` states that for every natural number `a` that is greater than or equal to 2, the function that raises `a` to the power of another natural number `x` is injective. In other words, if `a` is a natural number greater than or equal to 2, then for any two natural numbers `x` and `y`, if `a^x = a^y`, then `x` must equal to `y`.

For every natural number `a` greater than or equal to 2, the function `x => a^x` is injective (i.e., if `a^x = a^y`, then `x = y`).


theorem TensorProduct.tmul_zero :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} (N : Type u_5) [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M), m ⊗ₜ[R] 0 = 0 :=
  by sorry

This theorem states that for any commutative semiring `R`, any type `M` that forms an `R`-module with respect to an additive commutative monoid structure, and any type `N` that also forms an `R`-module with respect to another additive commutative monoid structure, the tensor product of any element `m` of `M` and the zero element of `N` is the zero element of the tensor product space. Symbolically, this can be represented as `m ⊗ₜ[R] 0 = 0`.

For any commutative semiring R, and for any R-module M and R-module N with additive structures, the tensor product of any element in M with the zero element in N is the zero element in the tensor product of M and N.


theorem Finset.coe_zero : ∀ {α : Type u_2} [inst : Zero α], ↑0 = 0 := by sorry

This theorem states that for any type `α` that has an instance of `0`, the coercion of `0` (in the context of a finite set `Finset`) to `α` is `0`. In other words, the set-representation `0` (a set with no elements) is equivalent to the numeric `0` in this context.

For any type `α` with an instance of `0`, the coercion of `Finset.zero` to `α` equals `α.zero`.


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

The theorem `Filter.Tendsto.eventually_ge_atTop` states that for any types `α` and `β`, where `β` has a preorder relation, and for any function `f` mapping from `α` to `β`, and for any filter `l` on `α`: if `f` tends to infinity (`Filter.atTop`) under the filter `l`, then for any value `c` in `β`, eventually (`∀ᶠ`) for every `x` in the domain `α` under the filter `l`, the value `c` is less than or equal to the value `f(x)`. In other words, if the function `f` tends to infinity at the filter `l`, then there exists a point after which all values of the function `f` are greater than or equal to any given value `c`.

If a function from type `α` to preordered type `β` tends to infinity under filter `l` on `α`, then for any `c` in `β`, there exists an element `x` in the filter `l` such that `f(x) ≥ c`.


MulEquiv.surjective

theorem MulEquiv.surjective :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N), Function.Surjective ⇑e := by sorry

The theorem `MulEquiv.surjective` states that for all types `M` and `N` equipped with multiplication (`Mul M` and `Mul N`), every multiplicative equivalence `e` from `M` to `N` is surjective. In other words, for every element `n` of `N`, there exists an element `m` of `M` such that applying the equivalence `e` to `m` results in `n`. This means that the equivalence `e` maps every element of `M` onto some element of `N`, covering the entirety of `N`.

Given types `M` and `N` with multiplications, every multiplicative equivalence from `M` to `N` is a surjection.


theorem zpow_pos_of_pos : ∀ {α : Type u_1} [inst : LinearOrderedSemifield α] {a : α}, 0 < a → ∀ (n : ℤ), 0 < a ^ n := by
  sorry

This theorem states that for any type `α` that is a linearly ordered semifield, if `a` is a positive element of this type, then raising `a` to any integer power `n` will always result in a positive value. In other words, if `0 < a`, then `0 < a^n` for any integer `n`. This is essentially an extension of the mathematical fact that any positive number raised to any power is always positive.

For any linearly ordered semifield type `α` and positive element `a` of `α`, `0 < a` implies `0 < a^n` for all integers `n`.


theorem List.get?_map :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (n : ℕ),
      List.get? (List.map f l) n = Option.map f (List.get? l n) :=
  by sorry

The `List.get?_map` theorem states that for any type `α` and `β`, a function `f` from `α` to `β`, a list `l` of type `α`, and a natural number `n`, getting the nth element of the list obtained by mapping the function `f` over the list `l` is the same as mapping the function `f` over the nth element of the list `l`. In other words, the order in which you map a function over a list and get an element from the list does not matter.

For any type `α`, function `f` from `α` to `β`, list `l` of type `α`, and natural number `n`, `(get_n (List.map f l)) = (List.map f (get_n l))`.


theorem sign_zero :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableRel fun x x_1 => x < x_1],
      SignType.sign 0 = 0 :=
  by sorry

This theorem, `sign_zero`, states that for any type `α` that has a zero element and a preorder relation (i.e., a relation that is reflexive and transitive), and for which the relation `x < x_1` is decidable, the sign of the zero element is zero. In mathematical terms, it says that the sign of zero is zero.

If `α` is a type with a zero element and a decidable preorder relation where `x < x_1` holds, then the sign of the zero element is zero.


theorem Multiset.not_mem_zero : ∀ {α : Type u_1} (a : α), a ∉ 0 := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, `a` is not a member of the empty multiset (`0`). In other words, no element can be found in an empty multiset, regardless of its type.

For any type `α` and any empty multiset `M` of type `multiset α`, it is not the case that `a ∈ M` for any `a : α`.


theorem instCoeTCLatticeHom.proof_2 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : LatticeHomClass F α β] (f : F) (a b : α), f (a ⊓ b) = f a ⊓ f b :=
  by sorry

The theorem `instCoeTCLatticeHom.proof_2` states that for all types `F`, `α`, and `β`, if `F` is a type that can be injected into a function type from `α` to `β` (i.e., `F` is "function-like" from `α` to `β`), and if `α` and `β` are both lattices, and if `F` is a homomorphism from the lattice `α` to the lattice `β`, then for any instance `f` of `F` and any elements `a` and `b` of `α`, the image of the infimum (or meet) of `a` and `b` under `f` is equal to the infimum of the images of `a` and `b` under `f`. This is essentially saying that `f` preserves the infimum operation, a key property of lattice homomorphisms.

Given type `F` function-like from lattices `α` and `β` with `F` being a homomorphism, the infimum of the images of any two elements under `F` equals the image of their infimum.


theorem instCoeTCLatticeHom.proof_1 :
    ∀ {F : Type u_3} {α : Type u_2} {β : Type u_1} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
      [inst_3 : LatticeHomClass F α β] (f : F) (a b : α), f (a ⊔ b) = f a ⊔ f b :=
  by sorry

This theorem states that for any types `F`, `α`, and `β`, if `F` is a function-like from `α` to `β`, and both `α` and `β` are lattices, and if `F` is a lattice homomorphism class from `α` to `β`, then for any function `f` of type `F` and any elements `a` and `b` of the lattice `α`, the function `f` preserves the lattice join operation. In other words, applying `f` to the join (or supremum, denoted by `⊔`) of `a` and `b` is the same as taking the join of `f(a)` and `f(b)`. This means that `f` is a lattice homomorphism, preserving the structure of the lattice under the join operation.

If `F` is a function-like from lattice `α` to lattice `β` that is a lattice homomorphism, then for all `a, b ∈ α`, `F(a ⊔ b) = F(a) ⊔ F(b)`.


theorem PartialEquiv.map_source :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {x : α}, x ∈ e.source → ↑e x ∈ e.target := by sorry

This theorem states that for any given partial equivalence relation `e` between two types `α` and `β`, if an element `x` of type `α` belongs to the source set of the partial equivalence, then the image of `x` under the partial equivalence relation `e` belongs to the target set of `e`. In other words, the theorem ensures the well-definedness of the partial equivalence relation by confirming that the mapping of `x` is indeed within the target set of the partial equivalence relation.

For any partial equivalence relation `e` between types `α` and `β`, if `x ∈ α` and `x ≈ᵥ e y` for some `y ∈ β`, then `y ∈ β`.


/-- The diameter is monotonous with respect to inclusion  -/
theorem EMetric.diam_mono :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α}, s ⊆ t → EMetric.diam s ≤ EMetric.diam t := by sorry

The theorem `EMetric.diam_mono` states that in any pseudoemetric space `α`, the diameter of a set is monotonic with respect to inclusion. More specifically, given any two sets `s` and `t` of type `α`, if `s` is a subset of `t` (denoted by `s ⊆ t`), then the diameter of `s` is less than or equal to the diameter of `t`. Here, the diameter of a set is defined as the supremum of the distances between all pairs of points in the set.

In any pseudometric space, the diameter of a subset is less than or equal to the diameter of any larger set it is contained in.


AEMeasurable.nullMeasurable

theorem AEMeasurable.nullMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
      {f : α → β}, AEMeasurable f μ → MeasureTheory.NullMeasurable f μ :=
  by sorry

This theorem states that for any types `α` and `β`, given a measurable space `α` and a measure `μ` on that space, any function `f` from `α` to `β` that is almost everywhere measurable is also null measurable. In other words, if a function coincides almost everywhere with a measurable function (it is almost everywhere measurable), then the preimage of a measurable set under this function is a null measurable set.

If `f: α → β` is almost everywhere measurable and `μ` is a measure on `α`, then for any measurable set `A ∈ σ(`α`)`, the preimage `f⁻¹(A) ∈ σ(`β`), and `μ(A) = 0` implies `μ(f⁻¹(A)) = 0`.


theorem QuotientAddGroup.eq_zero_iff :
    ∀ {G : Type u} [inst : AddGroup G] {N : AddSubgroup G} [nN : AddSubgroup.Normal N] (x : G), ↑x = 0 ↔ x ∈ N := by
  sorry

This theorem, `QuotientAddGroup.eq_zero_iff`, states that for any type `G` that has an `AddGroup` instance, given any `AddSubgroup` `N` of `G` that is normal, and an element `x` of `G`, the coset of `x` is equal to zero if and only if `x` is an element of `N`. This is a statement in the context of quotient groups in group theory. In mathematical terms, it states that $x \equiv 0 (\mod N)$ if and only if $x \in N$ for an additive group $G$ and its normal subgroup $N$.

In an additive group G with a normal subgroup N, an element x belongs to N if and only if the coset of x is equal to the identity element. In other words, x ≡ 0 (mod N) if and only if x ∈ N.


theorem Nat.pred_le : ∀ (n : ℕ), Nat.pred n ≤ n := by sorry

This theorem states that for any natural number `n`, the predecessor of `n` is less than or equal to `n`. The predecessor of a natural number `n` is defined as `n - 1` or `0` if `n` is `0`. The theorem thus captures the intuitive idea that a number is always greater than or equal to its predecessor.

For all natural numbers n, 0 <= pred n, where pred denotes the predecessor function.


theorem continuous_iff_isClosed :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      Continuous f ↔ ∀ (s : Set Y), IsClosed s → IsClosed (f ⁻¹' s) :=
  by sorry

This theorem states that a function `f` between two topological spaces `X` and `Y` is continuous if and only if for every closed set `s` in `Y`, the preimage of `s` under `f` is a closed set in `X`. Here, a topological space is a set equipped with a notion of nearness or continuity, the function's preimage of a set is the set of all elements in the domain that map to the elements of that set, and a set is said to be closed if it contains all its limit points.

A function between two topological spaces is continuous if and for every closed set in the codomain, its preimage is a closed set in the domain.


theorem Ideal.eq_top_of_isUnit_mem :
    ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) {x : α}, x ∈ I → IsUnit x → I = ⊤ := by sorry

This theorem states that for every type `α` that has a semiring structure, given an ideal `I` in this semiring and an element `x` of `α`, if `x` is a unit and it belongs to `I`, then `I` must be the top ideal (which contains all elements of the semiring). In other words, if a unit is a member of a given ideal, that ideal is the entire semiring.

If `α` is a semiring, `I` is an ideal of `α`, `x` is a unit in `α` belonging to `I`, then `I` is the top ideal of `α`.


theorem Nat.not_le : ∀ {a b : ℕ}, ¬a ≤ b ↔ b < a := by sorry

This theorem states that for any two natural numbers `a` and `b`, `a` is not less than or equal to `b` if and only if `b` is strictly less than `a`. In other words, it establishes an equivalence between the negation of the "less than or equal to" relation and the "strictly less than" relation.

For natural numbers `a` and `b`, `a` is not less than or equal to `b` if and only if `b` is strictly less than `a`. Equivalently, `a < b` if and only if `a >= b` does not hold.


theorem Real.sin_periodic : Function.Periodic Real.sin (2 * Real.pi) := by sorry

The theorem `Real.sin_periodic` states that the real sine function is periodic with a period of `2 * Real.pi`. In other words, for any real number `x`, the value of `Real.sin(x + 2 * Real.pi)` is the same as the value of `Real.sin(x)`. This is in line with the well-known mathematical fact that the sine function repeats its values every `2π` radians.

The real sine function is periodic with a period of 2π, i.e., Real.sin(x + 2π) = Real.sin(x) for all real x.


theorem LinearEquiv.map_eq_zero_iff :
    ∀ {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₂) {x : M},
      e x = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any semirings `R` and `S`, additive commutative monoids `M` and `M₂`, modules `M` over `R`, `M₂` over `S`, ring homomorphisms `σ` from `R` to `S` and `σ'` from `S` to `R` that form a pair of inverse ring homomorphisms `re₁` and `re₂`, and a linear equivalence `e` from `M` to `M₂` that respects these structures, an element `x` in `M` is mapped to the zero of `M₂` by `e` if and only if `x` is the zero of `M`. This implies that the linear equivalence `e` preserves the zero of the module.

For any semirings R and S, additive commutative monoids M and M₂, modules M over R and M₂ over S, ring homomorphisms σ:R -> S and σ':S -> R that form a pair of inverse ring homomorphisms, and a linear equivalence e:M -> M₂ respecting these structures, e(x) = 0 in M₂ if and only if x = 0 in M.


theorem Finset.disjoint_singleton_left : ∀ {α : Type u_1} {s : Finset α} {a : α}, Disjoint {a} s ↔ a ∉ s := by sorry

This theorem states that for any type `α`, any finite set `s` of type `α`, and any element `a` of type `α`, the singleton set containing `a` is disjoint with `s` if and only if `a` is not an element of `s`. In terms of lattice theory, this means that if the greatest lower bound (infimum) of `a` and any element of `s` is the bottom element, then `a` does not belong to `s`.

For any type `α`, finite set `s` of type `α`, and element `a` of type `α`, the singleton set `{a}` is disjoint from `s` if and only if `a` is not in `s`. Equivalently, `a` and every element of `s` have no common lower bound in the lattice sense.


theorem TopologicalSpace.isBasis_countableBasis :
    ∀ (α : Type u) [t : TopologicalSpace α] [inst : SecondCountableTopology α],
      TopologicalSpace.IsTopologicalBasis (TopologicalSpace.countableBasis α) :=
  by sorry

The theorem `TopologicalSpace.isBasis_countableBasis` states that for all types `α` that have a topological space structure and a second countable topology, the countable basis defined for `α` is indeed a topological basis. In other words, the set of sets defined as the countable basis forms a topological basis for the topology on the type `α`. This is true for any space that has a second countable topology, which means that the topology has a countable basis.

For any second countable topological space `α`, its countable basis is a topological basis.


/-- Also known as the stability axiom.  -/
theorem CategoryTheory.GrothendieckTopology.pullback_stable :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {S : CategoryTheory.Sieve X}
      (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X),
      S ∈ J.sieves X → CategoryTheory.Sieve.pullback f S ∈ J.sieves Y :=
  by sorry

The theorem, known as the "pullback stability axiom", is an assertion in the context of Grothendieck topologies in category theory. Given a category `C`, objects `X` and `Y` in `C`, a morphism `f` from `Y` to `X`, a Grothendieck topology `J` on `C`, and a sieve `S` on `X`, if `S` is in the collection of sieves determined by the Grothendieck topology `J` at `X`, then the pullback of `S` along `f` is in the collection of sieves determined by `J` at `Y`. In essence, a Grothendieck topology is 'stable' under the operation of pulling back sieves along morphisms.

Given a Grothendieck topology J on a category C and morphisms f : Y -> X in C, if S is a sieve on X belonging to the topology J at X, then the pullback of S along f belongs to the topology J at Y.


theorem SeparationQuotient.surjective_mk :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], Function.Surjective SeparationQuotient.mk := by sorry

The theorem `SeparationQuotient.surjective_mk` states that for any type `X` that has a topology defined on it, the natural map from this topological space to its separation quotient is surjective. In other words, for every element in the separation quotient of a topological space, there exists an element in the original topological space that maps to it through the natural map. The separation quotient is defined via the equivalence relation of having the same closure.

For any topological space X, the natural map from X to its separation quotient is surjective. (Two elements in X map to the same point in the quotient if and only if they have the same closure.)


theorem FractionalIdeal.coeToSubmodule_injective :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
      Function.Injective fun I => ↑I :=
  by sorry

The theorem `FractionalIdeal.coeToSubmodule_injective` states that for any commutative ring `R`, any submonoid `S` of `R`, and any type `P` that is also a commutative ring and an algebra over `R`, the function that maps a fractional ideal `I` to its underlying submodule (denoted by `↑I`) is injective. In other words, if two fractional ideals of `R` give rise to the same submodule when considered as submodules of `P`, then the two fractional ideals were originally the same.

The map from fractional ideals of a commutative ring `R` to their underlying submodules in a commutative ring `P` is an injection.


theorem Nat.prime_of_mem_primeFactors : ∀ {n p : ℕ}, p ∈ n.primeFactors → Nat.Prime p := by sorry

The theorem `Nat.prime_of_mem_primeFactors` states that for all natural numbers `n` and `p`, if `p` is a member of the prime factorization of `n`, then `p` is a prime number. Here, the prime factorization of a number `n` is a list of prime numbers such that their product is `n`. The function `Nat.Prime p` checks if `p` is a prime number, i.e., a natural number at least 2 whose only divisors are `p` and `1`.

If a prime number `p` is a factor of natural number `n`, then `p` is a prime number.


theorem isBounded_le_nhds :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : BoundedLENhdsClass α] (a : α),
      Filter.IsBounded (fun x x_1 => x ≤ x_1) (nhds a) :=
  by sorry

The theorem `isBounded_le_nhds` states that for any type `α` with a preorder relation and a topological space structure, and assuming that the type `α` belongs to the `BoundedLENhdsClass` class, for any element `a` of type `α`, the neighborhood filter of `a` (denoted by `nhds a`) is eventually bounded with respect to the `≤` relation. In other words, there exists a uniform bound `b` such that eventually every element `x` in the neighborhood of `a` satisfies `x ≤ b`.

For any type `α` with a preorder relation and a topological space structure that belongs to `BoundedLENhdsClass`, every element `a` has a uniform bound `b` such that every neighborhood element `x` of `a` satisfies `x ≤ b`.


theorem NNReal.coe_one : ↑1 = 1 := by sorry

This theorem states that the coercion of the natural number 1 to the non-negative real numbers is equal to the real number 1. In simpler terms, converting 1 from a natural number to a non-negative real number doesn't change its numeric value, it remains 1.

The natural number 1 is equal to its coercion to the non-negative real numbers.


theorem pow_lt_pow_right :
    ∀ {R : Type u_3} [inst : StrictOrderedSemiring R] {a : R} {n m : ℕ}, 1 < a → m < n → a ^ m < a ^ n := by sorry

This theorem states that for any strictly ordered semi-ring `R` of a certain type `u_3`, and for any element `a` from `R`, along with two natural numbers `n` and `m`, if `a` is greater than 1 and `m` is less than `n`, then `a` raised to the power of `m` is less than `a` raised to the power of `n`. In other words, if we have a number greater than 1 and two different natural number exponents, with one smaller than the other, the smaller exponent will result in a smaller result when both are raised to the base number.

For any strictly ordered semiring `R` and `a` in `R` with `a > 1`, `m < n` implies `a^m < a^n`.


theorem MeasureTheory.measurePreserving_vadd :
    ∀ {M : Type v} {α : Type w} {m : MeasurableSpace α} [inst : MeasurableSpace M] [inst_1 : VAdd M α]
      [inst : MeasurableVAdd M α] (c : M) (μ : MeasureTheory.Measure α)
      [inst : MeasureTheory.VAddInvariantMeasure M α μ], MeasureTheory.MeasurePreserving (fun x => c +ᵥ x) μ μ :=
  by sorry

This theorem states that for any type `M` and `α` with a measurable space `m` and `inst`, if `α` is endowed with the vector addition operation and `M` and `α` have the property of being measurable with respect to vector addition, then the measure `μ` is preserved under the translation operation by a constant `c`. In other words, the addition of a constant to every element in the set does not change the measure of the set, assuming that the measure is invariant under the vector addition operation.

Given a measurable space `(M, Σ, m)` and a measurable type `α` with vector addition, if `μ: Σ → ℝ` is a measure invariant under vector addition, then for all `c ∈ α` and `A ∈ Σ`, we have `μ(A) = μ(A + c)`.


theorem Basis.coe_mk :
    ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
      [inst_2 : Module R M] (hli : LinearIndependent R v) (hsp : ⊤ ≤ Submodule.span R (Set.range v)),
      ⇑(Basis.mk hli hsp) = v :=
  by sorry

The theorem `Basis.coe_mk` states that for any type `ι`, ring `R`, and additively commutative group `M`, if we have a function `v` from `ι` to `M` such that `v` is a linearly independent family of vectors over `R` and the span of the range of `v` is the entire module `M`, then the function returned by the constructor `Basis.mk` for these inputs is exactly the function `v`. This essentially means that `v` is a basis for the module `M`.

If `v : ι → M` is a linearly independent family of vectors over a ring `R` whose span equals `M`, then `Basis.mk ι R M v` is equal to `v`.


MeasureTheory.Integrable.smul

theorem MeasureTheory.Integrable.smul :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {𝕜 : Type u_5} [inst_1 : NormedAddCommGroup 𝕜] [inst_2 : SMulZeroClass 𝕜 β] [inst_3 : BoundedSMul 𝕜 β] (c : 𝕜)
      {f : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable (c • f) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.smul` states that, for any given measurable space `α`, a measure `μ` on `α`, a normed additive commutative group `β`, a type `𝕜` which forms a normed additive commutative group and has a scalar multiplication with `β` that is both zero-preserving and bounded, and any scalar `c` of type `𝕜`, if a function `f` from `α` to `β` is integrable with respect to the measure `μ`, then the function obtained by scalar multiplication of `f` by `c` is also integrable with respect to the same measure `μ`. In mathematical terms, this theorem asserts that the integrability property is preserved under scalar multiplication in the context of measure theory.

If `f` is an integrable function from a measurable space `(α, μ)` to a normed additive commutative group `β`, and `c` is a scalar in a normed additive commutative group `𝕜` with scalar multiplication preserving integrability, then `c • f` is an integrable function.


theorem Set.prod_singleton : ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {b : β}, s ×ˢ {b} = (fun a => (a, b)) '' s :=
  by sorry

The `Set.prod_singleton` theorem in Lean 4 states that for any set `s` of a particular type `α`, and any element `b` of another type `β`, the Cartesian product of `s` and the set containing only `b` (`s ×ˢ {b}`) is equal to the image of `s` under the function that pairs each element of `s` with `b` (`(fun a => (a, b)) '' s`). In other words, it states that the set of all pairs where the first element is from `s` and the second element is `b`, is the same as the set of all pairs generated by applying the pairing function to each element of `s`.

The Cartesian product of a set `s` with a singleton set `{b}` is equal to the image of `s` under the function that pairs each element of `s` with `b`.


theorem MeasureTheory.lintegral_eq_zero_iff' :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      AEMeasurable f μ → (∫⁻ (a : α), f a ∂μ = 0 ↔ f =ᶠ[MeasureTheory.Measure.ae μ] 0) :=
  by sorry

This theorem states that for any given measurable space `α`, measure `μ` on that space, and a function `f` from `α` to the extended nonnegative real numbers (usually denoted [0, ∞]), if the function `f` is almost everywhere measurable, then the Lebesgue integral (denoted ∫⁻ (a : α), f a ∂μ) of `f` with respect to measure `μ` is equal to 0 if and only if the function `f` is almost everywhere equal to 0 (with respect to the same measure `μ`). In other words, the Lebesgue integral of an almost everywhere measurable function is zero exactly when the function is zero almost everywhere.

The Lebesgue integral of an almost everywhere measurable function equals 0 if and only if the function is almost everywhere equal to 0.


theorem Ultrafilter.of_le : ∀ {α : Type u} (f : Filter α) [inst : Filter.NeBot f], ↑(Ultrafilter.of f) ≤ f := by sorry

This theorem states that for any type `α` and any filter `f` on `α` that is not the bottom filter, the ultrafilter extending `f` is less than or equal to `f`. In other words, every set in the ultrafilter (obtained using the function `Ultrafilter.of`) is also a set in the original filter `f`.

For any filter `f` on type `α` that is not the bottom filter, every set in the ultrafilter obtained from `f` using `Ultrafilter.of` is contained in `f`.


PrimeSpectrum.ext

theorem PrimeSpectrum.ext :
    ∀ {R : Type u} {inst : CommSemiring R} (x y : PrimeSpectrum R), x.asIdeal = y.asIdeal → x = y := by sorry

This theorem states that for any commutative semiring `R`, if two elements `x` and `y` of the prime spectrum of `R` have equivalent ideals (i.e., `x.asIdeal = y.asIdeal`), then `x` and `y` are the same element. In other words, in the context of a commutative semiring, the prime spectrum mapping is injective with respect to the ideals of the elements.

In a commutative semiring, two elements have equal prime spectra if and only if they are equal as elements.


theorem Thunk.sizeOf_eq : ∀ {α : Type u_1} [inst : SizeOf α] (a : Thunk α), sizeOf a = 1 + sizeOf (Thunk.get a) := by
  sorry

This theorem, `Thunk.sizeOf_eq`, states that for any type `α` equipped with a `SizeOf` instance and for any thunk `a` of type `Thunk α`, the size of `a` is equal to one plus the size of the value obtained by applying `Thunk.get` to `a`. In other words, the total size of a thunk includes 1 for the thunk itself, and the size of the actual value it computes.

For any type `α` with `SizeOf` instance and `Thunk α` value `a`, `SizeOf.eq (Thunk.sizeOf a) (1 + SizeOf.of (Thunk.get a))`.


theorem Polynomial.mem_degreeLT :
    ∀ {R : Type u} [inst : Semiring R] {n : ℕ} {f : Polynomial R},
      f ∈ Polynomial.degreeLT R n ↔ Polynomial.degree f < ↑n :=
  by sorry

This theorem states that for any semiring `R`, a natural number `n`, and a polynomial `f` of type `R`, the polynomial `f` is a member of the `R`-submodule of `R[X]` consisting of polynomials of degree less than `n` (denoted as `Polynomial.degreeLT R n`) if and only if the degree of the polynomial `f` (denoted as `Polynomial.degree f`) is less than `n`. Here, the degree of a polynomial is the largest `X`-exponent in the polynomial, or equivalently, the highest power of `X` that appears in the polynomial.

For any semiring R, natural number n, and polynomial f over R in one variable X, the polynomial f belongs to the submodule of polynomials of degree less than n if and only if the degree of f is less than n.


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

The theorem `Set.preimage_inter` states that, for all types `α` and `β`, a function `f` from `α` to `β`, and any two sets `s` and `t` of `β`, the preimage of the intersection of `s` and `t` under `f` is the same as the intersection of the preimages of `s` and `t` under `f`. In other words, if we have a function `f` and two sets `s` and `t`, then the elements in `α` that `f` maps to both `s` and `t` are the same as the elements that `f` maps to `s` and also the elements that `f` maps to `t`.

For all types `α` and `β`, functions `f` from `α` to `β`, and sets `s` and `t` of `β`, `f⁻¹(s ∩ t) = f⁻¹(s) ∩ f⁻¹(t)`.


/-- The **triangle inequality** in `LinearOrderedAddCommGroup`s.  -/
theorem abs_add : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] (a b : α), |a + b| ≤ |a| + |b| := by sorry

This is the triangle inequality theorem for LinearOrderedAddCommGroups. For any type `α` that is a LinearOrderedAddCommGroup, and any two elements `a` and `b` of this type, the absolute value of the sum of `a` and `b` is less than or equal to the sum of the absolute values of `a` and `b`. In mathematical terms, this theorem states that \(|a + b| ≤ |a| + |b|\), a fundamental property of distances on the number line or in geometric spaces.

For any element `a` and `b` in a LinearOrderedAddCommGroup `α`, the absolute difference of their sum and the sum of their absolute values is non-negative: `|a + b| ≤ |a| + |b|`.


CategoryTheory.CommaMorphism.ext

theorem CategoryTheory.CommaMorphism.ext :
    ∀ {A : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} A} {B : Type u₂}
      {inst_1 : CategoryTheory.Category.{v₂, u₂} B} {T : Type u₃} {inst_2 : CategoryTheory.Category.{v₃, u₃} T}
      {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L R}
      (x y : CategoryTheory.CommaMorphism X Y), x.left = y.left → x.right = y.right → x = y :=
  by sorry

This theorem states that in category theory, given any two categories `A` and `B` with another category `T`, and two functors `L` from `A` to `T` and `R` from `B` to `T`, for any two objects `X` and `Y` in the comma category formed by `L` and `R`, if we have two morphisms `x` and `y` from `X` to `Y` in the comma category, then `x` and `y` are equal if and only if their left and right components are equal. This is essentially asserting that a morphism in the comma category is uniquely determined by its two components.

In category theory, given functors L from category A to T and R from category B to T, morphisms x and y in the comma category L,R := {(f : A → T) | ∃ g : B → T, L(g)(f) = R(h)(f) for some h : B → A} are equal if and only if their left and right components are equal.


/-- **Alias** of `Int.natCast_ne_zero_iff_pos`. -/
theorem Int.coe_nat_ne_zero_iff_pos : ∀ {n : ℕ}, ↑n ≠ 0 ↔ 0 < n := by sorry

This theorem, `Int.coe_nat_ne_zero_iff_pos`, is essentially an alias of `Int.natCast_ne_zero_iff_pos`. It asserts a bi-conditional relationship between a natural number `n` not being 0 when cast to an integer and `n` being greater than 0. In other words, a natural number `n` is greater than 0 if and only if `n` is not equal to 0 when converted to an integer.

A natural number `n` is greater than 0 if and only if the integer `n` is not equal to 0.


theorem Real.rpow_logb : ∀ {b x : ℝ}, 0 < b → b ≠ 1 → 0 < x → b ^ Real.logb b x = x := by sorry

The theorem `Real.rpow_logb` states that for all real numbers `b` and `x`, if `b` is positive, `b` is not equal to `1`, and `x` is positive, then raising `b` to the power of the logarithm base `b` of `x` is equal to `x`. In mathematical notation, this can be written as: for all real numbers `b` and `x`, if `b > 0`, `b ≠ 1`, and `x > 0`, then `b^(log_b(x)) = x`.

For all positive real numbers `x` and `b` not equal to 1, `b^(log_b x) = x`.


/-- The distance equals the norm of subtracting two points. In this
lemma, it is necessary to have `V` as an explicit argument; otherwise
`rw dist_eq_norm_vsub'` sometimes doesn't work.  -/
theorem dist_eq_norm_vsub' :
    ∀ (V : Type u_2) {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] (x y : P), dist x y = ‖y -ᵥ x‖ :=
  by sorry

This theorem states that the distance between two points, `x` and `y`, in a pseudometric space `P` over a seminormed additive commutative group `V` (which is also a normed additive torsor) is equal to the norm of the vector obtained by subtracting `x` from `y`. It's important to explicitly specify `V` as an argument in this theorem, as without it, rewriting using `dist_eq_norm_vsub'` may sometimes fail.

In a pseudometric space over a seminormed additive commutative group, the distance between two points is equal to the norm of their difference.


theorem Ideal.span_singleton_eq_bot : ∀ {α : Type u} [inst : Semiring α] {x : α}, Ideal.span {x} = ⊥ ↔ x = 0 := by sorry

The theorem `Ideal.span_singleton_eq_bot` asserts that for any type `α` which forms a semiring, for any element `x` of type `α`, the ideal generated by the singleton set `{x}` is the bottom element (i.e., the zero ideal) if and only if `x` is zero. In other words, an ideal in a semiring constructed from just one element `{x}` is the zero ideal precisely when that element `x` is zero itself.

For any semiring type `α`, the ideal generated by a single element `x` in `α` is the zero ideal if and only if `x` is the additive identity of `α`.


/-- `Infinite α` is not `Finite` -/
theorem not_finite : ∀ (α : Sort u_3) [inst : Infinite α] [inst : Finite α], False := by sorry

This theorem states that a type `α` cannot be both `Infinite` and `Finite` at the same time. In other words, it's impossible for a type to simultaneously possess both the `Infinite` and `Finite` properties. This theorem is a contradiction, meaning that if you assume that a type is both `Infinite` and `Finite`, you will end up with a contradiction (denoted by `False` in Lean).

A type cannot be both infinite and finite.


theorem Mathlib.Combinatorics.SimpleGraph.Clique._auxLemma.7 :
    ∀ {α : Type u_1} (G : SimpleGraph α) {n : ℕ} {s : Finset α},
      SimpleGraph.IsNClique G n s = (SimpleGraph.IsClique G ↑s ∧ s.card = n) :=
  by sorry

The theorem `_auxLemma.7` states that for any simple graph `G` of type `α`, and for any finite set `s` of vertices in `G` and a natural number `n`, the predicate `IsNClique G n s` holds true if and only if two conditions are met: firstly, `s` is a clique in `G` (meaning that every pair of distinct vertices in `s` are adjacent in `G`), and secondly, the number of vertices in the set `s` equals `n`. In other words, `s` is a clique of size `n` in the graph `G`.

A finite subset of vertices in a simple graph is a clique of size n if and only if it is a clique and has exactly n elements.