theorem compl_inf : ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], (x ⊓ y)ᶜ = xᶜ ⊔ yᶜ := by sorry

This theorem states that for any type `α` equipped with a Boolean algebra structure, and for any two elements `x` and `y` of `α`, the complement of the infimum (or greatest lower bound) of `x` and `y` is equal to the supremum (or least upper bound) of the complements of `x` and `y`. In other words, it's saying that the De Morgan's Law holds in this Boolean algebra: not (x and y) is the same as (not x) or (not y).

For any Boolean algebra `α`, the complement of the infimum of elements `x` and `y` equals the supremum of the complements of `x` and `y`. Equivalently, `not (x && y) <-> not x || not y`.


theorem Nat.add_lt_add_right : ∀ {n m : ℕ}, n < m → ∀ (k : ℕ), n + k < m + k := by sorry

This theorem states that for all natural numbers `n`, `m`, and `k`, if `n` is less than `m`, then the sum of `n` and `k` is less than the sum of `m` and `k`. In other words, if one natural number is smaller than another, adding the same value to both will maintain the order.

For all natural numbers `n`, `m`, and `k`, if `n` < `m` then `n + k` < `m + k`.


theorem WfDvdMonoid.exists_irreducible_factor :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : WfDvdMonoid α] {a : α},
      ¬IsUnit a → a ≠ 0 → ∃ i, Irreducible i ∧ i ∣ a :=
  by sorry

This theorem states that for any commutative monoid with zero `α` which is also a well-founded divisible monoid, given an element `a` of `α` which is not a unit and is not zero, there exists an irreducible element `i` in `α` that is a factor of `a`. Here, an irreducible element is one that cannot be factored into two non-unit elements, and a well-founded divisible monoid is a structure where the divisibility relation is well-founded (i.e., there are no infinite descending chains).

In a commutative monoid with zero that is both well-founded and divisible, every non-zero, non-unit element can be factored into irreducible elements.


theorem inter_mem_nhdsWithin :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : Set α) {t : Set α} {a : α}, t ∈ nhds a → s ∩ t ∈ nhdsWithin a s :=
  by sorry

The theorem `inter_mem_nhdsWithin` states that for any type `α` which has a topological space structure, any set `s` of type `α`, any other set `t` of type `α`, and any element `a` of type `α`, if `t` is a neighborhood of `a` (i.e., `t` is in the neighborhood filter of `a`), then the intersection of `s` and `t` is in the "neighborhood within" filter of `a` with respect to `s`. In other words, any intersection of `s` and a neighborhood of `a` is a set containing the intersection of `s` and a neighborhood of `a`. This theorem is a fundamental property in topology, describing how the intersection of sets interacts with the concepts of neighborhood and "neighborhood within" in a topological space.

For any topological space `(α, τ)`, if `t ∈ 𝓝(a)` (neighborhood of `a`), then `s ∩ t ∈ 𝓛[s](a)` (intersection of `s` and `t` is in the "neighborhood within" `s` of `a`).


theorem CategoryTheory.MonoidalCategory.whiskerRight_tensor :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X X' : C}
      (f : X ⟶ X') (Y Z : C),
      CategoryTheory.MonoidalCategory.whiskerRight f (CategoryTheory.MonoidalCategory.tensorObj Y Z) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
          (CategoryTheory.CategoryStruct.comp
            (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.whiskerRight f Y) Z)
            (CategoryTheory.MonoidalCategory.associator X' Y Z).hom) :=
  by sorry

The theorem `CategoryTheory.MonoidalCategory.whiskerRight_tensor` states that for any category `C` with monoidal structure and objects `X`, `X'`, `Y`, `Z` of `C` and a morphism `f` from `X` to `X'`, the whiskering on the right of `f` with the tensor product of `Y` and `Z` is equivalent to the composition of the inverse of the associator of `X`, `Y`, `Z` and the composition of the whiskering on the right of `f` whiskered on the right with `Y` on `Z` and the homomorphism given by the associator of `X'`, `Y`, `Z`.

In terms of category theory, this theorem is about the interaction of the whiskering-right operation with the tensor product operation in a monoidal category. The theorem demonstrates how these two operations are related through the associator, which is part of the structure of a monoidal category and provides the coherence conditions for the tensor product.

For any monoidal category `C` and objects `X`, `X'`, `Y`, `Z` in `C`, and morphism `f : X → X'`, the right whiskering of `f` with the tensor product of `Y` and `Z` is equivalent to the composition of the inverse of the associator of `X`, `Y`, `Z`, `f`, the associator of `X'`, `Y`, `Z`, and the right whiskering of `f` with `Y` on `Z`.


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

The theorem `Set.subset_iInter` states that for all types `β` and `ι`, and for a set `t` of type `β` and a function `s` of type `ι` to `Set β`, if `t` is a subset of `s i` for all `i` in `ι`, then `t` must be a subset of the intersection of all `s i`. In simpler terms, if a set `t` is contained in each of a collection of sets, then it is also contained in their intersection.

If a set is subset of every set in a family, then it is a subset of their intersection.


/-- If a family of open sets `s` is such that every open neighbourhood contains some
member of `s`, then `s` is a topological basis.  -/
theorem TopologicalSpace.isTopologicalBasis_of_isOpen_of_nhds :
    ∀ {α : Type u} [t : TopologicalSpace α] {s : Set (Set α)},
      (∀ u ∈ s, IsOpen u) →
        (∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v ∈ s, a ∈ v ∧ v ⊆ u) → TopologicalSpace.IsTopologicalBasis s :=
  by sorry

The theorem states that for any type `α` equipped with a topology `t` and any set `s` of subsets of `α`, if all elements of `s` are open sets and for every element `a` of `α` and every open set `u` containing `a`, there exists a set `v` in `s` such that `a` is in `v` and `v` is a subset of `u`, then `s` is a topological basis.

In other words, a set of open sets forms a topological basis if and only if every open set can be written as a union of some collection of these sets. This is a fundamental concept in the study of topology, as it gives a way to construct and understand open sets.

If a collection of open sets in a topological space has the property that every open set contains some set in the collection, then the collection forms a topological basis.


Eq.superset

/-- **Alias** of `superset_of_eq`. -/
theorem Eq.superset :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1], a = b → b ⊆ a := by sorry

This theorem, referred to as `Eq.superset`, states that for any type `α` that has a subset operation, and for any two elements `a` and `b` of this type, if `a` equals `b`, then `b` is a subset of `a`. This holds under the condition that the subset relationship is reflexive on `α`, meaning any element of `α` is a subset of itself.

If `α` is a type with a reflexive subset relation, then for all `a` and `b` in `α`, `a = b` implies `b ⊆ a`.


Matroid.Basis.indep

theorem Matroid.Basis.indep : ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.Basis I X → M.Indep I := by sorry

This theorem states that for any type `α`, any `Matroid` `M` over `α`, and any two sets `I` and `X` of type `α`, if `X` is a basis of `I` under matroid `M` (denoted as `M.Basis I X`), then `I` is an independent set under matroid `M` (denoted as `M.Indep I`).

In other words, this theorem establishes that in a matroid structure, all basis sets are independent.

In a matroid, every basis is an independent set.


theorem Filter.disjoint_of_disjoint_of_mem :
    ∀ {α : Type u} {f g : Filter α} {s t : Set α}, Disjoint s t → s ∈ f → t ∈ g → Disjoint f g := by sorry

This theorem states that for any type `α`, any two filters `f` and `g` on this type, and any two sets `s` and `t` of this type, if `s` and `t` are disjoint and `s` belongs to filter `f` and `t` belongs to filter `g`, then filters `f` and `g` are also disjoint. Here, two sets are said to be disjoint if they have no elements in common, and two filters are considered disjoint if their infimum (or greatest lower bound) is the bottom element of the lattice structure.

Given filters `f` and `g` on type `α`, if sets `s` in `f` and `t` in `g` are disjoint, then filters `f` and `g` are disjoint in the sense that their infimum is the bottom element of the lattice structure.


theorem Complex.cpow_def_of_ne_zero : ∀ {x : ℂ}, x ≠ 0 → ∀ (y : ℂ), x ^ y = Complex.exp (Complex.log x * y) := by sorry

This theorem states that for any non-zero complex number `x` and any complex number `y`, the power of `x` raised to `y` is equivalent to the complex exponential of the product of the complex logarithm of `x` and `y`. In mathematical notation, this is commonly expressed as \(x^y = e^{(\log x) \cdot y}\) for all \(x \neq 0\). The logarithm and exponential functions used here are complex logarithm and complex exponential functions.

For any non-zero complex number `x`, the power `x^y` equals the complex exponential `exp(y * log x)`.


EquivLike.bijective

theorem EquivLike.bijective :
    ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [iE : EquivLike E α β] (e : E), Function.Bijective ⇑e := by sorry

The theorem `EquivLike.bijective` states that for any types `α`, `β` and `E` in given sorts, if there exists an `EquivLike` instance between `α` and `β` for the type `E`, then a function represented by the application of this `E` is bijective. In other words, this function is both injective (each element in the domain maps to a unique element in the codomain) and surjective (every element in the codomain is the image of at least one element in the domain).

If `α` and `β` are types with an `EquivLike` relation `E` between them, then the function induced by `E` is a bijection.


theorem FiniteDimensional.finrank_eq_of_rank_eq :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {n : ℕ},
      Module.rank R M = ↑n → FiniteDimensional.finrank R M = n :=
  by sorry

This theorem states that for any ring `R` and any additively commutative group `M`, if `M` is also a module over `R` and the rank of `M` as a module over `R` equals `n` (where `n` is a natural number), then the finite dimension (or rank) of `M` as a module over `R` is also `n`. In other words, when the rank of the module `M` over the ring `R` is a finite natural number `n`, the rank and the finite dimension of the module coincide.

For any ring `R` and additively commutative group `M` that is an `R`-module with finite rank `n`, the rank and finite dimension of `M` as an `R`-module are equal.


/-- An auxiliary lemma that can be used to prove `⇑(f ^ n) = ⇑f^[n]`.  -/
theorem hom_coe_pow :
    ∀ {M : Type u_1} {F : Type u_5} [inst : Monoid F] (c : F → M → M),
      c 1 = id → (∀ (f g : F), c (f * g) = c f ∘ c g) → ∀ (f : F) (n : ℕ), c (f ^ n) = (c f)^[n] :=
  by sorry

This theorem, `hom_coe_pow`, asserts that for any types `M` and `F`, where `F` is a monoid, and for any function `c` from `F` and `M` to `M` that satisfies two particular properties. The first property is that applying `c` to the identity element of `F` returns the identity function on `M`. The second property is that for any two elements `f` and `g` of `F`, applying `c` to the product of `f` and `g` is equivalent to first applying `c` to `g` and then applying `c` to `f`. Under these conditions, the theorem states that for any element `f` of `F` and any natural number `n`, applying `c` to `f` raised to the power `n` is equivalent to applying `c` to `f` `n` times.

For any monoid `F` and function `c` from `F` and a type `M` such that applying `c` to the identity element is the identity function and applying `c` to the product of two elements is equivalent to applying `c` to the elements in order, applying `c` to an element `f` raised to a natural number `n` is equivalent to applying `c` to `f` `n` times.


theorem LinearMap.id_apply :
    ∀ {R : Type u_1} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
      LinearMap.id x = x :=
  by sorry

This theorem, `LinearMap.id_apply`, states that for any semiring `R` and additive commutative monoid `M` that is also a module over `R`, the identity linear map, when applied to any element `x` of `M`, simply returns `x`. In other words, the action of the identity linear map leaves every element of the module unchanged.

For any semiring R and additive commutative monoid M that is an R-module, the identity linear map is the identity function on M.


theorem Real.volume_Ioo : ∀ {a b : ℝ}, ↑↑MeasureTheory.volume (Set.Ioo a b) = ENNReal.ofReal (b - a) := by sorry

This theorem, named `Real.volume_Ioo`, states that for any two real numbers `a` and `b`, the measure (think of this as the "volume" in a one-dimensional sense) of the open interval (excluding `a` and `b`) between `a` and `b` is equal to the nonnegative real part of the difference between `b` and `a`. In mathematical terms, this means that the Lebesgue measure of the interval $(a, b)$, denoted by $\mu((a, b))$, is equal to max$(b - a, 0)$. If `b` is greater than `a`, it is just `b - a`; otherwise, it is `0`.

The Lebesgue measure of the open real interval $(a, b)$ is equal to the non-negative difference between $b$ and $a$.


theorem iSup_const :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {a : α} [inst_1 : Nonempty ι], ⨆ x, a = a := by sorry

This theorem states that for any complete lattice `α`, any type `ι` that is nonempty, and any element `a` of `α`, the supremum of the constant function that assigns `a` to every element of `ι` is `a`. In other words, if you take any set of elements all equal to `a` from a complete lattice, the least upper bound of this set (the supremum) is also `a`.

For any complete lattice `α` and nonempty type `ι`, the supremum of the constant function mapping every element of `ι` to an arbitrary element `a` in `α` is equal to `a`.


theorem Real.volume_Icc : ∀ {a b : ℝ}, ↑↑MeasureTheory.volume (Set.Icc a b) = ENNReal.ofReal (b - a) := by sorry

The theorem `Real.volume_Icc` states that for any two real numbers `a` and `b`, the Lebesgue measure (volume) of the interval between `a` and `b` (inclusive of `a` and `b`) is equal to the nonnegative part of the difference between `b` and `a`. In mathematical terms, for any $a, b \in \mathbb{R}$, ${\mu([a, b])} = \max\{b - a, 0\}$ where $\mu$ denotes the Lebesgue measure. This theorem essentially asserts that the measure of an interval in the real numbers is just the difference of its endpoints when the left endpoint is less than or equal to the right endpoint, and zero otherwise.

The Lebesgue measure of the interval $[a, b]$ is equal to the maximum of the difference between $b$ and $a$, and 0.


theorem CategoryTheory.Limits.IsColimit.uniq_cocone_morphism :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {s t : CategoryTheory.Limits.Cocone F}, CategoryTheory.Limits.IsColimit t → ∀ {f f' : t ⟶ s}, f = f' :=
  by sorry

This theorem states that in the context of category theory, for any given category `J` and a functor `F` from `J` to another category `C`, if we have two cocones `s` and `t` over `F` with `t` being a colimit, then any two morphisms `f` and `f'` from `t` to `s` are equal. This theorem is asserting the uniqueness of such a morphism in a specific category-theoretic context, namely when the starting cocone is a colimit.

In category theory, given a category `J`, a functor `F` from `J` to another category `C`, and a colimit cocone `t` over `F`, any two morphisms from `t` to a cocone `s` over `F` are equal.


theorem BilinForm.add_right :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {B : BilinForm R M} (x y z : M), B.bilin x (y + z) = B.bilin x y + B.bilin x z :=
  by sorry

This theorem states that for any commutative semiring `R`, any additive commutative monoid `M` and any `R`-module structure on `M`, and for any bilinear form `B` on `M`, the bilinear form evaluated at `x` and `(y + z)` is equal to the sum of the bilinear form evaluated at `x` and `y` and the bilinear form evaluated at `x` and `z`. In other words, we can distribute the bilinear form over the addition operation.`B.bilin x (y + z) = B.bilin x y + B.bilin x z`. This is the property of bilinear forms, and in mathematics, it is known as right additivity or right linearity.

For any commutative semiring `R`, additive commutative monoid `M` with an `R`-module structure, and bilinear form `B` on `M`, we have `B(x, y + z) = B(x, y) + B(x, z)`.


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

The theorem `Polynomial.degree_mul'` states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the product of the leading coefficients of `p` and `q` is not zero, then the degree of the product `p * q` is equal to the sum of the degrees of `p` and `q`. In other words, provided the leading coefficients of the polynomials are not both zero, the degree of the multiplication of two polynomials is the sum of their individual degrees.

For polynomials $p$ and $q$ over a semiring $R$ with non-zero leading coefficients, the degree of their product $p \cdot q$ is equal to the sum of the degrees of $p$ and $q$.


theorem iSup_subtype :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : Subtype p → α},
      iSup f = ⨆ i, ⨆ (h : p i), f { val := i, property := h } :=
  by sorry

This theorem, `iSup_subtype`, states that for any type α that forms a complete lattice, a property `p` on another arbitrary type `ι`, and a function `f` mapping subtypes of `ι` that satisfy property `p` to `α`, the indexed supremum of `f` is equal to the supremum over all `i` in `ι` and all proofs `h` that `i` satisfies property `p`, of `f` applied to the subtype formed from `i` and `h`. In simpler terms, it describes a way to compute the supremum of a function applied to elements of a subtype, by instead taking the supremum over the range of the original type and the proofs that elements of this range belong to the subtype.

For any complete lattice α, property p on type ι, and function f mapping subtypes of ι satisfying p to α, the indexed supremum of f is equal to the supremum over all i in ι with property p and all proofs h that i has property p, of f applied to the subtype of i and h.


theorem Cardinal.mk_eq_aleph0 :
    ∀ (α : Type u_1) [inst : Countable α] [inst : Infinite α], Cardinal.mk α = Cardinal.aleph0 := by sorry

The theorem `Cardinal.mk_eq_aleph0` asserts that for any type `α` that is both countable and infinite, the cardinal number of `α` is equal to `ℵ₀`, the smallest infinite cardinal (which is the cardinality of the set of natural numbers). In other words, any infinite set that can be put into a one-to-one correspondence with the natural numbers has the same cardinality as the set of natural numbers, denoted as `ℵ₀` (aleph-null).

For any countable and infinite type `α`, its cardinality equals that of the natural numbers, denoted as `ℵ₀`.


theorem IsUnit.nonempty_invertible : ∀ {α : Type u} [inst : Monoid α] {a : α}, IsUnit a → Nonempty (Invertible a) := by
  sorry

The theorem `IsUnit.nonempty_invertible` states that for any type `α` which forms a monoid, and for any element `a` of type `α`, if `a` is a unit (meaning it has a two-sided inverse), then there exists an `Invertible` version of `a`. The `Invertible` type in Lean is used to denote invertible elements in a multiplicative monoid or group, thus the theorem essentially asserts the existence of an invertible counterpart for any unit element in a monoid.

For any monoid `α` and unit `a` in `α`, there exists an invertible element in `α` that is the multiplicative inverse of `a`.


UniformInducing.uniformContinuous

theorem UniformInducing.uniformContinuous :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformInducing f → UniformContinuous f :=
  by sorry

The theorem `UniformInducing.uniformContinuous` states that for any two types `α` and `β`, each equipped with a uniform space structure (i.e., they both have a topology that allows the measurement of "closeness"), and given a function `f` from `α` to `β`, if `f` is uniform inducing (meaning it preserves the uniformity structure in the sense that the uniformity on `α` is the same as the preimage under `f` of the uniformity on `β`), then `f` is also uniformly continuous. In other words, if `f` is such that it preserves the "closeness" relationship from `α` to `β`, then for any two points in `α` that are sufficiently close, their images under `f` in `β` are also close, regardless of their actual location in `α`.

If a function between two uniform spaces is uniformly inducing, then it is uniformly continuous.


PartialEquiv.leftInvOn

theorem PartialEquiv.leftInvOn :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), Set.LeftInvOn (↑(PartialEquiv.symm e)) (↑e) e.source := by
  sorry

The theorem `PartialEquiv.leftInvOn` states that for any partial equivalence `e` between two types `α` and `β`, the function `↑(PartialEquiv.symm e)` is a left inverse to the function `↑e` on the domain `e.source`. In other words, for all `x` in the domain `e.source`, applying `e` to `x` and then applying the inverse of `e` to the result will give you `x` back. This is a representation of the property that every element in the domain of a partial equivalence has a unique corresponding element in the target, and vice versa.

For any partial equivalence relation `e` between types `α` and `β`, `↑(PartialEquiv.symm e) ∘ ↑e = id_α` on the domain `e.source`. Here, `id_α` denotes the identity function on type `α`.


theorem Mathlib.GroupTheory.Submonoid.Basic._auxLemma.2 :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {s : AddSubmonoid M} {x : M}, (x ∈ s.toAddSubsemigroup) = (x ∈ s) := by
  sorry

This theorem states that for any type `M` that forms an `AddZeroClass`, for any additive submonoid `s` of `M`, and for any element `x` of `M`, `x` being an element of the additive subsemigroup associated with `s` is equivalent to `x` being an element of `s` itself. In other words, the membership of `x` in the additive subsemigroup derived from the submonoid is the same as its membership in the original submonoid.

For any AddZeroClass type M, any additive submonoid s of M, and any x in M, x belongs to the additive subsemigroup of s if and only if x belongs to s.


theorem Polynomial.eval_finset_sum :
    ∀ {R : Type u} {ι : Type y} [inst : Semiring R] (s : Finset ι) (g : ι → Polynomial R) (x : R),
      Polynomial.eval x (Finset.sum s fun i => g i) = Finset.sum s fun i => Polynomial.eval x (g i) :=
  by sorry

The theorem `Polynomial.eval_finset_sum` states that for any given type `R` with a semiring structure, any finset `s` of type `ι`, a function `g` from `ι` to polynomials of `R`, and an element `x` of `R`, the evaluation of the sum of the polynomials (given by `g`) at `x` is equal to the sum of the evaluations of each polynomial (given by `g`) at `x`. In mathematical terms, for any finite set of indices and a function mapping each index to a specific polynomial, the value of the sum of these polynomials evaluated at a specific point is the same as the sum of the individual polynomial values at that point, i.e., $\text{eval}(x, \sum_{i\in s}{g(i)}) = \sum_{i\in s}{\text{eval}(x, g(i))}$.

For any semiring `R`, finset `s` over index type `ι`, and function `g` from `ι` to polynomials of `R`, the evaluation of the sum of `g` at an element `x` of `R` is equal to the sum of the evaluations of each polynomial in `g` at `x`. In mathematical notation, $\text{eval}(x, \sum\_{i\in s}{g(i)}) = \sum\_{i\in s}{\text{eval}(x, g(i))}$.


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

The theorem `Set.image2_inter_subset_left` states that for all types `α`, `β`, and `γ`, and for all functions `f` from `α` and `β` to `γ`, if `s` and `s'` are sets of type `α` and `t` is a set of type `β`, then the image of the function `f` when applied on the intersection of the sets `s` and `s'` and the set `t` (expressed as `Set.image2 f (s ∩ s') t`) is a subset of the intersection of the image of the function `f` when applied on `s` and `t` and the image of `f` when applied on `s'` and `t` (expressed as `Set.image2 f s t ∩ Set.image2 f s' t`). In simpler terms, it asserts that the image of the intersection of two sets under a function is a subset of the intersection of the images of the individual sets under the same function.

For all types `α`, `β`, and `γ`, and functions `f` from `α` to `γ`, if `s` and `s'` are sets of type `α`, then `Set.image2 f (s ∩ s')` is a subset of `Set.image2 f s ∩ Set.image2 f s'`.


theorem Polynomial.C_mul' : ∀ {R : Type u} [inst : Semiring R] (a : R) (f : Polynomial R), Polynomial.C a * f = a • f :=
  by sorry

The theorem `Polynomial.C_mul'` states that for any type `R` that is a semiring, and for any element `a` of `R` and any polynomial `f` over `R`, the result of multiplying the constant polynomial of `a` with `f` is the same as the scalar multiplication of `a` and `f`. In other words, it shows that in the context of polynomials, the constant multiplication behaves the same way as scalar multiplication.

For any semiring `R`, element `a` in `R`, and polynomial `f` over `R`, the constant polynomial of `a` multiplied with `f` equals the scalar multiplication of `a` times `f`.


theorem Multiset.mem_add : ∀ {α : Type u_1} {a : α} {s t : Multiset α}, a ∈ s + t ↔ a ∈ s ∨ a ∈ t := by sorry

This theorem states that for any type `α`, a given element `a` of type `α`, and two multisets `s` and `t` of type `α`, `a` is a member of the multiset resulting from the addition of `s` and `t` if and only if `a` is a member of either `s` or `t`. Here, the addition of two multisets is analogous to the union operation in set theory, but allows for duplicates.

For any type `α` and elements `a` of type `α`, the multiset `s ± t` contains `a` if and only if `s` or `t` contains `a`. (Here, `±` denotes multiset addition in Lean 4.)


theorem Nat.leRecOn_self :
    ∀ {C : ℕ → Sort u_1} {n : ℕ} {next : {k : ℕ} → C k → C (k + 1)} (x : C n), Nat.leRecOn ⋯ (fun {k} => next) x = x :=
  by sorry

This theorem states that for any natural number `n` and a function `next` that takes a natural number `k` and a value of some type `C k` and produces a value of type `C (k + 1)`, when `Nat.leRecOn` is applied to `n`, the function `next`, and a value `x` of type `C n`, the result is `x`. In other words, the least number recursion on `n` using `next` and starting with `x` just gives `x` again.

For any function `next : ℕ → C → C` and value `x : C n`, `Nat.leRecOn n next x = x`.


PSet.Equiv.refl

theorem PSet.Equiv.refl : ∀ (x : PSet), PSet.Equiv x x := by sorry

The theorem `PSet.Equiv.refl` states that for any pre-set `x`, the pre-set `x` is extensionally equivalent to itself. In other words, every element of the pre-set `x` is extensionally equivalent to some element of the same pre-set `x` and vice-versa. This is a reflection of the reflexivity property in the context of extensional equivalence of pre-sets.

Every pre-set is extensionally equivalent to itself.


theorem AddSubgroup.subtype_range :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), AddMonoidHom.range (AddSubgroup.subtype H) = H := by sorry

The theorem `AddSubgroup.subtype_range` states that for any additive group `G` and any additive subgroup `H` of `G`, the range of the natural group homomorphism from `H` to `G` is precisely `H` itself. This means that applying the subgroup subtype function to every element of `H` will give us exactly the set `H`. In other words, the map that sends each element of `H` to its corresponding element in `G` (defined by the `AddSubgroup.subtype` function) is surjective on `H`.

The subtype map from an additive subgroup of an additive group to the group itself is a surjection.


theorem ContinuousAt.preimage_mem_nhds :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {x : X}
      {t : Set Y}, ContinuousAt f x → t ∈ nhds (f x) → f ⁻¹' t ∈ nhds x :=
  by sorry

This theorem, `ContinuousAt.preimage_mem_nhds`, states that for all types `X` and `Y` with the structure of topological spaces, any function `f` from `X` to `Y`, and any point `x` in `X` and set `t` of `Y`, if `f` is continuous at `x` and `t` is a neighborhood of `f(x)`, then the preimage of `t` under `f` is a neighborhood of `x`. In other words, the preimage of any neighborhood of `f(x)` under a function `f` that is continuous at `x`, forms a neighborhood of `x` in `X`.

For all topological spaces X and Y, continuous function f : X -> Y, point x in X, and neighborhood t of f(x) in Y, the preimage f^(-1)(t) is a neighborhood of x in X.


/-- Deprecated, use `_root_.map_list_prod` instead.  -/
theorem MonoidHom.map_list_prod :
    ∀ {M : Type u_5} {N : Type u_6} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (l : List M),
      f (List.prod l) = List.prod (List.map (⇑f) l) :=
  by sorry

This theorem, which is deprecated and should be replaced with `_root_.map_list_prod`, states that for any monoid homomorphism (`f`) from one monoid (`M`) to another monoid (`N`), the application of `f` to the product of a list of elements in `M` (`List.prod l`) is equal to the product of the list obtained by mapping `f` over `l`. In other words, applying the monoid homomorphism to the product of the list corresponds to taking the product of the list after applying the homomorphism to each of its elements. This theorem showcases the compatibility of the monoid homomorphism with the operation of taking products in the respective monoids.

For any monoid homomorphism `f` from monoid `M` to monoid `N`, `f (List.prod l) = List.prod (map f l)`.


theorem Algebra.adjoin_le_iff :
    ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A}
      {S : Subalgebra R A}, Algebra.adjoin R s ≤ S ↔ s ⊆ ↑S :=
  by sorry

The theorem `Algebra.adjoin_le_iff` states that for any commutative semiring `R`, semiring `A`, algebra structure on `R` and `A`, a set `s` of elements from `A`, and a subalgebra `S` of `R` and `A`, the minimal subalgebra that includes `s` is a subalgebra of `S` if and only if the set `s` is contained in the set of elements of `S`. In other words, the theorem provides a characterization of the containment relationship between the subalgebra generated by a set and another subalgebra in terms of set inclusion.

The subalgebra generated by a set in a commutative semiring with respect to an algebra structure is contained in another subalgebra if and only if the set is included in the other subalgebra.


theorem DFinsupp.coe_smul :
    ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : Monoid γ] [inst_1 : (i : ι) → AddMonoid (β i)]
      [inst_2 : (i : ι) → DistribMulAction γ (β i)] (b : γ) (v : Π₀ (i : ι), β i), ⇑(b • v) = b • ⇑v :=
  by sorry

This theorem states that for any types `ι`, `γ`, and a type function `β` from `ι` to some type, given a `Monoid` structure on `γ` and an `AddMonoid` structure on each `β i` as well as a `DistribMulAction` structure (a distribution law for multiplication over addition) for `γ` acting on each `β i`, if we have a `b` from the `γ` type and a direct sum (DFinsupp) `v` over the `β i`, we can distribute the scalar multiplication of `b` over `v` inside the function application of `v`. In more mathematical terms, for all `b` in `γ` and `v` in the direct sum of `β i` over `ι`, the application of the result of scaling `v` by `b` is equal to scaling the result of applying `v` by `b`. This essentially validates the law of scalar multiplication distribution over function application for this mathematical context.

For any Monoid `γ`, AddMonoid `β i`, and a Distribution Law for multiplication over addition `DistribMulAction` on `γ` acting on each `β i`, if `b` is an element of `γ` and `v` is a direct sum over `ι`, then scaling `v` by `b` and applying it is equivalent to applying `v` and scaling the result by `b`.


ContDiff.contDiffOn

theorem ContDiff.contDiffOn :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {n : ℕ∞}, ContDiff 𝕜 n f → ContDiffOn 𝕜 n f s :=
  by sorry

This theorem states that for any nontrivial normed field 𝕜, normed additive commutative groups E and F, and a set s of elements from E, if a function f from E to F is continuously differentiable up to an order n in the whole domain, then it is also continuously differentiable up to the same order on the subset s of its domain. The order of differentiation can be any natural number or infinity. The implication holds regardless of the specific types of the normed field and the normed additive commutative groups.

For any nontrivial normed field 𝕜, if a continuously differentiable up to order n function f : E → F between Banach spaces E and F remains so when restricted to any subset s of its domain, where E and F are normed additive commutative groups.


theorem Set.iUnion_singleton_eq_range : ∀ {α : Type u_11} {β : Type u_12} (f : α → β), ⋃ x, {f x} = Set.range f := by
  sorry

The theorem `Set.iUnion_singleton_eq_range` states that for any given function `f` mapping from a type `α` to a type `β`, the union of singleton sets `{f x}` for all `x` of type `α` is equal to the range of the function `f`. In mathematical terms, it says that for any function `f : α → β`, the set of all values `f(x)` for `x` in `α` (denoted as `⋃ x, {f x}` in Lean) is exactly the set of all possible outputs of the function `f`, also known as the range of `f`.

For any function f : α → β, the set {fx | x ∈ α} equals the range of f.


theorem or_false_iff : ∀ (p : Prop), p ∨ False ↔ p := by sorry

This theorem states that for any given proposition "p", the logical disjunction (or) of "p" and "false" is logically equivalent to "p". In other words, saying that either "p" is true or "false" is true, is the same as saying "p" is true, because "false" is always false and doesn't affect the outcome of the disjunction.

For any proposition p, p ∨ false is logically equivalent to p.


/-- If the distance between any two points in a set is bounded by some constant, this constant
bounds the diameter.  -/
theorem EMetric.diam_le :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α} {d : ENNReal},
      (∀ x ∈ s, ∀ y ∈ s, edist x y ≤ d) → EMetric.diam s ≤ d :=
  by sorry

This theorem states that for any given set `s` in a pseudo emetric space `α`, if the distance between any two points in this set is less than or equal to a certain non-negative real number `d` (possibly extended with positive infinity), then the diameter of the set `s` is also less than or equal to `d`. In other words, if every pair of points in the set is no further apart than `d`, then the greatest possible distance between any two points in the set (the diameter) is no greater than `d`.

In a pseudometric space, the diameter of a set is less than or equal to the greatest distance between any two of its points.


theorem CategoryTheory.ShortComplex.HasLeftHomology.mk' :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.LeftHomologyData S → CategoryTheory.ShortComplex.HasLeftHomology S :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.HasLeftHomology.mk'`, states that for any type `C` that forms a category with zero morphisms, and any short complex `S` of this category, if `S` has left homology data, then `S` has left homology. In the context of category theory, a complex is a sequence of morphisms such that the composition of any two consecutive morphisms is zero, and the homology of a complex measures the extent to which this sequence fails to be exact. Here, 'left homology' and 'left homology data' refer to the homology and homology data at the left end of the complex, respectively.

If `C` is a category with zero morphisms and `S` is a short complex in `C` with left homology data, then `S` has defined left homology.


theorem GaloisInsertion.u_le_u_iff :
    ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β],
      GaloisInsertion l u → ∀ {a b : β}, u a ≤ u b ↔ a ≤ b :=
  by sorry

The theorem states that for all types `α` and `β` with preorders, and for all functions `l` from `α` to `β` and `u` from `β` to `α` that form a Galois insertion, the inequality `u a ≤ u b` holds if and only if `a ≤ b` for any elements `a` and `b` of `β`. In other words, for a Galois insertion, the ordering of elements in `β` is preserved when mapped to `α` via function `u`.

For every Galois insertion between preordered types `α` and `β` via functions `l` from `α` to `β` and `u` from `β` to `α`, the order relation `u(a) ≤ u(b)` in `α` if and only if `a ≤ b` in `β` for all elements `a` and `b` in `β`.


theorem Finset.mem_Ici :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a x : α}, x ∈ Finset.Ici a ↔ a ≤ x := by
  sorry

This theorem, `Finset.mem_Ici`, states that for any type `α` that has a preorder (an order that is reflexive and transitive) and is a locally finite order (an order where every interval is finite), and for any elements `a` and `x` of type `α`, `x` is an element of the finset `Ici a` if and only if `a` is less than or equal to `x`. Here, `Ici a` represents the finset of all elements `x` such that `a ≤ x`. So, this theorem essentially provides a criterion for membership in the finset `Ici a`.

For any type `α` with a preorder and the locally finite order property, `x` is an element of the finset `Ici a` if and only if `a ≤ x`.


theorem CategoryTheory.Subobject.factors_iff :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (P : CategoryTheory.Subobject Y) (f : X ⟶ Y),
      CategoryTheory.Subobject.Factors P f ↔
        CategoryTheory.MonoOver.Factors (CategoryTheory.Subobject.representative.obj P) f :=
  by sorry

The theorem `CategoryTheory.Subobject.factors_iff` states that for any categories `X` and `Y` in a category `C`, a subobject `P` of `Y`, and a morphism `f` from `X` to `Y`, there exists a factorisation of `f` through `P` if and only if there exists a factorisation of `f` through the representative `MonoOver` of `P`. Simply put, it says that a morphism can be factored through a subobject if and only if it can be factored through a representative of that subobject.

For any categories C, subobject P of Y, and morphism f from X to Y in C, there exists a factorization of f through P if and only if there exists a factorization of f through the monomorphism MonoOver(P).


theorem ContinuousMultilinearMap.toMultilinearMap_injective :
    ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂],
      Function.Injective ContinuousMultilinearMap.toMultilinearMap :=
  by sorry

The theorem `ContinuousMultilinearMap.toMultilinearMap_injective` states that for any semiring `R`, any type `ι`, any type families `M₁ : ι → Type` and `M₂ : Type`, where `M₁ i` and `M₂` are additively commutative monoids and `R` modules, and `M₁ i` and `M₂` are topological spaces, the function `ContinuousMultilinearMap.toMultilinearMap` is injective. In other words, if two continuous multilinear maps between these spaces become the same after applying the function `toMultilinearMap` to them, then they were already the same to begin with.

For any semiring `R`, given type families `M₁ : ι → Type`, `M₂ : Type` of additively commutative monoids and `R`-modules, and topological spaces `M₁ i` and `M₂`, the function `ContinuousMultilinearMap.toMultilinearMap` from continuous multilinear maps between them to multilinear maps is injective.


theorem Nat.exists_eq_add_of_le : ∀ {m n : ℕ}, m ≤ n → ∃ k, n = m + k := by sorry

This theorem states that for any two natural numbers `m` and `n`, if `m` is less than or equal to `n`, then there exists a natural number `k` such that `n` is equal to the sum of `m` and `k`. In essence, it confirms that any natural number `n` greater than or equal to `m` can be expressed as the sum of `m` and some other natural number.

For all natural numbers `m` and `n`, if `m ≤ n`, then there exists a natural number `k` such that `n = m + k`.


theorem MulOpposite.continuous_op : ∀ {M : Type u_1} [inst : TopologicalSpace M], Continuous MulOpposite.op := by sorry

The theorem `MulOpposite.continuous_op` states that for any type `M` equipped with a topological space structure, the operation `MulOpposite.op` is continuous. The operation `MulOpposite.op` takes an element from type `M` and represents it as an element of `MulOpposite M`, a type which carries the 'opposite' multiplication structure. The continuity of this operation is stated in terms of the topology on `M` and the induced topology on `MulOpposite M`.

The operation `MulOpposite.op` mapping elements from a topological space `M` to `MulOpposite M`, which represents their opposites with respect to a multiplication structure, is a continuous function with respect to the given topology on `M` and the induced topology on `MulOpposite M`.


theorem MeasureTheory.MeasurePreserving.measure_preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α → β},
      MeasureTheory.MeasurePreserving f μa μb → ∀ {s : Set β}, MeasurableSet s → ↑↑μa (f ⁻¹' s) = ↑↑μb s :=
  by sorry

This theorem, `MeasureTheory.MeasurePreserving.measure_preimage`, states that for any two types `α` and `β` with measure spaces, a measure `μa` on `α`, a measure `μb` on `β`, and a function `f` from `α` to `β`, if `f` preserves the measure from `μa` to `μb`, then for any measurable set `s` in `β`, the measure `μa` of the preimage of `s` under `f` is equal to the measure `μb` of `s` itself. In mathematical terms, if `f` is a measure-preserving function from a measurable space `(α, μa)` to another measurable space `(β, μb)`, then for all measurable sets `s` in `β`, the measure of the set of all elements in `α` that get mapped to `s` by `f` (denoted as `f⁻¹' s`) under the measure `μa` is the same as the measure of `s` under the measure `μb`.

If `f: α → β` is a measure-preserving function between measurable spaces `(α, μa)` and `(β, μb)`, then for any measurable set `s` in `β`, the measure `μa` of the preimage `f⁻¹' s` is equal to `μb(s)`.


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

The theorem `CategoryTheory.MonoidalCategory.whisker_assoc` states that for any category `C` that also has a monoidal structure, and any objects `X`, `Y`, `Y'`, `Z` in `C`, and a morphism `f` from `Y` to `Y'`, the process of first whiskering `f` on the left by `X` and then on the right by `Z` (expressed as `CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.whiskerLeft X f) Z`) is equivalent to another process. The other process involves taking the composition of the homeomorphism part of the associator for `X`, `Y`, `Z` and then the composition of the left whiskering of `X` by the right whiskering of `f` by `Z`, and the inverse of the associator for `X`, `Y'`, `Z`. Here, the associator provides a specific isomorphism that enforces the associativity property in the monoidal category, and whiskering refers to the act of pre- or post-composing a given morphism with a fixed morphism.

For any monoidal category `C` and objects `X`, `Y`, `Y'`, `Z` in `C`, and a morphism `f` from `Y` to `Y'`, the diagram commuting between `CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.MonoidalCategory.whiskerRight f Z)` and `(CategoryTheory.MonoidalCategory.associator X Y Z) o (CategoryTheory.MonoidalCategory.left_whisker X (CategoryTheory.MonoidalCategory.right_whisker f Z)) o (CategoryTheory.MonoidalCategory.associator X Y' Z).inv` holds.


theorem Set.preimage_smul :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] (a : α) (t : Set β),
      (fun x => a • x) ⁻¹' t = a⁻¹ • t :=
  by sorry

This theorem asserts that, for any types `α` and `β` where `α` is a group and `β` is an object of `α`'s action, and given any element `a` from `α` and set `t` of `β`, the preimage of `t` under the function that maps `x` to `a` multiplied by `x` is equal to the set of elements obtained by multiplying `a⁻¹` with each element of `t`. In mathematical terms, this theorem states that for a group action, the preimage of a set under scalar multiplication is equal to scalar multiplication by the inverse element in the group.

For any group action of type `α` on type `β`, the preimage of a set `t` under the scalar multiplication by an element `a` from `α` is equal to the set of elements obtained by scaling each element `x` in `t` with the inverse `a⁻¹` of `a`. In other words, `a⁺¹⁇{x | x ∈ t} = {a⁻¹ * x | x ∈ t}`.


theorem SetTheory.PGame.nim_def :
    ∀ (o : Ordinal.{u_1}),
      let_fun this := ⋯;
      SetTheory.PGame.nim o =
        SetTheory.PGame.mk (Quotient.out o).α (Quotient.out o).α
          (fun o₂ => SetTheory.PGame.nim (Ordinal.typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
          SetTheory.PGame.nim (Ordinal.typein (fun x x_1 => x < x_1) o₂) :=
  by sorry

The theorem `SetTheory.PGame.nim_def` states that for any ordinal `o`, the game of single-heap nim with `o` stones is the game where each player can choose an index from `o` (represented as the equivalence class of the well-order `o`), and the moves are to play a game of nim with a heap size given by the order type of elements less than the chosen index in the well-order `o`. This highlights that the nature of a nim game is completely determined by the ordinal number of stones it starts with.

For any ordinal number `o`, the game of single-heap nim with `o` stones is the recursively defined game where each player chooses an index from `o` and plays a game of nim with a heap size equal to the cardinality of the set of indices less than the chosen index in the well-order `o`.


/-- A product of a function `f : Fin (n + 1) → β` over all `Fin (n + 1)`
is the product of `f 0` plus the remaining product  -/
theorem Fin.prod_univ_succ :
    ∀ {β : Type u_2} [inst : CommMonoid β] {n : ℕ} (f : Fin (n + 1) → β),
      (Finset.prod Finset.univ fun i => f i) = f 0 * Finset.prod Finset.univ fun i => f (Fin.succ i) :=
  by sorry

The theorem `Fin.prod_univ_succ` states that for any commutative monoid `β`, natural number `n`, and function `f` from the finite set `Fin (n + 1)` to `β`, the product of `f` applied to every element in the universal finite set (which includes all elements of `Fin (n + 1)`) is equal to the product of `f 0` and the product of `f` applied to every successor element in the universal finite set. In simpler terms, it decomposes the product over a finite set into the product of the first element and the product of the remaining elements.

For any commutative monoid β, natural number n, and function f from Fin (n + 1) to β, the product of f evaluated at the universal finite set equals the product of f evaluated at 0 and the product of f evaluated at the successor elements in the universal finite set.


theorem subset_lowerClosure : ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, s ⊆ ↑(lowerClosure s) := by sorry

This theorem states that for any given set `s` of a type `α` that has a preorder relation, `s` is a subset of the lower closure of `s`. In other words, every element in `s` is also an element in the lower closure of `s`. The lower closure of a set is defined as the set of all elements that are less than or equal to some element in the original set.

For any set `s` of type `α` with a preorder relation, `s` is a subset of the lower closure of `s`. Alternatively, every element in `s` is less than or equal to some element in `s`, so `s` is included in the set of elements that are less than or equal to elements in `s`.


/-- The normal closure of `s` is the smallest normal subgroup containing `s`.  -/
theorem Subgroup.normalClosure_le_normal :
    ∀ {G : Type u_1} [inst : Group G] {s : Set G} {N : Subgroup G} [inst_1 : Subgroup.Normal N],
      s ⊆ ↑N → Subgroup.normalClosure s ≤ N :=
  by sorry

The theorem `Subgroup.normalClosure_le_normal` states that for any type `G` that forms a group, any set `s` of elements of `G`, and any normal subgroup `N` of `G`, if `s` is a subset of `N` then the normal closure of `s` is a subgroup of, or equal to, `N`. In other words, the smallest normal subgroup that contains `s` is contained within any other normal subgroup that contains `s`. This is a property of the normal closure operation in group theory.

For any group G, normal subgroup N, and subset s of G, if s is contained in N and the normal closure of s is defined, then the normal closure of s is a subgroup of N.


theorem Sbtw.left_ne :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {x y z : P}, Sbtw R x y z → x ≠ y :=
  by sorry

The theorem `Sbtw.left_ne` states that for any types `R`, `V`, and `P`, where `R` is an ordered ring, `V` is an additive commutative group, `R` is a module over `V`, and `V` is an additive torsor over `P`, given any three points `x`, `y`, `z` of type `P`, if `y` is strictly between `x` and `z` (as defined by the `Sbtw` property), then `x` is not equal to `y`. In other words, if a point is strictly between two other points, it cannot coincide with the first of those points.

If `R` is an ordered ring, `V` is an additive commutative group with `R` as a module and `V` an additive torsor over some type `P`, then for any `x`, `y`, `z` in `P` with `y` strictly between `x` and `z`, we have `x ≠ y`.


Polynomial.IsSplittingField.splits

theorem Polynomial.IsSplittingField.splits :
    ∀ {K : Type v} (L : Type w) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (f : Polynomial K)
      [inst_3 : Polynomial.IsSplittingField K L f], Polynomial.Splits (algebraMap K L) f :=
  by sorry

This theorem states that for any field `K` and any splitting field `L` over `K` for a polynomial `f`, the polynomial `f` splits over `L`. More specifically, the polynomial `f` maps to zero or all of its irreducible factors have degree 1 under the embedding given by the algebra structure from `K` to `L`. The splitting of a polynomial is defined by the condition that every irreducible factor of the polynomial over the field has degree 1. The concept of a splitting field concerns the field extension in which a given polynomial can be factored into linear factors.

For any field `K`, polynomial `f` over `K`, and splitting field `L` of `f` over `K`, `f`splits into linear factors in `L`.


IsClopen.compl

theorem IsClopen.compl : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClopen s → IsClopen sᶜ := by sorry

The theorem `IsClopen.compl` states that for any type `X` equipped with a topological space structure and any set `s` of type `X`, if `s` is a clopen set (i.e., both closed and open), then the complement of `s` (denoted as `sᶜ`) is also a clopen set. In other words, the property of being clopen is preserved under the operation of taking complements in the context of topological spaces.

If a set is clopen in a topological space, then its complement is also clopen.


theorem OrderIso.image_eq_preimage :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set α),
      ⇑e '' s = ⇑(OrderIso.symm e) ⁻¹' s :=
  by sorry

This theorem states that for any ordered types `α` and `β`, given an order isomorphism `e` from `α` to `β` and a set `s` in `α`, the image of `s` under `e` is equal to the preimage of `s` under the inverse of `e`. In other words, applying the order isomorphism `e` to each element of set `s` provides the same set as if you were to apply the inverse of `e` to each element of set `s` and consider their pre-images in `α`.

For any order isomorphism between ordered types `α` and `β`, and any set `s` in `α`, the forward and inverse images of `s` under this isomorphism are equal: `e(s) = {x | ∃y ∈ s, e(y) = x}`.


theorem Finset.image₂_subset_iff :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
      {u : Finset γ}, Finset.image₂ f s t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, f x y ∈ u :=
  by sorry

This theorem provides a condition to determine whether the image of a binary function `f : α → β → γ` over two finite sets `s : Finset α` and `t : Finset β` is a subset of another finite set `u : Finset γ` in a type with decidable equality. Specifically, it states that the image of `f` over `s` and `t` is a subset of `u` if and only if for every element `x` in `s` and every element `y` in `t`, the result `f x y` is an element of `u`.

For finite sets `s`, `t`, and `u`, and a binary function `f : α → β → γ`, `f (s : Finset α) (t : Finset β) ⊆ u : Finset γ` if and only if for all `x ∈ s` and `y ∈ t`, `f x y ∈ u`.


/-- A subfield `t` includes `closure s` if and only if it includes `s`.  -/
theorem Subfield.closure_le :
    ∀ {K : Type u} [inst : DivisionRing K] {s : Set K} {t : Subfield K}, Subfield.closure s ≤ t ↔ s ⊆ ↑t := by sorry

This theorem states that for any type `K` equipped with a `DivisionRing` structure, and any set `s` of type `K` and subfield `t` of type `K`, the closure of the set `s` under the operation of the subfield is a subset of `t` if and only if `s` is a subset of `t`. In other words, a subfield `t` contains the closure of a set `s` exactly when it contains the set `s` itself. This encapsulates the idea of a closure operation, which gathers all elements related to the set `s` under the operations of the subfield in a way that the result is still within the subfield `t`.

For any set `s` and subfield `t` of a division ring `K`, the closure of `s` under `t` equals `s` if and only if `s` is a subset of `t`.


theorem continuous_pow :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Monoid M] [inst_2 : ContinuousMul M] (n : ℕ),
      Continuous fun a => a ^ n :=
  by sorry

This theorem states that for any natural number `n`, the function that raises `a` to the power of `n` is continuous in any topological space `M` that also forms a monoid and supports continuous multiplication. In other words, for any point in the topological space, small changes in the input lead to small changes in the output when we're raising the input to the power `n`.

For any natural number `n` and any commutative monoid `M` with a continuous multiplication operation, the power function `x ↦ x ^ n` is continuous on `M`.


List.Perm.append

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

This theorem states that for any type `α` and any lists `l₁`, `l₂`, `t₁`, `t₂` of this type, if `l₁` is a permutation of `l₂` and `t₁` is a permutation of `t₂`, then the concatenation of `l₁` and `t₁` is a permutation of the concatenation of `l₂` and `t₂`. In mathematical terms, it establishes that permutations are preserved under list concatenation.

If `l₁` is a permutation of `l₂` and `t₁` is a permutation of `t₂`, then the concatenation of `l₁` and `t₁` is a permutation of the concatenation of `l₂` and `t₂`. In symbols: `(l₁ ∘ l₃) ∧ (t₁ ∘ t₃) ⟹ (l₁ ++ t₁) ≃ (l₂ ++ t₂)`, where `∘` denotes function composition, `++` denotes list concatenation, and `≃` denotes list isomorphism.


theorem NNReal.coe_eq_zero : ∀ {r : NNReal}, ↑r = 0 ↔ r = 0 := by sorry

This theorem states that for any nonnegative real number `r` (denoted by `NNReal`), the condition that its coercion (or embedding) into the real numbers equals zero is equivalent to the condition that `r` itself equals zero. In more mathematical terms, it asserts that a nonnegative real number `r` is zero if and only if its image under the natural embedding of nonnegative real numbers into the real numbers is zero.

For any nonnegative real number `r`, `r = 0` if and only if the real number representation of `r` is 0.


theorem MeasureTheory.measurePreserving_smul :
    ∀ {M : Type v} {α : Type w} {m : MeasurableSpace α} [inst : MeasurableSpace M] [inst_1 : SMul M α]
      [inst : MeasurableSMul M α] (c : M) (μ : MeasureTheory.Measure α)
      [inst : MeasureTheory.SMulInvariantMeasure M α μ], MeasureTheory.MeasurePreserving (fun x => c • x) μ μ :=
  by sorry

This theorem states that for any type `M` and `α`, and a measure space `α`, if `M` and `α` have a scalar multiplication (`SMul`) operation and `M`, `α` and a measure `μ` satisfy the `SMulInvariantMeasure` property, then the function that maps each element `x` of `α` to the result of the scalar multiplication of `x` by some constant `c` of type `M` preserves the measure `μ`. In other words, scalar multiplication does not change the measure of the space under these conditions.

For any measure space `(α, μ)`, type `M` with scalar multiplication `SMul`, and constant `c` in `M`, the measure `μ` is invariant under scalar multiplication, i.e., for all `x` in `α`, `μ(cx) = μ(x)`.


theorem neg_inv : ∀ {K : Type u_3} [inst : DivisionMonoid K] [inst_1 : HasDistribNeg K] {a : K}, -a⁻¹ = (-a)⁻¹ := by
  sorry

This theorem, `neg_inv`, states that for any type `K` (where `K` is a division monoid and has the property of distributive negation) and for any instance `a` of type `K`, the inverse of the negative of `a` is equal to the negative of the inverse of `a`. In mathematical terms, this can be represented as `-a⁻¹ = (-a)⁻¹`. This theorem is a demonstration of the property of negation in relation to inversion in a division monoid.

For any division monoid `K` and element `a` of type `K` with distributive negation, the inverse of the negative of `a` equals the negative of the inverse of `a`: `-a⁻¹ = (-a)⁻¹`.


theorem addOrderOf_dvd_iff_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x : G} {n : ℕ}, addOrderOf x ∣ n ↔ n • x = 0 := by sorry

The theorem `addOrderOf_dvd_iff_nsmul_eq_zero` states that for any type `G` which is an instance of `AddMonoid`, for any element `x` of `G` and any natural number `n`, the order of `x` (as defined by the function `addOrderOf`) divides `n` if and only if `n` times `x` equals the additive identity (i.e., `0`). In other words, if `n` is a multiple of `x`'s order, then `n`-fold sum of `x` results in the additive identity, and conversely, if `n`-fold sum of `x` is the additive identity, then `n` is a multiple of `x`'s order.

For any AddMonoid type G and its element x, the order of x divides natural number n if and only if n * x = 0.


theorem MvPowerSeries.coeff_mul :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (n : σ →₀ ℕ) (φ ψ : MvPowerSeries σ R) [inst_1 : DecidableEq σ],
      (MvPowerSeries.coeff R n) (φ * ψ) =
        Finset.sum (Finset.antidiagonal n) fun p => (MvPowerSeries.coeff R p.1) φ * (MvPowerSeries.coeff R p.2) ψ :=
  by sorry

The theorem `MvPowerSeries.coeff_mul` is about the multiplication operation in the ring of multivariate formal power series. Given variables `σ`, a coefficient ring `R` which is a semiring, two multivariate formal power series `φ` and `ψ`, and a function `n` from `σ` to natural numbers, the theorem states that the `n`th coefficient of the product of `φ` and `ψ` is equal to the sum, over all pairs of natural number functions whose sum equals `n`, of the product of corresponding coefficients in `φ` and `ψ`. This sum is taken over the antidiagonal of `n`, which represents all pairs of natural number functions whose sum equals `n`. The equality holds under the assumption that equality of variables `σ` is decidable. In mathematical terms, this theorem formalizes how to compute the `n`th coefficient of the product of two power series in a semiring.

Given multivariate formal power series φ and ψ over a semiring R, and variables σ with decidable equality, the (n)(i) + (n)(j) = nth coefficient of the product φψ is the sum over the antidiagonal of pairs (i, j) of the products of the i-th coefficient of φ and j-th coefficient of ψ.


FirstOrder.Language.LHom.funext

theorem FirstOrder.Language.LHom.funext :
    ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {F G : L →ᴸ L'},
      F.onFunction = G.onFunction → F.onRelation = G.onRelation → F = G :=
  by sorry

This theorem states that for any two language homomorphisms `F` and `G` from a first-order language `L` to another first-order language `L'`, if `F` and `G` map the same functions to the same functions in `L'`, and `F` and `G` map the same relations to the same relations in `L'`, then `F` and `G` are identical. In other words, two language homomorphisms are equal if they map functions and relations in the same way from one language to another.

If two first-order language homomorphisms from one language to another agree on the mapping of functions and relations, then they are equal.


theorem Filter.prod_pure :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {b : β}, f ×ˢ pure b = Filter.map (fun a => (a, b)) f := by sorry

This theorem states that for any filter `f` of type `α` and an element `b` of type `β`, the Cartesian product of `f` and the singleton set `{b}` (expressed as `pure b`) is equal to the filter obtained by mapping each element `a` in `f` to the pair `(a, b)`. In other words, all the elements in the resulting filter are pairs where the first component comes from the original filter and the second component is the fixed element `b`.

For any filter `f` on type `α` and element `b` of type `β`, the filters `{a | ∃ x, (a, b) ∈ f} × {pure b}` and `{a, b | a ∈ f}` are equal.


/-- A specialization of `mem_iInter₂`.  -/
theorem Set.mem_biInter :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : α → Set β} {y : β}, (∀ x ∈ s, y ∈ t x) → y ∈ ⋂ x ∈ s, t x := by
  sorry

The theorem `Set.mem_biInter` states that for any types `α` and `β`, any set `s` of type `α`, any function `t` from `α` to a set of `β`, and any element `y` of type `β`, if `y` is in `t x` for every `x` in the set `s`, then `y` is in the intersection of `t x` over all `x` in `s`. In mathematical terms, it says if $y \in t(x)$ for all $x \in s$, then $y \in \bigcap_{x \in s} t(x)$.

If a element `y` is in the image of function `t` for every element `x` in set `s`, then `y` is in the intersection of the images of `t` over all elements in `s`. In mathematical notation, $\forall x \in s, y \in t(x) \implies y \in \bigcap\_{x \in s} t(x)$.


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

This theorem states that for any two propositions `a` and `b`, if `a` is not true (denoted `¬a`) and `b` is not true (denoted `¬b`), then the statement "either `a` or `b` is true" (denoted `a ∨ b`) is not true. In other words, the denial of each of two propositions implies the denial of their disjunction.

 ∀ (a b : Prop), ¬a ∧ ¬b → ¬(a ∨ b)

(This statement says that for all propositions a and b, if not-a and not-b hold then not (a or b) holds)


/-- If `algebraMap R A` is injective and `A` has no zero divisors,
`R`-multiples in `A` are zero only if one of the factors is zero.

Cannot be an instance because there is no `Injective (algebraMap R A)` typeclass.
 -/
theorem NoZeroSMulDivisors.of_algebraMap_injective :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : NoZeroDivisors A], Function.Injective ⇑(algebraMap R A) → NoZeroSMulDivisors R A :=
  by sorry

The theorem `NoZeroSMulDivisors.of_algebraMap_injective` states that if the function `algebraMap R A`, which embeds a commutative semiring `R` into a semiring `A` in the context of an algebra structure, is injective, and if `A` has no zero divisors (meaning that the product of two non-zero elements in `A` is always non-zero), then any product in `A` that is a multiple of an element from `R` is zero if and only if one of the factors is zero. This theorem cannot be an instance as there is no `Injective (algebraMap R A)` typeclass.

If `algebraMap R A` embeds a commutative semiring `R` into a semiring `A` with no zero divisors and is injective, then for all `x, y in A`, `x * y = 0` implies `x = 0` or `y = 0`.


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

This theorem states that for any type `α` that forms a group and is ordered under a less-than relation (`<`), if this type also satisfies two covariance properties with respect to multiplication and the less-than relation, then for any two elements `a` and `b` of this type, `a` is less than `b` if and only if the inverse of `b` is less than the inverse of `a`. In mathematical notation, this can be written as `(a⁻¹ < b⁻¹) = (b < a)`. The two covariance properties mentioned are properties that relate the order of elements and their multiplication.

For any group type `α` ordered by `<`, if multiplication is covariant with respect to the order relation, then `a < b` if and only if `a⁻¹ > b⁻¹`.


theorem MeasurableSpace.comap_le_iff_le_map :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {m' : MeasurableSpace β} {f : α → β},
      MeasurableSpace.comap f m' ≤ m ↔ m' ≤ MeasurableSpace.map f m :=
  by sorry

This theorem states that for any two types `α` and `β`, any measurable spaces `m` over `α` and `m'` over `β`, and any function `f` from `α` to `β`, the reverse image of the measurable space `m'` under the function `f` is a sub-measurable-space of `m` if and only if `m'` is a sub-measurable-space of the forward image of the measurable space `m` under the function `f`.

For measurable spaces `m` over type `α` and `m'` over type `β`, and any function `f` from `α` to `β`, the reverse image `f⁺(m')` is a sub-measurable-space of `m` if and only if `m'` is a sub-measurable-space of the forward image `f⁻¹(m)`.


theorem Set.subset_iInter₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_7} {s : Set α} {t : (i : ι) → κ i → Set α},
      (∀ (i : ι) (j : κ i), s ⊆ t i j) → s ⊆ ⋂ i, ⋂ j, t i j :=
  by sorry

This theorem states that for any type `α` and an indexed family of sorts `{ι : Sort u_4} {κ : ι → Sort u_7}`, given a set `s` of type `α` and a function `t` that takes an index `i` of type `ι` and a second index `j` of type `κ i` and returns a set of type `α`, if `s` is a subset of every set `t i j`, then `s` is also a subset of the intersection over all `i` and `j` of the sets `t i j`. In mathematical terms, if for all `i` and `j`, `s` is a subset of `t_i_j`, then `s` is a subset of the intersection over all `i` and `j` of the sets `t_i_j`.

If for all indices i and j, a set s is a subset of the set t(i) (j), then s is a subset of the intersection over all i and j of the sets t(i) (j).


theorem Ideal.span_singleton_prime :
    ∀ {α : Type u} [inst : CommSemiring α] {p : α}, p ≠ 0 → (Ideal.IsPrime (Ideal.span {p}) ↔ Prime p) := by sorry

The theorem `Ideal.span_singleton_prime` states that for any commutative semiring `α` and any element `p` of `α` that is not zero, the ideal generated by the singleton set `{p}` is a prime ideal if and only if `p` is a prime element. Here, a prime element `p` in a commutative monoid with zero is defined as a non-zero element that is not a unit, and for every two elements `a` and `b` in the commutative monoid, if `p` divides the product `a * b`, then `p` must divide either `a` or `b`.

The ideal generated by a non-zero element in a commutative semiring is prime if and only if the element is a prime element, meaning it is not a unit and for all elements a and b, if p divides a * b, then p divides a or p divides b.


Function.Involutive.bijective

theorem Function.Involutive.bijective : ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.Bijective f := by
  sorry

The theorem `Function.Involutive.bijective` states that for any type `α` and any function `f` from `α` to `α`, if `f` is involutive (i.e., applying `f` twice to any element `x` in `α` yields `x` back, formally `f ∘ f = id`), then `f` is bijective. A bijective function is both injective (each element of the domain maps to a unique element of the codomain) and surjective (every element of the codomain is mapped to by some element of the domain).

If a function from a type to itself is involutive (i.e., self-inverse), then it is bijective.


theorem Ordinal.zero_or_succ_or_limit : ∀ (o : Ordinal.{u_4}), o = 0 ∨ (∃ a, o = Order.succ a) ∨ Ordinal.IsLimit o := by
  sorry

This theorem, `Ordinal.zero_or_succ_or_limit`, states that for any ordinal `o`, `o` is either zero, a successor of some element, or a limit ordinal. Specifically, an ordinal `o` is a successor of an element `a` if there exists such `a` that `o` equals to the successor of `a`. Meanwhile, an ordinal `o` is a limit ordinal if it is not zero and for all elements `a` less than `o`, the successor of `a` is still less than `o`.

Every ordinal is either zero, a successor of some ordinal, or a limit ordinal, where a limit ordinal is an ordinal greater than zero that is not the successor of any ordinal.


theorem Set.mem_inv_smul_set_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A : Set β} {a : α} {x : β},
      x ∈ a⁻¹ • A ↔ a • x ∈ A :=
  by sorry

This theorem is stating that for any two types `α` and `β`, where `α` has a group structure and `β` has a multiplication action by `α`, for any set `A` of elements of type `β`, any element `a` of type `α`, and any element `x` of type `β`, `x` is in the set obtained by multiplying each element of `A` by `a⁻¹` if and only if the element obtained by multiplying `a` and `x` is in `A`. In mathematical terms, for any group `α`, any `α`-set `β`, any subset `A` of `β`, any element `a` in `α`, and any element `x` in `β`, we have that `x ∈ a⁻¹ • A` if and only if `a • x ∈ A`.

For any group `α`, `α`-set `β`, subset `A` of `β`, element `a` in `α`, and `x` in `β`, `x` is in the set of elements obtained by taking the inverse of `a`-action on `A` if and only if the element obtained by multiplying `a` and `x` is in `A`.


theorem Mathlib.Order.MinMax._auxLemma.8 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b < c) = (a < c ∧ b < c) := by sorry

This theorem states that for any type `α` that has an instance of `LinearOrder`, and for any three elements `a`, `b`, `c` of this type, the maximum of `a` and `b` being less than `c` is equivalent to both `a` and `b` being less than `c`. In other words, if `c` is greater than both `a` and `b`, then `c` is also greater than the maximum of `a` and `b`, and vice-versa.

For any type `α` with a `LinearOrder` instance, the maximum of `a` and `b` in `α` is equal to `c` if and only if both `a` and `b` are less than `c`.


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

This theorem, `iInf₂_mono`, states that for any types `α`, `ι`, and a dependent type `κ` indexed by `ι`, given a complete lattice structure on `α`, and two functions `f` and `g` from (an `ι` and a `κ i`) to `α`, if for all `i` of type `ι` and `j` of type `κ i`, `f i j` is less than or equal to `g i j`, then the infimum of `f i j` over all `i` and `j` is less than or equal to the infimum of `g i j` over all `i` and `j`. In other words, if each element of one function is less than or equal to the corresponding element of another function, then the greatest lower bound of the first function is also less than or equal to the greatest lower bound of the second function.

If `f` and `g` are functions from `ι × κ` to a complete lattice `α` with `f(i, j) ≤ g(i, j)` for all `(i, j)`, then `⊓ (λ (i, j), f i j) ≤ ⊓ (λ (i, j), g i j)`. Here, `⊓` denotes the infimum (greatest lower bound) operator.


theorem dense_iff_closure_eq : ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], Dense s ↔ closure s = Set.univ :=
  by sorry

This theorem states that for any set `s` in a topological space `X`, `s` is dense if and only if the closure of `s` equals the universal set. In other words, a set is considered dense in a topological space if every point in the space is either in the set or is a limit point of the set, which corresponds to the closure of the set being the entire space.

A set is dense in a topological space if and only if its closure equals the entire space.


theorem dist_pi_le_iff :
    ∀ {β : Type v} {π : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (π b)]
      {f g : (b : β) → π b} {r : ℝ}, 0 ≤ r → (dist f g ≤ r ↔ ∀ (b : β), dist (f b) (g b) ≤ r) :=
  by sorry

This theorem establishes a condition under which the distance between two functions `f` and `g` (mapping from type `β` to a pseudo-metric space `π b`) is less than or equal to a real number `r`. Specifically, given non-negative `r`, the theorem states that the distance between `f` and `g` is less than or equal to `r` if and only if the distance between `f(b)` and `g(b)` is less than or equal to `r` for every `b` in the finite type `β`. These distances are calculated in the pseudo-metric space `π b`.

The theorem states that the distance between functions `f` and `g` from type `β` to pseudo-metric space `π b`, with non-negative real number `r`, holds if and only if the distance between `f(b)` and `g(b)` in `π b` is less than or equal to `r` for all `b` in `β`.


theorem Nat.and_one_is_mod : ∀ (x : ℕ), x &&& 1 = x % 2 := by sorry

This theorem states that for any natural number `x`, the bitwise `and` operation of `x` and `1` is equal to the remainder when `x` is divided by `2`. In other words, it's asserting that performing a bitwise `and` operation on a natural number `x` and `1` will always give the same result as taking modulus `2` of `x`. This is reliable because both operations effectively determine if `x` is odd or even.

For any natural number `x`, `x` and `1` bitwise AND equals the remainder of `x` divided by `2`.


theorem Finset.filter_val :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Finset α),
      (Finset.filter p s).val = Multiset.filter p s.val :=
  by sorry

This theorem states that for any type `α`, predicate `p` (a function from `α` to a propositional logic value) which is decidable, and a finite set `s` of type `α`, the underlying value (as a multiset) of the finite set filtered by the predicate `p` is equal to the multiset obtained by filtering the underlying value of the finite set `s` by the same predicate `p`. In simpler terms, filtering a finite set and then obtaining the multiset of values is the same as first obtaining the multiset of values from the finite set and then filtering it.

For any decidable predicate `p` on type `α` and finite set `s` of type `α`, the multiset of elements in `s` satisfying `p` is equal to the multiset of elements in the filtered set `{x | x ∈ s ∧ p x}`.


theorem BilinForm.add_left :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {B : BilinForm R M} (x y z : M), B.bilin (x + y) z = B.bilin x z + B.bilin y z :=
  by sorry

This theorem, `BilinForm.add_left`, states that for any commutative semiring `R`, any additive commutative monoid `M`, and any `R`-module structure on `M`, and for any bilinear form `B` on `M` over `R`, the bilinear form satisfies the property of additivity in its first argument. Specifically, applying the bilinear form to the sum of two elements `x` and `y` in `M` and a third element `z` in `M` is the same as applying the bilinear form to `x` and `z`, and then adding the result of applying the bilinear form to `y` and `z`. In other words, for all `x`, `y`, and `z` in `M`, `B.bilin (x + y) z` equals `B.bilin x z + B.bilin y z`. This is a standard property of bilinear forms, which formalizes the intuitive idea of linearity in each argument.

For any commutative semiring `R`, additive commutative monoid `M` with an `R`-module structure, and bilinear form `B` on `M` over `R`, the bilinear form `B` is additive in its first argument, i.e., `B.bilin (x + y) z = B.bilin x z + B.bilin y z` for all `x, y, z` in `M`.


theorem Cardinal.lift_add :
    ∀ (a b : Cardinal.{u}), Cardinal.lift.{v, u} (a + b) = Cardinal.lift.{v, u} a + Cardinal.lift.{v, u} b := by sorry

The theorem `Cardinal.lift_add` states that for all cardinal numbers `a` and `b` in a particular universe `u`, the operation of lifting the sum of `a` and `b` to a larger universe `v` (via `Cardinal.lift`) is equivalent to separately lifting `a` and `b` to universe `v` and then adding them. In mathematical terms, this property can be represented as `lift(a + b) = lift(a) + lift(b)`. This theorem essentially shows the compatibility of the lift operation with the addition operation on cardinal numbers.

For all cardinal numbers `a` and `b`, the operation of lifting their sum to a larger universe is equal to the sum of their individual lifts: `Cardinal.lift (a + b) = Cardinal.lift a + Cardinal.lift b`.


theorem and_self_iff : ∀ {a : Prop}, a ∧ a ↔ a := by sorry

This theorem, `and_self_iff`, states that for any proposition `a`, the condition `a` and `a` is logically equivalent to just `a`. In other words, saying `a` is true and `a` is true again, is the same as simply saying `a` is true. This applies to any proposition `a`.

For all propositions `a`, `a` is logically equivalent to `a` and `a` together.


theorem sInf_eq_iInf : ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α}, sInf s = ⨅ a ∈ s, a := by sorry

The theorem `sInf_eq_iInf` states that for any type `α` that has a complete lattice structure, and for any set `s` of elements of type `α`, the supremum of the set `s` (`sInf s`) is equal to the infimum over all elements `a` in the set `s` (`⨅ a ∈ s, a`). In other words, it asserts that the greatest lower bound of the set is the same as the least upper bound of all elements in the set, in the context of a complete lattice.

In a complete lattice, for any set, the supremum equals the infimum of its elements.


theorem TopologicalSpace.PositiveCompacts.interior_nonempty :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.PositiveCompacts α),
      Set.Nonempty (interior ↑s) :=
  by sorry

This theorem, named `TopologicalSpace.PositiveCompacts.interior_nonempty`, asserts that for any topological space `α` and any element `s` of the set `TopologicalSpace.PositiveCompacts α`, the interior of `s` is not empty. Here, `TopologicalSpace.PositiveCompacts α` refers to the set of compact subsets of the topological space `α` that have positive measure. In other words, for any compact subset `s` with positive measure in a given topological space, its interior (the largest open subset of `s`) always contains at least one point.

In a topological space, every compact subset of positive measure has a non-empty interior.


theorem IsCompact.compl_mem_cocompact :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → sᶜ ∈ Filter.cocompact X := by sorry

The theorem `IsCompact.compl_mem_cocompact` asserts that for any topological space `X` and any set `s` in `X`, if `s` is compact, then the complement of `s` is in the cocompact filter of `X`. In other words, it states that the complement of any compact set is a member of the filter generated by the complements of compact sets in the given topological space.

If a set in a topological space is compact, then the complement of that set belongs to the filter generated by the complements of compact sets in the space.


theorem Mathlib.Algebra.Module.Submodule.Lattice._auxLemma.1 :
    ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
      (x ∈ ⊥) = (x = 0) :=
  by sorry

This theorem states that for any semiring `R` and for any module `M` over `R`, an element `x` belongs to the zero submodule (denoted as `⊥`) if and only if `x` is equal to the zero element. Here, `Semiring R` implies that `R` is a semiring, `AddCommMonoid M` implies that `M` is an additive commutative monoid, and `Module R M` implies that `M` is a module over the semiring `R`. The zero submodule `⊥` of `M` is the set containing only the zero element of `M`.

For any semiring `R` and module `M` over `R`, an element `x` in `M` is in the zero submodule if and only if `x` is the zero element of `M`.


theorem WithBot.not_coe_le_bot : ∀ {α : Type u_1} [inst : LE α] (a : α), ¬↑a ≤ ⊥ := by sorry

This theorem states that for any type `α` that has a less than or equal to (`LE`) operation, and any instance `a` of that type, the coerced value of `a` (`↑a`) is not less than or equal to the bottom element (`⊥`). In other words, no element in the `WithBot α` extension of `α` is less than or equal to the bottom element. This is essentially a statement about the order properties of the "with bottom" extension of a pre-existing ordered type.

For any type `α` with a `LE` relation and any `a : α`, the coerced value `↑a` does not `LE` the bottom element `⊥` in the `WithBot α` extension.


/-- `f` is Lipschitz iff it is Lipschitz on the entire space.  -/
theorem lipschitzOn_univ :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzOnWith K f Set.univ ↔ LipschitzWith K f :=
  by sorry

The theorem `lipschitzOn_univ` states that a function `f` mapping from a pseudometric space `α` to a pseudometric space `β` is Lipschitz continuous with a nonnegative constant `K` if and only if it is Lipschitz continuous with the same constant `K` over the entire set of `α`. In other words, the Lipschitz continuity of `f` over all elements of `α` (the universal set of `α`) is equivalent to the Lipschitz continuity of `f` under any subset of `α`. This is formalized in the context of pseudometric spaces, where the notion of distance is generalized with the extended distance `edist`, and the Lipschitz condition is expressed in terms of this `edist`.

A function between pseudometric spaces is Lipschitz continuous with a constant K over the entire space if and only if it is Lipschitz continuous with the same constant K over any subset.


Sublattice.supClosed

theorem Sublattice.supClosed : ∀ {α : Type u_2} [inst : Lattice α] (L : Sublattice α), SupClosed ↑L := by sorry

The theorem `Sublattice.supClosed` states that for any type `α` that forms a lattice structure, every sublattice `L` of this lattice is supremum-closed, meaning that for all elements `a` and `b` in the sublattice `L`, their supremum `a ⊔ b` also belongs to `L`.

For any lattice `α` and sublattice `L` of `α`, every supremum of elements in `L` lies in `L`.


theorem Nat.properDivisors.not_self_mem : ∀ {n : ℕ}, n ∉ Nat.properDivisors n := by sorry

This theorem states that for any natural number 'n', 'n' is not a member of its own proper divisors set. In other words, a natural number 'n' cannot be a proper divisor of itself. Proper divisors are those divisors of 'n' that are less than 'n' and greater than 1, excluding 'n' itself.

For any natural number n, n is not a divisor of itself when considering only proper divisors (i.e., divisors strictly less than and greater than n).


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

The theorem `sign_neg` states that for any type `α` that has a zero, a defined ordering relation, and a decidable relation for whether one element is less than another, if an element `a` of this type is less than zero, then the sign of `a` is `-1`. In other words, this theorem asserts that the `SignType.sign` function will return `-1` for all negative elements in any ordered set where "less than" is a decidable relation.

For any type with a zero, ordering relation, and decidable less-than relation, the sign of an element less than zero is -1.


theorem Stream'.tail_cons : ∀ {α : Type u} (a : α) (s : Stream' α), Stream'.tail (Stream'.cons a s) = s := by sorry

The theorem `Stream'.tail_cons` states that for all types `α`, and for any element `a` of type `α` and any stream `s` of type `α`, the tail of the stream that results from prepending `a` to `s` is equal to `s` itself. In other words, if you prepend an element to a stream and then drop the first element of the new stream, you get the original stream back.

For all types `α` and streams `s` of type `α`, the tail of the stream obtained by prepending an element `a` to `s` is equal to `s`. In other words, `Stream.tail (a :: s) = s`.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.9 :
    ∀ {α : Type u_3} [inst : OrderedSemiring α] [inst_1 : Nontrivial α] {n : ℕ}, (0 < ↑n) = (0 < n) := by sorry

This theorem, `Mathlib.Data.Nat.Cast.Order._auxLemma.9`, states that for any ordered semiring `α` of any type `u_3`, and any non-trivial instance `α`, for a given natural number `n`, the inequality `0 < ↑n` (which represents the cast of `n` to type `α`) is equivalent to `0 < n`. In simpler terms, this theorem asserts that a natural number `n` is greater than zero if and only if its cast to an ordered semiring is also greater than zero.

For any ordered semiring `α` and natural number `n`, `0 < ↑n` if and only if `0 < n`.


theorem Submodule.span_image :
    ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] [inst_3 : Semiring R₂] {σ₁₂ : R →+* R₂} [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₂ M₂]
      {F : Type u_8} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F σ₁₂ M M₂] {s : Set M}
      [inst_8 : RingHomSurjective σ₁₂] (f : F), Submodule.span R₂ (⇑f '' s) = Submodule.map f (Submodule.span R s) :=
  by sorry

This theorem, `Submodule.span_image`, states that for any semiring `R`, any semiring `R₂`, any additively commutative monoid `M`, any additively commutative monoid `M₂`, any module structure over `M` relative to `R`, any module structure over `M₂` relative to `R₂`, any ring homomorphism `σ₁₂` from `R` to `R₂`, any function `F` from `M` to `M₂` that behaves like a linear map respecting the semiring homomorphism `σ₁₂`, and any set of elements `s` in `M`, the span (the smallest submodule that contains `s`) in `M₂` of the image of `s` under the function `F` is equal to the image under `F` of the span of `s` in `M`. This is under the condition that the ring homomorphism `σ₁₂` is surjective. In simpler terms, this theorem describes a property of how linear mapping between two modules interacts with the process of taking spans of sets in those modules.

Given a surjective ring homomorphism `σ₁₂` from semiring `R` to `R₂`, for any module `M` over `R`, `M₂` over `R₂`, and any function `F : M -> M₂` that respects the module structures and the semiring homomorphism, the span of `F(s)` in `M₂` equals the image of the span of `s` in `M`.


/-- `X` commutes with everything, even when the coefficients are noncommutative.  -/
theorem Polynomial.X_mul : ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, Polynomial.X * p = p * Polynomial.X :=
  by sorry

The theorem `Polynomial.X_mul` states that, for any semiring `R`, and any polynomial `p` with coefficients in `R`, the polynomial variable `X` commutes with `p`. In other words, multiplying `X` by `p` is the same as multiplying `p` by `X`. This is true even when the coefficients in `R` are noncommutative. In mathematical terms, if we denote by `X` the polynomial variable and `p` is any polynomial, then `X * p = p * X`.

For any semiring `R` and polynomial `p` over `R`, `X * p = p * X`, where `X` is a polynomial variable.


theorem Valuation.map_mul :
    ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
      (x y : R), v (x * y) = v x * v y :=
  by sorry

This theorem, `Valuation.map_mul`, states that for any ring `R` and any linear ordered commutative monoid with zero `Γ₀`, and for any valuation `v` from `R` to `Γ₀`, the valuation of the product of two elements `x` and `y` from `R` is equal to the product of the valuations of `x` and `y`. This is a mathematical property that is often associated with valuation maps; it is similar to how a logarithm of a product is the sum of the logarithms.

For any ring `R`, commutative monoid with zero `Γ₀`, and valuation `v` from `R` to `Γ₀`, `v (xy) = v x * v y`.


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

This theorem states that for any types `α` and `β`, and for any functions `l : α → β` and `u : β → α`, given that the pair `(l, u)` forms a Galois Insertion and that `α` and `β` are both complete lattices, then for any function `f : ι → β` (where `ι` is any type), the lower bound (infimum) of the image of `f` under `u`, after being transformed by `l`, returns the infimum of `f`. In mathematical terms, if `l` and `u` form a Galois Insertion and `α`, `β` are complete lattices, then we have `l (inf i, u (f i)) = inf i, f i`.

Given a Galois connection between complete lattices `α` and `β` via functions `l : α → β` and `u : β → α`, the infimum of the composition `l (inf i, u (f i))` equals the infimum of `f` for any function `f : ι → β`.


theorem lt_of_add_lt_add_left :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : LT α]
      [inst_2 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      a + b < a + c → b < c :=
  by sorry

This theorem, `lt_of_add_lt_add_left`, states that for any type `α` that has an addition operation, a less-than relation, and satisfies the contravariant property (i.e., adding something to both sides of a less-than comparison doesn't change the comparison), if `a + b` is less than `a + c`, then `b` is less than `c`. In other words, if adding the same value `a` to two quantities `b` and `c` results in a smaller sum for `b`, then `b` must have been smaller than `c` to begin with.

If `α` is a type with addition and less-than relations satisfying the contravariant property, then `b < c` implies `a + b < a + c`.


IsAntichain.eq

theorem IsAntichain.eq :
    ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsAntichain r s → ∀ {a b : α}, a ∈ s → b ∈ s → r a b → a = b := by
  sorry

The theorem `IsAntichain.eq` states that for any type `α` and any relation `r` on `α`, if a set `s` of type `α` is an antichain with respect to `r` (meaning that no two distinct elements in `s` are related by `r`), then for any two elements `a` and `b` in `s`, if `a` is related to `b` by `r`, then `a` must be equal to `b`. In other words, this theorem asserts that in an antichain, no two distinct elements can be related, which is consistent with the definition of an antichain.

In an antichain, distinct elements are not related by the given relation.


theorem List.length_eq_zero : ∀ {α : Type u_1} {l : List α}, List.length l = 0 ↔ l = [] := by sorry

This theorem states that for any list `l` of elements of an arbitrary type `α`, the length of `l` is equal to zero if and only if `l` is an empty list. In other words, it provides a condition to check if a list is empty: a list is empty if and only if its length is zero. This theorem applies to lists of any type of elements.

The length of a list equals zero if and only if the list is empty.


/-- Isometries preserve the diameter in pseudoemetric spaces.  -/
theorem Isometry.ediam_image :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
      Isometry f → ∀ (s : Set α), EMetric.diam (f '' s) = EMetric.diam s :=
  by sorry

This theorem states that isometries, which are functions preserving the extended distance between elements in pseudoemetric spaces, also preserve the diameter of a set in such spaces. More specifically, for every type `α` and `β` with a pseudoemetric space structure, for every isometric function `f` from `α` to `β`, and for any set `s` of type `α`, the diameter of the image of `s` under `f` is equal to the diameter of `s` itself.

Given a pseudometric space `(α, d)` and an isometric function `f: α → β` between pseudometric spaces `(α, d)` and `(β, δ)`, the diameter of `f(S)` equals the diameter of `S` for any set `S ⊆ α`.


theorem Computation.corec_eq :
    ∀ {α : Type u} {β : Type v} (f : β → α ⊕ β) (b : β),
      Computation.destruct (Computation.corec f b) = Computation.rmap (Computation.corec f) (f b) :=
  by sorry

The theorem `Computation.corec_eq` states that for all types `α` and `β`, and for any function `f` that maps from `β` to the sum type of `α ⊕ β` and an element `b` of type `β`, the result of destructing the computation formed by co-recursion on `f` and `b` is equal to the result of applying the right map (with the co-recursive computation as the mapping function) to the output of `f b`. In other words, destructing the computation created by co-recursion is equivalent to applying the right map to the original function's result.

For all types `α` and `β`, and for any function `f : β → α ⊕ β`, the computation formed by co-recursion on `f` and an element `b` of type `β` is equal to the application of the right map to `f b`.


theorem Polynomial.C_neg : ∀ {R : Type u} {a : R} [inst : Ring R], Polynomial.C (-a) = -Polynomial.C a := by sorry

The theorem `Polynomial.C_neg` states that for any type `R` and any element `a` of `R`, where `R` is a ring, the constant polynomial of `-a` is equivalent to the negation of the constant polynomial of `a`. In other words, if we denote the constant polynomial associated with a value as `Polynomial.C`, then `Polynomial.C` maps negation in the ring to negation in the ring of polynomials. This can be expressed mathematically as: for all `a` in ring `R`, `Polynomial.C(-a) = -Polynomial.C(a)`.

For any ring `R` and its element `a`, the constant polynomial of `-a` equals the negation of the constant polynomial of `a`: `Polynomial.C(-a) = -Polynomial.C(a)`.


/-- If one controls the norm of every `f x`, then one controls the norm of `f`.  -/
theorem NormedAddGroupHom.opNorm_le_bound :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : NormedAddGroupHom V₁ V₂) {M : ℝ}, 0 ≤ M → (∀ (x : V₁), ‖f x‖ ≤ M * ‖x‖) → ‖f‖ ≤ M :=
  by sorry

This theorem states that in the context of seminormed additive commutative groups, if for a normed additive group homomorphism `f` from group `V₁` to `V₂`, there exists a non-negative real number `M` such that the norm of `f(x)` is less than or equal to `M` times the norm of `x` for every `x` in `V₁`, then the norm of the homomorphism `f` itself is less than or equal to `M`.

If `f` is a normed additive group homomorphism from seminormed additive group `V₁` to `V₂` with the property that `∀x ∈ V₁, ‖f(x)‖ ≤ M * ‖x‖,` then `‖f‖ ≤ M.`


/-- A variant of `Cardinal.lift_mk_le` with specialized universes.
Because Lean often can not realize it should use this specialization itself,
we provide this statement separately so you don't have to solve the specialization problem either.
 -/
theorem Cardinal.lift_mk_le' :
    ∀ {α : Type u} {β : Type v},
      Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β) ↔ Nonempty (α ↪ β) :=
  by sorry

This theorem, `Cardinal.lift_mk_le'`, provides a specialized variant of `Cardinal.lift_mk_le` for particular universes. It states that for any types `α` and `β` that exist in universes `u` and `v` respectively, the lift of the cardinality of `α` from universe `v` to `u` is less than or equal to the lift of the cardinality of `β` from universe `u` to `v` if and only if there exists an injective function from `α` to `β`. This theorem is provided separately as Lean often struggles to apply this specialization automatically, thus aiding in avoiding the problem of manually establishing the specialization.

For types α and β in universes u and v respectively, the lift of the cardinality of α from universe v to u is less than or equal to the cardinality of β in universe u if and only if there exists an injection from α to β.


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

This theorem states that for all lists `l₁` and `l₂` of any type `α`, concatenating `l₁` and `l₂` in that order is permutation-equivalent to concatenating `l₂` and `l₁` in that order. In other words, appending two lists does not depend on the order of the lists, i.e., `l₁ ++ l₂` is a permutation of `l₂ ++ l₁`.

For all lists `l₁` and `l₂` of type `α`, the concatenation of `l₁` and `l₂`, `l₁ ++ l₂`, is permutation-equivalent to the concatenation of `l₂` and `l₁`, `l₂ ++ l₁`.