theorem zsmul_eq_mul : ∀ {α : Type u_3} [inst : Ring α] (a : α) (n : ℤ), n • a = ↑n * a := by sorry

This theorem states that for every type `α` that forms a ring and for every element `a` of type `α` and integer `n`, the operation of "scalar multiplication" (`n • a`) is equivalent to converting `n` into the ring type and then performing ring multiplication (`↑n * a`). Essentially, it says that scalar multiplication by an integer in a ring is the same as ring multiplication.

For every ring `α` and integer `n`, scalar multiplication `n • a` equals ring multiplication `↑n * a` for all `a` in `α`.


theorem MeasureTheory.measure_mono_null :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
      s₁ ⊆ s₂ → ↑↑μ s₂ = 0 → ↑↑μ s₁ = 0 :=
  by sorry

The theorem `MeasureTheory.measure_mono_null` states that for any type `α` that forms a measurable space, given a measure `μ` over this space and any two sets `s₁` and `s₂` of `α`, if `s₁` is a subset of `s₂` and the measure of `s₂` is zero, then the measure of `s₁` is also zero. In mathematical terms, if $s₁ \subseteq s₂$ and $\mu(s₂) = 0$ then $\mu(s₁) = 0$. It essentially provides a monotonicity property for measures in a measure space where null sets are inherited by their subsets.

If `μ` is a measure on a measurable space `α` and `s₁ ⊆ s₂` with `μ(s₂) = 0`, then `μ(s₁) = 0`. In mathematical notation, `∀ α μ (s₁ s₂ : set α) [measurable_space α μ], s₁ ⊆ s₂ → μ s₂ = 0 → μ s₁ = 0`.


theorem add_left_injective :
    ∀ {G : Type u_3} [inst : Add G] [inst_1 : IsRightCancelAdd G] (a : G), Function.Injective fun x => x + a := by sorry

The theorem `add_left_injective` states that for any type `G` which has an addition operation and possesses the right cancellation property with respect to addition, the function that adds a fixed element `a` from `G` to its input is injective. In other words, if for any two elements `x` and `y` of `G`, `x + a = y + a` implies `x = y`. This theorem essentially captures the idea that if adding a certain number doesn't change the uniqueness of the sum, then the original numbers were unique.

For any additive type `G` with right cancellation property, the function `x => x + a` is injective.


theorem Set.iInter_exists :
    ∀ {α : Type u_1} {ι : Sort u_4} {p : ι → Prop} {f : Exists p → Set α},
      ⋂ (x : Exists p), f x = ⋂ i, ⋂ (h : p i), f ⋯ :=
  by sorry

This theorem states that for any type `α` and any predicate `p` on a sort `ι`, the intersection over all sets `f x` where `x` satisfies `Exists p`, is equal to the intersection over all `i` and for each `i`, the intersection over all `h` that satisfy `p i` of `f h`. In other words, it says that intersecting over all existing `x` that satisfy a predicate `p` is the same as intersecting over all `i` and then intersecting over all `h` that satisfy `p i`.

For any type `α` and predicate `p` on a sort `ι`, the intersection of `{f x | ∃ (x : α), p x}` is equal to the intersection of `{⋈ {i : ι} {h : i | p i} | f h}` where `⋈` denotes set intersection.


theorem Pi.single_eq_same :
    ∀ {I : Type u} {f : I → Type v₁} [inst : DecidableEq I] [inst_1 : (i : I) → Zero (f i)] (i : I) (x : f i),
      Pi.single i x i = x :=
  by sorry

The theorem `Pi.single_eq_same` states that for any type `I` and a type-valued function `f` on `I`, given that `I` has decidable equality and each type `f i` for `i` in `I` has a defined zero, for any element `i` of `I` and an element `x` of type `f i`, the function `Pi.single i x` evaluated at `i` is equal to `x`. In other words, if we define a function using `Pi.single` where the function is supposed to be `x` at index `i` and zero elsewhere, then indeed, the function's value at `i` is `x`.

For any type `I` with decidable equality, and a function `f` from `I` to a type with defined zero for each `i`, the element-wise application of `Pi.single i x` and `x` coincides for all `i` in `I`.


theorem one_add_one_eq_two : ∀ {α : Type u_1} [inst : AddMonoidWithOne α], 1 + 1 = 2 := by sorry

This theorem states that in any type `α` that is an additive monoid with a unit (`AddMonoidWithOne`), the sum of `1` and `1` equals `2`. An additive monoid with a unit is a mathematical structure that includes an addition operation and a distinguished element called `1` that serves as an "identity element" for multiplication. Thus, the theorem can be thought of as formalizing the intuitive notion that "one plus one equals two" in this general context.

In an additive monoid with a unit, the sum of two units is equal to the monoid's unit element with multiplicity two. (Or, more simply: In an additive monoid with a unit, 1 + 1 = 2.)


theorem not_le_of_gt : ∀ {α : Type u} [inst : Preorder α] {a b : α}, a > b → ¬a ≤ b := by sorry

This theorem, `not_le_of_gt`, states that for any preordered type `α` and any two elements `a` and `b` of that type, if `a` is greater than `b`, then it cannot be the case that `a` is less than or equal to `b`. In mathematical terms, it says that if `a > b` then it is not possible that `a ≤ b` for any `a` and `b` in a given preordered set.

For any preordered type `α` and elements `a` and `b` in `α`, if `a > b` then `a ≤ b` is false.


theorem Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.7 :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) := by sorry

This theorem, `Mathlib.Topology.MetricSpace.PseudoMetric._auxLemma.7`, states that for any type `α` endowed with a pseudo-metric space structure, and for any elements `x` and `y` of this type, along with a real number `ε`, the proposition "the point `y` lies in the ε-ball centered at `x`" is equivalent to the proposition "the distance from `y` to `x` is less than `ε`". Here, `Metric.ball x ε` defines the ε-ball around `x`, meaning the set of all points that are less than `ε` distance away from `x`.

For any pseudo-metric space `(α, d)`, and for all `x, y : α` and `ε : ℝ`, the point `y` lies in the `ε`-ball `Metric.ball x ε` if and only if the distance `d(x y)` between `x` and `y` is less than `ε`.


theorem Finset.mul_sum :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : NonUnitalNonAssocSemiring α] (s : Finset ι) (f : ι → α) (a : α),
      (a * Finset.sum s fun i => f i) = Finset.sum s fun i => a * f i :=
  by sorry

The theorem `Finset.mul_sum` states that for any index type `ι`, any type `α` which forms a `NonUnitalNonAssocSemiring` (a type of algebraic structure with addition and multiplication operations), any finite set `s` of type `ι`, any function `f` from `ι` to `α`, and any value `a` of type `α`, the operation of multiplying `a` with the sum of the values of `f` over all elements in `s` is the same as first multiplying `a` with each value of `f(i)` for each `i` in `s` and then taking the sum of all these products. In mathematical terms, this means that `a * Σ(f(i) for i in s) = Σ(a * f(i) for i in s)`. This theorem is essentially a version of the distributive law for sums over finite sets in a non-unital, non-associative semiring.

For any non-unital, non-associative semiring `α`, finite set `s` of index type `ι`, function `f` from `ι` to `α`, and value `a` of type `α`, we have `a * Σ(f(i): ι → α | i ∈ s) = Σ(a * f(i) | i ∈ s)`.


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

This theorem states that for any type `α` that forms a Heyting Algebra, any element `a` of that type is disjoint with its complement `aᶜ`. In other words, for every element `x` that is less than or equal to `a` and less than or equal to `aᶜ`, `x` must also be less than or equal to the bottom element of the algebra. In the context of lattice theory, the bottom element is often represented as `⊥`, and this theorem essentially says that the meet (greatest lower bound) of `a` and `aᶜ` is `⊥`, generalizing the concept of disjoint sets.

In a Heyting Algebra, for all elements `a`, `a` and `a`'s complement `aᶜ` have an empty meet, that is, there does not exist any element that is less than or equal to both `a` and `a`'s complement.


theorem Equiv.self_comp_symm : ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), ⇑e ∘ ⇑e.symm = id := by sorry

This theorem states that for any types `α` and `β`, and for any equivalence `e` between `α` and `β`, the composition of `e` and its inverse (i.e., `e.symm`) is equivalent to the identity function. In mathematical terms, given any equivalence `e : α ≃ β`, applying `e` and then its inverse will yield the original element, exactly as if the identity function had been applied. This is a restatement of one of the fundamental properties of bijective (invertible) functions.

For any equivalence `e : α ≃ β`, `e * e.symm` is equal to the identity function `id : α → α` (or `id : β → β`).


theorem mul_inv_self : ∀ {G : Type u_1} [inst : Group G] (a : G), a * a⁻¹ = 1 := by sorry

This theorem states that for any element 'a' in a group 'G', the product of 'a' and its inverse 'a⁻¹' equals the identity element '1'. This is a fundamental property of groups in abstract algebra, where every element has an inverse such that multiplying the element and its inverse always gives the identity element.

In a group, the product of any element and its inverse is the identity element.


theorem mul_right_comm : ∀ {G : Type u_3} [inst : CommSemigroup G] (a b c : G), a * b * c = a * c * b := by sorry

The theorem `mul_right_comm` states that for any type `G` that is a commutative semigroup, and for any three elements `a`, `b`, and `c` of this type, the statement `a * b * c = a * c * b` holds true. In other words, within a commutative semigroup, if you multiply three elements together, the result stays the same even if you swap the last two elements.

In a commutative semigroup, the order of multiplication of three elements does not affect the result: `a * b * c = a * c * b`.


theorem Matrix.det_mul :
    ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
      (M N : Matrix n n R), Matrix.det (M * N) = Matrix.det M * Matrix.det N :=
  by sorry

This theorem states that, for any type `n` with decidable equality and finite number of elements, and any commutative ring `R`, the determinant of the product of two matrices `M` and `N` (whose entries are in `R` and both are indexed by `n`) is equal to the product of the determinants of `M` and `N`. In other words, it formalizes the well-known property from linear algebra: if `M` and `N` are square matrices, then `det(M * N) = det(M) * det(N)`.

For any commutative ring R and finite type n with decidable equality, the determinant of the product of two n x n matrices over R is equal to the product of their determinants.


theorem LE.le.le_iff_eq : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → (b ≤ a ↔ b = a) := by sorry

This theorem states that for any given type `α` with a partial order, and for any two elements `a` and `b` of this type such that `a` is less than or equal to `b`, then `b` is less than or equal to `a` if and only if `b` is equal to `a`. Essentially, in a partial order, when `a` is not strictly greater than `b`, the only way for `b` to be not strictly greater than `a` is for `b` and `a` to be equal.

In a partial order, for all types `α` and elements `a` and `b` of `α`, if `a` is less than or equal to `b` and `b` is not strictly greater than `a`, then `a` and `b` are equal.


Iff.and

/-- **Alias** of `and_congr`. -/
theorem Iff.and : ∀ {a c b d : Prop}, (a ↔ c) → (b ↔ d) → (a ∧ b ↔ c ∧ d) := by sorry

This theorem, `Iff.and`, states that for any four properties `a`, `b`, `c` and `d`, if `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then the conjunction `a ∧ b` is logically equivalent to the conjunction `c ∧ d`. In other words, if the logical relationships between `a` and `c` and between `b` and `d` are preserved, then the same holds for their conjunctions.

If `a` is logically equivalent to `c` and `b` is logically equivalent to `d`, then `a ∧ b` is logically equivalent to `c ∧ d`.


theorem CategoryTheory.Discrete.functor_map_id :
    ∀ {J : Type v₁} {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C]
      (F : CategoryTheory.Functor (CategoryTheory.Discrete J) C) {j : CategoryTheory.Discrete J} (f : j ⟶ j),
      F.map f = CategoryTheory.CategoryStruct.id (F.obj j) :=
  by sorry

The theorem `CategoryTheory.Discrete.functor_map_id` states that for any given type `J`, type `C` which forms a category, and a functor `F` from the discrete category on `J` to `C`, any morphism `f` from an object `j` to itself in the discrete category gets mapped to the identity morphism on the object `F.obj j` in category `C`. In other words, this theorem ensures that the functor `F` preserves the identity morphisms of the discrete category.

Given a functor F from the discrete category on J to category C, for all objects j in J and their identity morphisms id\_j, F(id\_j) = id\_{F.obj j} in C.


Continuous.sub

theorem Continuous.sub :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G]
      [inst_3 : TopologicalSpace α] {f g : α → G}, Continuous f → Continuous g → Continuous fun x => f x - g x :=
  by sorry

This theorem states that for any two functions `f` and `g` from a topological space `α` to another topological space `G`, if `f` and `g` are both continuous, then the function that subtracts the output of `g` from the output of `f` (for any input `x`) is also continuous. This is under the conditions that `G` has a subtraction operation and that subtraction is continuous. In mathematical terms, if `f` and `g` are continuous functions from `α` to `G`, and `G` is a topological algebra where subtraction is a continuous operation, then `(f - g)` is also a continuous function from `α` to `G`.

If `f` and `g` are continuous functions from a topological space `α` to a topological algebra `G` where subtraction is continuous, then the function `x ↦ f(x) - g(x)` is continuous from `α` to `G`.


theorem Nat.pow_succ : ∀ (n m : ℕ), n ^ Nat.succ m = n ^ m * n := by sorry

This theorem states that for all natural numbers `n` and `m`, the power of `n` to the successor of `m` (`n` to the power of `m + 1`) is equal to the result of `n` to the power of `m` multiplied by `n`. In mathematical terms, it's saying that $n^{m + 1} = n^m * n$ for all natural numbers `n` and `m`.

For all natural numbers `n` and `m`, `n^(m + 1)` equals `n^m * n`.


theorem min_le_right : ∀ {α : Type u} [inst : LinearOrder α] (a b : α), min a b ≤ b := by sorry

This theorem states that for any type `α` that has a linear order, the minimum of any two elements `a` and `b` of this type is always less than or equal to `b`. This is a general property of minimum operations in ordered types.

For any type `α` with a linear order, the minimum element is less than or equal to any other element.


ZMod.card

theorem ZMod.card : ∀ (n : ℕ) [inst : Fintype (ZMod n)], Fintype.card (ZMod n) = n := by sorry

The theorem `ZMod.card` states that for any natural number `n`, given that the set of integers modulo `n` (denoted as `ZMod n`) is a finite set (indicated by `[inst : Fintype (ZMod n)]`), the number of elements in this set, or its 'cardinality' (given by `Fintype.card (ZMod n)`), is equal to `n` itself. In other words, the set of integers modulo `n` has exactly `n` distinct elements.

The theorem `ZMod.card` asserts that the cardinality of the set of integers modulo a natural number `n` is equal to `n`, provided that `ZMod n` is a finite type.


theorem Finset.subset_univ : ∀ {α : Type u_1} [inst : Fintype α] (s : Finset α), s ⊆ Finset.univ := by sorry

This theorem states that for any finite type `α` and any finite set `s` of type `α`, `s` is a subset of the universal finite set of type `α`. In other words, any finite set is always a subset of the universe set for that type.

For any finite type `α` and finite set `s` of type `α`, `s` is a subset of the universal set of type `α`.


theorem Set.union_singleton : ∀ {α : Type u} {a : α} {s : Set α}, s ∪ {a} = insert a s := by sorry

This theorem states that for any set `s` of a given type `α` and any element `a` of type `α`, the union of `s` and the singleton set containing `a` is equivalent to inserting `a` into `s`. Here, the `insert a s` operation signifies the addition of the element `a` to the set `s`, and the `∪` symbol denotes the union operation between two sets.

For any set `s` of type `α` and any element `a` of type `α`, the union of `s` and the singleton set `{a}` is equal to the set `insert a s`.


theorem CategoryTheory.Iso.inv_comp_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
      CategoryTheory.CategoryStruct.comp α.inv f = g ↔ f = CategoryTheory.CategoryStruct.comp α.hom g :=
  by sorry

This theorem is about the composition of morphisms in a category theory context. It states that for any category `C`, and any objects `X`, `Y`, `Z` in `C`, given an isomorphism `α` from `X` to `Y` and morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the composition of the inverse of `α` and `f` is equal to `g` if and only if `f` is equal to the composition of `α` and `g`. In simpler terms, if you can get from `X` to `Z` by first following the reverse of `α` and then `f`, this is the same as going directly from `Y` to `Z` using `g`. Likewise, going from `X` to `Z` using `f` is the same as first transforming `X` to `Y` using `α` and then going to `Z` using `g`.

In a category `C`, given objects `X`, `Y`, `Z`, an isomorphism `α: X ≅ Y`, and morphisms `f: X → Z`, `g: Y → Z`, the following are equivalent: `f = g ∘ α` and `g = f ∘ α^−1`.


theorem Set.Icc_self : ∀ {α : Type u_1} [inst : PartialOrder α] (a : α), Set.Icc a a = {a} := by sorry

This theorem is stating that for any given type `α` which is a partial order, the left-closed and right-closed interval from a value `a` to itself, denoted as `Set.Icc a a`, is simply a set containing the single element `a`. In other words, the interval between a number and itself in a partial order only contains that number.

For any partial order type `α`, the interval `Set.Icc a a` consists of exactly the element `a`.


theorem Set.piecewise_eq_of_mem :
    ∀ {α : Type u_1} {δ : α → Sort u_6} (s : Set α) (f g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] {i : α},
      i ∈ s → Set.piecewise s f g i = f i :=
  by sorry

The theorem `Set.piecewise_eq_of_mem` states that for any type `α`, any dependent type `δ` that depends on `α`, any set `s` of type `α`, any two functions `f` and `g` from `α` to `δ`, and any instance of a decidable predicate that determines whether an element of `α` is in the set `s`, if an element `i` from `α` is in the set `s`, then the piecewise function defined by `s`, `f`, and `g` at `i` is equal to the function `f` at `i`. In other words, when an element is a member of the specified set, the piecewise function behaves exactly as the function `f`.

If `i` is an element of set `s` in type `α`, then the piecewise function `(λ x, if h : x ∈ s then f x else g x)` equals function `f` at `i`.


/-- In a linearly ordered monoid, we are happy for `bot_eq_zero` to be a `@[simp]` lemma -/
theorem bot_eq_zero' : ∀ {α : Type u} [inst : CanonicallyLinearOrderedAddCommMonoid α], ⊥ = 0 := by sorry

This theorem states that in any canonically linearly ordered additive commutative monoid, the bottom element is equal to zero. In other words, for any type `α` that has a structure of a canonically linearly ordered additive commutative monoid, the lowest possible value or the smallest element (`⊥`) is always zero (`0`).

In any canonically linearly ordered additive commutative monoid, the least element is equal to zero.


ArithmeticFunction.ext

theorem ArithmeticFunction.ext :
    ∀ {R : Type u_1} [inst : Zero R] ⦃f g : ArithmeticFunction R⦄, (∀ (x : ℕ), f x = g x) → f = g := by sorry

This theorem states that for any type `R` which has a zero element, if `f` and `g` are arithmetic functions from natural numbers to `R` (meaning they map 0 to 0), then `f` and `g` are identical if and only if they assign the same value to each natural number. In other words, two arithmetic functions are considered equal if they produce the same output for every natural number input.

For any type `R` with a zero element, two arithmetic functions `f` and `g` from natural numbers to `R` are equal if and only if they agree on all natural numbers, i.e., `∀n, f n = g n`.


theorem MeasurableSpace.generateFrom_le :
    ∀ {α : Type u_1} {s : Set (Set α)} {m : MeasurableSpace α},
      (∀ t ∈ s, MeasurableSet t) → MeasurableSpace.generateFrom s ≤ m :=
  by sorry

The theorem `MeasurableSpace.generateFrom_le` states that for any type `α`, any set `s` of sets of `α`, and any measurable space `m` of `α`, if every set `t` in `s` is a measurable set, then the smallest measure space generated from `s` is less than or equal to `m`. In other words, this theorem ensures that if a set of sets satisfies the property of being measurable, the measure space generated by this set is contained in any other measure space in which the sets are measurable.

For any type `α`, any set `s` of measurable subsets of `α`, and any measurable space `m` on `α`, the smallest measurable space generated from `s` is a sub-measure space of `m`.


CategoryTheory.Limits.pushout.condition

theorem CategoryTheory.Limits.pushout.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPushout f g],
      CategoryTheory.CategoryStruct.comp f CategoryTheory.Limits.pushout.inl =
        CategoryTheory.CategoryStruct.comp g CategoryTheory.Limits.pushout.inr :=
  by sorry

The theorem `CategoryTheory.Limits.pushout.condition` asserts that, for any category `C` and any three objects `X`, `Y`, and `Z` in `C`, and morphisms `f : X ⟶ Y` and `g : X ⟶ Z` that have a pushout, the composition of `f` with the first inclusion `CategoryTheory.Limits.pushout.inl` is equal to the composition of `g` with the second inclusion `CategoryTheory.Limits.pushout.inr`. In other words, if you first apply `f` and then include the result into the pushout, you get the same thing as if you first apply `g` and then include that result into the pushout. This captures one of the defining properties of a pushout in category theory.

Given any category `C`, objects `X`, `Y`, `Z`, morphisms `f : X ⟶ Y`, `g : X ⟶ Z` with a pushout, the diagram commutes: `f ∘ CategoryTheory.Limits.pushout.inl = CategoryTheory.Limits.pushout.inr ∘ g`.


theorem dvd_trans : ∀ {α : Type u_1} [inst : Semigroup α] {a b c : α}, a ∣ b → b ∣ c → a ∣ c := by sorry

This theorem, `dvd_trans`, states that for any type `α` that is a semigroup, if one element `a` divides another element `b`, and `b` divides a third element `c`, then `a` also divides `c`. This is the principle of transitivity applied to the "divides" relation in a semigroup.

If `a` divides `b` and `b` divides `c` in a semigroup, then `a` divides `c`.


theorem MeasureTheory.Measure.measurable_rnDeriv :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α), Measurable (μ.rnDeriv ν) := by sorry

This theorem states that for any type `α` with a measurable space `m`, and for any two measures `μ` and `ν` on that measurable space, the Radon-Nikodym derivative of `μ` with respect to `ν` is a measurable function. This means that the preimage of any measurable set under this function is also a measurable set. The Radon-Nikodym derivative provides a way to represent one measure as an integral with respect to another, assuming certain conditions are met.

The Radon-Nikodym derivative of two measures on a measurable space is a measurable function.


theorem GaloisConnection.u_inf :
    ∀ {α : Type u} {β : Type v} {b₁ b₂ : β} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {l : α → β}
      {u : β → α}, GaloisConnection l u → u (b₁ ⊓ b₂) = u b₁ ⊓ u b₂ :=
  by sorry

The theorem `GaloisConnection.u_inf` states that for any types `α` and `β`, given two elements `b₁` and `b₂` in `β`, if `α` and `β` are both semilattice inf (i.e., they are equipped with a binary operation "infimum" or "meet" denoted by `⊓` which is associative, commutative, idempotent, and satisfies the absorption law), and if `l` and `u` establish a Galois connection between `α` and `β`, then the infimum of `u(b₁)` and `u(b₂)` in `α` is equal to `u` of the infimum of `b₁` and `b₂` in `β`. In simpler terms, the `u` function preserves the infimum operation from `β` to `α`.

For any semilattices `α` and `β` with Galois connection `l` and `u`, the operation `u` preserves the infimum, i.e., `u(inf b₁ b₂) = inf (u b₁) (u b₂)` for all `b₁, b₂ ∈ β`.


theorem CategoryTheory.op_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
      (CategoryTheory.CategoryStruct.comp f g).op = CategoryTheory.CategoryStruct.comp g.op f.op :=
  by sorry

The theorem `CategoryTheory.op_comp` states that for any category `C` and any three objects `X`, `Y`, `Z` in this category, and any two morphisms `f: X ⟶ Y` and `g: Y ⟶ Z`, the opposite of the composition of `f` and `g` (denoted `(CategoryTheory.CategoryStruct.comp f g).op`) is equal to the composition of the opposites of `g` and `f` (denoted `CategoryTheory.CategoryStruct.comp g.op f.op`). In other words, reversing the direction of morphisms in a composition in a category is equivalent to reversing the order of the composition.

For any category C and morphisms f : X 券 ↘ Y and g : Y peon ↘ Z, (f ∘ g)^op = g^op ∘ f^op, where (∘) denotes composition and ^op denotes the opposite operation.


theorem Set.Ico_subset_Icc_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b ⊆ Set.Icc a b := by sorry

This theorem states that for any type `α` that has a preorder, and any two elements `a` and `b` of type `α`, the left-closed right-open interval from `a` to `b` (denoted as `Set.Ico a b`) is a subset of the left-closed right-closed interval from `a` to `b` (denoted as `Set.Icc a b`). In other words, any element that is in the interval `[a, b)` is also in the interval `[a, b]`.

For any preorder type `α` and elements `a` and `b` of `α`, the left-closed right-open interval `Set.Ico a b` is a subset of the left-closed right-closed interval `Set.Icc a b`. In other words, `a ≤ x ≤ b` implies `a ≤ x ≤ b` for all `x` in `α`.


/-- `e.symm` is a right inverse of `e`, written as `e (e.symm y) = y`. -/
theorem AddEquiv.apply_symm_apply :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N) (y : N), e ((AddEquiv.symm e) y) = y :=
  by sorry

The theorem `AddEquiv.apply_symm_apply` states that for any isomorphism `e` from an additive group `M` to an additive group `N`, applying `e` to the result of applying the inverse of `e` (`e.symm`) to any element `y` of `N` returns `y` itself. In other words, the inverse of `e` (`e.symm`) is a right inverse of `e`, meaning that `e` followed by `e.symm` is the identity on `N`.

For any additive group isomorphism `e` from `M` to `N`, `e (e.symm x) = x` for all `x` in `N`.


LT.lt.false

theorem LT.lt.false : ∀ {α : Type u} [inst : Preorder α] {x : α}, x < x → False := by sorry

The theorem `LT.lt.false` states that for any type `α` which has a preorder relation, and for any element `x` of type `α`, the statement that `x` is less than itself is always false. This corresponds to the antisymmetry property of preorder relations, which asserts that no element can be strictly less than itself.

For any preordered type `α` and its element `x`, `x` is not less than `x`.


theorem Mathlib.Data.Set.Intervals.Basic._auxLemma.8 :
    ∀ {α : Type u_1} [inst : Preorder α] {a x : α}, (x ∈ Set.Ioi a) = (a < x) := by sorry

This theorem states that for any type `α` which has a preorder (i.e., a relation that is reflexive and transitive) and any elements `a` and `x` of that type, `x` belongs to the set `Set.Ioi a` (which represents the set of all elements greater than `a`) if and only if `a` is less than `x`. In other words, this theorem equates membership in the set of values greater than `a` to the condition `a < x`.

For any type `α` with a preorder and any elements `a` and `x` of type `α`, `x` is in `Set.Ioi a` if and only if `a` is strictly less than `x`.


theorem mul_div_assoc : ∀ {G : Type u_3} [inst : DivInvMonoid G] (a b c : G), a * b / c = a * (b / c) := by sorry

This theorem states that for any type `G` that is a `DivInvMonoid`, and for any elements `a`, `b`, `c` of `G`, the operation of multiplication and division is associative. In other words, multiplying `a` and `b` first and then dividing the result by `c` is the same as first dividing `b` by `c` and then multiplying the result with `a`. In mathematical notation, this can be written as `(a * b) / c = a * (b / c)`.

For any `DivInvMonoid` type `G` and elements `a`, `b`, `c` in `G`, `(a * b) / c = a * (b / c)`.


theorem Ideal.one_eq_top : ∀ {R : Type u} [inst : CommSemiring R], 1 = ⊤ := by sorry

This theorem states that for any type `R` implementing the `CommSemiring` behavior, the ideal generated by the number one is the entire set of `R`. In other words, in any commutative semiring, the ideal generated by one includes all elements of the semiring. In the notation of abstract algebra, this is expressed as `1 = ⊤`, where `1` represents the principal ideal generated by one and `⊤` represents the entire semiring.

In any commutative semiring, the principal ideal generated by one is equal to the entire semiring.


/-- Two morphisms out of a colimit are equal if their compositions with
each cocone morphism are equal.  -/
theorem CategoryTheory.Limits.IsColimit.hom_ext :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {t : CategoryTheory.Limits.Cocone F},
      CategoryTheory.Limits.IsColimit t →
        ∀ {W : C} {f f' : t.pt ⟶ W},
          (∀ (j : J),
              CategoryTheory.CategoryStruct.comp (t.ι.app j) f = CategoryTheory.CategoryStruct.comp (t.ι.app j) f') →
            f = f' :=
  by sorry

This theorem, `CategoryTheory.Limits.IsColimit.hom_ext`, states that given any category `J`, any category `C`, and any functor `F` from `J` to `C`, if `t` is a cocone over `F` and is also a colimit, then for any object `W` in `C` and any two morphisms `f` and `f'` from the tip of the cocone `t` to `W`, if for every object `j` in `J` the composition of the morphism from `j` to the tip of the cocone with `f` equals the composition of the same morphism with `f'`, then `f` and `f'` must be equal.

In simpler terms, in the context of category theory, this theorem asserts that two morphisms from a colimit in a category to another object in the category are equal if they yield the same result when composed with each morphism from the indexing category to the colimit. This is a formal statement of the uniqueness property of colimits in a category.

Given any category `C`, functor `F` from a small category `J` to `C`, and a colimit `t` of `F`, if for every morphism `j:` `J` → `t` and for all morphisms `f, f'` : `t` → `W` in `C`, `j∘f = j∘f'` implies `f = f'`, then `t` is the unique colimit of `F`.


theorem Set.insert_eq_of_mem : ∀ {α : Type u} {a : α} {s : Set α}, a ∈ s → insert a s = s := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any set `s` of type `α`, if `a` is an element of `s` (i.e., `a ∈ s`), then inserting `a` into `s` does not change `s`. In other words, inserting an element into a set, where the element is already a member of the set, leaves the set unchanged.

For any type `α`, any set `s` of type `α`, and any element `a` in `s`, the set `insert a s` equals `s`.


theorem Nat.div_one : ∀ (n : ℕ), n / 1 = n := by sorry

This theorem states that for any natural number `n`, the quotient of `n` when divided by `1` is `n` itself. This is essentially an embodiment of the mathematical principle that any number divided by one remains the same.


theorem Set.piecewise_eq_of_not_mem :
    ∀ {α : Type u_1} {δ : α → Sort u_6} (s : Set α) (f g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] {i : α},
      i ∉ s → Set.piecewise s f g i = g i :=
  by sorry

This theorem states that for any type `α`, a set `s` of elements of that type, and two functions `f` and `g` mapping elements of `α` to some type `δ`, along with a decidable instance for determining set membership, if a particular element `i` of type `α` does not belong to the set `s`, then applying the `piecewise` function of the set `s` to `f` and `g` at `i` is equivalent to applying `g` at `i`. In more mathematical terms, for some $i \notin s$, we have $s.piecewise(f, g)(i) = g(i)$.

For any set `s` of type `α`, and functions `f` and `g` from `α` to some type `δ` with a decidable membership relation, if `i ∉ s`, then `s.piecewise f g i = g i`.


theorem mul_self_nonneg :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] [inst_1 : ExistsAddOfLE α] (a : α), 0 ≤ a * a := by sorry

This theorem states that for any type `α` that has a structure of a linearly ordered semiring (a mathematical structure that combines the properties of an ordered ring and a semiring), and in which addition operation is defined for elements that satisfy less than or equal to relation, the square of any element `a` (represented as `a * a`) is always non-negative (greater than or equal to 0).

For any linearly ordered semiring type `α` with non-negative addition, the square of any element `a` in `α` is non-negative (i.e., `a * a ≥ 0`).


theorem Ideal.Quotient.eq_zero_iff_mem :
    ∀ {R : Type u} [inst : CommRing R] {a : R} {I : Ideal R}, (Ideal.Quotient.mk I) a = 0 ↔ a ∈ I := by sorry

This theorem states that for any commutative ring `R`, any element `a` of `R`, and any ideal `I` of `R`, the image of `a` under the quotient map `Ideal.Quotient.mk I` is zero if and only if `a` is an element of the ideal `I`. In other words, in the quotient ring `R/I`, an element `a` of `R` becomes zero if and only if it belongs to the ideal being quotiented by.

For any commutative ring `R`, element `a` in `R`, and ideal `I` of `R`, `a` maps to zero in the quotient ring `R/I` if and only if `a` is an element of `I`.


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

The theorem `Polynomial.eval_one` states that for any type `R` equipped with a semiring structure and any element `x` of `R`, if we evaluate the polynomial `1` at `x`, we always get `1`. Essentially, this theorem underlines the fact that the constant polynomial `1` returns `1` irrespective of the value at which it is evaluated.

For any semiring `R` and element `x` in `R`, the evaluation of the constant polynomial `1` at `x` is equal to `1`.


CategoryTheory.Limits.HasColimit.mk

theorem CategoryTheory.Limits.HasColimit.mk :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C}, CategoryTheory.Limits.ColimitCocone F → CategoryTheory.Limits.HasColimit F :=
  by sorry

The theorem `CategoryTheory.Limits.HasColimit.mk` states that for any category `J` and functor `F` from `J` to category `C`, if there exists a ColimitCocone for `F`, then `F` has a colimit in `C`. In other words, a functor is guaranteed to have a colimit if a ColimitCocone for this functor can be identified.

If a functor from a small category to another category has a ColimitCocone, then the functor has a colimit.


Differentiable.differentiableOn

theorem Differentiable.differentiableOn :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {s : Set E}, Differentiable 𝕜 f → DifferentiableOn 𝕜 f s :=
  by sorry

The theorem `Differentiable.differentiableOn` states that for any nontrivially normed field `𝕜`, normed addative commutative group `E`, normed space `𝕜 E`, normed addative commutative group `F`, normed space `𝕜 F`, a function `f` from `E` to `F`, and a set `s` of `E`, if the function `f` is differentiable at any point, then the function `f` is also differentiable within the set `s` at any point of `s`. In other words, global differentiability implies local differentiability.

If a function between normed spaces is differentiable at any point, then it is differentiable at every point in its domain.


theorem GaloisConnection.u_iInf :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {l : α → β}
      {u : β → α}, GaloisConnection l u → ∀ {f : ι → β}, u (iInf f) = ⨅ i, u (f i) :=
  by sorry

The theorem `GaloisConnection.u_iInf` states that for any types `α`, `β`, and `ι`, given that `α` and `β` form complete lattices, and given a Galois connection between `α` and `β` defined by the functions `l` and `u`, then for any function `f` from `ι` to `β`, the application of `u` to the infimum over `f` is equal to the infimum over the application of `u` to `f(i)` for all `i` in `ι`. In other words, the function `u` distributes over the infimum of a set, transforming the infimum of the image set under `f` to the infimum of the image set under the composition of `u` and `f`.

For any complete lattices α, β and a Galois connection between them defined by functions l and u, the application of u to the infimum over a function f from ι to β is equal to the infimum over the application of u to f(i) for all i in ι. In other words, u distributes over the infimum.


theorem CategoryTheory.IsIso.inv_hom_id_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f] {Z : C}
      (g : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) (CategoryTheory.CategoryStruct.comp f g) = g :=
  by sorry

The theorem `CategoryTheory.IsIso.inv_hom_id_assoc` states that for any category `C`, and for any objects `X`, `Y`, and `Z` in `C`, given a morphism `f` from `X` to `Y` that is an isomorphism, and another morphism `g` from `Y` to `Z`, the composition of the inverse of `f` with the composition of `f` and `g` is equal to `g`. This is a property of the categories where the composition of a morphism with its inverse behaves like an identity in the context of composition.

For any category `C`, given isomorphisms `f : X ⟶ Y` and `g : Y ⟶ Z` in `C`, the composition `g ∘ f⁻¹` is equal to the identity morphism `id_Z : Z ⟶ Z`.


theorem Nat.mul_le_mul_left : ∀ {n m : ℕ} (k : ℕ), n ≤ m → k * n ≤ k * m := by sorry

This theorem states that, for any natural numbers `n`, `m`, and `k`, if `n` is less than or equal to `m` (`n ≤ m`), then the product of `k` and `n` (`k * n`) is less than or equal to the product of `k` and `m` (`k * m`). In other words, multiplication by a non-negative integer preserves the order of natural numbers.

For all natural numbers n, m, and k, if n ≤ m then k * n ≤ k * m.


theorem ENNReal.rpow_one : ∀ (x : ENNReal), x ^ 1 = x := by sorry

This theorem states that for any extended nonnegative real number `x`, raising `x` to the power of 1 is equal to `x` itself. In mathematical terms, for all `x` in the set of extended nonnegative real numbers, which is usually denoted as [0, ∞], it holds that x^1 = x. This rule reflects a fundamental property of exponents in the field of real numbers.

For all extended nonnegative real numbers x, x^1 = x.


theorem Asymptotics.IsBigOWith_def :
    ∀ {α : Type u_17} {E : Type u_18} {F : Type u_19} [inst : Norm E] [inst_1 : Norm F] (c : ℝ) (l : Filter α)
      (f : α → E) (g : α → F), Asymptotics.IsBigOWith c l f g = ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ :=
  by sorry

The theorem `Asymptotics.IsBigOWith_def` states that for any real number `c`, any filter `l` over a type `α`, and any two functions `f` and `g` mapping from `α` to normed types `E` and `F` respectively, the property of `f` being Big O of `g` with respect to `c` and `l` (denoted as `Asymptotics.IsBigOWith c l f g`) is equivalent to the statement that, eventually for every element `x` in the filter `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`. In other words, the value of `f` is eventually bounded above by `c` times the value of `g` for all inputs in the filter `l`.

For any real number `c`, filter `l`, functions `f` and `g` mapping from `α` to normed types `E` and `F` respectively, `Asymptotics.IsBigOWith c l f g` if and only if for all `x` in `l`, `||f(x)|| ≤ c * ||g(x)||`.


theorem CategoryTheory.congr_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} {α β : F.NatTrans G},
      α = β → ∀ (X : C), α.app X = β.app X :=
  by sorry

The theorem `CategoryTheory.congr_app` states that given two categories `C` and `D`, and two functors `F` and `G` from `C` to `D`, if we have two natural transformations `α` and `β` from `F` to `G`, and `α` equals to `β`, then for any object `X` in category `C`, the application of `α` to `X` is equal to the application of `β` to `X`. In simpler terms, it says that if two natural transformations between the same functors are equal, then they act identically on every object in the source category.

If two natural transformations between functors are equal, then they induce the same function on objects in the source category.


theorem le_iSup₂ :
    ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_7} [inst : CompleteLattice α] {f : (i : ι) → κ i → α} (i : ι)
      (j : κ i), f i j ≤ ⨆ i, ⨆ j, f i j :=
  by sorry

This theorem, `le_iSup₂`, states that for any complete lattice `α`, and any function `f` which maps an index `i` of type `ι` and another index `j` of type `κ i` to an element of `α`, the value `f i j` for any specific `i` and `j` is less than or equal to the supremum (or least upper bound) over all possible `i` and `j` of `f i j`. This theorem essentially states that any specific output of the function `f` is less than or equal to the maximum possible output of the function `f` over all inputs.

For any complete lattice `α` and function `f` from the product type `ι × κ` to `α`, `∀ i ∈ ι ∀ j ∈ κ i, f i j ≤ ⨜ (i, j) in ι × κ, f i j)`.


theorem Finsupp.not_mem_support_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M} {a : α}, a ∉ f.support ↔ f a = 0 := by sorry

This theorem states that for any given types `α` and `M`, where `M` has an instance of `Zero`, and for any function `f` from `α` to `M` and any element `a` of `α`, `a` is not in the support of `f` if and only if the value of function `f` at `a` is zero. In other words, an element `a` does not belong to the support of a function `f` if applying `f` to `a` yields zero.

For any function `f` from type `α` to a type `M` with instance of `Zero`, an element `a` in `α` is not in the support of `f` if and only if `f a` equals `0`.


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

This theorem, `LT.lt.not_lt`, is an alias for `lt_asymm` in Lean. It states that for any type `α` equipped with a preorder relation, if one element `a` is strictly less than another element `b`, then it's not the case that `b` is strictly less than `a`. This rule essentially states that the "less than" relation is asymmetric, which is a defining feature of preorders.

If `a` is strictly less than `b` in a preorder relation on type `α`, then it is not the case that `b` is strictly less than `a`.


theorem Finset.not_mem_erase : ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), a ∉ Finset.erase s a :=
  by sorry

This theorem states that for any type `α` with decidable equality and any element `a` of type `α`, `a` is not a member of the set obtained by erasing `a` from a given finite set `s` of `α`. In other words, once an element is removed from a finite set, it no longer belongs to that set.

For any finite set `s` of type `α` with decidable equality and any element `a` in `s`, `a` is not an element of the set `s \ {a}`.


theorem Nat.one_mul : ∀ (n : ℕ), 1 * n = n := by sorry

This theorem states that for any natural number `n`, the product of `1` and `n` is equal to `n`. In the language of mathematics, it asserts that 1 is the multiplicative identity in the set of natural numbers, i.e., multiplying any natural number by 1 results in the same number.

For every natural number n, 1 * n = n. (This statement asserts that the multiplicative identity 1 maps every natural number to itself in the multiplication operation.)


theorem List.concat_eq_append : ∀ {α : Type u} (as : List α) (a : α), List.concat as a = as ++ [a] := by sorry

The theorem `List.concat_eq_append` states that for any type `α`, any list `as` of type `List α`, and any element `a` of type `α`, concatenating the element `a` to the end of the list `as` using the `List.concat` function is equivalent to appending the singleton list containing `a` to the end of `as` using the append (`++`) operator. This means in both cases, the resulting list will be `as` followed by the element `a`.

For any type `α` and list `as` of length `n` over `α`, `List.concat [a] (List.init as ++ [a]) = as`.


theorem Fintype.card_congr' :
    ∀ {α β : Type u_4} [inst : Fintype α] [inst_1 : Fintype β], α = β → Fintype.card α = Fintype.card β := by sorry

The theorem `Fintype.card_congr'` states that for any two types `α` and `β` that are both finite types (`Fintype`), if `α` is equal to `β`, then the cardinality (number of elements) of `α` is equal to the cardinality of `β`. In mathematical terms, it ensures the equality of the sizes of two sets if the two sets are the same.

If `α` and `β` are finite types (sets) in Lean, then `card α = card β` if and only if `α = β`.


theorem MeasureTheory.ae_restrict_iff' :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {p : α → Prop},
      MeasurableSet s → ((∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x) :=
  by sorry

The theorem `MeasureTheory.ae_restrict_iff'` states that for any type `α`, a measurable space `m0` over `α`, a measure `μ` on that space, a set `s` of elements of type `α`, and a predicate `p` over `α`, if the set `s` is measurable, then the property `p` holds almost everywhere with respect to the measure `μ` restricted to `s` if and only if `p` holds almost everywhere with respect to the measure `μ` for all elements in the set `s`. Here, "almost everywhere" means for all elements except for a set of measure zero.

For any measurable space `(α, m0)`, measure `μ` on `m0`, set `s ⊆ α` with measurable boundary, and predicate `p` over `α`, if `μ(s^c) = 0` and `p` is measurable, then `p` almost everywhere holds on `s` if and only if `p` almost everywhere holds on `α`.


theorem Monotone.map_max :
    ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {a b : α},
      Monotone f → f (max a b) = max (f a) (f b) :=
  by sorry

The theorem `Monotone.map_max` states that, for any types `α` and `β` that have a linear order, and for any function `f` from `α` to `β`, if `f` is a monotone function, then the result of applying `f` to the maximum of two elements `a` and `b` of type `α` is equivalent to the maximum of the results of applying `f` to `a` and `b` individually. In mathematical terms, given `a, b ∈ α` and a monotone function `f: α → β`, we have `f(max(a, b)) = max(f(a), f(b))`.

For any types `α` and `β` with a linear order, and any monotone function `f: α → β`, `f(max(a, b)) = max(f(a), f(b))` for all `a, b ∈ α`.


theorem RelEmbedding.map_rel_iff :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) {a b : α},
      s (f a) (f b) ↔ r a b :=
  by sorry

This theorem states that for any two types `α` and `β`, and any two relations `r` on `α` and `s` on `β`, and a relation-preserving embedding `f` from `r` into `s`, for any `a` and `b` of type `α`, `s (f a) (f b)` is true if and only if `r a b` is true. In other words, a relation holds between two elements in the original space if and only if the same relation holds between their images in the target space under a relation-preserving embedding.

For any relation-preserving embedding `f` between types `α` and `β` and relations `r` on `α` and `s` on `β`, `r(a, b)` implies `s(f a, f b)` and vice versa, for all `a, b` in `α`.


theorem isOpen_iff_mem_nhds : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, s ∈ nhds x :=
  by sorry

The theorem `isOpen_iff_mem_nhds` states that for any Type `X` and any set `s` of type `X` in a given topological space, `s` is open if and only if for every element `x` in `s`, `s` is a neighborhood of `x`. In other words, a set is open in a topological space if and only if for all elements of the set, the set is a neighborhood of each of its elements.

A set in a topological space is open if and only if it is a neighborhood of each of its elements.


theorem isometry_vadd :
    ∀ {M : Type u} (X : Type w) [inst : PseudoEMetricSpace X] [inst_1 : VAdd M X] [inst_2 : IsometricVAdd M X] (c : M),
      Isometry fun x => c +ᵥ x :=
  by sorry

The theorem `isometry_vadd` states that for any type `M`, any pseudometric space `X` and any vector addition operation `+ᵥ` which is isometric on `M` and `X`, given any element `c` of type `M`, the function that adds `c` to any element of `X` is an isometry. This means that adding `c` preserves the edistance between any two elements in the pseudometric space `X`.

For any pseudometric space `(X, d)` and type `M` with an isometric vector addition `+ᵥ` on `M` and `X`, the function `x même c : X -> X` defined by `x meille c := x +ᵥ c` is an isometry.


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

This theorem, named `CategoryTheory.MonoidalCategory.comp_whiskerRight`, states that in any monoidal category `C`, for any three objects `W`, `X`, `Y` in `C`, and any two morphisms `f` from `W` to `X` and `g` from `X` to `Y`, the whiskering of the composition of `f` and `g` on the right by any object `Z` in `C` (denoted `CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.CategoryStruct.comp f g) Z`) is equal to the composition of the whiskering of `f` and `g` on the right by `Z` (denoted `CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f Z) (CategoryTheory.MonoidalCategory.whiskerRight g Z)`). Here, "whiskering" refers to a specific binary operation on morphisms in a monoidal category, and "composition" refers to the standard composition of morphisms in a category.

In any monoidal category, for all objects W, X, Y, and morphisms f : W -> X and g : X -> Y, the whiskering of the composition f * g on the right by any object Z is equal to the composition of the whiskered morphisms f \*_Z and g \*_Z.


theorem NNReal.coe_le_coe : ∀ {r₁ r₂ : NNReal}, ↑r₁ ≤ ↑r₂ ↔ r₁ ≤ r₂ := by sorry

This theorem states that for any two nonnegative real numbers `r₁` and `r₂`, the inequality `r₁ ≤ r₂` holds if and only if the inequality holds when `r₁` and `r₂` are coerced to real numbers, i.e., `↑r₁ ≤ ↑r₂`. In other words, the order of nonnegative real numbers is preserved under the coercion from `NNReal` to `Real`.

For all nonnegative real numbers `r₁` and `r₂`, `r₁ ≤ r₂` if and only if `↑r₁ ≤ ↑r₂`.


Quotient.ind

/-- The analogue of `Quot.ind`: every element of `Quotient s` is of the form `Quotient.mk s a`.  -/
theorem Quotient.ind :
    ∀ {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop},
      (∀ (a : α), motive ⟦a⟧) → ∀ (q : Quotient s), motive q :=
  by sorry

This theorem serves as the counterpart to `Quot.ind` for the `Quotient` type. It asserts that for any type `α`, any setoid `s` on `α`, and any property `motive` that you might want to prove about elements of the quotient type `Quotient s`, if you have a proof that `motive` holds for any element `a : α` (under the equivalence class ⟦a⟧), then `motive` holds for all elements `q : Quotient s`. In mathematical terms, this can be interpreted as saying that properties of representatives of an equivalence class can be lifted to the entire equivalence class in the quotient set.

If `motive` is a property that preserves the equivalence relation `s` on `α`, then `motive` holds for all elements of the quotient type `Quotient s`.


LipschitzWith.uniformContinuous

/-- A Lipschitz function is uniformly continuous.  -/
theorem LipschitzWith.uniformContinuous :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → UniformContinuous f :=
  by sorry

This theorem states that a Lipschitz continuous function is uniformly continuous. In more detail, for any two types `α` and `β` that form pseudo-emetric spaces, a function `f` from `α` to `β` that is Lipschitz continuous with a non-negative constant `K`, is also uniformly continuous. In mathematical terms, if for every pair of points `x` and `y` the distance between `f(x)` and `f(y)` is less than or equal to `K` times the distance between `x` and `y`, then `f` is uniformly continuous, meaning that as `x` gets arbitrarily close to `y`, `f(x)` gets arbitrarily close to `f(y)` regardless of the location of `x` and `y` in their space.

A Lipschitz continuous function between pseudo-metric spaces is uniformly continuous.


theorem Mathlib.Algebra.GroupWithZero.Divisibility._auxLemma.2 :
    ∀ {α : Type u_1} [inst : SemigroupWithZero α] (a : α), (a ∣ 0) = True := by sorry

This theorem, named `Mathlib.Algebra.GroupWithZero.Divisibility._auxLemma.2` in Lean 4, states that for any type `α` that is a semigroup with zero, any element `a` of that type divides zero. In other words, in the context of algebra where a semigroup with zero is considered, zero can be expressed as the product of any element and some other element in the set. This is a universal property of zero in the context of divisibility within semigroups.

In a semigroup with zero, any element divides zero.


/-- Given an element `a` of a commutative semigroup with zero, there exists another element whose
product with zero equals `a` iff `a` equals zero.  -/
theorem zero_dvd_iff : ∀ {α : Type u_1} [inst : SemigroupWithZero α] {a : α}, 0 ∣ a ↔ a = 0 := by sorry

This theorem states that for any given element `a` in a commutative semigroup that includes zero, there exists another element that, when multiplied by zero, results in `a` if and only if `a` itself is equal to zero. This theorem essentially captures the property of zero in multiplication, as any number multiplied by zero gives zero.

For any commutative semigroup with zero, an element multiplies to zero if and only if it is equal to zero.


theorem Int.ofNat_nonneg : ∀ (n : ℕ), 0 ≤ ↑n := by sorry

This theorem, `Int.ofNat_nonneg`, states that for any natural number `n`, the integer representation of `n` is always non-negative. In mathematical terms, given any natural number `n`, the inequality `0 ≤ n` holds when `n` is considered as an integer.

For any natural number `n`, `0 ≤ Int.ofNat n`.


theorem Mathlib.Data.Finset.Basic._auxLemma.158 : ∀ (p : Prop), (False ∧ p) = False := by sorry

This theorem in Lean 4's `Mathlib.Data.Finset.Basic._auxLemma.158` states that for any proposition `p`, the logical AND (`∧`) of `False` and `p` is always `False`. This is consistent with the standard logic rule that if one of the operands of an AND operation is false, the whole statement becomes false regardless of the other operand.

The logical AND of `False` and any proposition `p` is equal to `False`.


Filter.Tendsto.add

theorem Filter.Tendsto.add :
    ∀ {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [inst_2 : ContinuousAdd M]
      {f g : α → M} {x : Filter α} {a b : M},
      Filter.Tendsto f x (nhds a) →
        Filter.Tendsto g x (nhds b) → Filter.Tendsto (fun x => f x + g x) x (nhds (a + b)) :=
  by sorry

This theorem states that for a topological space `M` with a defined addition operation and equipped with continuous addition, if two functions `f` and `g` from an arbitrary set `α` to `M` respectively tend to points `a` and `b` (in the sense that for any neighborhood of `a` or `b`, the preimage of this neighborhood under `f` or `g` creates a set that "filters" the values of `α`), then the function representing the sum of `f` and `g` tends to the sum of `a` and `b`. In mathematical terms, this theorem establishes the limit law for addition: if $\lim_{x \to c} f(x) = a$ and $\lim_{x \to c} g(x) = b$ then $\lim_{x \to c} (f(x) + g(x)) = a + b$.

If `f` and `g` are continuous functions from a set `α` to a topological space `M` with defined addition and equipped with continuous addition, and `a` and `b` are limits of `f(x)` and `g(x)`, respectively, as `x` approaches a limit point `c` in `α`, then the limit of `(f(x) + g(x))` as `x` approaches `c` is equal to `(a + b)`.


MultilinearMap.ext

theorem MultilinearMap.ext :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] {f f' : MultilinearMap R M₁ M₂}, (∀ (x : (i : ι) → M₁ i), f x = f' x) → f = f' :=
  by sorry

This theorem, `MultilinearMap.ext`, states that for any semiring `R`, an index type `ι`, function types `M₁ : ι → Type v₁` and `M₂ : Type v₂`, where each `M₁ i` and `M₂` are an additive commutative monoid and `R`-module, if we have two multilinear maps `f` and `f'` from `M₁` to `M₂`, then `f` and `f'` are equal if and only if they map every `x` in the domain (which is a function from `ι` to `M₁`) to the same value. In other words, two multilinear maps are equal if they agree on all inputs.

Two multilinear maps from a semiring-valued function type to an additive commutative monoid and R-module are equal if and only if they map every input function to the same output.


theorem mul_two : ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n * 2 = n + n := by sorry

This theorem, `mul_two`, states that for any non-associative semiring `α` and for any element `n` in that semiring, multiplying `n` by 2 is equivalent to adding `n` to itself. Here, a non-associative semiring is a mathematical structure that extends the concept of a semiring by not requiring the multiplication operation to be associative.

For any non-associative semiring `α` and element `n` in `α`, `n` multiplied by 2 is equivalent to `n` added to itself. (Or, `2 * n = n + n` in infix notation.)


theorem Polynomial.eval_add :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R} {x : R},
      Polynomial.eval x (p + q) = Polynomial.eval x p + Polynomial.eval x q :=
  by sorry

The theorem `Polynomial.eval_add` states that for any type `R` which is a semiring, for any polynomials `p` and `q` over `R`, and for any element `x` of `R`, the evaluation of the sum of `p` and `q` at `x` is equivalent to the sum of the evaluation of `p` at `x` and the evaluation of `q` at `x`. In mathematical terms, this theorem asserts the linearity of polynomial evaluation: `eval(x, p + q) = eval(x, p) + eval(x, q)`, which is a fundamental property in algebra.

For any semiring `R`, polynomial `p` and `q` over `R`, and `x` in `R`, `eval(x, p + q) = eval(x, p) + eval(x, q)`.


theorem Int.cast_sub : ∀ {R : Type u} [inst : AddGroupWithOne R] (m n : ℤ), ↑(m - n) = ↑m - ↑n := by sorry

This theorem, `Int.cast_sub`, states that for any type `R` that is an instance of `AddGroupWithOne` (meaning it is a mathematical group that has addition as its operation and contains an identity element) and for any two integers `m` and `n`, the result of casting the difference between `m` and `n` (i.e., `m - n`) to type `R` is equal to the difference of `m` and `n` as `R` (cast individually and then subtracted). Simply put, the casting operation respects subtraction for `AddGroupWithOne` instances.

For any `AddGroupWithOne` type `R` and integers `m` and `n`, the operation `(m : R) - (n : R)` equals `(m : R) -^ (n : R)`, where `-` is subtraction on integers and `-^` is subtraction on type `R`.


theorem Finset.eq_empty_or_nonempty : ∀ {α : Type u_1} (s : Finset α), s = ∅ ∨ s.Nonempty := by sorry

This theorem states that for any given finite set `s` of any type `α`, `s` is either equal to the empty set or is nonempty. In other words, any finite set must be one of two cases: it contains no elements at all (it is the empty set), or it has at least one element (it is nonempty).

Every finite set is either empty or nonempty.


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

This theorem states that for every integer `a`, adding zero to `a` results in `a`. In mathematical terms, it expresses the identity property of addition for integers, i.e., `a + 0 = a` for all integers `a`.

The theorem asserts that for all integers `a`, `a + 0 = a`.


Finset.Subset.rfl

theorem Finset.Subset.rfl : ∀ {α : Type u_1} {s : Finset α}, s ⊆ s := by sorry

The theorem `Finset.Subset.rfl` states that for any type 'α' and any finite set 's' of type 'α', 's' is a subset of itself. It is a fundamental property of set theory that every set is a subset of itself, and this theorem encodes this fact in the context of finite sets in the Lean 4 theorem prover.


theorem Filter.atTop_basis :
    ∀ {α : Type u_3} [inst : Nonempty α] [inst : SemilatticeSup α],
      Filter.HasBasis Filter.atTop (fun x => True) Set.Ici :=
  by sorry

The theorem `Filter.atTop_basis` states that for any type `α`, given that `α` is nonempty and forms a semilattice with respect to an operation `sup` (which stands for supremum), the filter `Filter.atTop` (representing the limit towards positive infinity in an ordered set) has a basis specified by the predicate function which always returns `True` and the set function `Set.Ici`. `Set.Ici` produces left-closed right-infinite intervals. In other words, this theorem asserts that the filter representing the limit towards positive infinity in a semilattice can be generated by considering all intervals of the form `[a, ∞)`, irrespective of the value of `a`.

The filter `Filter.atTop` on a nonempty semilattice `α` with supremum operation `sup` has a basis consisting of all left-closed, right-infinite intervals `[a, ∞)`.


theorem isUnit_of_mul_eq_one : ∀ {M : Type u_1} [inst : CommMonoid M] (a b : M), a * b = 1 → IsUnit a := by sorry

This theorem states that for any type `M` that is a commutative monoid, if we have two elements `a` and `b` of `M` such that the product of `a` and `b` equals the identity element `1`, then `a` is a unit in `M`. In the context of mathematics, a unit is an element in a ring (or in this case, monoid) that has a multiplicative inverse. Therefore, this theorem is essentially saying that if two elements multiply to give the identity, then each of those elements must have a multiplicative inverse, i.e., they are units.

In a commutative monoid, if an element has an identity product with another element, then it is a unit.


theorem CategoryTheory.Limits.prod.comp_lift :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {V W X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y] (f : V ⟶ W) (g : W ⟶ X) (h : W ⟶ Y),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.prod.lift g h) =
        CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.comp f g)
          (CategoryTheory.CategoryStruct.comp f h) :=
  by sorry

This theorem, titled `CategoryTheory.Limits.prod.comp_lift`, states that for any category `C` and objects `V`, `W`, `X`, and `Y` in `C`, if `X` and `Y` have a binary product, then for any morphisms `f : V ⟶ W`, `g : W ⟶ X`, and `h : W ⟶ Y`, the composite of `f` with the morphism induced by `g` and `h` via the product lifting operation (`prod.lift g h : W ⟶ X ⨯ Y`) is equal to the morphism induced by the composites `f ≫ g : V ⟶ X` and `f ≫ h : V ⟶ Y`. In other words, lifting to the product and then composing with `f` is the same as first composing with `f` and then lifting to the product. The theorem thus expresses a kind of associativity property of the product lifting operation with respect to composition of morphisms in a category.

For any category `C`, objects `V`, `W`, `X`, and `Y` with a binary product, and morphisms `f : V ⟶ W`, `g : W ⟶ X`, and `h : W ⟶ Y`, the composite `f ∘ prod.lift g h` is equal to `prod.lift (f ∘ g) (f ∘ h)`.


theorem Iff.not_left : ∀ {a b : Prop}, (a ↔ ¬b) → (¬a ↔ b) := by sorry

This theorem states that for any two propositions `a` and `b`, if `a` is logically equivalent to `not b` (denoted in Lean 4 as `¬b`), then `not a` is logically equivalent to `b`. In other words, if `a` being true means `b` is false, and `a` being false means `b` is true, then the converse also holds: `a` being false means `b` is true, and `a` being true means `b` is false.

If `a` is logically equivalent to `not b` in Lean 4, then `not a` is logically equivalent to `b`.


theorem Function.iterate_succ_apply' : ∀ {α : Type u} (f : α → α) (n : ℕ) (x : α), f^[Nat.succ n] x = f (f^[n] x) := by
  sorry

This theorem states that for any function `f` of type `α → α` (meaning it takes an input of type `α` and returns an output of type `α`), any natural number `n`, and any `x` of type `α`, the application of the function `f` iterated `(n+1)` times to `x` is equivalent to applying `f` to the result of applying `f` `n` times to `x`. In the notation `f^[Nat.succ n] x`, `f^[Nat.succ n]` represents the function `f` iterated `(n+1)` times, and `x` is the input to this iterated function.

For any function `f` of type `α → α` and any natural number `n` and input `x` of type `α`, applying `f` `(n+1)` times to `x` is equivalent to applying `f` `n` times and then once more to the result. In mathematical notation, `f^[Nat.succ n] x = f^[Nat.n] x <<< f x`, where `<<<` denotes function composition.


/-- The open sets containing `x` are a basis for the neighborhood filter. See `nhds_basis_opens'`
for a variant using open neighborhoods instead.  -/
theorem nhds_basis_opens :
    ∀ {X : Type u} [inst : TopologicalSpace X] (x : X),
      Filter.HasBasis (nhds x) (fun s => x ∈ s ∧ IsOpen s) fun s => s :=
  by sorry

The theorem `nhds_basis_opens` states that for any topological space `X` and any point `x` in `X`, the open sets containing `x` form a basis for the neighborhood filter of `x`. In other words, the neighborhood filter of `x` can be generated from the collection of all open sets that contain `x`. This theorem provides a fundamental characterization of the structure of the neighborhood filter in terms of open sets, which is a key concept in topology.

The neighborhood filter of a point in a topological space can be generated by the collection of open sets containing that point.


theorem lt_or_eq_of_le : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → a < b ∨ a = b := by sorry

This theorem states that in a partial order for any given type, for any two elements `a` and `b` of that type, if `a` is less than or equal to `b`, then either `a` is strictly less than `b` or `a` is equal to `b`. A partial order is a binary relation that is reflexive, antisymmetric, and transitive, which are common properties in many mathematical structures.

In a partial order, if `a` is less than or equal to `b`, then `a` is strictly less than `b` or `a` equals `b`.


theorem Set.subset_iUnion : ∀ {β : Type u_2} {ι : Sort u_4} (s : ι → Set β) (i : ι), s i ⊆ ⋃ i, s i := by sorry

The theorem `Set.subset_iUnion` states that, for any type `β` and an indexing type `ι`, any set `s` indexed by `ι` is a subset of the union over all `i` in `ι` of the sets `s i`. In other words, for every index `i`, the set `s i` is contained within the union of all the sets `s i` for each `i` in the indexing type `ι`. This is a general concept in set theory, where any member of a collection of sets is necessarily a subset of the union of the entire collection of sets.

For any indexed family of sets `{s i | i ∈ ι}`, the set `s` is a subset of their union `⋃i∈ι si`.


theorem sup_idem : ∀ {α : Type u} [inst : SemilatticeSup α] (a : α), a ⊔ a = a := by sorry

This theorem, named `sup_idem`, states that for any type `α` that is a semilattice with a supremum, the supremum of any element `a` with itself is equal to `a`. In terms of set theory and lattice theory, it's saying that the least upper bound (or supremum) of a single element is the element itself. This principle is fundamental in order theory and is a key property of lattices and semilattices.

In any semilattice with supremum, the supremum of an element with itself is equal to that element.


theorem Subtype.mk_eq_mk :
    ∀ {α : Sort u_1} {p : α → Prop} {a : α} {h : p a} {a' : α} {h' : p a'},
      { val := a, property := h } = { val := a', property := h' } ↔ a = a' :=
  by sorry

This theorem states that for every type `α`, and a predicate `p` on `α`, for any two elements `a` and `a'` of type `α` satisfying the predicate `p` (denoted by `h` and `h'`), the subtypes created by these elements and their respective properties are equal if and only if the elements `a` and `a'` are equal. Essentially, two subtypes are equal when their underlying elements in the original type are equal.

For all types `α` and predicates `p` on `α`, if `a` and `a'` are elements of type `α` satisfying `p`, then the subtypes `{x : α | p x} at a` and `{x : α | p x} at a'` are equal if and only if `a` is equal to `a'`.


/-- A submonoid contains the monoid's 1.  -/
theorem Submonoid.one_mem : ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M), 1 ∈ S := by sorry

This theorem states that for any given submonoid `S` of a type `M` that forms a `MulOneClass` (a multiplicative monoid with a multiplicative identity, or `1`), the multiplicative identity (`1`) is an element of `S`. In other words, in the context of abstract algebra, this theorem says that the identity element of a monoid is also an element of any of its submonoids.

In any multiplicative monoid with identity, the identity is an element of every submonoid.


theorem GaloisInsertion.l_u_eq :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : PartialOrder β],
      GaloisInsertion l u → ∀ (b : β), l (u b) = b :=
  by sorry

This theorem states that for any types `α` and `β`, and any functions `l : α → β` and `u : β → α`, given a preorder on `α` and a partial order on `β`, if a Galois insertion is established between `l` and `u`, then for any element `b` of type `β`, applying `u` followed by `l` to `b` will yield `b` again. In other words, the composition of `l` and `u` acts as the identity on the domain of `β`. This is a characteristic property of Galois insertions, which are a fundamental concept in order theory and lattice theory.

Given a Galois insertion between functions `l : α → β` and `u : β → α` over a preorder on `α` and a partial order on `β`, `u ∘ l = id_β`.


theorem Or.imp_left : ∀ {a b c : Prop}, (a → b) → a ∨ c → b ∨ c := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, if `a` implies `b`, then the disjunction of `a` and `c` implies the disjunction of `b` and `c`. In other words, if we know that `a` leads to `b`, and we have either `a` or `c` is true, then we can conclude that either `b` or `c` is true.

If `a` implies `b`, then `a || c` implies `b || c` (disjunction of `a` and `c` implies disjunction of `b` and `c`).


theorem vadd_assoc :
    ∀ {α : Type u_6} {M : Type u_10} {N : Type u_11} [inst : VAdd M N] [inst_1 : VAdd N α] [inst_2 : VAdd M α]
      [inst_3 : VAddAssocClass M N α] (x : M) (y : N) (z : α), x +ᵥ y +ᵥ z = x +ᵥ (y +ᵥ z) :=
  by sorry

This theorem, `vadd_assoc`, states that for any types `α`, `M`, `N` where `M` and `N` are vectorially added to get `α`, the operation of vector addition (denoted by `+ᵥ`) is associative. That is, given elements `x` of type `M`, `y` of type `N`, and `z` of type `α`, adding `y` and `z` together (with vector addition) first, then adding `x` to the result is the same as adding `x` and `y` together first (with vector addition), then adding `z` to the result. This theorem requires the assumption that the types `M`, `N`, and `α` form a `VAddAssocClass` which essentially means that vector addition between these types is associative.

For types `M`, `N`, and `α` forming a `VAddAssocClass`, the vector addition operation `+ᵥ` is associative, i.e., `(x +ᵥ y) +ᵥ z = x +ᵥ (y +ᵥ z)` for all `x : M`, `y : N`, and `z : α`.


BoundedContinuousFunction.ext

theorem BoundedContinuousFunction.ext :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      {f g : BoundedContinuousFunction α β}, (∀ (x : α), f x = g x) → f = g :=
  by sorry

This theorem states that for any two bounded continuous functions `f` and `g` from a topological space `α` to a pseudo metric space `β`, if for every element `x` in the topological space `α` the value of the functions `f` and `g` are equal, then the functions `f` and `g` are the same. In other words, two bounded continuous functions are identical if they coincide at every point in their domain.

If two bounded continuous functions from a topological space to a pseudo metric space are equal at every point, then they are identical.


theorem Fintype.card_coe :
    ∀ {α : Type u_1} (s : Finset α) [inst : Fintype { x // x ∈ s }], Fintype.card { x // x ∈ s } = s.card := by sorry

The theorem `Fintype.card_coe` states that for any type `α` and any finite set `s` of elements of type `α`, the cardinality (i.e., the number of elements) of the subtype consisting of elements in `s` is equal to the cardinality of `s` itself. In other words, if you restrict your attention to only those elements in `s`, the number of such elements doesn't change.

For any finite type `α` and subset `s` of `α`, the cardinality of the subtype of `α` equal to `s` is equal to the cardinality of `s`.


theorem MeasureTheory.AEStronglyMeasurable.aemeasurable :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_5} [inst : MeasurableSpace β]
      [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace.PseudoMetrizableSpace β] [inst_3 : BorelSpace β]
      {f : α → β}, MeasureTheory.AEStronglyMeasurable f μ → AEMeasurable f μ :=
  by sorry

This theorem states that for any measure space `α` with measure `μ`, and for any space `β` that is a measurable, topological, pseudometrizable and Borel space, if a function `f` from `α` to `β` is almost everywhere strongly measurable with respect to `μ`, then `f` is also almost everywhere measurable with respect to `μ`.

In more detail, a function is almost everywhere strongly measurable if on almost all of the domain, it is equal to the limit of a sequence of simple functions. On the other hand, a function is almost everywhere measurable if it coincides almost everywhere with a measurable function. This theorem shows that if the stronger condition of almost everywhere strong measurability is met, then the function is indeed almost everywhere measurable.

For any measure space `(α, μ)` and any measurable, topological, pseudometrizable and Borel space `(β, Δ)`, a strongly almost everywhere measurable function `f : α → β` is almost everywhere measurable.


theorem tsum_zero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α], ∑' (x : β), 0 = 0 := by
  sorry

This theorem states that for any types `α` and `β`, given `α` is an additive commutative monoid and also a topological space, the infinite sum (`tsum`) of zeros over all elements of `β` is zero. The infinite sum is a concept from the field of analysis, where summing an arbitrary number of elements (possibly infinite) in a specific order can produce a well-defined result. In this case, since all the elements are zero, the sum is zero.

For any additive commutative monoid and topological space `α`, the infinite sum of zeros over all elements of `α` is equal to the zero element.


IsClosed.inter

theorem IsClosed.inter :
    ∀ {X : Type u} {s₁ s₂ : Set X} [inst : TopologicalSpace X], IsClosed s₁ → IsClosed s₂ → IsClosed (s₁ ∩ s₂) := by
  sorry

The theorem `IsClosed.inter` states that for any type `X`, and any two sets `s₁` and `s₂` of type `X`, given a topology (or `TopologicalSpace`) on `X`, if both `s₁` and `s₂` are closed sets, then their intersection (expressed as `s₁ ∩ s₂`) is also a closed set in the given topological space.
The theorem essentially formalizes one of the standard properties of topological spaces, namely that the intersection of any collection of closed sets is itself a closed set.

In a topological space, the intersection of any two closed sets is a closed set.


theorem Set.inter_self : ∀ {α : Type u} (a : Set α), a ∩ a = a := by sorry

The theorem `Set.inter_self` states that for all types `α`, and for any set `a` of type `α`, the intersection of the set `a` with itself is equal to the set `a`. This is a reflection of the intuitive concept in set theory where the intersection of a set with itself will obviously yield the original set since all elements in the set are common to the set itself.

For any set `a` of type `α`, `a ∩ a = a`.


Nat.succ.injEq

theorem Nat.succ.injEq : ∀ (n n_1 : ℕ), (Nat.succ n = Nat.succ n_1) = (n = n_1) := by sorry

This theorem, `Nat.succ.injEq`, states that for any two natural numbers `n` and `n_1`, the equality of their successors (i.e., `Nat.succ n = Nat.succ n_1`) is equivalent to the equality of the numbers themselves (i.e., `n = n_1`). In other words, if the successors of two numbers are equal, then the numbers themselves are equal. This is a reflection of the injective (or one-to-one) property of the successor function on natural numbers.

The successor function is injective on natural numbers, that is, for all natural numbers `n` and `n_1`, `Nat.succ n = Nat.succ n_1` implies `n = n_1`.


theorem Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.17 :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [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

The theorem, denoted as `Mathlib.Algebra.Order.Monoid.Lemmas._auxLemma.17`, states that for any type `α` that has an addition operation (`AddZeroClass α`), a less than or equal to operation (`LE α`), and satisfies both the covariant and contravariant properties for the swapping function (which switches the order of addition and comparison), the inequality `a ≤ b + a` is equivalent to `0 ≤ b`. The variables `a` and `b` are elements of type `α`. In more informal terms, this theorem is about a certain ordering property of additive monoids, stating that adding `a` to both sides of `0 ≤ b` does not change the truth value of the inequality.

For any additive monoid type `α` with covariant and contravariant order properties, the inequality `a <= b` is equivalent to `0 <= b + a`.


ContDiff.comp

/-- The composition of `C^n` functions is `C^n`.  -/
theorem ContDiff.comp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
      [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ∞} {g : F → G} {f : E → F},
      ContDiff 𝕜 n g → ContDiff 𝕜 n f → ContDiff 𝕜 n (g ∘ f) :=
  by sorry

This theorem states that if we have two functions, `f` and `g`, where `f` maps from a normed additively commutative group `E` to `F` and `g` maps from `F` to `G`, all over a nontrivially normed field `𝕜`, then the composition of these functions `g ∘ f` is continuously differentiable up to the `n`th derivative if both `f` and `g` are also continuously differentiable up to the `n`th derivative. This is true for all `n` in the extended natural numbers `ℕ∞`, which includes infinity.

If `f : E → F` and `g : F → G` are `n`-times continuously differentiable functions between normed spaces over a nontrivially normed field, then their composition `g ∘ f` is also `n`-times continuously differentiable.


theorem invOf_mul_self : ∀ {α : Type u} [inst : Mul α] [inst_1 : One α] (a : α) [inst_2 : Invertible a], ⅟a * a = 1 :=
  by sorry

This theorem states that for any type `α` that has a multiplication operation and a defined element 'one', if we have an element `a` of type `α` which is invertible (has a multiplicative inverse denoted as ⅟a), then the product of ⅟a and `a` is equal to 'one'. This is a formal statement of a fundamental property of multiplicative inverses in the field of mathematics.

For any type `α` with multiplication and identity element, if `a` is invertible then `a * ⅟a = one`.


theorem CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_inv_comp :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t)
      (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso P Q).inv (s.π.app j) =
        t.π.app j :=
  by sorry

This theorem states that for any category `J` and `C`, and any covariant functor `F` from `J` to `C`, if `s` and `t` are limits of the functor `F`, with `P` certifying that `s` is a limit and `Q` certifying that `t` is a limit, then for any object `j` in the category `J`, the composition of the inverse of the isomorphism from `s.pt` to `t.pt` and the morphism from the limit cone `s` to `j` equals the morphism from the limit cone `t` to `j`. In essence, this shows that the points (or apexes) of the limiting cones `s` and `t` are uniquely determined up to isomorphism.

For any covariant functor F from category J to C, if objects s and t in C are limits of F with limit cones certified by P and Q respectively, then the inverse of the isomorphism from s.pt to t.pt equals the morphism from s to j composed with the morphism from j to t for any object j in J.


/-- A submonoid is closed under multiplication.  -/
theorem Submonoid.mul_mem :
    ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M) {x y : M}, x ∈ S → y ∈ S → x * y ∈ S := by sorry

This theorem states that a submonoid is closed under multiplication. In the context of any type `M` equipped with multiplication and a neutral element ("one"), if `S` is a submonoid of `M`, and if `x` and `y` are elements of `S`, then the multiplication of `x` and `y` (denoted `x * y`) is also an element of `S`. This is a fundamental property of submonoids: they are subsets of monoids that are also monoids with the inherited operation.

If `S` is a submonoid of a monoid `M` with multiplication `*` and neutral element `one`, then `x * y` belongs to `S` for all `x, y` in `S`.


theorem add_nsmul : ∀ {A : Type y} [inst : AddMonoid A] (a : A) (m n : ℕ), (m + n) • a = m • a + n • a := by sorry

This theorem states that for any type `A` that is an additive monoid, and for any element `a` of `A` and natural numbers `m` and `n`, the scalars `m` and `n` can distribute over the addition operation in `A`. More formally, if we perform an `n`-times scalar multiplication operation on `a` and add that to the result of an `m`-times scalar multiplication operation on `a`, the result is the same as performing an `(m + n)`-times scalar multiplication operation on `a`. In mathematical notation, this can be written as `(m + n) * a = m * a + n * a`, where `*` is the scalar multiplication operation.

For any additive monoid type `A` and elements `a` in `A` and natural numbers `m` and `n`, the distributive property holds: `(m + n) * a = m * a + n * a`.


CategoryTheory.Limits.Fork.condition

theorem CategoryTheory.Limits.Fork.condition :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      (t : CategoryTheory.Limits.Fork f g),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι t) f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι t) g :=
  by sorry

The theorem `CategoryTheory.Limits.Fork.condition` states that for any category `C`, any objects `X` and `Y` in `C`, and any morphisms `f` and `g` from `X` to `Y`, if we have a fork `t` on `f` and `g`, then the composition of the morphism from the apex of the fork `t` with `f` is equal to the composition of the morphism from the apex of the fork `t` with `g`. In other words, in the diagrammatic representation of the fork, the two possible paths from the apex of the fork to `Y` via `f` and `g` respectively are equal.

Given a category `C`, objects `X`, `Y`, morphisms `f`, `g`, and a fork `t` on `f` and `g` at `Y`, the composition of `t` with `f` equals the composition of `t` with `g`.


theorem Nat.gcd_comm : ∀ (m n : ℕ), Nat.gcd m n = Nat.gcd n m := by sorry

This theorem, `Nat.gcd_comm`, states that for all natural numbers `m` and `n`, the greatest common divisor (gcd) of `m` and `n` is the same as the gcd of `n` and `m`. In other words, the order in which the numbers are passed to the gcd function does not matter, making the gcd function commutative. This mirrors the mathematical property that $\gcd(m, n) = \gcd(n, m)$ for any natural numbers $m$ and $n$.

The greatest common divisor of natural numbers `m` and `n` is commutative, i.e., `gcd m n = gcd n m`.


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

The theorem `MvPolynomial.aeval_X` states that for any commutative semirings `R` and `S₁`, where `S₁` is an algebra over `R`, any map `f` from a type `σ` to `S₁`, and any element `s` of type `σ`, applying the algebraic evaluation map induced by `f` to the degree `1` multivariate polynomial `MvPolynomial.X s` (which corresponds to the monomial $X_s$) yields the value `f s`. In other terms, it means that the evaluation of the variable $X_s$ under the map `f` is exactly `f s`.

For any commutative semirings R and an algebra S₁ over R, map f from type σ to S₁, and element s of type σ, the algebraic evaluation of the degree 1 multivariate polynomial MvPolynomial.X s along f equals f(s).


theorem Option.map_id : ∀ {α : Type u_1}, Option.map id = id := by sorry

The theorem `Option.map_id` states that for any type `α`, mapping the identity function over an `Option` value results in the same `Option` value. In other words, if we have an `Option α` (which is either `some a` for some `a` of type `α`, or `none`), and we apply the `Option.map` function to it with the identity function as the argument, we get the original `Option α` back. This is essentially stating that the `Option.map` function is compatible with the identity function.

For any type `α`, the application of `Option.map` with the identity function to an `Option α` leaves it unchanged.


theorem Finset.map_eq_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] (f : α ↪ β) (s : Finset α),
      Finset.map f s = Finset.image (⇑f) s :=
  by sorry

The theorem `Finset.map_eq_image` states that for any two types `α` and `β` with `β` having decidable equality, and for any embedding function `f` from `α` to `β` and a finite set `s` of type `α`, the image of `s` under `f` obtained through the `map` function is the same as the image obtained through the `image` function. In other words, both operations `map` and `image` provide the same result when transforming a finite set via an embedding function. This is useful because it provides flexibility to use either the `map` or `image` function based on specific requirements without affecting the outcome.

For any finite set `s` of type `α` and an embedding function `f` from `α` to `β` with decidable equality, `map f s` equals `image f s`.


theorem Set.toFinset_card : ∀ {α : Type u_4} (s : Set α) [inst : Fintype ↑s], (Set.toFinset s).card = Fintype.card ↑s :=
  by sorry

The theorem `Set.toFinset_card` states that for any type `α` and any set `s` of that type, given a `Fintype` instance for the set `s`, the cardinality of the finite set corresponding to `s` (obtained using `Set.toFinset`) is equal to the cardinality of the `Fintype` instance of `s`. In other words, converting a finite set to a finite type and calculating the number of elements will yield the same result as directly calculating the number of elements in the original finite set.

For any finite type `α` and finite set `s` of type `α`, the cardinality of `Set.toFinset s` equals the cardinality of the `Fintype` instance of `s`.


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

This theorem, `Nat.dvd_antisymm`, states that for any two natural numbers `m` and `n`, if `m` divides `n` and `n` divides `m`, then `m` must be equal to `n`. In other words, if one natural number is a divisor of another and vice versa, the two numbers are the same. The divisibility relationship here is denoted by the `∣` symbol.

If `m` divides `n` and `n` divides `m` in the natural numbers, then `m` equals `n`. (`m ∣ n` and `n ∣ m` imply `m = n`)


theorem isometry_smul :
    ∀ {M : Type u} (X : Type w) [inst : PseudoEMetricSpace X] [inst_1 : SMul M X] [inst_2 : IsometricSMul M X] (c : M),
      Isometry fun x => c • x :=
  by sorry

This theorem states that, for any pseudoemetric space `X` and any type `M` with a scalar multiplication operation on `X` (denoted as `SMul M X`), if the scalar multiplication is isometric (i.e., it preserves the edistance, as captured by the `IsometricSMul M X` instance), then for any element `c` of type `M`, the function that multiplies each element of `X` by `c` is an isometry. In other words, scalar multiplication by `c` doesn't change the distances between the elements of the pseudoemetric space `X`.

For any pseudometric space `X` and type `M` with an isometric scalar multiplication `SMul M X`, the function that multiplies each element of `X` by an element `c` of `M` is an isometry. In other words, the scalar multiplication preserves the pseudo-metric on `X`.


theorem Nat.pos_iff_ne_zero : ∀ {n : ℕ}, 0 < n ↔ n ≠ 0 := by sorry

This theorem, `Nat.pos_iff_ne_zero`, states that for any natural number `n`, `n` is greater than 0 if and only if `n` is not equal to 0. In mathematical terms, this means ∀ n ∈ ℕ, n > 0 ↔ n ≠ 0.

A natural number is positive if and only if it is not zero. (Equivalently, n > 0 if and only if n ≠ 0.)


ConcaveOn.dual

theorem ConcaveOn.dual :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : SMul 𝕜 β] {s : Set E} {f : E → β},
      ConcaveOn 𝕜 s f → ConvexOn 𝕜 s (⇑OrderDual.toDual ∘ f) :=
  by sorry

The theorem `ConcaveOn.dual` states that for any ordered semiring `𝕜`, types `E` and `β`, additive commutative monoid `E`, ordered additive commutative monoid `β`, and scalar multiplication on `E` and `β`, given a set `s` of type `E` and a function `f` from `E` to `β`, if the function `f` is concave on the set `s`, then the function `f` composed with the identity function to the `OrderDual` of `β` is convex on the set `s`. Here, `OrderDual` of a type is a type that reverses the order of elements in the original type.

If `f` is a concave function from an additive commutative semigroup `E` to an ordered additive commutative monoid `β`, then the composition `f ∘ id` with the order dual `OrderDual β` is a convex function on `E`.


/-- A function applied to a `ite` is a `ite` of that function applied to each of the branches.  -/
theorem apply_ite :
    ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [inst : Decidable P] (x y : α),
      f (if P then x else y) = if P then f x else f y :=
  by sorry

This theorem states that for any function `f` mapping from a sort `α` to a sort `β`, a proposition `P`, and two objects `x` and `y` of sort `α`, applying `f` to the result of an 'if-then-else' expression (where `P` is the condition, `x` is the result if `P` is true, and `y` is the result if `P` is false) is the same as constructing a new 'if-then-else' expression where `f` is applied to `x` if `P` is true, and `f` is applied to `y` if `P` is false. In other words, it is permissible to move a function application inside an 'if-then-else' expression. This theorem requires that `P` be decidable.

For any decidable proposition P and functions f from sort α to sort β, the application of f to the result of an if-then-else expression (using P as the condition and x, y as the results for true and false, respectively) is equal to the if-then-else expression where f is applied to x if P holds, and f is applied to y otherwise.


theorem bot_sup_eq : ∀ {α : Type u} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (a : α), ⊥ ⊔ a = a := by sorry

This theorem states that, for any type `α` that is both a semilattice with respect to the supremum operation and has a least element (`OrderBot α`), the supremum (denoted by `⊔`) of the least element (denoted by `⊥`) and any element `a` of type `α` is always `a`. In other words, in such a structure, taking the supremum of the least element and any other element always yields that other element.

For any semilattice `α` with a least element, `⊔ ⊥ a = a`.


theorem abs_le : ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] {a b : α}, |a| ≤ b ↔ -b ≤ a ∧ a ≤ b := by sorry

This theorem states that for any type `α` that is a linearly ordered additive commutative group, the absolute value of a member `a` of that type is less than or equal to another member `b` of that type if and only if `a` is greater than or equal to negative `b` and also less than or equal to `b`. This theorem essentially defines the mathematical property that the absolute value of a number is within a range centered at zero.

For any linearly ordered additive commutative group type `α`, the absolute value `|a|` of `α` element `a` satisfies `-b ≤ a ≤ b` if and only if `|a| ≤ |b|`.


theorem abs_neg : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a : α), |(-a)| = |a| := by sorry

This theorem, `abs_neg`, states that for any type `α` which is a Lattice and an AddGroup, the absolute value of the negation of any element `a` of type `α` is equal to the absolute value of `a`. In mathematical terms, the theorem expresses the property that |(-a)| = |a| for all `a` in this type `α`.

For any type `α` being both a Lattice and an AddGroup, the absolute value of the negation of an element `a` equals the absolute value of `a`, i.e., |-a| = |a|.


theorem abs_mul : ∀ {α : Type u_1} [inst : LinearOrderedRing α] (a b : α), |a * b| = |a| * |b| := by sorry

This theorem, `abs_mul`, states that for any given type `α`, which is an instance of a `LinearOrderedRing`, the absolute value of the product of any two elements `a` and `b` of type `α` is equal to the product of the absolute values of `a` and `b`. In mathematical terms, it expresses that |a * b| = |a| * |b| for all a, b in a linear ordered ring.

For any linear ordered ring (α, +, *, |.|), |a * b| = |a| * |b| for all a, b in α.


theorem Submodule.mem_top :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
      x ∈ ⊤ :=
  by sorry

This theorem states that for any semiring `R` and additive commutative monoid `M` that forms a module over `R`, every element `x` of `M` belongs to the top element `⊤` of the submodule lattice. In other words, all elements of a module are included in the universal submodule.

For any semiring `R` and additive commutative monoid `M` being an `R`-module, every element of `M` belongs to the top element of the submodule lattice.


theorem Polynomial.Monic.ne_zero :
    ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : Nontrivial R] {p : Polynomial R}, Polynomial.Monic p → p ≠ 0 := by
  sorry

This theorem states that for any semiring `R` that is nontrivial (i.e., `R` has at least two distinct elements), if a polynomial `p` over `R` is monic (meaning its leading coefficient is 1), then `p` must be non-zero.

In a nontrivial semiring, every monic non-zero polynomial is non-zero.


List.Sublist.subperm

theorem List.Sublist.subperm : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.Subperm l₁ l₂ := by sorry

The theorem `List.Sublist.subperm` establishes that for any type `α` and any two lists `l₁` and `l₂` of that type, if `l₁` is a sublist of `l₂`, then `l₁` is also a subpermutation of `l₂`. In other words, if every element of `l₁` appears in `l₂` in the same order (which is the definition of a sublist), then we can find a permutation of `l₁` that is a sublist of `l₂`. This is a property connecting sublists and subpermutations in the context of lists.

If `l₁` is a sublist of `l₂`, then there exists a permutation of `l₁` that is a sublist of `l₂`.


theorem half_pos : ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a : α}, 0 < a → 0 < a / 2 := by sorry

This theorem, `half_pos`, states that for any type `α` that is a linear ordered semifield, if a value `a` of type `α` is greater than zero, then half of `a` is also greater than zero. In other words, dividing a positive number by 2 in such a field will still yield a positive number.

If `α` is a linear ordered semifield and `0 < a : α`, then `0 < a / 2`.


theorem Int.natAbs_mul : ∀ (a b : ℤ), Int.natAbs (a * b) = Int.natAbs a * Int.natAbs b := by sorry

The theorem `Int.natAbs_mul` states that for any two integers `a` and `b`, the absolute value of the product of `a` and `b` is equal to the product of the absolute values of `a` and `b`. In other words, in mathematical terms, it expresses that |ab| = |a|*|b| for all integers `a` and `b`. This theorem essentially shows that the function `Int.natAbs` (which converts an integer to its absolute value) is multiplicative.

For all integers a and b, |ab| = |a| * |b|.