theorem Finset.sup_le_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
      Finset.sup s f ≤ a ↔ ∀ b ∈ s, f b ≤ a :=
  by sorry

The theorem `Finset.sup_le_iff` states that for any types `α` and `β`, where `α` is a semilattice sup and has a bottom element, and given a finite set `s` of type `β`, a function `f` from `β` to `α`, and an element `a` of type `α`, the supremum of the set `s` under function `f` is less than or equal to `a` if and only if every element `b` in `s` satisfies `f(b)` is less than or equal to `a`. In mathematical terms, this can be written as: $\sup_{b\in s}f(b)\leq a \iff \forall b\in s, f(b)\leq a$.

For any semilattice sup type `α` with a bottom element, function `f` from a finite set `s` of type `β` to `α`, and element `a` of type `α`, the supremum of `f(s)` is less than or equal to `a` if and only if every `b` in `s` satisfies `f(b)` is less than or equal to `a`.


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

This theorem, `le_iff_lt_or_eq`, states that for any given type `α` that has a partial order, `a` is less than or equal to `b` if and only if `a` is strictly less than `b` or `a` equals `b`. Here, `a` and `b` are elements of the type `α`. This theorem connects the "less than or equal to" relation to the "strictly less than" relation and the "equality" relation in the context of a partial order.

For any type `α` with a partial order, `a ≤ b` if and only if `a < b` or `a = b`.


theorem ENNReal.inv_zero : 0⁻¹ = ⊤ := by sorry

This theorem states that the reciprocal (or 'inverse') of zero in the extended non-negative real numbers is positive infinity. In other words, when you take 1 divided by 0 in the set of extended non-negative real numbers (which includes positive real numbers, zero, and positive infinity), you get positive infinity. This convention is often used in mathematical analysis to handle certain types of limits and operations.

In the extended non-negative real numbers, 0^-1 = +∞.


theorem Set.mem_smul_set_iff_inv_smul_mem₀ :
    ∀ {α : Type u_2} {β : Type u_3} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
      a ≠ 0 → ∀ (A : Set β) (x : β), x ∈ a • A ↔ a⁻¹ • x ∈ A :=
  by sorry

This theorem states that for any types `α` and `β`, given `α` as a group with zero and `β` as a set on which `α` acts multiplicatively, for any non-zero element `a` of `α`, any set `A` of `β`, and any element `x` of `β`, `x` is an element of the set `A` scaled by `a` if and only if the inverse of `a` scaled by `x` is an element of `A`. This provides a characterization for membership of a point in a scaled set in terms of the action of the inverse of the scaling factor on the point.

For any group `α` with zero, set `β`, and non-zero `a` in `α`, an element `x` in `β` belongs to the set `A` scaled by `a` if and only if the inverse of `a` scaled by `x` belongs to `A`.


/-- Group homomorphisms preserve division.  -/
theorem map_div :
    ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
      [inst_3 : MonoidHomClass F G H] (f : F) (a b : G), f (a / b) = f a / f b :=
  by sorry

The theorem `map_div` states that for any groups `G` and `H`, and for any type `F` that is a function-like from `G` to `H`, if `F` is a homomorphism between the monoids `G` and `H`, and `H` is a division monoid, then this homomorphism preserves the division operation. In other words, applying the homomorphism to the quotient of two elements from `G` results in the same value as the quotient of the images of the two elements under the homomorphism.

If `F : G →* H` is a homomorphism of monoids from a group `G` into a division monoid `H`, then `F (x / y) = F x / F y` for all `x, y ∈ G`.


theorem Mathlib.Algebra.GroupWithZero.Basic._auxLemma.15 :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) := by sorry

This theorem, named `Mathlib.Algebra.GroupWithZero.Basic._auxLemma.15`, states that for any type `G₀` that has a GroupWithZero structure, the inverse `a⁻¹` of any element `a` of `G₀` is zero if and only if `a` itself is zero. In the context of algebra, a GroupWithZero is a group with an additional zero element that is distinct from the identity and annihilates the group under multiplication.

For any GroupWithZero type `G₀`, the inverse of an element `a` is zero if and only if `a` itself is the zero element.


Continuous.neg

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

This theorem states that for any topological space `G` and any other type `α` with a continuous function `f : α → G`, if `G` supports negation operation and this negation operation is continuous, then the function that applies negation to the result of `f`, i.e., `-f x`, is also continuous. In mathematical parlance, if `f` is continuous and `G` is a topological space with a continuous negation, then the composition of `f` with the negation function is also continuous.

If `f : α → G` is a continuous function from a type `α` to a topological space `G` with a continuous negation operation, then the function `-f : α → G` defined by `-f x := -(f x)` is continuous.


theorem Nat.odd_iff : ∀ {n : ℕ}, Odd n ↔ n % 2 = 1 := by sorry

This theorem establishes an equivalence for a natural number `n` to be considered odd in two different ways. According to the theorem, a natural number `n` is odd if and only if `n` modulo 2 equals 1. This is equivalent to the definition of oddness in semirings, where an element `a` of a semiring is considered odd if there exists a `k` such that `a` is equal to `2*k + 1`.

A natural number `n` is equivalent to being odd, as defined in Lean 4, if and only if `n` modulo 2 equals 1, which is equivalent to `n` being expressible as `2*k + 1` for some natural number `k`.


theorem Mathlib.Data.Complex.Basic._auxLemma.8 : ∀ {z : ℂ}, (0 < Complex.normSq z) = (z ≠ 0) := by sorry

This theorem states that for any complex number 'z', the norm squared of 'z' (denoted as Complex.normSq z), is greater than zero if and only if 'z' is not equal to zero. In other words, the norm squared of a complex number is positive if the complex number is non-zero.

The theorem asserts that the square of the complex norm is positive for non-zero complex numbers.


theorem Set.left_mem_Ico : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ∈ Set.Ico a b ↔ a < b := by sorry

This theorem states that for any type `α` that has a preorder (an order that is reflexive and transitive), and for any two elements `a` and `b` of `α`, `a` is an element of the left-closed right-open interval from `a` to `b` (denoted by `Set.Ico a b` in Lean) if and only if `a` is less than `b`. This interval is defined as the set of all `x` in `α` such that `a` is less than or equal to `x` and `x` is strictly less than `b`.

For any preordered type `α` and elements `a` and `b` of `α`, `a` belongs to the left-closed right-open interval `[a, b)` if and only if `a` is less than `b`.


LinearIsometryEquiv.continuous

theorem LinearIsometryEquiv.continuous :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂), Continuous ⇑e :=
  by sorry

This theorem states that for any linear isometry equivalence `e` between two seminormed additive commutative group modules `E` and `E₂`, over semirings `R` and `R₂` respectively with ring homomorphism pairs `σ₁₂` and `σ₂₁`, the mapping defined by `e` is continuous. This means, intuitively, that small changes in the input to `e` result in small changes in its output, in the context of topological spaces - which in this case are the modules `E` and `E₂`.

For any linear isometry equivalence between seminormed additive commutative group modules over commutative semirings with compatible ring homomorphisms, the equivalence is a continuous linear map between the modules.


theorem OrderEmbedding.lt_iff_lt :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β) {a b : α},
      f a < f b ↔ a < b :=
  by sorry

The theorem `OrderEmbedding.lt_iff_lt` states that for any two types `α` and `β` that are both preordered, and any order-embedding function `f` from `α` to `β`, the images `f a` and `f b` of any two elements `a` and `b` of `α` under `f` satisfy `f a < f b` if and only if `a < b`. In other words, the order-embedding function preserves the order of the elements from `α` into `β`.

For any preordered types `α` and `β` and order-embedding function `f` from `α` to `β`, `a < b` in `α` implies `f a < f b` in `β`.


theorem eq_self_iff_true : ∀ {α : Sort u_1} (a : α), a = a ↔ True := by sorry

This theorem, `eq_self_iff_true`, states that for any sort `α` and any instance `a` of `α`, the equality of `a` to itself is equivalent to the truth value `True`. In other words, an element is always equal to itself, and this self-equality can be replaced with `True` in logical expressions. This is a fundamental property of equality in mathematics, often known as the Reflexivity of Equality.

For all types α and elements a : α, a = a if and only if True. (Reflexivity of Equality)


CategoryTheory.IsPullback.flip

theorem CategoryTheory.IsPullback.flip :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z}
      {g : Y ⟶ Z}, CategoryTheory.IsPullback fst snd f g → CategoryTheory.IsPullback snd fst g f :=
  by sorry

This theorem states that in any category `C`, if we have objects `P`, `X`, `Y`, and `Z` with morphisms `fst : P ⟶ X`, `snd : P ⟶ Y`, `f : X ⟶ Z` and `g : Y ⟶ Z` that form a pullback square (meaning that the diagram commutes and `P` is a product of `X` and `Y` over `Z` with projections `fst` and `snd`), then flipping the roles of `X` and `Y`, and `fst` and `snd`, also results in a pullback square. In other words, a pullback in a category is symmetric with respect to the two projection morphisms.

In a category C, if objects P, X, Y, and Z, and morphisms fst : P → X, snd : P → Y, f : X → Z, and g : Y → Z form a pullback square, then interchanging X and Y, and fst and snd, also results in a pullback square.


theorem Set.nonempty_Icc : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Nonempty (Set.Icc a b) ↔ a ≤ b := by
  sorry

This theorem, `Set.nonempty_Icc`, states that for any type `α` (denoted by `{α : Type u_1}`) equipped with a preorder (denoted by `[inst : Preorder α]`), and any two elements `a` and `b` of type `α` (denoted by `{a b : α}`), the left-closed and right-closed interval from `a` to `b` (expressed as `Set.Icc a b`) is nonempty if and only if `a` is less than or equal to `b`. In other words, there exists at least one element in the interval `[a, b]` if `a ≤ b`.

For any type `α` with preorder and any `a, b ∈ α`, the interval `Icc a b` is nonempty if and only if `a ≤ b`.


theorem Measurable.subtype_mk :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {p : β → Prop} {f : α → β},
      Measurable f → ∀ {h : ∀ (x : α), p (f x)}, Measurable fun x => { val := f x, property := ⋯ } :=
  by sorry

The theorem `Measurable.subtype_mk` states that for all types `α` and `β` with measurable spaces `m` and `mβ` respectively, for any property `p` of `β` and any function `f` from `α` to `β`, if `f` is a measurable function and, for all `x` in `α`, `p (f x)` holds, then the function that maps `x` to the subtype `{ val := f x, property := ⋯ }` is also measurable. Here, the subtype `{ val := f x, property := ⋯ }` is the set of elements of `β` that satisfy the property `p` and its measurability means that the preimage of any measurable set under this function is also measurable.

If `f` is a measurable function from a measurable space `(α, m)` to another measurable space `(β, mβ)`, and for all `x` in `α`, `p(f x)` holds where `p` is a property of `β`, then the function that maps `x` to the subtype `{val := f x, property := p(f x)}` is also measurable.


theorem isLUB_sSup : ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] (s : Set α), IsLUB s (sSup s) := by sorry

The theorem `isLUB_sSup` states that for any set `s` in a complete semilattice with supremum (denoted by `CompleteSemilatticeSup`), the supremum of the set `s` (denoted by `sSup s`) is a least upper bound of the set `s`. Here, a least upper bound of a set is defined as the smallest element that is greater than or equal to every element in the set. In other words, if `α` is a type that forms a complete semilattice with supremum, then for any set of elements of type `α`, the supremum of the set serves as a least upper bound for that set.

In a complete semilattice with supremum, the supremum is the least upper bound of any set.


theorem HasDerivAt.comp_hasFDerivAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type w} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {𝕜' : Type u_1} [inst_3 : NontriviallyNormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜']
      {h₂ : 𝕜' → 𝕜'} {h₂' : 𝕜'} {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} (x : E),
      HasDerivAt h₂ h₂' (f x) → HasFDerivAt f f' x → HasFDerivAt (h₂ ∘ f) (h₂' • f') x :=
  by sorry

This theorem states that if a function `h₂` has a derivative `h₂'` at the point `f(x)` and a function `f` has a continuous linear map `f'` as a derivative at the point `x`, then the composition of `h₂` and `f` has a derivative at the point `x` which is the scalar product of `h₂'` and `f'`. In more mathematical terms, if `h₂` is differentiable at `f(x)` and `f` is differentiable at `x`, then `(h₂ ∘ f)` is differentiable at `x`, and the derivative is given by `h₂' • f'`.

If functions `f` and `h₂` are differentiable at points `x` and `f(x)` respectively, then their composition `h₂ ∘ f` is differentiable at `x`, and its derivative is equal to the scalar product of `h₂'` and `f'`, where `h₂'` is the derivative of `h₂` and `f'` is the derivative of `f`.


theorem Finset.coe_sup' :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α),
      ↑(Finset.sup' s H f) = Finset.sup s (WithBot.some ∘ f) :=
  by sorry

This theorem states that for any types `α` and `β`, where `α` forms a join-semilattice, and for any nonempty finite set `s` of type `β`, as well as any function `f` from `β` to `α`, the supremum of the image of `s` under `f` when taken as an element of the extended type `WithBot α`, is equal to the supremum of the image under `f` composed with the canonical map from `α` to `WithBot α`. In other words, `↑(Finset.sup' s H f)` (the coercive map of the supremum of the image of `s` under `f` to `WithBot α`) equals `Finset.sup s (WithBot.some ∘ f)` (the supremum of the image under `f` composed with the canonical embedding to `WithBot α`). This establishes the commutativity between the supremum operation and the canonical embedding function in this context.

For any join-semilattice `α`, function `f` from type `β` to `α`, and nonempty finite set `s` of type `β`, the supremum of `f` applied to `s` in the extended type `WithBot α` equals the supremum of `f`(x) for all x in `s`, composed with the canonical map from `α` to `WithBot α`.


theorem Ideal.mk_ker : ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, RingHom.ker (Ideal.Quotient.mk I) = I := by
  sorry

The theorem `Ideal.mk_ker` states that for an arbitrary commutative ring `R` and any ideal `I` of `R`, the kernel of the ring homomorphism from `R` to the quotient ring `R/I` (denoted as `Ideal.Quotient.mk I`) is exactly the ideal `I` itself. In other words, all elements of `R` that map to the additive identity in the quotient ring `R/I` form the ideal `I`.

The kernel of the quotient homomorphism from a commutative ring to its quotient by an ideal equals that ideal.


theorem eq_intCast :
    ∀ {F : Type u_1} {α : Type u_3} [inst : NonAssocRing α] [inst_1 : FunLike F ℤ α] [inst_2 : RingHomClass F ℤ α]
      (f : F) (n : ℤ), f n = ↑n :=
  by sorry

The theorem `eq_intCast` states that for any type `F` and `α`, where `α` is a non-associative ring, `F` is a type which behaves like a function from integers to `α` (expressed by the `FunLike F ℤ α` instance), and `F` is a ring homomorphism from integers to `α` (expressed by the `RingHomClass F ℤ α` instance), then for any function `f` of type `F` and any integer `n`, the result of applying `f` to `n` is equal to the integer value of `n` coerced to type `α` (expressed by `f n = ↑n`).

For any non-associative ring `α` and a ring homomorphism `F : ℤ → α` (behaving like a function), `F(n) = ↑n` for all integers `n`.


theorem IsOfFinAddOrder.addOrderOf_pos :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, IsOfFinAddOrder x → 0 < addOrderOf x := by sorry

The theorem `IsOfFinAddOrder.addOrderOf_pos` states that for any additive monoid `G` and any element `x` of `G`, if `x` has a finite additive order (i.e., there exists a positive integer `n` such that `n` times `x` equals the additive identity), then the additive order of `x` (which is the smallest positive `n` that satisfies `n * x = 0`) is strictly greater than zero.

For any additive monoid G and any element x with finite additive order, the additive order of x is a positive integer.


Function.Injective.countable

theorem Function.Injective.countable :
    ∀ {α : Sort u} {β : Sort v} [inst : Countable β] {f : α → β}, Function.Injective f → Countable α := by sorry

The theorem `Function.Injective.countable` states that for any two types `α` and `β`, if `β` is countable (i.e., there exists a surjective function from the natural numbers to `β`) and `f` is a function from `α` to `β` that is injective (i.e., no two different elements in `α` map to the same element in `β`), then `α` is also countable. In other words, if we have an injective function from `α` to a countable set `β`, then `α` must also be countable.

If `β` is countable and `f : α → β` is an injective function, then `α` is countable.


theorem Int.ofNat_mul : ∀ (n m : ℕ), ↑(n * m) = ↑n * ↑m := by sorry

This theorem, `Int.ofNat_mul`, demonstrates a property of the multiplication operation involving natural numbers and integers. Specifically, it states that for all natural numbers `n` and `m`, the result of first multiplying `n` and `m` (as natural numbers) and then casting the result to an integer is the same as first casting `n` and `m` to integers and then multiplying them. In mathematical notation, this can be written as \( \forall n, m \in \mathbb{N}, \, \text{Int}(n \cdot m) = \text{Int}(n) \cdot \text{Int}(m) \). This theorem exemplifies the preservation of the multiplication operation under the embedding of the natural numbers into the integers.

For all natural numbers `n` and `m`, the conversion of `n` and `m` to integers and their multiplication is equal to the multiplication of the integer conversions of `n` and `m`. In mathematical notation, \( \forall n, m \in \mathbb{N}, \ \text{Int}(n) \cdot \text{Int}(m) = \text{Int}(n \cdot m) \).


/-- The indexed minimum of a function is bounded below by a uniform lower bound -/
theorem le_ciInf :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [inst_1 : Nonempty ι] {f : ι → α} {c : α},
      (∀ (x : ι), c ≤ f x) → c ≤ iInf f :=
  by sorry

The theorem `le_ciInf` states that for any type `α` that forms a conditionally complete lattice and any nonempty indexing type `ι`, given a function `f` from `ι` to `α` and an element `c` of `α`, if `c` is less than or equal to the value of `f` at every point in the indexing type `ι`, then `c` is less than or equal to the indexed infimum of `f`. In other words, if `c` is a lower bound for the range of `f`, then `c` is less than or equal to the greatest lower bound of the range of `f`.

If `α` is a conditionally complete lattice and `f: ι → α` is a function with `c ∈ α` being a lower bound of `{f x | x ∈ ι}`, then `c ≤ ⨯₋ x. (f x)` (infimum of `f`).


theorem MeasureTheory.Integrable.hasFiniteIntegral :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.HasFiniteIntegral f μ :=
  by sorry

The theorem `MeasureTheory.Integrable.hasFiniteIntegral` states that for any measure space `α` with a measure `μ`, any normed add commutative group `β`, and any function `f` from `α` to `β`, if the function `f` is integrable with respect to `μ`, then the integral of the norm of `f` with respect to `μ` is finite. In other words, if `f` satisfies the properties of being measurable and having a finite integral, then the integral `∫⁻ a, ‖f a‖ ∂μ` is finite.

If a function from a measure space to a normed add commutative group is integrable, then the integral of the norm of the function is finite.


List.Perm.map

theorem List.Perm.map :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {l₁ l₂ : List α},
      List.Perm l₁ l₂ → List.Perm (List.map f l₁) (List.map f l₂) :=
  by sorry

The theorem `List.Perm.map` states that for any two lists `l₁` and `l₂` of type `α` and a function `f` that maps from `α` to `β`, if `l₁` and `l₂` are permutations of each other, then the lists resulting from mapping `f` to each element of `l₁` and `l₂` are also permutations of each other. In other words, applying the same function to each element of two lists that are permutations of each other will yield two new lists that are also permutations of each other.

If `l₁` and `l₂` are permutations of each other, then `map f l₁` and `map f l₂` are also permutations of each other for any function `f` from type `α` to type `β`.


theorem Set.Ioi_inter_Iic : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioi a ∩ Set.Iic b = Set.Ioc a b := by
  sorry

This theorem states that for any type `α` equipped with a preorder relation, and for any two elements `a` and `b` of this type, the intersection of the set of elements greater than `a` (an open interval on the left) and the set of elements less than or equal to `b` (a closed interval on the right) is exactly the set of elements that are strictly greater than `a` and less than or equal to `b` (a left-open right-closed interval). In other words, $(a, +\infty) \cap (-\infty, b] = (a, b]$.

For any preordered type `α` and elements `a` and `b` of `α`, the intersection of the sets of elements strictly greater than `a` and less than or equal to `b` equals the set of elements strictly greater than `a` and less than or equal to `b`. In other words, $(a, \infty) \cap (-\infty, b] = (a, b]$.


theorem Option.map₂_none_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (f : α → β → γ) (a : Option α), Option.map₂ f a none = none := by
  sorry

This theorem states that for any types α, β, and γ, and any binary function `f` from α and β to γ, if you apply the function `Option.map₂` to `f` and an optional value of α, with the second optional value being `none`, the result will always be `none`. In other words, if the second argument of the `Option.map₂` function is a `none`, no matter what the other arguments are, the function will always return a `none`.

For any types α, β, and γ, and any binary function f: α × β → γ, Option.map₂ f (some x) none = none, where Option is the option type.


MeasurableEquiv.measurable

theorem MeasurableEquiv.measurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
      Measurable ⇑e :=
  by sorry

This theorem states that for any two types `α` and `β` which are equipped with measurable spaces, any measurable equivalence `e` from `α` to `β` is a measurable function. In other words, if `e` is a bijective mapping from `α` to `β` such that both `e` and its inverse are measurable (i.e., the preimage of any measurable set under either function is measurable), then the function `e` itself is measurable. This means that for any measurable set in the codomain `β`, its preimage under `e` is a measurable set in the domain `α`.

If `α` and `β` are measurable spaces and `e: α → β` is a bijective measurable function with measurable inverse, then `e` is a measurable function.


PartialEquiv.ext

/-- Two partial equivs that have the same `source`, same `toFun` and same `invFun`, coincide.  -/
theorem PartialEquiv.ext :
    ∀ {α : Type u_1} {β : Type u_2} {e e' : PartialEquiv α β},
      (∀ (x : α), ↑e x = ↑e' x) →
        (∀ (x : β), ↑(PartialEquiv.symm e) x = ↑(PartialEquiv.symm e') x) → e.source = e'.source → e = e' :=
  by sorry

The theorem `PartialEquiv.ext` states that for any two partial equivalences `e` and `e'` between two types `α` and `β`, if `e` and `e'` have the same source, and for every `x` in `α` and `β`, the application of `e` and `e'` (or their inverses) to `x` produces the same result, then `e` and `e'` must be identical. In other words, two partial equivalences are the same if they have the same source and map elements in the same way in both directions.

If two partial equivalences between types have the same source and agree on their applications to elements, they are equal.


Iff.refl

theorem Iff.refl : ∀ (a : Prop), a ↔ a := by sorry

This theorem, `Iff.refl`, asserts that for any proposition `a`, `a` is logically equivalent to itself. In other words, it establishes the reflexivity of logical equivalence. For any proposition, it is always true that the proposition implies itself and is implied by itself. This is a fundamental concept in logic.

For all propositions `a`, `a` is logically equivalent to itself.


theorem Set.Nonempty.some_mem : ∀ {α : Type u} {s : Set α} (h : Set.Nonempty s), Set.Nonempty.some h ∈ s := by sorry

The theorem `Set.Nonempty.some_mem` states that for any type `α` and any set `s` of type `Set α`, if `s` is nonempty, then the element extracted by the function `Set.Nonempty.some` from the nonemptiness property `h` is an element of the set `s`. This theorem is significant because it allows us to extract an element from a nonempty set and guarantees that the extracted element is indeed a member of the set.

For any nonempty set `s` of type `α`, the element extracted by `Set.Nonempty.some` from its nonemptiness proof `h` is an element of `s`.


theorem Function.rightInverse_surjInv :
    ∀ {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Surjective f),
      Function.RightInverse (Function.surjInv hf) f :=
  by sorry

This theorem states that for any sets `α` and `β`, and function `f` that maps `α` to `β`, if `f` is surjective (meaning every element in `β` can be mapped from some element in `α`), then the function `surjInv hf` is a right inverse to `f`. In other words, the composition of `f` and `surjInv hf` (in that order) is the identity function on `β`. In mathematical notation, this would be expressed as `f ∘ (surjInv hf) = id`, where `id` is the identity function. The function `surjInv hf` is defined as the inverse of the surjective function `f`.

For any surjective function `f` from set `α` to set `β`, there exists a unique function `g` from `β` to `α` such that `f ∘ g = id_{{\beta}}`.


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

This theorem, `Nat.pos_of_dvd_of_pos`, states that for any two natural numbers `m` and `n`, if `m` divides `n` and `n` is greater than 0, then `m` is also greater than 0. In terms of number theory, it asserts that a non-zero number cannot be divided by zero, since division by zero is undefined.

If `m` divides `n` and `n` is positive, then `m` is also positive.


theorem Matrix.transpose_transpose :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (M : Matrix m n α), Matrix.transpose (Matrix.transpose M) = M := by
  sorry

This theorem states that for any matrix `M` with entries in a type `α` and whose rows are indexed by a type `m` and columns are indexed by a type `n`, the transpose of the transpose of `M` is equal to `M` itself. This is a fundamental property of matrices, identical to the mathematical statement that the double transpose of a matrix returns the original matrix. In mathematical terms, if $M$ is any matrix, then $(M^T)^T = M$, where $T$ denotes the transpose operation.

The transpose of a matrix's transpose is equal to the original matrix.


theorem Nat.add_sub_cancel_left : ∀ (n m : ℕ), n + m - n = m := by sorry

This theorem states that for all natural numbers 'n' and 'm', if you subtract 'n' from the sum of 'n' and 'm', you will get 'm'. In other words, this is the cancellation law of addition and subtraction for natural numbers: adding a number and then subtracting the same number leaves you with the original number.

For all natural numbers n and m, n + m = (n + m) - n.


theorem tsub_le_self :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b : α},
      a - b ≤ a :=
  by sorry

This theorem states that for any type `α` that is a canonically ordered additive commutative monoid (where addition is associative, commutative, and has an identity element, and there exists a canonical total order compatible with the addition), which also supports subtraction and the subtraction operation is ordered, the result of subtracting any element `b` from another element `a` is always less than or equal to `a`. In other words, for all `a` and `b` in `α`, `a - b ≤ a`.

For any canonically ordered, additive commutative monoid `α` with subtraction that respects the order, for all `a` and `b` in `α`, `a - b ≤ a`.


theorem MeasureTheory.integrable_const :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      [inst_1 : MeasureTheory.IsFiniteMeasure μ] (c : β), MeasureTheory.Integrable (fun x => c) μ :=
  by sorry

The theorem `MeasureTheory.integrable_const` states that for any types `α` and `β`, with `α` having a measurable space structure and a measure `μ`, and `β` forming a normed additively commutative group, if the measure `μ` is finite, then the constant function mapping every element of `α` to a fixed value `c` in `β` is integrable with respect to the measure `μ`. In other words, a constant function is measurable and its integral over the measure space is finite.

For any measurable space `(α, Σ, μ)` with a finite measure `μ`, and any constant function `c : β`, the constant function from `α` to `β` is Σ-integrable.


theorem Complex.continuous_exp : Continuous Complex.exp := by sorry

The theorem `Complex.continuous_exp` states that the complex exponential function is continuous. In other words, for any given complex number, any small change in the input results in a correspondingly small change in the output of the function. This is a fundamental property of the complex exponential function, which is defined via its Taylor series in Lean 4.

The complex exponential function is a continuous mapping from the complex numbers to themselves.


SetTheory.PGame.Relabelling.equiv

/-- A relabelling lets us prove equivalence of games.  -/
theorem SetTheory.PGame.Relabelling.equiv : ∀ {x y : SetTheory.PGame}, SetTheory.PGame.Relabelling x y → x ≈ y := by
  sorry

This theorem states that if we have a relabelling of any two games `x` and `y` in Set Theory's Game theory, then `x` and `y` are equivalent. In other words, if we can essentially rename the moves in game `x` to match the moves in game `y` without changing the structure of the game itself, then the two games are equivalent in terms of strategy and outcome. Here, equivalence (≈) is a specific mathematical concept that means the two games have the same outcomes for optimal play.

If two games in Set Theory's Game theory are relabeling equivalent, then they are strategically and outcome-wise equal.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.18 : (0 < ⊤) = True := by sorry

This theorem, named `Mathlib.Data.ENNReal.Basic._auxLemma.18`, states that the positive infinity (`⊤`) is greater than zero. In mathematical terms, the inequality `0 < ⊤` is true. This theorem comes from the `Mathlib.Data.ENNReal.Basic` collection of lemmas and theorems in Lean 4.

The theorem `Mathlib.Data.ENNReal.Basic._auxLemma.18` in Lean 4 asserts that 0 is less than positive infinity (0 < ⊤).


theorem Set.BijOn.image_eq :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → f '' s = t := by sorry

This theorem states that for any two types `α` and `β`, and for any sets `s` of type `α` and `t` of type `β`, and any function `f` mapping from `α` to `β`, if the function `f` is bijective from set `s` to set `t` (i.e., `f` is injective on `s` and `f` maps `s` to `t`), then the image of set `s` under function `f` is equal to set `t`. In mathematical terms, we can say that for a bijective function `f : α → β`, `f(s) = t`.

For any sets `s` of type `α` and `t` of type `β`, and any bijective function `f : α → β`, `f(s) = t`.


theorem Real.log_mul : ∀ {x y : ℝ}, x ≠ 0 → y ≠ 0 → Real.log (x * y) = Real.log x + Real.log y := by sorry

This theorem states that for all real numbers `x` and `y`, given that neither `x` nor `y` are zero, the logarithm of the product of `x` and `y` is equal to the sum of the logarithm of `x` and the logarithm of `y`. In other words, `log(x * y) = log(x) + log(y)` for all non-zero real numbers `x` and `y`. This property is a well-known logarithmic identity, often referred to as the product rule of logarithms.

For all non-zero real numbers `x` and `y`, `log(x * y) = log(x) + log(y)`.


theorem List.take_append_drop : ∀ {α : Type u_1} (n : ℕ) (l : List α), List.take n l ++ List.drop n l = l := by sorry

The theorem `List.take_append_drop` states that for any type `α`, any natural number `n`, and any list `l` of type `α`, if you take the first `n` elements from the list `l` and concatenate (`++`) it with the result of dropping the first `n` elements from the list `l`, you will get the original list `l` back. This theorem asserts that splitting a list into a "taken" part and a "dropped" part and then appending them together gives you back the original list.

For any type `α` and natural number `n`, the list `take n l ++ drop n l` equals `l`, where `take n` and `drop n` are the functions that return the first `n` elements and remaining elements of a list `l` respectively.


theorem Mathlib.Algebra.Divisibility.Units._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Monoid α] {a u : α}, IsUnit u → (u ∣ a) = True := by sorry

This theorem states that for any type `α` that forms a Monoid, and for any elements `a` and `u` of `α`, if `u` is a unit (meaning it has a two-sided inverse in the Monoid), then `u` divides `a`. Here, the divisibility relation `u ∣ a` is always true if `u` is a unit element, regardless of what `a` is.

For any monoid `α` and unit `u` in `α`, `u` divides every element `a` in `α`.


theorem CategoryTheory.Limits.coprod.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryCoproduct X Y] {f g : X ⨿ Y ⟶ W},
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl f =
          CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl g →
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr f =
            CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr g →
          f = g :=
  by sorry

The theorem `CategoryTheory.Limits.coprod.hom_ext` states that in a category `C` with binary coproduct of objects `X` and `Y`, for any two morphisms `f` and `g` from the coproduct `X ⨿ Y` to another object `W`, if the composition of `f` and the inclusion map from `X` to `X ⨿ Y` is equal to the composition of `g` and the same inclusion map, and similarly for the inclusion from `Y`, then `f` must be equal to `g`. This can be viewed as a uniqueness property of morphisms out of the binary coproduct.

In a category with binary coproducts, if for morphisms `f` and `g` from `X ⨿ Y` to `W`, the composition of `f` with the inclusion of `X` is equal to the composition of `g` with the inclusion of `X`, and the same for the inclusion of `Y`, then `f` is equal to `g`.


Asymptotics.IsEquivalent.symm

theorem Asymptotics.IsEquivalent.symm :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
      Asymptotics.IsEquivalent l u v → Asymptotics.IsEquivalent l v u :=
  by sorry

The theorem `Asymptotics.IsEquivalent.symm` states that for any two functions `u` and `v` over a normed additive commutative group `β` and a filter `l` in `α`, if `u` and `v` are asymptotically equivalent along `l` (in the sense that the difference between `u x` and `v x` is infinitesimal compared to `v x` as `x` approaches `l`), then `v` and `u` are also asymptotically equivalent along `l`. In other words, the relationship of asymptotic equivalence between two functions along a filter is symmetric.

If functions `u` and `v` are asymptotically equivalent along filter `l` in a normed additive commutative group `β`, then `v` and `u` are also asymptotically equivalent along `l`.


Path.target

theorem Path.target : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (γ : Path x y), γ 1 = y := by sorry

This theorem, "Path.target", states that for every path `γ` from point `x` to point `y` in any topological space `X`, the endpoint of the path (which is `γ` evaluated at `1`) is equal to `y`. The theorem holds for all types `X` and points `x` and `y` in `X`. In simpler terms, the theorem ensures that a path starting at `x` and ending at `y` indeed ends at `y`.

For every path γ : X → ℝ with endpoints x and y in any topological space X, x = γ 1 implies y = γ 1.


theorem Matrix.empty_eq : ∀ {α : Type u} (v : Fin 0 → α), v = ![] := by sorry

This theorem states that for any type `α` and any function `v` that maps from the finite type of size 0 (essentially an empty set) to `α`, `v` is equal to an empty list. In other words, any function from an empty set to some type can only be represented as an empty list in the context of matrices.

For any type `α` and any function `v : Fin 0 → α`, `v` is equal to the empty list `[] : list α`.


theorem div_inv_eq_mul : ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b : α), a / b⁻¹ = a * b := by sorry

This theorem states that for any type `α` that is a division monoid, and for any two elements `a` and `b` of that type, the quotient of `a` by the inverse of `b` (`b⁻¹`) is equal to the product of `a` and `b`. In mathematical terms, it says that for all `a` and `b` in `α`, `a / b⁻¹ = a * b`.

For any division monoid `α`, the quotient of `a` by the inverse of `b` equals the product of `a` and `b`, i.e., `a / b⁻¹ = a * b`.


theorem List.foldl_append :
    ∀ {α : Type u_1} {β : Type u_2} (f : β → α → β) (b : β) (l l' : List α),
      List.foldl f b (l ++ l') = List.foldl f (List.foldl f b l) l' :=
  by sorry

The theorem `List.foldl_append` states that for all types `α` and `β`, and for any function `f` of type `β → α → β`, any element `b` of type `β`, and any two lists `l` and `l'` of type `List α`, folding `f` over the concatenation of `l` and `l'` starting with `b`, is equivalent to folding `f` over `l'`, but starting with the result of folding `f` over `l` starting with `b`. In mathematical terms, `foldl f b (l ++ l') = foldl f (foldl f b l) l'`. This is a property of how folding a function over a list interacts with list concatenation.

For all types `α` and `β` and functions `f` of type `β → α → β`, the composition of folding `f` over list `l` starting with `b` and then concatenating list `l'`, is equivalent to folding `f` over list `l'` starting with the result of folding `f` over `l` starting with `b`. In mathematical notation: `(∀ α β, (∀ (f : β → α → β), foldl f b (l ++ l') = foldl f (foldl f b l) l')`.


theorem Quot.exists_rep : ∀ {α : Sort u} {r : α → α → Prop} (q : Quot r), ∃ a, Quot.mk r a = q := by sorry

This theorem, `Quot.exists_rep`, states that for any type `α` and any equivalence relation `r` on `α`, for every element `q` of the quotient type `Quot r` (the type of equivalence classes of `α` under `r`), there exists an element `a` of `α` such that `a` is a representative of the equivalence class `q`. In other words, each equivalence class in the quotient type `Quot r` has at least one representative element in the original type `α`.

For every equivalence relation `r` on type `α` and every equivalence class `q` in the quotient `Quot r`, there exists a representative `a` in `α` such that `a` is related to every element in `q` under `r`.


theorem CategoryTheory.Limits.Fork.IsLimit.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      {s : CategoryTheory.Limits.Fork f g},
      CategoryTheory.Limits.IsLimit s →
        ∀ {W : C} {k l : W ⟶ s.pt},
          CategoryTheory.CategoryStruct.comp k (CategoryTheory.Limits.Fork.ι s) =
              CategoryTheory.CategoryStruct.comp l (CategoryTheory.Limits.Fork.ι s) →
            k = l :=
  by sorry

This theorem, `CategoryTheory.Limits.Fork.IsLimit.hom_ext`, states that in a category `C`, for any two morphisms `f` and `g` from object `X` to object `Y`, given a fork `s` on `f` and `g` that is a limit, for any object `W` and any two morphisms `k` and `l` from `W` to the fork's point `s.pt`, if the composite of `k` and the injection `CategoryTheory.Limits.Fork.ι s` is equal to the composite of `l` and the injection `CategoryTheory.Limits.Fork.ι s`, then `k` and `l` are the same morphism. This theorem embodies the uniqueness part of the universal property of limits in category theory.

In a category, if two morphisms to a limit have equal compositions with the injections from the limit's point to each morphism, then they are equal.


theorem abs_of_neg :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] {a : α}
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], a < 0 → |a| = -a :=
  by sorry

This theorem, `abs_of_neg`, states that for any type `α` that is a lattice and an add group (additive group), and for every instance `a` of this type `α`, if `a` is less than zero then the absolute value of `a` is equivalent to the negation of `a`. Note that the property of covariance is also required for the `α` elements under the operation of addition and a comparison function to guarantee the order relation.

For any lattice and add group type `α` with covariance property, if `a` is an element of `α` and `a` is negative, then `|a| = -a`.


theorem sInf_le_sInf : ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] {s t : Set α}, s ⊆ t → sInf t ≤ sInf s := by
  sorry

This theorem, named `sInf_le_sInf`, states that for any type `α` that forms a complete semilattice under the infimum operation, and for any two sets `s` and `t` of this type, if `s` is a subset of `t`, then the infimum of `t` is less than or equal to the infimum of `s`. In other words, if all elements of `s` are also in `t`, then the greatest lower bound of `t` cannot be greater than the greatest lower bound of `s`. This theorem is a part of order theory in mathematics, which studies the properties of ordered sets.

For any complete semilattice `α` and sets `s` and `t` in `α` with `s ⊆ t`, the infimum of `t` is less than or equal to the infimum of `s`.


theorem iInf_mono :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {f g : ι → α},
      (∀ (i : ι), f i ≤ g i) → iInf f ≤ iInf g :=
  by sorry

The theorem `iInf_mono` states that for all types `α` and `ι`, where `α` is a complete lattice, and for all functions `f` and `g` from `ι` to `α`, if each element of `f` is less than or equal to the corresponding element of `g`, then the indexed infimum (`iInf`) of `f` is less than or equal to the indexed infimum of `g`. In other words, if all elements of one function are less than or equal to the elements of another function, then the greatest lower bound of the first function's range is less than or equal to the greatest lower bound of the second function's range.

For all complete lattices α and functions f and g from ι to α, if f i ≤ gi for all i, then iInf (f) ≤ iInf (g).


theorem Measurable.coe_nnreal_ennreal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → NNReal}, Measurable f → Measurable fun x => ↑(f x) := by sorry

This theorem states that for any measurable space `α` and a measurable function `f` mapping `α` to nonnegative real numbers (`NNReal`), the function that maps each element `x` of `α` to the image of `f(x)` under the embedding from nonnegative real numbers to extended nonnegative real numbers (`ennreal`) is also measurable. In other words, if you have a measurable function that outputs nonnegative real numbers, the function that takes those outputs and embeds them into the extended nonnegative reals remains measurable.

If `α` is a measurable space and `f : α → ℝADER` is a measurable function, then the function `g : α → ℝADER` defined by `g x := f x.to_ennreal` is measurable.


theorem Int.le_floor :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {z : ℤ} {a : α}, z ≤ ⌊a⌋ ↔ ↑z ≤ a := by sorry

This theorem, `Int.le_floor`, states that for any type `α` which forms a linearly ordered ring and has a floor function, and for any integer `z` and element `a` of type `α`, the integer `z` is less than or equal to the floor of `a` if and only if the real number representation of `z` is less than or equal to `a`. In other words, it establishes the equivalence between the inequality of an integer and the floor of a real number, and the inequality of the real representations of those numbers.

For any linearly ordered ring type `α` with a floor function, the integer `z` is less than or equal to the floor of the element `a` of type `α` if and only if the real number representation of `z` is less than or equal to `a`.


theorem PMF.toOuterMeasure_apply :
    ∀ {α : Type u_1} (p : PMF α) (s : Set α), ↑(PMF.toOuterMeasure p) s = ∑' (x : α), Set.indicator s (⇑p) x := by sorry

This theorem, `PMF.toOuterMeasure_apply`, states that for any type `α`, any probability mass function `p` over `α`, and any set `s` of `α`, the measure of the set `s` under the outer measure constructed from the probability mass function `p` is equal to the sum (potentially infinite) over all elements `x` of `α` of the value of `p` at `x`, but only considering those `x` that belong to `s` (this is what the set indicator function ensures). In other words, it is summing up the probabilities of each element in the set `s` according to the probability mass function `p`, which corresponds to the measure of `s`.

For any probability mass function `p` over a type `α` and any set `s` of `α`, the outer measure of `s` constructed from `p` equals the sum of `p` over all elements in `s`.


theorem CategoryTheory.Limits.colimit.isoColimitCocone_ι_hom :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
      (t : CategoryTheory.Limits.ColimitCocone F) (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j)
          (CategoryTheory.Limits.colimit.isoColimitCocone t).hom =
        t.cocone.ι.app j :=
  by sorry

This theorem states that in the category theory, given a category `J`, another category `C`, a functor `F` from `J` to `C` which has a colimit, a colimit cocone `t` of the functor `F`, and an object `j` in `J`, the composition of the coprojection from `j` through the functor `F` to the colimit of `F`, and the morphism from the colimit of `F` to the colimit cocone `t`, is equal to the coprojection from `j` to the colimit cocone `t`. This essentially captures one of the properties of colimits in category theory.

Given a functor `F` from category `J` to `C` with a colimit `t` and an object `j` in `J`, the composition of `F(j) ↓ t` and `t ↑ colim(F)` equals `j ↓ t` in `C`, where `↓` and `↑` denote the coprojections of the cocone.


theorem Polynomial.coeff_C_mul :
    ∀ {R : Type u} {a : R} {n : ℕ} [inst : Semiring R] (p : Polynomial R),
      Polynomial.coeff (Polynomial.C a * p) n = a * Polynomial.coeff p n :=
  by sorry

The theorem `Polynomial.coeff_C_mul` states that for any semiring `R`, any element `a` of `R`, any natural number `n`, and any polynomial `p` over `R`, the coefficient of `X^n` in the polynomial resulting from multiplying the constant polynomial `a` with `p` is equal to `a` multiplied by the coefficient of `X^n` in `p`. Essentially, when multiplying a polynomial by a constant, each coefficient of the polynomial is multiplied by that constant.

For any semiring R, element a of R, natural number n, and polynomial p over R, the coefficient of X^n in the product of constant polynomial a and polynomial p equals a times the coefficient of X^n in p.


theorem List.cons_ne_nil : ∀ {α : Type u_1} (a : α) (l : List α), a :: l ≠ [] := by sorry

This theorem, named `List.cons_ne_nil`, states that for any type of data `α` and any element `a` of type `α`, and any list `l` of type `α`, a list that begins with `a` and is followed by `l` is not equal to an empty list. This is a fundamental property of lists, asserting that a list with at least one element (the head of the list) is never equal to an empty list.

For any type `α` and elements `a : α` and `l : list α`, the list `[a] :: l` is not equal to the empty list `[]`.


/-- Making this a global instance would make the typeclass search go in an infinite loop.  -/
theorem CategoryTheory.Limits.hasPullback_symmetry :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Limits.HasPullback f g], CategoryTheory.Limits.HasPullback g f :=
  by sorry

The theorem `CategoryTheory.Limits.hasPullback_symmetry` states that for any category `C` and objects `X`, `Y`, `Z` in `C`, if a pullback exists for a pair of morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, then a pullback also exists for the pair `g : Y ⟶ Z` and `f : X ⟶ Z`. In other words, the existence of a pullback in a category is invariant under swapping the morphisms. This theorem is necessary for the robustness and generality of concepts in category theory, but making it a global instance would cause an infinite loop in the typeclass search, hence it is defined as a standalone theorem.

If objects X, Y, Z in a category C and morphisms f : X ⟶ Z and g : Y ⟶ Z have a pullback, then so do g and f.


theorem Fintype.card_pos_iff : ∀ {α : Type u_1} [inst : Fintype α], 0 < Fintype.card α ↔ Nonempty α := by sorry

The theorem `Fintype.card_pos_iff` states that for any type `α` that is finite (`Fintype α`), the number of elements in `α` (given by `Fintype.card α`) is greater than zero if and only if `α` is not empty. In other words, a finite type has more than zero elements exactly when there is at least one element in it.

A finite type `α` has more elements than zero if and only if `α` is non-empty. (Equivalently, `Fintype.card α > 0 iff ∃x, x ∈ α`)


theorem Function.Injective.preimage_image :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β}, Function.Injective f → ∀ (s : Set α), f ⁻¹' (f '' s) = s := by sorry

The theorem `Function.Injective.preimage_image` states that for any types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is injective then the preimage of the image of a set `s` under `f` is equal to `s` itself. In other words, if we apply `f` to every element of a set `s`, and then look at the set of all inputs that could have produced those outputs, we get back `s`. This is a property of injective functions, which are functions where every output is produced by exactly one input.

If `f: α → β` is an injective function, then `f''(s) = s` for any set `s` in `α`. Here, `f''(s)` denotes the preimage of the image of `s` under `f`.


theorem CategoryTheory.Limits.pullback.lift_snd :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
      (w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.lift h k w)
          CategoryTheory.Limits.pullback.snd =
        k :=
  by sorry

The theorem `CategoryTheory.Limits.pullback.lift_snd` states that in the category `C`, for any four objects `W, X, Y, Z`, morphisms `f: X -> Z` and `g: Y -> Z`, and provided that `f` and `g` has a pullback, if you have additional morphisms `h: W -> X` and `k: W -> Y` satisfying the property that the composition of `h` and `f` equals the composition of `k` and `g`, then the composition of the pullback lift of `h` and `k` with respect to `w` (where `w` is the equality between the two compositions) and the second projection of the pullback equals `k`. In simpler terms, this theorem is about the commutativity of a certain diagram in the category `C` involving the pullback of two morphisms `f` and `g`.

Given morphisms $f: X \to Z$, $g: Y \to Z$, $h: W \to X$, $k: W \to Y$ in a category $C$ with pullbacks, if $h \circ f = g \circ k$ and there exists a pullback of $f$ and $g$ at $Z$, then the pullback lift of $h$ and $k$ and the second projection of the pullback equal $k$.


theorem WithTop.coe_lt_coe : ∀ {α : Type u_1} [inst : LT α] {a b : α}, ↑a < ↑b ↔ a < b := by sorry

This theorem, `WithTop.coe_lt_coe`, is about type lifting and comparison in a partially ordered set. It states that for all types `α` with a less-than order (`LT`) and for every pair of elements `a` and `b` from `α`, the statement "coerced `a` is less than coerced `b`" holds if and only if " `a` is less than `b`". Here, coercion `↑` is used for embedding `α` into an extended type that includes a top element, and the comparison `<` is with respect to the order on `α`.

For any type `α` with a less-than order and for all `a` and `b` in `α`, `↑a < ↑b` if and only if `a < b`.


theorem CategoryTheory.Limits.colimit.ι_desc_assoc :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
      (c : CategoryTheory.Limits.Cocone F) (j : J) {Z : C} (h : c.pt ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F j)
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.desc F c) h) =
        CategoryTheory.CategoryStruct.comp (c.ι.app j) h :=
  by sorry

This theorem, named `CategoryTheory.Limits.colimit.ι_desc_assoc`, is a statement about morphisms in the category theory. Specifically, it says that for any type `J` with a category structure, a type `C` with a category structure, a functor `F` from `J` to `C` that has a colimit, a cocone `c` over that functor, an object `j` from `J`, and a morphism `h` from the cocone point to an object `Z`, the composition of the coprojection from a value of the functor to the colimit object (denoted `CategoryTheory.Limits.colimit.ι F j`) and the composition of the morphism from the colimit object to the cocone point of any other cocone (denoted `CategoryTheory.Limits.colimit.desc F c`) with `h` is the same as the composition of the natural transformation of the cocone at `j` and `h`. In mathematical terms, `(CategoryTheory.Limits.colimit.ι F j) ≫ ((CategoryTheory.Limits.colimit.desc F c) ≫ h) = (c.ι.app j) ≫ h`. The symbol `≫` stands for the composition of morphisms.

For any functor with a colimit, the composition of the coprojection from the functor to the colimit object, the morphism from the colimit object to any cocone point, and a given morphism to the coconet point is equal to the composition of the natural transformation of the cocone at the source object and the given morphism.


Setoid.trans'

theorem Setoid.trans' :
    ∀ {α : Type u_1} (r : Setoid α) {x y z : α}, Setoid.Rel r x y → Setoid.Rel r y z → Setoid.Rel r x z := by sorry

This theorem states that for any given type `α` and an equivalence relation `r` on `α`, and for any three elements `x`, `y`, `z` of type `α`, if `x` is related to `y` by `r` and `y` is related to `z` by `r`, then `x` is also related to `z` by `r`. In other words, this theorem is asserting the transitivity property of the equivalence relation `r`.

If `r` is an equivalence relation on type `α`, then for all `x`, `y`, `z` in `α`, if `x r y` and `y r z`, then `x r z`.


theorem Finsupp.mapDomain_single :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α → β} {a : α} {b : M},
      (Finsupp.mapDomain f fun₀ | a => b) = fun₀ | f a => b :=
  by sorry

The theorem `Finsupp.mapDomain_single` states that for any types `α`, `β`, and `M`, where `M` is an additive commutative monoid, and any function `f` from `α` to `β`, and any elements `a` of `α` and `b` of `M`, the application of the function `mapDomain` with `f` to a finite support function that only takes value `b` at `a` and zero elsewhere, yields another finite support function that takes the value `b` at `f(a)` and zero elsewhere. In mathematical terms, this can be written as $(\text{{mapDomain}}\, f\, (\lambda x . \text{{if }} x=a \text{{ then }} b \text{{ else }} 0)) (f(a)) = b$.

For any additive commutative monoid M, function f from type α to β, and elements a in α and b in M, the application of mapDomain with f to the finite support function that maps a to b and zero elsewhere yields the finite support function that maps f(a) to b and zero elsewhere. In other words, mapDomain (f) (λx. if x = a then b else 0) (fa) = b.


/-- Additive group homomorphisms preserve integer scaling. -/
theorem AddMonoidHom.map_zsmul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : SubtractionMonoid β] (f : α →+ β) (g : α) (n : ℤ),
      f (n • g) = n • f g :=
  by sorry

The theorem `AddMonoidHom.map_zsmul` states that for any additive group homomorphism `f` from an additive group `α` to a subtraction monoid `β`, any element `g` of `α`, and any integer `n`, the homomorphism `f` applied to `n` times `g` (denoted `n • g`) is equal to `n` times the homomorphism `f` applied to `g` (denoted `n • f g`). In other words, additive group homomorphisms preserve the operation of integer scaling.

For any additive group homomorphism $f : \alpha \rightarrow \beta$ where $\beta$ is a subtraction monoid, and for all $g \in \alpha$ and integer $n$, we have $f(n \cdot g) = n \cdot f(g)$.


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

This theorem states that for any types `α` and `β`, and any index type `ι`, given a function `f` from `ι` to `α` and a function `g` from `α` to `Set β` (which maps elements of `α` to sets of `β`), the intersection over `x` of the intersections over `y` and `h` (where `h` is the hypothesis that `f y = x`) of `g x` is equal to the intersection over `y` of `g (f y)`. In mathematical terms, this theorem provides a new expression for the intersection of sets: $\bigcap_x \bigcap_y \bigcap_{f(y)=x} g(x) = \bigcap_y g(f(y))$. This expression can be particularly helpful when working with complex nested intersections.

For any functions $f: ι → α$ and $g: α → Set(β)$, the intersections commute: $\bigcap\_x \bigcap\_y \{y : ι | f(y) = x\} \subseteq g(x) ∣ f(y) = x \} = \bigcap\_y g(f(y))$.


theorem CategoryTheory.Limits.id_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C], CategoryTheory.CategoryStruct.id 0 = 0 :=
  by sorry

This theorem, `CategoryTheory.Limits.id_zero`, states that for any category `C` equipped with a zero object and zero morphisms, the identity morphism on the zero object is equal to the zero morphism. More formally, in the context of category theory, given a category `C` that has zero objects (which serve as both initial and terminal objects) and zero morphisms (which serve as both the initial and terminal morphisms), the identity morphism on the zero object (represented as `CategoryTheory.CategoryStruct.id 0`) is equal to the zero morphism (represented as `0`).

In any category with zero objects and zero morphisms, the identity morphism on the zero object is equal to the zero morphism.


theorem Filter.empty_mem_iff_bot : ∀ {α : Type u} {f : Filter α}, ∅ ∈ f ↔ f = ⊥ := by sorry

This theorem states that for any given type `α` and filter `f` on `α`, the empty set is an element of `f` if and only if `f` is the bottom filter. In the context of filters, the bottom filter (`⊥`) is the smallest possible filter, consisting only of the empty set.

A filter `f` on type `α` contains the empty set if and only if `f` is the bottom filter.


theorem Polynomial.eval₂_one :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S),
      Polynomial.eval₂ f x 1 = 1 :=
  by sorry

The theorem `Polynomial.eval₂_one` states that for any semiring `R` and `S`, and for any ring homomorphism `f` from `R` to `S`, and for any value `x` in `S`, the evaluation of the polynomial `1` (which is a constant polynomial with value `1`) at `x` using the ring homomorphism `f` is `1`. This is to say, regardless of the ring homomorphism and the value for the variable, the evaluation of the constant polynomial `1` is always `1`.

For any semiring R and ring homomorphism f from R to S, f(1\_R) = 1\_S, where 1\_R is the constant polynomial with value 1 in R and 1\_S is the constant value 1 in S.


Function.Surjective.hasRightInverse

theorem Function.Surjective.hasRightInverse :
    ∀ {α : Sort u} {β : Sort v} {f : α → β}, Function.Surjective f → Function.HasRightInverse f := by sorry

The theorem `Function.Surjective.hasRightInverse` states that for every function `f` from a set (or type) `α` to a set `β`, if `f` has the property of being surjective (that is, for every element `b : β`, there exists an element `a : α` such that `f(a) = b`), then `f` also has a right inverse. A right inverse of `f` is another function `finv` such that applying `f` and then `finv` to any element of `β` returns that element, i.e., `f(finv(b)) = b` for all `b` in `β`.

If `f` is a surjective function from `α` to `β`, then there exists a right inverse `finv` for `f` such that `f(finv(b)) = b` for all `b` in `β`.


Cardinal.inductionOn

theorem Cardinal.inductionOn :
    ∀ {p : Cardinal.{u_1} → Prop} (c : Cardinal.{u_1}), (∀ (α : Type u_1), p (Cardinal.mk α)) → p c := by sorry

The theorem `Cardinal.inductionOn` is a principle of mathematical induction for cardinal numbers. Given a property `p` that applies to cardinal numbers, and a specific cardinal number `c`, if we can show that the property `p` holds for the cardinality of any type `α`, then it must also hold for the cardinal number `c`.

If a property holds for the cardinality of every type, then it holds for a given cardinal number. (Cardinal induction)


theorem Mathlib.Algebra.Order.Monoid.Canonical.Defs._auxLemma.15 :
    ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b : α}, (0 < a + b) = (0 < a ∨ 0 < b) := by sorry

This theorem from the Mathlib library in the Algebra.Order.Monoid.Canonical.Defs module is named '_auxLemma.15'. It states that for any type `α` that forms a 'CanonicallyOrderedAddCommMonoid', and for any two elements `a` and `b` of that type, the statement that `0` is less than the sum of `a` and `b` is equivalent to the statement that `0` is less than `a` or `0` is less than `b`. This theorem holds true under the mathematical rules of 'CanonicallyOrderedAddCommMonoid' and applies to any element from such a set.

For any CanonicallyOrderedAddCommMonoid type `α` and elements `a`, `b` in `α`, `0` is less than `a + b` if and only if `0` is less than `a` or `0` is less than `b`.


theorem Primrec.encode_iff :
    ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f : α → σ},
      (Primrec fun a => Encodable.encode (f a)) ↔ Primrec f :=
  by sorry

The theorem `Primrec.encode_iff` states that for any two types `α` and `σ`, given both types are primitively encodable, and for any function `f` from `α` to `σ`, the function `f` is primitive recursive if and only if the function that applies `f` to an argument `a` from `α` and then encodes the result is also primitive recursive. This essentially says that encoding a function's output does not change whether the function is primitive recursive.

For any primitively encodable types α and σ, and primitive recursive function f : α → σ, the function x ↦ encode (f x) is also primitive recursive, where encode is the primitively encodable function from σ to some codomain.


Set.BijOn.injOn

theorem Set.BijOn.injOn :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.InjOn f s := by sorry

This theorem states that for any two types `α` and `β`, and any sets `s` of type `α` and `t` of type `β`, and any function `f` that maps `α` to `β`, if `f` is bijective from set `s` to set `t`, then `f` is also injective on set `s`. In mathematical terms, if a function `f` is bijective (both injective and surjective) from one set to another, it is guaranteed to be injective (no two different elements in the domain map to the same element in the co-domain) on the domain set.

If a function between two sets is bijective, then it is injective.


/-- Subtracting two points produces 0 if and only if they are
equal.  -/
theorem vsub_eq_zero_iff_eq :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] {p₁ p₂ : P}, p₁ -ᵥ p₂ = 0 ↔ p₁ = p₂ := by
  sorry

This theorem, denoted as `vsub_eq_zero_iff_eq`, states that for any two points `p₁` and `p₂` of type `P` in an additive torsor `T` over an additive group `G`, the vector subtraction of `p₁` and `p₂` equals zero if and only if `p₁` and `p₂` are equal. In other words, it establishes the equivalence between the condition of two points being identical and the resulting vector from their subtraction being a zero vector in the given torsor and group structure.

For any additive torsor T over an additive group G and any points p₁, p₂ of type P in T, p₁ - p₂ = 0 if and only if p₁ = p₂.


MeasureTheory.Integrable.norm

theorem MeasureTheory.Integrable.norm :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable (fun a => ‖f a‖) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.norm` states that for any measurable space `α`, any normed additive commutative group `β`, any measure `μ` on `α`, and any function `f` from `α` to `β`, if `f` is integrable with respect to `μ`, then the function that maps each element of `α` to the norm of `f` at that element is also integrable with respect to `μ`. In other words, if the function `f` is integrable, then the function that gives the norm of `f` at each point is also integrable.

If `f` is a measurable and integrable function from a measurable space `(α, Σ, μ)` to a normed additive commutative group `(β, +, ||·||)`, then the function `x ↦ ||f x||` is integrable on `α` with respect to `μ`.


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

This theorem states that the complement of the empty set, for any given type `α` is equivalent to the universal set. In set theory, the complement of a set `A` is made up of all the elements not in `A`. Here, as the set is empty, its complement includes every possible element of type `α`, hence it is equivalent to the universal set `Set.univ`.

The empty set and the universal set of type `α` are equivalent.


theorem Mathlib.Data.Sigma.Basic._auxLemma.3 :
    ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop},
      (∀ (x : (a : α) × β a), p x) = ∀ (a : α) (b : β a), p { fst := a, snd := b } :=
  by sorry

This theorem, `Mathlib.Data.Sigma.Basic._auxLemma.3`, asserts that for any type `α`, function `β` from `α` to another type, and predicate `p` over pairs `(a : α) × β a`, the statement "the predicate `p` holds true for all pairs `(x : α) × β x`" is equivalent to "for every `a : α` and `b : β a`, the predicate `p` holds for the pair composed of `a` and `b`". In other words, it's stating that quantification over the elements of a dependent pair is the same as separate quantification over each component of the pair.

For any type `α`, function `β : α → *`, and predicate `p : ∀ (a : α), β a → Prop`, the statements `∀ (x : α) (b : β x), p x b` and `∀ a, ∀ b, p a b` are equivalent.


/-- As well as being linear, `ι Q` squares to the quadratic form  -/
theorem CliffordAlgebra.ι_sq_scalar :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (Q : QuadraticForm R M) (m : M),
      (CliffordAlgebra.ι Q) m * (CliffordAlgebra.ι Q) m = (algebraMap R (CliffordAlgebra Q)) (Q m) :=
  by sorry

The theorem `CliffordAlgebra.ι_sq_scalar` states that for any commutative ring `R`, and any `R`-module `M` equipped with a quadratic form `Q`, and for any element `m` of `M`, the mapping `ι Q` (which is a linear map from `M` to the Clifford algebra of `Q`) has the property that the square of this mapping applied to `m` is equal to the algebra map from `R` to the Clifford algebra of `Q` applied to the value of the quadratic form `Q` at `m`. In other words, the square of the canonical linear map of `m` is equivalent to the algebra map of the quadratic form evaluated at `m`.

For any commutative ring `R`, `R`-module `M` with quadratic form `Q`, and `m` in `M`, the square of the linear map `ιQ(m)` from `M` to the Clifford algebra of `Q` equals the algebra map of `Q` evaluated at `m`.


theorem embedding_subtype_val : ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop}, Embedding Subtype.val := by
  sorry

The theorem `embedding_subtype_val` states that for any type `X` with a topology (denoted by `TopologicalSpace X`), and for any predicate `p` on `X`, the function `Subtype.val` (which extracts the underlying element from a subtype defined by `p`) is an embedding. In other words, this function preserves the topological properties of the elements from the subtype to the original type `X`.

The function `Subtype.val` from a subtype of a topological space `X` defined by a predicate `p` is a topological embedding.


CategoryTheory.Limits.ConeMorphism.ext

theorem CategoryTheory.Limits.ConeMorphism.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}
      {c c' : CategoryTheory.Limits.Cone F} (f g : c ⟶ c'), f.hom = g.hom → f = g :=
  by sorry

This theorem states that, in the context of category theory, given two cones `c` and `c'` over a functor `F` from a category `J` to a category `C`, if two morphisms `f` and `g` exist from `c` to `c'` such that their homomorphisms are equal, then `f` and `g` themselves must be equal. This is essentially a statement about the uniqueness of such morphisms in this context.

In category theory, if two cones over a functor have equal homomorphisms, then their morphisms are equal.


/-- image2 is monotone with respect to `⊆`.  -/
theorem Set.image2_subset :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t t' : Set β},
      s ⊆ s' → t ⊆ t' → Set.image2 f s t ⊆ Set.image2 f s' t' :=
  by sorry

This theorem asserts that the function `image2` is monotone with respect to the subset operation `⊆`. In other words, for any types `α`, `β`, and `γ`, and any binary function `f : α → β → γ`, if `s` is a subset of `s'` and `t` is a subset of `t'` (where `s` and `s'` are sets of `α`, and `t` and `t'` are sets of `β`), then the image of the binary function `f` applied to `s` and `t` is a subset of the image of the binary function `f` applied to `s'` and `t'`. In mathematical notation, this would be represented as: if $s \subseteq s'$ and $t \subseteq t'$, then $f(s,t) \subseteq f(s',t')$.

For any functions $f : \alpha \to \beta \to \gamma$ and sets $s \subseteq s'$ of type $\alpha$ and $t \subseteq t'$ of type $\beta$, we have $f(s,t) \subseteq f(s',t')$.


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

This theorem states that for any type `α`, any element `a` of type `α`, and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a permutation of `l₂`, then `a` is an element of `l₁` if and only if `a` is an element of `l₂`. In simple terms, if two lists are permutations of each other, then any given element is in the first list if and only if it's also in the second list.

If `α` is a type, `a` is an element of `α`, and `l₁` and `l₂` are permutations of each other as lists of `α`, then `a` is an element of `l₁` if and only if `a` is an element of `l₂`.


theorem Units.val_one : ∀ {α : Type u} [inst : Monoid α], ↑1 = 1 := by sorry

This theorem states that for any type `α` that forms a monoid, the value of the "lifting" or "upcasting" of 1 (i.e., `↑1`) is equal to 1. Here, `Units.val_one` means that the monoid unit (which is usually denoted as `1` in abstract algebra) remains unchanged when it is cast from the set of units (`Units`) to the underlying monoid (`α`).

For any monoid type `α`, the upcasting of its unit `1` (denoted `↑1`) is equal to the monoid unit itself (`Units.val_one`).


StrictMono.strictMonoOn

theorem StrictMono.strictMonoOn :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      StrictMono f → ∀ (s : Set α), StrictMonoOn f s :=
  by sorry

This theorem states that for any types `α` and `β` that have a preorder, and for any function `f` from `α` to `β`, if `f` is strictly monotonic, then `f` is strictly monotonic on any given set `s` of type `α`. In mathematical terms, this means that if for all `a` and `b` in `α` such that `a < b`, we have `f(a) < f(b)`, then for any subset `s` of `α`, if `a` and `b` are in `s` and `a < b`, we also have `f(a) < f(b)`.

If `α` and `β` have a preorder and `f : α → β` is strictly monotonic, then `f` is strictly monotonic on any subset `s` of `α`.


Homeomorph.inducing

theorem Homeomorph.inducing :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
      Inducing ⇑h :=
  by sorry

This theorem states that for any two types `X` and `Y` that are equipped with topological spaces, a homeomorphism `h` from `X` to `Y` is inducing. In the context of topology, an inducing function is one that, given the topology on `Y`, generates the same topology on `X` when we consider the preimage of every open set in `Y`. Thus, this theorem asserts that homeomorphisms preserve the topology under preimages.

A homeomorphism between topological spaces preserves the topology, that is, the preimage of any open set under a homeomorphism is an open set.


theorem Mathlib.Data.Polynomial.Degree.Definitions._auxLemma.1 :
    ∀ {R : Type u} [inst : Semiring R] [inst_1 : Subsingleton R] (p : Polynomial R), Polynomial.Monic p = True := by
  sorry

This theorem states that for any type `R` that forms a semiring, and if `R` is a subsingleton, then any polynomial `p` with coefficients from `R` is monic. Recall that a polynomial is considered monic if its leading coefficient is 1. In a subsingleton, there is only one element, so every polynomial in such a structure is monic by definition.

In a subsingleton semiring, every polynomial is monic by definition.


/-- An isometry preserves distances.  -/
theorem Isometry.dist_eq :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (x y : α), dist (f x) (f y) = dist x y :=
  by sorry

The theorem `Isometry.dist_eq` states that for any two types `α` and `β` that are both instances of the `PseudoMetricSpace` type class, for any function `f` from `α` to `β`, if `f` is an isometry (i.e., a function that preserves the extended distance between elements in `α` and `β`), then for any two elements `x` and `y` in `α`, the distance between `f(x)` and `f(y)` in `β` is the same as the distance between `x` and `y` in `α`. In simple terms, an isometric function preserves the distances between elements under transformation.

For any functions `f` between pseudo-metric spaces `α` and `β` that are isometries, `∋ x, y in α, dβ(f(x), f(y)) = dα(x, y)`, where `dα` and `dβ` denote the distance functions on `α` and `β`, respectively.


/-- If we map a measure along a measurable equivalence, we can compute the measure on all sets
(not just the measurable ones).  -/
theorem MeasurableEquiv.map_apply :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} (f : α ≃ᵐ β) (s : Set β), ↑↑(MeasureTheory.Measure.map (⇑f) μ) s = ↑↑μ (⇑f ⁻¹' s) :=
  by sorry

The theorem `MeasurableEquiv.map_apply` states that for any two types `α` and `β` that are both equipped with a measurable space structure, any measure `μ` on `α`, a measurable equivalence `f` from `α` to `β`, and any set `s` of type `β`, the measure of `s` when we pushforward the measure `μ` along `f` (which is denoted by `MeasureTheory.Measure.map (⇑f) μ`) is equal to the measure of the preimage of `s` under `f` with respect to the measure `μ` (which is denoted by `μ (⇑f ⁻¹' s)`). In other words, mapping a measure along a measurable equivalence allows us to compute the measure on all sets, not just the measurable ones, by using the original measure on the preimage of the sets.

For measurable spaces (α, μ) and (β), any measurable equivalence f : α → β, and any set s in β, the measure of s under the pushforward measure ⇑f μ is equal to the measure of f⁻¹(s) under the original measure μ.


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

This theorem, `sup_inf_right`, states that for all types `α` equipped with a distributive lattice structure, for any elements `a`, `b`, and `c` of that type, the supremum (join, denoted by `⊔`) of the infimum (meet, denoted by `⊓`) of `a` and `b` with `c` is equal to the infimum of the supremum of `a` with `c` and the supremum of `b` with `c`. In mathematical terms, this is saying that `a ⊓ b ⊔ c = (a ⊔ c) ⊓ (b ⊔ c)` for all `a`, `b`, `c` in a distributive lattice. This property is one of the defining characteristics of distributive lattices.

In a distributive lattice, the supremum of the infimum of two elements with a third element is equal to the infimum of their supremums: `(a ⊓ b) ⊔ c = a ⊔ c ⊓ b ⊔ c` for all `a`, `b`, `c`.


theorem CategoryTheory.ShortComplex.RightHomologyData.p_g' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.RightHomologyData S),
      CategoryTheory.CategoryStruct.comp h.p (CategoryTheory.ShortComplex.RightHomologyData.g' h) = S.g :=
  by sorry

The theorem `CategoryTheory.ShortComplex.RightHomologyData.p_g'` states that for any category `C`, which has zero morphisms, and for any short complex `S` in this category, the morphism `g'` induced by `S.g` and the fact that `h.Q` is a cokernel of `S.f`, when composed with `h.p`, is equal to `S.g`. This means that if we follow the morphism `h.p` from the object `h.Q`, and then `g'` from there to the object `S.X₃`, we end up at the same place as if we took `S.g` directly from `S.X₂` to `S.X₃`. This property is a crucial one for short complexes in category theory.

Given a short complex `S` in a zero-morphism category `C`, the composite of `h.p` and `g'` is equal to `S.g`, where `h.Q` is a cokernel of `S.f`.


theorem Nat.le_total : ∀ (m n : ℕ), m ≤ n ∨ n ≤ m := by sorry

This theorem, `Nat.le_total`, states that for any two natural numbers `m` and `n`, either `m` is less than or equal to `n`, or `n` is less than or equal to `m`. This is a formal statement of the total ordering of the natural numbers, ensuring that given any two natural numbers, they are either equal or one is greater than the other.

For all natural numbers m and n, either m ≤ n or n ≤ m.


theorem Submodule.map_le_iff_le_comap :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {F : Type u_9} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂]
      [inst_8 : RingHomSurjective σ₁₂] {f : F} {p : Submodule R M} {q : Submodule R₂ M₂},
      Submodule.map f p ≤ q ↔ p ≤ Submodule.comap f q :=
  by sorry

The theorem `Submodule.map_le_iff_le_comap` states that for all semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `σ₁₂` from `R` to `R₂`, a function `f` of type `F` which is "fun-like" from `M` to `M₂`, and is a semilinear map between `M` and `M₂` under the ring homomorphism `σ₁₂`, and submodules `p` of `M` and `q` of `M₂`, the image of `p` under `f` is a subset of `q` if and only if `p` is a subset of the preimage of `q` under `f`. In other words, the theorem establishes a correspondence between direct mapping and inverse mapping of submodules under the conditions mentioned. This theorem is particularly useful in the study of linear algebra and module theory, where such transformations and their properties play a crucial role.

For a ring homomorphism σ₁₂ from semirings R and R₂, fun-like semilinear map f between modules M over R and M₂ over R₂, and submodules p of M and q of M₂, p ⊆ f⁻¹(q) if and only if f(p) ⊆ q.


theorem CauSeq.equiv_lim :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {β : Type u_2} [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] [inst_3 : CauSeq.IsComplete β abv] (s : CauSeq β abv),
      s ≈ CauSeq.const abv (CauSeq.lim s) :=
  by sorry

The theorem `CauSeq.equiv_lim` states that for any given Cauchy sequence `s` over a ring `β` with respect to an absolute value function `abv`, and given the conditions that `α` is a linearly ordered field, `abv` is a valid absolute value function and `β` is a complete ring with respect to `abv`, the sequence `s` is equivalent to the constant Cauchy sequence whose value is the limit of `s`. In other words, as you progress along the sequence, the elements of the sequence get arbitrarily close to the sequence's limit.

For any Cauchy sequence `s` over a complete ring `β` with respect to an absolute value `abv` in a linearly ordered field `α`, the sequence `s` is equivalent to the constant sequence whose value is the limit of `s`.


NeZero.pos

theorem NeZero.pos : ∀ {M : Type u_1} (a : M) [inst : CanonicallyOrderedAddCommMonoid M] [inst_1 : NeZero a], 0 < a :=
  by sorry

The theorem `NeZero.pos` states that for any type `M` that is a canonically ordered additive commutative monoid, and for any element `a` of `M` that is not zero, `a` is strictly greater than zero. In more mathematical terms, for all `a` in `M` where `M` is a canonically ordered additive commutative monoid and `a` is not equal to zero (`a ≠ 0`), `a` is strictly greater than zero (`0 < a`).

For any non-zero element `a` in a canonically ordered additive commutative monoid `M`, `0 < a`.


HasStrictDerivAt.comp

theorem HasStrictDerivAt.comp :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'} {h' h₂' : 𝕜'},
      HasStrictDerivAt h₂ h₂' (h x) → HasStrictDerivAt h h' x → HasStrictDerivAt (h₂ ∘ h) (h₂' * h') x :=
  by sorry

The theorem `HasStrictDerivAt.comp` states that if a function `h₂` has a strict derivative `h₂'` at the point `h(x)` and a function `h` has a strict derivative `h'` at the point `x`, in the context of nontrivially normed fields, then the composition of the two functions `(h₂ ∘ h)` has a strict derivative at the point `x` which is the product of the derivatives `h₂'` and `h'`. This captures the chain rule concept in calculus.

If `h` and `h₂` are functions with strict derivatives at a point `x` in a nontrivially normed field, then `(h₂ ∘ h)'(x) = h₂'(h(x)) * h'(x)`.


theorem Function.Injective.extend_apply :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
      Function.Injective f → ∀ (g : α → γ) (e' : β → γ) (a : α), Function.extend f g e' (f a) = g a :=
  by sorry

The theorem `Function.Injective.extend_apply` states that for any types `α`, `β`, and `γ`, and any function `f` from `α` to `β`, if `f` is injective, then for any function `g` from `α` to `γ`, any function `e'` from `β` to `γ`, and any element `a` of `α`, applying the extension of `f` by `g` and `e'` to `f(a)` yields `g(a)`. In other words, when we extend an injective function with another function, the value of the extended function at any point is the same as the value of the original function at that point.

If `f: α → β` is injective and `g: α → γ` and `e': β → γ` are functions, then for all `a ∈ α`, `(extend f g e') a = g a`.


/-- Extensionality lemma for additive monoid homomorphisms `AddMonoid.Coprod M N →+ P`.
If two homomorphisms agree on the ranges of `AddMonoid.Coprod.inl` and `AddMonoid.Coprod.inr`,
then they are equal. -/
theorem AddMonoid.Coprod.hom_ext :
    ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : AddZeroClass P] {f g : AddMonoid.Coprod M N →+ P},
      AddMonoidHom.comp f AddMonoid.Coprod.inl = AddMonoidHom.comp g AddMonoid.Coprod.inl →
        AddMonoidHom.comp f AddMonoid.Coprod.inr = AddMonoidHom.comp g AddMonoid.Coprod.inr → f = g :=
  by sorry

This theorem, known as the Extensionality Lemma for Additive Monoid Homomorphisms from the Coproduct of M and N to P, states that given two additive monoid homomorphisms, f and g, from the coproduct of monoids M and N into a monoid P, if these homomorphisms agree on the ranges of the natural embeddings of M and N into the coproduct (termed as `AddMonoid.Coprod.inl` and `AddMonoid.Coprod.inr` respectively), then these homomorphisms are equal. In other words, the mapping properties of f and g through these natural embeddings uniquely determine these homomorphisms.

Given additive monoid homomorphisms f and g from the coproduct of monoids M and N to monoid P, if f (AddMonoid.Coprod.inl x) = g (AddMonoid.Coprod.inl x) for all x in M and f (AddMonoid.Coprod.inr y) = g (AddMonoid.Coprod.inr y) for all y in N, then f = g.


theorem Module.Free.of_basis :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type w},
      Basis ι R M → Module.Free R M :=
  by sorry

This theorem states that given any semiring `R`, additively commutative monoid `M` and a module `M` over `R`, for any type `ι`, if there exists a basis of `M` indexed by `ι`, then `M` is a free module over `R`. In other words, a module over a semiring is free if and only if it has a basis.

A module over a semiring is free if and only if it has a basis. (In other words, a module over a semiring is free if it has a linearly independent set spanning the entire module.)


MeasurableSet.prod

theorem MeasurableSet.prod :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set α} {t : Set β},
      MeasurableSet s → MeasurableSet t → MeasurableSet (s ×ˢ t) :=
  by sorry

The theorem `MeasurableSet.prod` states that for any two types `α` and `β`, given measurable spaces `m` and `mβ` over these types respectively, and for any sets `s` of type `α` and `t` of type `β`, if `s` and `t` are both measurable sets, then their Cartesian product `s ×ˢ t` is also a measurable set. In other words, the measurability property is preserved under the operation of taking Cartesian products of sets.

If `α` and `β` are types, `m` and `mβ` are measurable spaces over `α` and `β` respectively, and `s` and `t` are measurable sets in `α` and `β` respectively, then their Cartesian product `s ×ˢ t` is a measurable set in `α × β`.


theorem Multiset.mem_cons : ∀ {α : Type u_1} {a b : α} {s : Multiset α}, a ∈ b ::ₘ s ↔ a = b ∨ a ∈ s := by sorry

The theorem `Multiset.mem_cons` states that for any type `α`, and any elements `a` and `b` of type `α`, and any multiset `s` of type `α`, the element `a` belongs to the multiset formed by adding `b` to `s` if and only if `a` is equal to `b` or `a` belongs to `s`. In other words, an element `a` is in the multiset created by prefixing `b` to `s` exactly when `a` is either `b` or an element of `s`.

For any type α and multiset s of α, an element a belongs to the multiset formed by adding an element b to s if and only if a is equal to b or is an element of s.


/-- **Alias** of `add_lt_add_of_lt_of_lt`. -/
theorem add_lt_add :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c d : α},
      a < b → c < d → a + c < b + d :=
  by sorry

This theorem, named `add_lt_add`, states that for a type `α` that has an addition operation and is a preorder (i.e., it has a binary relation that is reflexive and transitive), given the covariant classes for the addition operation, if `a` and `b` are elements of this type such that `a` is less than `b`, and `c` and `d` are also elements of this type such that `c` is less than `d`, then the sum of `a` and `c` is less than the sum of `b` and `d`. This theorem is an alias of `add_lt_add_of_lt_of_lt`. The function `Function.swap` is used to indicate that the binary operation and the less-than relation can be swapped in their arguments without changing their meaning.

If `α` is a preorder type with a reflexive and transitive relation `≤`, and `a ≤ b` and `c ≤ d` in `α`, then `a + c ≤ b + d`.


theorem List.Sublist.length_le :
    ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → List.length l₁ ≤ List.length l₂ := by sorry

This theorem states that for any two lists `l₁` and `l₂` of any type `α`, if `l₁` is a sublist of `l₂` (denoted as `List.Sublist l₁ l₂`), then the length of `l₁` is less than or equal to the length of `l₂`. In other words, a sublist cannot be longer than the list it is contained within. The length of a list is calculated as the total number of elements in the list, with the length of an empty list being 0 and the length of a list with a head element and a tail list being 1 plus the length of the tail list.

For all types `α` and lists `l₁` and `l₂` of length `n₁` and `n₂` respectively, if `l₁` is a sublist of `l₂` then `n₁ ≤ n₂`.


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

This theorem states that for every extended nonnegative real number `a`, the inverse of `a` is zero if and only if `a` is infinity. In other words, within the context of extended nonnegative real numbers, only infinity has a reciprocal of zero, and conversely, any extended nonnegative real number whose reciprocal is zero must be infinity.

For every extended nonnegative real number `a`, `a^(-1) = 0` if and only if `a = ∞`.


theorem top_add : ∀ {α : Type u_1} [inst : LinearOrderedAddCommMonoidWithTop α] (a : α), ⊤ + a = ⊤ := by sorry

This theorem states that for any type `α` that is a linearly ordered additive commutative monoid with a top element (denoted ⊤), the sum of the top element and any other element `a` from the same type `α` is always the top element. In other words, if we add any element to the maximum possible element (top) in such a structure, the result will always be the top element itself.

For any linearly ordered additive commutative monoid `α` with a top element ⊤, the sum of any element `a` from `α` and the top element is equal to the top element. (∀α : Type, LinearlyOrderedAddCommMonoid α ∧ TopElement α α ⊤ → α → α, ∀a, a ⊔ ⊤ = ⊤)


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

The theorem `uniformContinuous_div` states that for all types `α` which have a Uniform Space structure, a Group structure, and a Uniform Group structure, the function which takes a pair `p` and returns the division of the first element of the pair by the second element of the pair is uniformly continuous. In mathematical terms, this means that for any `α` that forms a uniform group, the division operation is a uniformly continuous function. This implies that no matter where two elements `x` and `y` are located in `α`, if `x` is sufficiently close to `y`, the result of the division `x/y` is close to the result of the division `y/y` (which is 1).

For any type `α` with a Uniform Space, Group, and Uniform Group structure, the division function `x ÷ y` on `α` is uniformly continuous.


theorem Finset.mem_Ioo :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      x ∈ Finset.Ioo a b ↔ a < x ∧ x < b :=
  by sorry

The theorem `Finset.mem_Ioo` states that for any type `α` that has a preorder and is a locally finite order, and for any elements `a`, `b`, and `x` of this type, `x` is in the finite set defined by the interval `(a,b)` (exclusive) if and only if `a` is less than `x` and `x` is less than `b`. This means that `a < x < b` is the criteria for membership in the finite set `Finset.Ioo a b`.

For any locally finite preordered type $\alpha$, and any $a, b \in \alpha$ with $a < b$, the element $x \in \alpha$ belongs to the open interval $(a, b)$ if and only if $a < x < b$.


theorem Polynomial.degree_C_le : ∀ {R : Type u} {a : R} [inst : Semiring R], Polynomial.degree (Polynomial.C a) ≤ 0 :=
  by sorry

This theorem states that for any semiring `R` and any element `a` from `R`, the degree of the constant polynomial `C a` is less than or equal to zero. In other words, the highest power of `X` that appears in the constant polynomial is zero or, in a case where the constant is zero, there are no terms at all. This is based on our definition where the degree of a polynomial is the highest power of `X` that appears in the polynomial, and the degree of the zero polynomial is negative infinity (`⊥`).

For any semiring `R` and its element `a`, the degree of the constant polynomial `C a` (where `C` is the constant polynomial functor) is less than or equal to zero.


/-- If you actually have an element of `Fin n`, then the `n` is always positive  -/
theorem Fin.size_pos : ∀ {n : ℕ}, Fin n → 0 < n := by sorry

This theorem, `Fin.size_pos`, states that for all natural numbers `n`, if there exists an element in the finite set `Fin n`, then `n` must always be greater than 0. The finite set `Fin n` represents a set of `n` distinct elements, so if there exists an element in this set, it implies that the set is not empty, consequently `n` is positive.

If a finite set of size `n` is non-empty, then `n` is a positive natural number.


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

This theorem states that for any given type `α` with a pseudometric space structure, any two elements of this type `x` and `y`, and any real number `ε`, `y` is in the closed ball centered at `x` with radius `ε` if and only if the distance between `y` and `x` is less than or equal to `ε`. In other words, the condition for a point `y` to be in the `ε`-closed ball around `x` is equivalent to the condition that the distance from `y` to `x` is at most `ε`.

For any pseudometric space `(α, d)`, and for all `x ∈ α`, `y ∈ α`, and `ε ∈ ℝ`, `y` is in the closed ball `{z | d(x, z) ≤ ε}` around `x` if and only if `d(x, y) ≤ ε`.


theorem List.drop_nil : ∀ {α : Type u} {i : ℕ}, List.drop i [] = [] := by sorry

The theorem `List.drop_nil` states that for any type `α` and any natural number `i`, if you attempt to drop `i` elements from an empty list, the result will always be an empty list. In other words, if there are no elements to be removed from the list, the operation of dropping elements will not change the list.

For any type `α` and natural number `i`, `List.drop i [] = []`.


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

This theorem states that for any type `α` that forms a linearly ordered semifield, given any two elements `a` and `b` of this type, if `b` is greater than zero, then the fraction `a / b` is less than 1 if and only if `a` is less than `b`. This is a standard result in elementary number theory and algebra.

For any linearly ordered semifield type `α`, elements `a` and `b` with `b` positive, have the property that `a / b` is less than 1 if and only if `a` is less than `b`.


/-- The direction of the affine span is the `vectorSpan`.  -/
theorem direction_affineSpan :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (s : Set P), AffineSubspace.direction (affineSpan k s) = vectorSpan k s :=
  by sorry

The theorem `direction_affineSpan` states that for any set `s` of points in an affine space `P` over a ring `k`, with the associated vector space `V`, the direction of the affine subspace spanned by `s` is equal to the submodule spanned by the pairwise differences of the points in `s`. Here, the direction of an affine subspace is understood as the set of all vectors that can be obtained by subtracting any two points in the subspace, and the affine span of a set of points is the smallest affine subspace that contains all of those points.

The direction of the affine subspace spanned by a set of points in an affine space is equal to the submodule generated by the pairwise differences of those points.


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

The theorem `lt_sub_iff_add_lt` is a statement about elements of an additive group of a certain type, which also possess a less-than order relation, and this order relation is covariant with respect to the group's addition operation. Specifically, for any elements `a`, `b`, and `c` of this type, the theorem states that `a` is less than `c` subtract `b` if and only if `a` plus `b` is less than `c`. This essentially means subtracting `b` from `c` on one side of a less-than inequality is the same as adding `b` to `a` on the other side of the inequality.

For all elements `a`, `b`, and `c` in an additive group with a covariant less-than order relation, `a < c < b` if and only if `a + b < c`.