CategoryTheory.CostructuredArrow.w

theorem CategoryTheory.CostructuredArrow.w :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D}
      {A B : CategoryTheory.CostructuredArrow S T} (f : A ⟶ B),
      CategoryTheory.CategoryStruct.comp (S.map f.left) B.hom = A.hom :=
  by sorry

The theorem `CategoryTheory.CostructuredArrow.w` states that for any categories `C` and `D`, a functor `S` from `C` to `D`, an object `T` in `D`, and costructured arrows `A` and `B` from `S` to `T`, if there exists a morphism `f` from `A` to `B`, then the composition of the mapping of `f.left` under `S` and `B.hom` is equal to `A.hom`. In other words, the diagram involving the category `C`, the category `D`, the functor `S`, and the costructured arrows `A` and `B` commutes for any morphism `f` from `A` to `B`.

 For any functors S from category C to D, objects T in D, and costructured arrows A and B from S to T, if there exists a morphism f from A to B, then the diagram commutes, that is, S(A.hom) ∘ f.left = B.hom.

Or more succinctly: Given functor S, objects T in D and A,B in S/T, and a morphism f: A → B, we have S(A.hom) ∘ f.left = B.hom.


/-- To rewrite from right to left, use `Finset.inf'_comp_eq_image`.  -/
theorem Finset.inf'_image :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeInf α] [inst_1 : DecidableEq β] {s : Finset γ}
      {f : γ → β} (hs : (Finset.image f s).Nonempty) (g : β → α),
      Finset.inf' (Finset.image f s) hs g = Finset.inf' s ⋯ (g ∘ f) :=
  by sorry

The theorem `Finset.inf'_image` is about the computation of infimum over a nonempty finset in the context of a semilattice. It states that for any types `α`, `β`, and `γ`, if we have a semilattice structure on `α` and decidable equality on `β`, and if `s` is a nonempty finset of type `γ` with a mapping `f` to `β` such that the image of `s` under `f` is nonempty, then the infimum of the image of `s` under `f` with a map `g` to `α` is the same as the infimum of `s` under the composition of `g` and `f`. In other words, it shows the compatibility of the infimum operation with the image of a function on a finset.

For any semilattice `α`, if `s` is a nonempty finset mapped to a nonempty image under `f: γ → β`, then `inf (map f s) = inf s . map g f` for any maps `g: β → α`.


theorem MvPolynomial.vars_sum_subset :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {ι : Type u_3} (t : Finset ι) (φ : ι → MvPolynomial σ R)
      [inst_1 : DecidableEq σ],
      MvPolynomial.vars (Finset.sum t fun i => φ i) ⊆ Finset.biUnion t fun i => MvPolynomial.vars (φ i) :=
  by sorry

The theorem `MvPolynomial.vars_sum_subset` states that for any commutative semiring `R`, any type `σ`, any finite set `t` of indices `ι`, and any function `φ` that maps each index `ι` to a multivariate polynomial with variables from `σ` and coefficients from `R`, the set of variables that appear in the sum of the polynomials `φ i` for all `i` in `t` is a subset of the union of the sets of variables that appear in each `φ i` individually. Here, the "sum" of a set of polynomials is defined as the result of adding them together, and "union" of a set of sets of variables is defined as the set of all variables that appear in at least one of the sets. The theorem assumes that equality between variables in `σ` is decidable.

For any commutative semiring R, type σ, finite set ι, and function φ mapping each index ι to a multivariate polynomial with variables from σ and coefficients from R, the set of variables appearing in the sum of polynomials φ i for all i in ι is a subset of the union of the sets of variables appearing in each φ i. (Assuming decidable equality between variables in σ.)


theorem MulOpposite.uniformContinuous_unop :
    ∀ {α : Type ua} [inst : UniformSpace α], UniformContinuous MulOpposite.unop := by sorry

This theorem states that for any type `α` that has a uniform space structure, the operation `MulOpposite.unop`, which retrieves the original element from its multiplicative opposite, is uniformly continuous. In other words, if two points in the multiplicative opposite space are close to each other, their corresponding points in the original space via `MulOpposite.unop` are also close to each other, regardless of their location in the space.

For any uniform space `(α, d)` with a multiplicative opposite structure, the map `MulOpposite.unop : α → α` is uniformly continuous with respect to the given metric `d`.


theorem FirstOrder.Language.Term.relabel_id_eq_id :
    ∀ {L : FirstOrder.Language} {α : Type u'}, FirstOrder.Language.Term.relabel id = id := by sorry

This theorem states that for any first-order language `L` and any type `α`, the relabeling of a term in `L` with the identity function (`id`) is equivalent to the identity operation. In other words, performing a relabel operation on a term where each element is mapped to itself (which is what the identity function does) leaves the term unchanged. Hence, `relabel id` and `id` are the same for any term in any first-order language.

For any first-order language and type, the relabeling of terms with the identity function equals the identity operation.


theorem Set.range_const_subset : ∀ {α : Type u_1} {ι : Sort u_4} {c : α}, (Set.range fun x => c) ⊆ {c} := by sorry

This theorem states that for any type `α` and any sort `ι`, and for any constant `c` of type `α`, the range of the constant function (that assigns `c` to every element of `ι`) is a subset of the set containing only the constant `c`. In other words, all outputs of this constant function are indeed `c`, so the set of all these outputs (the range) is either empty (if `ι` is empty) or includes only `c`.

For any type `α`, sort `ι`, and constant `c` of type `α`, the range of the constant function from `ι` to `α` that maps all elements to `c` is a subset of the singleton set `{c}`.


theorem pow_ite :
    ∀ {α : Type u_4} {β : Type u_5} [inst : Pow α β] (p : Prop) [inst_1 : Decidable p] (a : α) (b c : β),
      (a ^ if p then b else c) = if p then a ^ b else a ^ c :=
  by sorry

This theorem states that for any types `α` and `β` where `α` has a power operation and a proposition `p` which is decidable, and any elements `a` of type `α` and `b, c` of type `β`, the power of `a` to the `b` if `p` is true or `c` if `p` is false is the same as `a` to the power of `b` if `p` is true or `a` to the power of `c` if `p` is false. In other words, it tells us that the exponentiation operation commutes with the if-then-else decision-making construct.

For any types `α` with power operation, and decidable proposition `p`, and elements `a : α`, `b, c : β`, `a^(if p then b else c)` is equal to `(if p then a^b else a^c)`.


theorem inv_closure :
    ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G] (s : Set G),
      (closure s)⁻¹ = closure s⁻¹ :=
  by sorry

The theorem `inv_closure` states that for any set `s` of elements of type `G`, where `G` is a type equipped with a topology, an involutive inverse operation, and where this inverse operation is continuous, the closure of the inverse of `s` (i.e., `(closure s)⁻¹`) is equal to the inverse of the closure of `s` (i.e., `closure s⁻¹`). This means that taking the closure and taking the inverse of a set can be interchanged without affecting the result.

For any topological space `(G, top)` with an involutive, continuous inverse operation, the closure of the inverse of a set `s` equals the inverse of the closure of `s`: `(closure s)⁻¹ = closure s⁻¹`.


theorem PiTensorProduct.smul_add :
    ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {R₁ : Type u_5} {s : ι → Type u_7}
      [inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
      [inst_4 : DistribMulAction R₁ R] [inst_5 : SMulCommClass R₁ R R] (r : R₁) (x y : PiTensorProduct R fun i => s i),
      r • (x + y) = r • x + r • y :=
  by sorry

The theorem `PiTensorProduct.smul_add` states that for any type `ι`, a commutative semiring `R`, a monoid `R₁`, a type family `s : ι → Type` such that each `s i` is an additive commutative monoid and a module over `R`, an action of `R₁` on `R` that is distributive over multiplication, a scalar multiplication that is commutative between `R₁` and `R`, and for any `r` in `R₁` and `x` and `y` in the Pi tensor product of the `s i`'s over `R`, the scalar multiplication of `r` with the sum of `x` and `y` equals the sum of the scalar multiplication of `r` with `x` and `r` with `y`. This is equivalent to the property `r • (x + y) = r • x + r • y` in the language of scalar multiplication and addition, where `•` denotes scalar multiplication and `+` denotes addition.

For any commutative semiring `R`, monoid `R₁`, type family `s : ι → Type` of additive commutative monoids and `R`-modules, and distributive action of `R₁` on `R` and commutative scalar multiplication on `R₁ × (∏ i, s i)`, the scalar multiplication of an element `r` in `R₁` with the sum of two elements `x` and `y` in the Pi tensor product equals the sum of the scalar multiplications of `r` with `x` and `r` with `y`.


theorem Pell.pellZd_add :
    ∀ {a : ℕ} (a1 : 1 < a) (m n : ℕ), Pell.pellZd a1 (m + n) = Pell.pellZd a1 m * Pell.pellZd a1 n := by sorry

The theorem `Pell.pellZd_add` states that for any natural number `a` greater than 1, and for any two natural numbers `m` and `n`, the value of the Pell sequence at the sum of `m` and `n` is equal to the product of the values of the Pell sequence at `m` and `n`. The Pell sequence here is viewed as an element of the integer square root of the Pell number `d`. This is an important property of the Pell sequence in the context of number theory.

For any natural number `d` and integers `a > 1`, `m`, `n`, the Pell sequence value at `m + n` is equal to the product of the Pell sequence values at `m` and `n` in the sequence of integer square roots of `d`.


/-- A function is `C^(n + 1)` if and only if it is differentiable,
and its derivative (formulated in terms of `fderiv`) is `C^n`.  -/
theorem contDiff_succ_iff_fderiv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ}, ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ContDiff 𝕜 ↑n fun y => fderiv 𝕜 f y :=
  by sorry

The theorem `contDiff_succ_iff_fderiv` states that for all fields `𝕜` with a topology and a norm, and for all normed additive commutative group `E` over `𝕜`, and all normed additive commutative group `F` over `𝕜`, and for all function `f` from `E` to `F`, and all natural numbers `n`, a function `f` is `𝕜`-continuously differentiable for the `n + 1` times if and only if `f` is differentiable and its derivative (expressed with `fderiv`) is `𝕜`-continuously differentiable `n` times. In terms of analysis, this theorem connects the continuous differentiability of a function and its derivative.

A function between two normed spaces is `n` times continuously differentiable if and only if it is differentiable and its derivative is also `(n-1)` times continuously differentiable.


theorem Complex.hasStrictFDerivAt_log_real :
    ∀ {x : ℂ}, x ∈ Complex.slitPlane → HasStrictFDerivAt Complex.log (x⁻¹ • 1) x := by sorry

This theorem states that for every complex number 'x' belonging to the slit plane (the complex plane with the closed negative real axis removed), the complex logarithm function has a strict derivative at 'x'. The derivative of the complex logarithm at 'x' is given by `1/x`. In other words, this theorem is establishing the derivative of the logarithm function in the context of complex analysis, assuming the input is within the slit complex plane.

The complex logarithm function has a strict derivative equal to `1/x` at every complex number 'x' in the slit complex plane.


Filter.Tendsto.nsmul

theorem Filter.Tendsto.nsmul :
    ∀ {α : Type u_2} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [inst_2 : ContinuousAdd M]
      {l : Filter α} {f : α → M} {x : M},
      Filter.Tendsto f l (nhds x) → ∀ (n : ℕ), Filter.Tendsto (fun x => n • f x) l (nhds (n • x)) :=
  by sorry

The theorem `Filter.Tendsto.nsmul` states that for any topological space `M` that is also an additive monoid with continuous addition, any filter `l`, any function `f` from `α` to `M`, and any point `x` in `M`, if `f` tends to `x` with respect to `l` (meaning the limit of `f` as it approaches `l` is `x`), then for any natural number `n`, the function that maps `x` to `n` times `f(x)` also tends to `n` times `x` with respect to `l`. In other words, if `f` approaches `x` under filter `l`, then `n * f` approaches `n * x` under the same filter for any natural number `n`, which is a property that shows the compatibility of limit operation with scalar multiplication in this context.

If a function `f` tends to a point `x` in a topological monoid `M` with respect to filter `l`, then the function `x => n * f(x)` (scalar multiplication by a natural number `n`) also tends to `n * x` with respect to `l`.


theorem Mathlib.Analysis.Analytic.IsolatedZeros._auxLemma.3 :
    ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) := by sorry

This theorem, `Mathlib.Analysis.Analytic.IsolatedZeros._auxLemma.3`, states that for any type `G` that has an addition group structure, the difference of any two elements `a` and `b` of this type is zero if and only if `a` equals `b`. In mathematical terms, it says that for all `a`, `b` in a group `G`, `a - b = 0` is equivalent to `a = b`.

For any group `G`, the element `a - b` is equal to zero if and only if `a` is equal to `b`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxAddLemma.76 :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} {h : ↥K},
      (h ∈ AddSubgroup.addSubgroupOf H K) = (↑h ∈ H) :=
  by sorry

This theorem states that for any type `G` equipped with an additive group structure, and any subgroups `H` and `K` of `G`, an element `h` of `K` is in the intersection of `H` and `K` (as viewed as a subgroup of `K`) if and only if the underlying element of `h` in `G` is in `H`. In other words, it connects the membership of an element in the intersected subgroup with its membership in the original subgroup `H`.

For any additive group `G`, subgroups `H` and `K` of `G`, and `h` in `G`, `h` is in the intersection of `H` and `K` if and only if `h` is in `H`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxAddLemma.89 :
    ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → AddGroup (f i)] (I : Set η) {H : (i : η) → AddSubgroup (f i)}
      {p : (i : η) → f i}, (p ∈ AddSubgroup.pi I H) = ∀ i ∈ I, p i ∈ H i :=
  by sorry

This theorem states that for any type `η`, any function `f` from `η` to another type, any set `I` of type `η`, and any function `H` that assigns to each element of `η` an additive subgroup of `f i`, a function `p` from `η` to `f i` is in the additive subgroup `pi I H` (which is the set of functions whose values are in the corresponding additive subgroup for each index in `I`) if and only if for every element `i` in `I`, the value `p i` is in the additive subgroup `H i`.

For any type `η`, function `f` from `η` to another type, set `I` of type `η`, and function `H` that assigns to each element of `η` an additive subgroup of `f i`, a function `p` from `η` to `fi` is in the additive subgroup `pi I H` if and only if `p i` is in `Hi` for all `i` in `I`.


LinearIsometry.ext

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

The theorem `LinearIsometry.ext` states that for any two linear isometries `f` and `g` from a seminormed add-commutative group `E` over a semiring `R` to a seminormed add-commutative group `E₂` over a semiring `R₂`, with the linear map from `R` to `R₂` denoted by `σ₁₂`, if `f` and `g` are equal at every point in `E`, then `f` and `g` are equal. In simpler terms, if two linear isometries produce the same result for every input, they are the same linear isometry.

If two linear isometries from a seminormed add-commutative group over semirings to another such group, with compatible linear maps between the semirings, agree on every point, then they are equal.


/-- The composition of right adjoint mates is the adjoint mate of the composition.  -/
theorem CategoryTheory.comp_rightAdjointMate :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
      [inst_2 : CategoryTheory.HasRightDual X] [inst_3 : CategoryTheory.HasRightDual Y]
      [inst_4 : CategoryTheory.HasRightDual Z] {f : X ⟶ Y} {g : Y ⟶ Z},
      CategoryTheory.CategoryStruct.comp f gᘁ = CategoryTheory.CategoryStruct.comp (gᘁ) (fᘁ) :=
  by sorry

This theorem is set within the context of category theory and monoidal categories. It states that for any objects X, Y, and Z in a monoidal category C, if X, Y, and Z each have a right dual, then the composition of the right adjoint mates of the morphisms f : X ⟶ Y and g : Y ⟶ Z is equal to the right adjoint mate of the composition of f and g. Here, the right adjoint mate of a morphism is denoted by the superscript dagger (ᘁ). This property is fundamental to the concept of adjoint functors in category theory.

In a monoidal category, if objects X, Y, and Z have right duals, then (f^! ∘ g^!) = (f ∘ g)^!, where f : X ⟶ Y, g : Y ⟶ Z, and the superscript "!" denotes the right adjoint mate.


theorem Polynomial.aeval_algebraMap_apply_eq_algebraMap_eval :
    ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : R)
      (p : Polynomial R), (Polynomial.aeval ((algebraMap R A) x)) p = (algebraMap R A) (Polynomial.eval x p) :=
  by sorry

This theorem states that for any commutative semiring `R`, any semiring `A` with an algebra structure over `R`, any element `x` of `R`, and any polynomial `p` over `R`, the algebra homomorphism that arises from evaluating the polynomial `p` at `x` via `Polynomial.aeval` (where `x` is first mapped from `R` to `A` via the `algebraMap`), yields the same result as first evaluating the polynomial `p` at `x` and then mapping the result from `R` to `A` via the `algebraMap`. In mathematical terms, it asserts that for any polynomial $p$ and any scalar $x$ in $R$, $(\text{Polynomial.aeval} \circ \text{algebraMap} \, R \, A)(x)(p)= (\text{algebraMap} \, R \, A)(\text{Polynomial.eval} \, x \, p)$.

For any commutative semiring `R`, semiring `A` with an algebra structure over `R`, element `x` of `R`, and polynomial `p` over `R`, the algebra homomorphism of evaluating `p` at `x` via `Polynomial.aeval` and then mapping the result to `A` via `algebraMap` equals mapping `x` to `A` via `algebraMap` and then evaluating `p` at `x` in `R`. In symbols: `(Polynomial.aeval ∘ algebraMap R A) x p = algebraMap R A (Polynomial.eval x p)`.


theorem Polynomial.aroots_C_mul :
    ∀ {S : Type v} {T : Type w} [inst : CommRing T] [inst_1 : CommRing S] [inst_2 : IsDomain S] [inst_3 : Algebra T S]
      [inst_4 : NoZeroSMulDivisors T S] {a : T} (p : Polynomial T),
      a ≠ 0 → Polynomial.aroots (Polynomial.C a * p) S = Polynomial.aroots p S :=
  by sorry

The theorem `Polynomial.aroots_C_mul` states that for any commutative rings `S` and `T`, where `S` is also a domain and an algebra over `T`, and there are no zero `S`-multiples of non-zero `T` elements, given a non-zero element `a` in `T` and a polynomial `p` with coefficients in `T`, the multiset of roots of the polynomial obtained by multiplying `p` with the constant polynomial associated with `a`, when observed as a polynomial over `S`, is the same as the multiset of roots of the original polynomial `p` over `S`. In mathematical terms, if $a$ is a non-zero constant and $p(x)$ is a polynomial, then the roots of $a \cdot p(x)$ are the same as the roots of $p(x)$.

For any commutative rings S and T with no zero-divisors in T, and where S is a domain and an algebra over T, the roots of the polynomial p(x) over S are equal to the roots of the constant multiplied by p(x) polynomial over S, for any non-zero constant a in T.


theorem t2_iff_ultrafilter :
    ∀ {X : Type u_1} [inst : TopologicalSpace X],
      T2Space X ↔ ∀ {x y : X} (f : Ultrafilter X), ↑f ≤ nhds x → ↑f ≤ nhds y → x = y :=
  by sorry

This theorem states that a topological space 'X' is a T2 space (also known as a Hausdorff space) if and only if for any two points 'x' and 'y' in 'X' and any ultrafilter 'f' on 'X', if 'f' is included in the neighborhood filter of 'x' and the neighborhood filter of 'y', then 'x' must be equal to 'y'. In other words, no ultrafilter can be included in the neighborhood filters of two distinct points in a T2 space. The neighborhood filter of a point includes all the open sets that contain the point. An ultrafilter is a maximally consistent notion of largeness for subsets of a given set. The condition that 'f' is included in the neighborhood filter of a point means that the ultrafilter deems all the neighborhoods of the point as large.

A topological space is T2 (Hausdorff) if and only if no ultrafilter intersects the neighborhood filters of distinct points.


/-- If `s` is a convex set, then `a • interior s + b • closure s ⊆ interior s` for all `0 < a`,
`0 ≤ b`, `a + b = 1`. See also `Convex.combo_interior_self_subset_interior` for a weaker version.  -/
theorem Convex.combo_interior_closure_subset_interior :
    ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : LinearOrderedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
      [inst_3 : TopologicalSpace E] [inst_4 : TopologicalAddGroup E] [inst_5 : ContinuousConstSMul 𝕜 E] {s : Set E},
      Convex 𝕜 s → ∀ {a b : 𝕜}, 0 < a → 0 ≤ b → a + b = 1 → a • interior s + b • closure s ⊆ interior s :=
  by sorry

The theorem `Convex.combo_interior_closure_subset_interior` states that given a convex set `s` in a topological space with an additive group structure, and a module over a linearly ordered field, if `a` and `b` are scalars such that `a` is positive, `b` is non-negative, and their sum equals 1, then the set formed by adding `a` times the interior of `s` and `b` times the closure of `s` is a subset of the interior of `s`. This extends a weaker version of the theorem, `Convex.combo_interior_self_subset_interior`, which holds for similar conditions.

Given a convex set `s` in a topological space with an additive group structure and over a linearly ordered field, if `a` and `b` are scalars with `a` positive, `b` non-negative, and `a + b = 1`, then the intersection of `a * Int(s)` and `b * Cl(s)` is a subset of `Int(s)`.


theorem Function.Commute.iterate_pos_lt_iff_map_lt :
    ∀ {α : Type u_1} [inst : LinearOrder α] {f g : α → α},
      Function.Commute f g → Monotone f → StrictMono g → ∀ {x : α} {n : ℕ}, 0 < n → (f^[n] x < g^[n] x ↔ f x < g x) :=
  by sorry

The theorem `Function.Commute.iterate_pos_lt_iff_map_lt` states that for any type `α` with a linear order, and any two functions `f` and `g` from `α` to `α` that commute, if `f` is monotone and `g` is strictly monotone, then for any element `x` in `α` and any positive natural number `n`, the `n`th iteration of `f` on `x` is less than the `n`th iteration of `g` on `x` if and only if `f(x)` is less than `g(x)`.

For any type `α` with a linear order, and functions `f` and `g` from `α` to `α` that commute, if `f` is monotone and `g` is strictly monotone, then `x < y` implies `(iterate f x n) < (iterate g x n)` if and only if `f x < g x`, where `n` is a positive natural number.


ContinuousAffineMap.ext

theorem ContinuousAffineMap.ext :
    ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R]
      [inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P]
      [inst_5 : AddCommGroup W] [inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q]
      {f g : P →A[R] Q}, (∀ (x : P), f x = g x) → f = g :=
  by sorry

This theorem states that for any two continuous affine maps 'f' and 'g' from a vector space 'P' to another vector space 'Q', if for every point 'x' in 'P', the image of 'x' under 'f' and 'g' are the same, then 'f' and 'g' are the same continuous affine map. Here, the vector spaces 'P' and 'Q' are over a ring 'R', and have underlying additive abelian groups 'V' and 'W', respectively. The vector spaces are also topological spaces, and 'P' and 'Q' are torsor spaces over 'V' and 'W', respectively.

Given continuous affine maps $f, g : P \to Q$ between topological vector spaces $P$ and $Q$ over a ring $R$, if $f(x) = g(x)$ for all $x \in P$, then $f = g$.


theorem Units.coe_map :
    ∀ {M : Type u} {N : Type v} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (x : Mˣ),
      ↑((Units.map f) x) = f ↑x :=
  by sorry

The theorem `Units.coe_map` states that for any two types `M` and `N` which are instances of the `Monoid` class, and for any monoid homomorphism `f` from `M` to `N`, and any unit `x` in `M`, applying the unit map induced by `f` to `x` and then taking the corresponding element in `N` (i.e., `↑((Units.map f) x)`) is the same as first taking the corresponding element of `x` in `M` and then applying `f` (i.e., `f ↑x`). In other words, the process of mapping units commutes with the process of taking corresponding elements in their respective monoids.

For any monoid homomorphism f between monoids M and N and any unit x in M, the application of the unit map and f commutes: ↑((Units.map f) x) = f ↑x.


theorem Mathlib.Logic.Equiv.Basic._auxLemma.2 : (¬False) = True := by sorry

This theorem, `Mathlib.Logic.Equiv.Basic._auxLemma.2`, states that the negation of `False` is `True`. In other words, it's expressing the basic logic principle that if something is not false, then it must be true.

The theorem asserts that the negation of False is True. In mathematical notation, ¬False = True.


theorem Matrix.dotProduct_smul :
    ∀ {m : Type u_2} {R : Type u_7} {α : Type v} [inst : Fintype m] [inst_1 : Monoid R] [inst_2 : Mul α]
      [inst_3 : AddCommMonoid α] [inst_4 : DistribMulAction R α] [inst_5 : SMulCommClass R α α] (x : R) (v w : m → α),
      Matrix.dotProduct v (x • w) = x • Matrix.dotProduct v w :=
  by sorry

The theorem `Matrix.dotProduct_smul` states that for any scalar `x` and any two vectors `v` and `w`, the dot product of `v` and the scalar multiplication of `x` with `w` is equal to the scalar multiplication of `x` with the dot product of `v` and `w`. This property holds for all types `m` corresponding to the vector dimensions, `R` corresponding to the scalar type, and `α` corresponding to the type of the vector entries, as long as `m` is finite, `R` is a monoid (a set equipped with an associative binary operation and an identity element), `α` is a commutative additive monoid (an additive monoid where the operation is commutative) and a multiplication operation is defined on `α`, `R` acts distributively on `α`, and the scalar multiplication of `R` and `α` is commutative. This is a generalization of the standard property of dot product in real vector spaces.

For any scalar `x` and vectors `v` and `w` of finite dimension, the dot product of `v` and `x`(\*w\*) is equal to `x` \* (the dot product of `v` and `w`).


Disjoint.ne

theorem Disjoint.ne :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a b : α}, a ≠ ⊥ → Disjoint a b → a ≠ b := by sorry

This theorem states that for any type `α` that has a partial order and a bottom element, if two elements `a` and `b` of `α` are disjoint, and `a` is not the bottom element, then `a` and `b` cannot be equal. In other words, if `a` is disjoint from `b` and `a` is not the least element of the partial order, then `a` is necessarily different from `b`. The concept of disjointness here generalizes the idea of disjoint sets: in a lattice structure, two elements are considered disjoint if their greatest lower bound (infimum) is the bottom element of the lattice.

For any type `α` with a bottom element and a partial order, if `a` and `b` are disjoint elements of `α` and `a` is not the bottom element, then `a` is distinct from `b`.


theorem upperClosure_iUnion :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : Preorder α] (f : ι → Set α),
      upperClosure (⋃ i, f i) = ⨅ i, upperClosure (f i) :=
  by sorry

The theorem `upperClosure_iUnion` states that for any type `α` with a preorder structure and a function `f` from some index set `ι` to the set of `α`, the upper closure of the union over `f i` for all `i` in `ι` is equivalent to the infimum of the upper closures of `f i` for all `i` in `ι`. In simpler terms, it says that the smallest upper bound containing all elements of a union of sets is the same as the smallest upper bound of all upper bounds of the individual sets.

For any preordered type `α` and function `f` from an index set `ι` to `α`, the upper closure of the union of images `{f i | i ∈ ι}` is equal to the infimum of the upper closures of `{f i | i ∈ ι}`.


theorem card_nsmul_eq_zero :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Fintype G] {x : G}, Fintype.card G • x = 0 := by sorry

The theorem `card_nsmul_eq_zero` states that for any type `G` that has both an additive group structure and a finite type structure, and any element `x` of that type `G`, the finite cardinality of `G` (notated as `Fintype.card G`) times `x` (i.e., the element `x` added to itself `Fintype.card G` times) equals `0`. In other words, if you add an element to itself as many times as there are elements in the finite set, you will get the additive identity (zero).

For any finite additive group `G` and its element `x`, we have `Fintype.card G * x = 0`.


theorem dimH_bUnion :
    ∀ {ι : Type u_1} {X : Type u_2} [inst : EMetricSpace X] {s : Set ι},
      Set.Countable s → ∀ (t : ι → Set X), dimH (⋃ i ∈ s, t i) = ⨆ i ∈ s, dimH (t i) :=
  by sorry

The theorem `dimH_bUnion` states that for any type `ι`, type `X` with an eMetricSpace instance, a countable set `s` of type `ι`, and a function `t` from `ι` to `Set X`, the Hausdorff dimension of the union of all sets `t i` where `i` belongs to `s` is equal to the supremum of the Hausdorff dimensions of all sets `t i` where `i` belongs to `s`. In mathematical terms, we can write this as: for a countable index set `s`, the Hausdorff dimension of the union over `s` of sets `t i` is the supremum of the Hausdorff dimensions of the individual sets `t i`.

The Hausdorff dimension of the countable union of sets in a metric space, each with finite Hausdorff dimension, is equal to the supreme of their individual Hausdorff dimensions.


/-- The distance from `x` to `s` or `t` is controlled in terms of the Hausdorff distance
between `s` and `t`.  -/
theorem EMetric.infEdist_le_infEdist_add_hausdorffEdist :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s t : Set α},
      EMetric.infEdist x t ≤ EMetric.infEdist x s + EMetric.hausdorffEdist s t :=
  by sorry

The theorem `EMetric.infEdist_le_infEdist_add_hausdorffEdist` states that for any pseudo-extended metric space `α` and any sets `s` and `t` in this space, as well as any point `x` in this space, the extended distance from `x` to `t` is always less than or equal to the extended distance from `x` to `s` plus the Hausdorff (greatest shortest) distance between the sets `s` and `t`. Here, the concept of extended distance allows for the consideration of infinitely distant points, and the Hausdorff distance between two sets is the greatest of all the shortest distances from a point in one set to the other set.

For any pseudo-extended metric space, extended distance from a point to a set plus Hausdorff distance between the sets is an upper bound for the extended distance from that point to any other set.


theorem Mathlib.Order.Filter.Prod._auxLemma.31 :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, (f ×ˢ g = ⊥) = (f = ⊥ ∨ g = ⊥) := by sorry

This theorem states that for any two types `α` and `β`, and any two filters `f` and `g` on these types, the product filter `f ×ˢ g` is the bottom element (denoted by `⊥`, which can be thought of as the "smallest" filter) if and only if either `f` or `g` is the bottom element. In other words, the product of two filters is the smallest possible filter if and only if at least one of the filters is the smallest possible filter.

For filters \(f\) and \(g\) on types \(\alpha\) and \(\beta\) respectively, \(f \times_\bot g = \bot\) if and only if \(f = \bot\) or \(g = \bot\).


theorem Mathlib.Data.Int.Cast.Basic._auxLemma.4 : ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℤ), -↑n = ↑(-n) := by
  sorry

This theorem, named `Mathlib.Data.Int.Cast.Basic._auxLemma.4`, states that for all types `R` that form an Additive Group with a multiplicative identity (also known as a `AddGroupWithOne`), the negation of the cast of an integer `n` to type `R` is equal to the cast of the negation of `n` to type `R`. In mathematical terms, the theorem says that for any integer `n` and any `R` in the class of add groups with one, `-cast(n) = cast(-n)`.

For any additive group with a multiplicative identity `R`, the cast of the negative of an integer to `R` is equal to the negative of the cast of the integer to `R`. In other words, `cast(-n) = -cast(n)` for all integers `n` and additive groups with a multiplicative identity `R`.


theorem measure_Icc_lt_top :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : CompactIccSpace α]
      {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst_3 : MeasureTheory.IsLocallyFiniteMeasure μ] {a b : α},
      ↑↑μ (Set.Icc a b) < ⊤ :=
  by sorry

This theorem states that for any given type `α`, with a pre-order relation, a topology, and a condition that every interval `[a, b]` is compact, and given a measurable space over `α` and a measure `μ` on it which is locally finite, then the measure of any closed interval `[a, b]` is strictly less than infinity. In other words, the measure of any closed interval in such a space is always finite.

For any type `α` with a pre-order relation, a topology, and the property that every interval is compact; if we have a measurable space over `α` with a locally finite measure `μ`, then the measure of any closed interval is finite.


theorem Subtype.strictMono_coe : ∀ {α : Type u} [inst : Preorder α] (t : Set α), StrictMono Subtype.val := by sorry

This theorem states that for any type `α` with a preorder structure, and for any set `t` of elements of type `α`, the function `Subtype.val` is strictly monotone. In other words, if `a` and `b` are two elements in `t` such that `a < b`, then `Subtype.val a < Subtype.val b`. Here, `Subtype.val` is a function that retrieves the underlying element of a subtype. The theorem is saying that retrieving the underlying elements preserves the strict order.

For any preorder type `α` and subset `t` of `α`, the function `Subtype.val` maps strictly smaller elements to strictly smaller values, that is, if `a` is strictly smaller than `b` in `t`, then `Subtype.val(a)` is strictly smaller than `Subtype.val(b)`.


theorem Mathlib.Order.Atoms._auxLemma.4 : ∀ {a b : Prop}, (¬a → ¬b) = (b → a) := by sorry

This theorem, `Mathlib.Order.Atoms._auxLemma.4`, states that for any two propositions `a` and `b`, the statement "if `a` is not true, then `b` is not true" is logically equivalent to the statement "if `b` is true, then `a` is also true". In mathematical notation, this theorem expresses the equivalence between `¬a → ¬b` and `b → a`.

The negation of proposition `a` is logically equivalent to the implication `b` implies `a`. In symbols, `¬a ≃ b → a`.


theorem Mathlib.Order.Atoms._auxLemma.3 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (⊥ < a) = (a ≠ ⊥) := by sorry

This theorem, `Mathlib.Order.Atoms._auxLemma.3`, states that for any type `α` that has a partial order and a least element (notated as `⊥`), and for any element `a` of this type, the proposition that the least element is less than `a` is equivalent to the proposition that `a` is not equal to the least element. In other words, `a` being greater than the absolute minimum implies that `a` is distinct from it.

For any type with a partial order and a least element, the least element is strictly less than any element distinct from it.


/-- A function `f` on `Fin (n + 1)` is strictly monotone if and only if `f i < f (i + 1)`
for all `i`.  -/
theorem Fin.strictMono_iff_lt_succ :
    ∀ {n : ℕ} {α : Type u_1} [inst : Preorder α] {f : Fin (n + 1) → α},
      StrictMono f ↔ ∀ (i : Fin n), f (Fin.castSucc i) < f (Fin.succ i) :=
  by sorry

The theorem `Fin.strictMono_iff_lt_succ` states that, for any natural number `n` and any type `α` that has a `Preorder` relation, a function `f` from `Fin (n + 1)` to `α` is strictly monotone if and only if the value of `f` at `i` is less than the value of `f` at `i + 1` for every `i` in `Fin n`. Here, `Fin (n + 1)` represents the set of natural numbers less than `n + 1`, `Fin.castSucc i` represents embedding `i` from `Fin n` into `Fin (n + 1)`, and `Fin.succ i` represents the successor of `i` in `Fin (n + 1)`.

A function from `Fin (n+1)` to a type with a preorder relation is strictly monotone if and only if `f (Fin.castSucc i) < f (Fin.succ i)` for all `i` in `Fin n`.


Function.LeftInverse.comp

theorem Function.LeftInverse.comp :
    ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : β → α} {h : β → γ} {i : γ → β},
      Function.LeftInverse f g → Function.LeftInverse h i → Function.LeftInverse (h ∘ f) (g ∘ i) :=
  by sorry

The theorem `Function.LeftInverse.comp` states that given two pairs of functions `(f, g)` and `(h, i)` where `g` is a left inverse to `f` and `i` is a left inverse to `h`, the composition of `h` and `f` also has a left inverse, which is the composition of `g` and `i`. In other words, if `g ∘ f = id` and `i ∘ h = id`, then `(g ∘ i) ∘ (h ∘ f) = id`. This asserts the composability of left inverses in function composition.

If functions `f` and `g`, and `h` and `i` are pairs with `g` a left inverse of `f` and `i` a left inverse of `h`, then `g ∘ i` is a left inverse of their composite `h ∘ f`.


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

This theorem states that for all types `α` and for all elements `a` of type `α`, the set that contains `a` twice is equal to the set that contains `a` once. In other words, in set notation, a set with repeated elements is equivalent to the same set where the repeated elements are only listed once.

For all types `α` and all elements `a` of type `α`, the set `{a, a} = {a}`.


theorem Nat.mul_right_inj : ∀ {a b c : ℕ}, a ≠ 0 → (a * b = a * c ↔ b = c) := by sorry

This theorem states that for any natural numbers `a`, `b`, and `c`, if `a` is not zero, then `a` multiplied by `b` equals `a` multiplied by `c` if and only if `b` equals `c`. In other words, multiplication by a non-zero natural number on the right is injective, i.e., it preserves distinctness. This means if two natural numbers are distinct, then their products with a non-zero natural number will also be distinct.

For any natural numbers `a` (not equal to zero) and `b` and `c`, `a * b = a * c` if and only if `b = c`.


theorem Ordinal.nfpFamily_le_fp :
    ∀ {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}},
      (∀ (i : ι), Monotone (f i)) →
        ∀ {a b : Ordinal.{max u v}}, a ≤ b → (∀ (i : ι), f i b ≤ b) → Ordinal.nfpFamily f a ≤ b :=
  by sorry

The theorem `Ordinal.nfpFamily_le_fp` states that for any type `ι` and a function `f` from `ι` to a mapping from an ordinal to another ordinal, if every `f i` is a monotone function, then for any two ordinals `a` and `b` where `a` is less than or equal to `b`, and for every `i` in `ι`, `f i b` is less than or equal to `b`, it follows that the next common fixed point for the family of functions `f`, starting at least `a`, is less than or equal to `b`. In short, it states that the least ordinal fixed point for a family of monotone functions is bounded.

For any type `ι` and a family `f` of monotone functions from `ι` to ordinals, if for all `i` in `ι` and ordinals `a` and `b` with `a ≤ b`, we have `f i b ≤ b`, then the least fixed point of `f` is less than or equal to `b`.


/-- In a normed ring, the coercion from `Rˣ` (equipped with the induced topology from the
embedding in `R × R`) to `R` is an open embedding.  -/
theorem Units.openEmbedding_val :
    ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R], OpenEmbedding Units.val := by sorry

This theorem states that in a normed ring `R` which is also a complete space, the coercion from the non-zero elements of `R` (denoted as `Rˣ`, and equipped with the topology induced from the embedding in `R × R`) to `R` is an open embedding. Here, an open embedding means that the image of an open set under the function is open and the function is injective and continuous. The function in consideration is `Units.val`, which essentially takes a non-zero element of the ring and returns its underlying value in the base `Monoid`.

In a complete and normed ring `R`, the coercion map from its non-zero elements `Rˣ` to `R` is an open, injective, and continuous function. (Or equivalently, the `Units.val` function is an open embedding from `Rˣ` to `R`.)


QuasiconcaveOn.dual

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

This theorem states that for any ordered semiring `𝕜`, any additively commutative monoid `E`, any set `s` of elements from `E`, any function `f` from `E` to a type `β` equipped with a less-than-or-equal-to (`LE`) relation, and any scalar multiplication (`SMul`) between `𝕜` and `E`, if the function `f` is quasiconcave on the set `s` (meaning that all its superlevel sets are `𝕜`-convex), then the function `f`, when composed with the identity function to the order-dual of `β` (i.e., `f` considered in the opposite order), is quasiconvex on the set `s` (meaning that all its sublevel sets are `𝕜`-convex). In other words, the order-dual of a quasiconcave function is quasiconvex.

The order-dual of a quasiconcave function defined on an ordered semiring and an additively commutative monoid is quasiconvex.


/-- The reversed version of **Tonelli's Theorem**. In this version `f` is in curried form, which
makes it easier for the elaborator to figure out `f` automatically.  -/
theorem MeasureTheory.lintegral_lintegral :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : MeasureTheory.SFinite ν]
      ⦃f : α → β → ENNReal⦄,
      AEMeasurable (Function.uncurry f) (MeasureTheory.Measure.prod μ ν) →
        ∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (z : α × β), f z.1 z.2 ∂MeasureTheory.Measure.prod μ ν :=
  by sorry

This theorem is a reversed version of Tonelli's Theorem. It states that given two measurable spaces `α` and `β`, measures `μ` on `α` and `ν` on `β` (with `ν` being sigma-finite), and a function `f` from `α` and `β` to the extended nonnegative real numbers that is almost everywhere measurable when considered as a function on the product of `α` and `β`, the double integral of `f` with respect to `ν` and then `μ` is equal to the integral of `f` with respect to the product measure on `α × β`. In this version of the theorem, `f` is presented in its curried form (`f : α → β → ENNReal`), which makes it easier for Lean's elaborator to automatically figure out `f`.

Given measurable spaces `α`, `β`, measures `μ` on `α` and `σ-finite ν` on `β`, and a curried almost everywhere measurable function `f : α → β → ENNReal`, the double integral of `f` with respect to `ν` then `μ` equals the integral of `f` with respect to the product measure on `α × β`.


theorem isOpen_iInter :
    ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : AlexandrovDiscrete α] {f : ι → Set α},
      (∀ (i : ι), IsOpen (f i)) → IsOpen (⋂ i, f i) :=
  by sorry

The theorem `isOpen_iInter` states that for any index type `ι`, any type `α`, given a topological space over `α` and an Alexandrov discrete topology, and a function `f` from `ι` to the set of `α`, if each set `f i` is open for all `i` in `ι`, then the intersection of all such sets `f i` (denoted as `⋂ i, f i`) is also an open set. In other words, in an Alexandrov discrete topological space, the intersection of any collection of open sets is also an open set.

In an Alexandrov discrete topological space, the intersection of any collection of open sets is open.


/-- A module is Noetherian iff every increasing chain of submodules stabilizes.  -/
theorem monotone_stabilizes_iff_noetherian :
    ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
      (∀ (f : ℕ →o Submodule R M), ∃ n, ∀ (m : ℕ), n ≤ m → f n = f m) ↔ IsNoetherian R M :=
  by sorry

This theorem states that a module is Noetherian if and only if every increasing chain of its submodules eventually stabilizes. In more detail, given a semiring `R` and an additive commutative monoid `M` with a module structure over `R`, for any strictly increasing function `f` that maps each natural number to a submodule of `M`, there exists a certain natural number `n` such that for all numbers `m` greater than or equal to `n`, the `m`-th submodule in the chain is the same as the `n`-th one. The theorem shows this condition is equivalent to the module `M` being Noetherian.

A module over a semiring is Noetherian if and only if every increasing chain of its submodules is eventually constant.


theorem Function.Semiconj.set_image :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β},
      Function.Semiconj f ga gb → Function.Semiconj (Set.image f) (Set.image ga) (Set.image gb) :=
  by sorry

This theorem states that for all functions `f` from type `α` to `β`, and functions `ga` from type `α` to itself and `gb` from type `β` to itself, if `f` semi-conjugates `ga` to `gb`, then the set image of `f` also semi-conjugates the set image of `ga` to the set image of `gb`. In other words, if for every element `x` of type `α`, applying `f` after `ga` yields the same result as applying `gb` after `f`, then this property also holds when considering the sets of elements obtained by applying these functions.

If function `f` semi-conjugates `ga` to `gb`, then the image of `f` maps the image of `ga` onto the image of `gb`.


theorem Equivalence.quot_mk_eq_iff :
    ∀ {α : Type u_3} {r : α → α → Prop}, Equivalence r → ∀ (x y : α), Quot.mk r x = Quot.mk r y ↔ r x y := by sorry

The theorem `Equivalence.quot_mk_eq_iff` states that for any type `α` and any equivalence relation `r` on `α`, for any elements `x` and `y` of `α`, the quotient of `x` and `y` under relation `r` (i.e., `Quot.mk r x` and `Quot.mk r y`) are equal if and only if `x` and `y` are related by `r`. This essentially provides a characterization for when two elements are considered equivalent under the quotient construction, by linking it directly to the equivalence relation used to form the quotient.

For any type `α` and equivalence relation `r` on `α`, `Quot.mk r x = Quot.mk r y` if and only if `x` is related to `y` by `r`.


theorem DenseRange.induction_on :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {e : α → β},
      DenseRange e → ∀ {p : β → Prop} (b₀ : β), IsClosed {b | p b} → (∀ (a : α), p (e a)) → p b₀ :=
  by sorry

This theorem states that for any two types `α` and `β`, with `β` having a topological space structure, and any function `e` from `α` to `β` whose range is dense in `β`, for any property `p` of elements in `β` and any element `b₀` in `β`, if the set of elements in `β` that satisfy the property `p` is a closed set, and if all the images of elements in `α` under the function `e` satisfy the property `p`, then the element `b₀` also satisfies the property `p`.

If `e: α → β` is a dense function from type `α` to a topological space `β` with property `p` holding for all images `e(a)` in `β` for `a` in `α`, and the set of elements in `β` satisfying `p` is closed, then `b₀` satisfies `p` for any `b�!_0` in `β`.


theorem MeasureTheory.Measure.count_apply_finset' :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Finset α},
      MeasurableSet ↑s → ↑↑MeasureTheory.Measure.count ↑s = ↑s.card :=
  by sorry

This theorem states that for any finite set `s` in a measurable space `α`, if the set `s` is measurable, then applying the counting measure to `s` is equivalent to finding the cardinality (or number of elements) of `s`. In other words, the counting measure of a measurable finite set is simply its size.

For any finite measurable set `s` in a measurable space, the counting measure of `s` equals its cardinality.


/-- If `C` has all colimits of diagrams `parallelPair f g`, then it has all coequalizers  -/
theorem CategoryTheory.Limits.hasCoequalizers_of_hasColimit_parallelPair :
    ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C]
      [inst_1 : ∀ {X Y : C} {f g : X ⟶ Y}, CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f g)],
      CategoryTheory.Limits.HasCoequalizers C :=
  by sorry

The theorem `CategoryTheory.Limits.hasCoequalizers_of_hasColimit_parallelPair` states that if a category `C` has all colimits of diagrams formed by a parallel pair of morphisms `f` and `g` (i.e., two morphisms from the same source object `X` to the same target object `Y`), then `C` has all coequalizers. Here, coequalizers are a specific type of colimit, representing an object that is the "best" way to map two parallel morphisms to a single morphism.

If a category has all colimits of parallel morphism pairs, then it has all coequalizers.


/-- An induction principle for `Cycle`. Use as `induction s using Cycle.induction_on`.  -/
theorem Cycle.induction_on :
    ∀ {α : Type u_1} {C : Cycle α → Prop} (s : Cycle α),
      C Cycle.nil → (∀ (a : α) (l : List α), C ↑l → C ↑(a :: l)) → C s :=
  by sorry

This theorem is an induction principle for `Cycle`. For a given type `α` and a function `C` that assigns a property to each `Cycle α`, if `C` holds for the unique empty cycle (`Cycle.nil`), and if for any element `a : α` and list `l : List α` the property `C` holding for `l` implies `C` holding for the cycle with `a` added to `l`, then the property `C` holds for any cycle `s : Cycle α`. This theorem can be used for proving properties that hold for all cycles, and can be invoked as `induction s using Cycle.induction_on`.

If a property `C` holds for the empty cycle and is closed under the addition of an element to a list, then `C` holds for any cycle.


theorem AddGroupSeminorm.add_bddBelow_range_add :
    ∀ {E : Type u_4} [inst : AddCommGroup E] {p q : AddGroupSeminorm E} {x : E},
      BddBelow (Set.range fun y => p y + q (x - y)) :=
  by sorry

This theorem states that for any type `E` that forms an additive commutative group, and for any two additive group seminorms `p` and `q` on `E`, and for any element `x` from `E`, the set of all values obtained by applying the function `y => p y + q (x - y)` is bounded below. In other words, there exists a lower bound for the set of these function values. The function takes an element `y` from `E`, applies the seminorm `p` to `y`, subtracts `y` from `x`, applies the seminorm `q` to the result, and adds these two seminorm values together.

For any additive commutative group `E`, any two additive group seminorms `p` and `q` on `E`, and any `x` in `E`, there exists a real number `b` such that for all `y` in `E`, `p y + q (x - y) ≥ b`.


theorem QuotientAddGroup.lift_mk' :
    ∀ {G : Type u} [inst : AddGroup G] (N : AddSubgroup G) [nN : AddSubgroup.Normal N] {M : Type x}
      [inst_1 : AddMonoid M] {φ : G →+ M} (HN : N ≤ AddMonoidHom.ker φ) (g : G),
      (QuotientAddGroup.lift N φ HN) ↑g = φ g :=
  by sorry

The theorem `QuotientAddGroup.lift_mk'` states that for any additive group `G`, subgroup `N` of `G` that is normal, additive monoid `M`, and an additive group homomorphism `φ` from `G` to `M` such that `N` is a subset of the kernel of `φ`, and any element `g` of `G`, the result of applying the `lift` of `φ` over the quotient group `G/N` to the coset of `g` (denoted `(QuotientAddGroup.lift N φ HN) ↑g`) is equal to the result of applying `φ` to `g` (denoted `φ g`). Essentially, it means that lifting a homomorphism to the quotient group and applying it to a coset gives the same result as applying the original homomorphism to the representative of the coset.

For any additive group homomorphism φ from a normal subgroup N of an additive group G to an additive monoid M such that the kernel of φ contains N, the diagram commutes: φ ∘ (QuotientAddGroup.lift N) = (QuotientAddGroup.lift N ∘ ι), where ι is the inclusion map from G to G/N.


theorem Submodule.iSup_torsionBySet_ideal_eq_torsionBySet_iInf :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {ι : Type u_3} {p : ι → Ideal R} {S : Finset ι},
      (Set.Pairwise ↑S fun i j => p i ⊔ p j = ⊤) →
        ⨆ i ∈ S, Submodule.torsionBySet R M ↑(p i) = Submodule.torsionBySet R M ↑(⨅ i ∈ S, p i) :=
  by sorry

The theorem `Submodule.iSup_torsionBySet_ideal_eq_torsionBySet_iInf` states that for a commutative semiring `R` and an additive commutative monoid `M` that is also an `R`-module, given a family of ideals `p` indexed by type `ι` and a finite set `S` of these indices, if for every pair of distinct elements in `S`, the sup of their corresponding ideals is the whole ring (denoted as `p i ⊔ p j = ⊤`), then the supremum of the set of submodules obtained by taking the torsion elements of `M` by the set of elements of the ideals corresponding to each index in `S`, equals the submodule obtained by taking the torsion elements of `M` by the set of elements of the infimum of the ideals corresponding to each index in `S`. In other words, the "torsion part" of the supremum of a pairwise top set of ideals is the same as the "torsion part" of the infimum of these ideals.

Given a commutative semiring R, an additive commutative monoid M that is an R-module, a family of ideals p indexed by type ι, and a finite set S of indices such that p i ⊔ p j = ⊤ for all distinct i, j ∈ S, the torsion submodules of M by the sets of elements of the infimum and supremum of the ideals indexed by S are equal.


/-- If an integer with larger absolute value divides an integer, it is
zero.  -/
theorem Int.eq_zero_of_dvd_of_natAbs_lt_natAbs : ∀ {a b : ℤ}, a ∣ b → Int.natAbs b < Int.natAbs a → b = 0 := by sorry

The theorem `Int.eq_zero_of_dvd_of_natAbs_lt_natAbs` states that for any two integers `a` and `b`, if `a` divides `b` and the absolute value of `b` is less than the absolute value of `a`, then `b` must be zero. Essentially, this theorem asserts that no integer can be divided by an integer with a larger absolute value without reducing to zero.

If an integer `a` divides `b` and `|b| < |a|`, then `b` equals zero.


/-- **Primitive element theorem**: a finite separable field extension `E` of `F` has a
primitive element, i.e. there is an `α ∈ E` such that `F⟮α⟯ = (⊤ : Subalgebra F E)`.  -/
theorem Field.exists_primitive_element :
    ∀ (F : Type u_1) (E : Type u_2) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
      [inst_3 : FiniteDimensional F E] [inst_4 : IsSeparable F E], ∃ α, F⟮α⟯ = ⊤ :=
  by sorry

This is the **Primitive Element Theorem**. It states that for any finite separable field extension `E` over `F`, there exists a primitive element. In other words, there exists an element `α` in `E` such that the field generated by `F` and `α` equals the whole field `E`. This theorem is a fundamental result in field theory and it essentially says that any finite separable field extension is generated by a single element.

Any finite separable field extension has a primitive element, that is, there exists an element generating the entire extension.


theorem SeminormFamily.basisSets_iff :
    ∀ {𝕜 : Type u_1} {E : Type u_5} {ι : Type u_8} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
      [inst_2 : Module 𝕜 E] (p : SeminormFamily 𝕜 E ι) {U : Set E},
      U ∈ SeminormFamily.basisSets p ↔ ∃ i r, 0 < r ∧ U = Seminorm.ball (Finset.sup i p) 0 r :=
  by sorry

The theorem `SeminormFamily.basisSets_iff` states that for any normed field `𝕜`, additive commutative group `E`, and type `ι`, given a seminorm family `p` and a set `U` of type `E`, `U` is in the basis sets of the seminorm family `p` if and only if there exist `i` and `r` such that `r` is greater than 0 and `U` is equal to the ball of radius `r` at 0 with respect to the supremum of the seminorms in `i` under the seminorm family `p`. In other words, a set `U` belongs to the basis sets of a seminorm family `p` if it can be represented as the ball in the seminorm space defined by the supremum of a subset of seminorms from `p`, with radius `r` and center at the origin.

A set in a normed vector space is a basis set for a seminorm family if and only if it is equal to the ball centered at the origin with respect to the supremum of a subset of seminorms from the family.


theorem NNReal.tsum_eq_toNNReal_tsum :
    ∀ {β : Type u_2} {f : β → NNReal}, ∑' (b : β), f b = (∑' (b : β), ↑(f b)).toNNReal := by sorry

The theorem `NNReal.tsum_eq_toNNReal_tsum` states that for any type `β` and function `f` from `β` to the nonnegative real numbers (NNReal), the sum of the series generated by applying `f` to elements of `β` is equal to the sum of the series generated by applying the function which first applies `f` and then the embedding of NNReal in the reals to elements of `β`, where the sums are interpreted as nonnegative real numbers. In short, summing first and then embedding into the reals gives the same result as embedding into the reals first and then summing.

For any type `β` and function `f` from `β` to the nonnegative real numbers, the series sum of applying `f` to elements of `β` equals the series sum of applying `f` and the NNReal embedding function to elements of `β`, where the series sums are interpreted as nonnegative real numbers.


theorem WithTop.coe_iInf :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : Nonempty ι] [inst : InfSet α] (f : ι → α), ↑(⨅ i, f i) = ⨅ i, ↑(f i) := by
  sorry

This theorem states that for any type `α`, any sort `ι`, given that `ι` is nonempty and `α` has an infimum set structure, for any function `f` from `ι` to `α`, the infimum of the co-domain of `f` when considered in the "WithTop" extension of `α` is equal to the "WithTop" extension of the infimum of the co-domain of `f`. In simpler terms, it establishes that taking the infimum then embedding into the "WithTop" extension is the same as embedding each element into the "WithTop" extension then taking the infimum.

For any type `α` with an infimum set structure and nonempty sort `ι`, the infimum of the image of a function from `ι` to `α` in the "WithTop" extension of `α` equals the "WithTop" extension of the infimum of the function's image.


theorem Fin.succ_last : ∀ (n : ℕ), Fin.succ (Fin.last n) = Fin.last (Nat.succ n) := by sorry

The theorem `Fin.succ_last` states that for all natural numbers `n`, the successor of the greatest value of `Fin (n+1)` (represented as `Fin.succ (Fin.last n)`) is equal to the greatest value of `Fin (n+2)` (represented as `Fin.last (Nat.succ n)`). In other words, it asserts a property about how the "successor" function (`Fin.succ`) interacts with the "last" function (`Fin.last`), specifically, if you take the successor of the last element in a finite set of size `n+1`, you get the last element in a finite set of size `n+2`.

For all natural numbers `n`, `Fin.last (Nat.succ n) = Fin.succ (Fin.last n)`.


theorem Equiv.Perm.sign_mul :
    ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] (f g : Equiv.Perm α),
      Equiv.Perm.sign (f * g) = Equiv.Perm.sign f * Equiv.Perm.sign g :=
  by sorry

The theorem `Equiv.Perm.sign_mul` states that for any type `α` that has decidable equality and is a finite type, and for any two permutations `f` and `g` on `α`, the signature of the product of `f` and `g` is equal to the product of the signatures of `f` and `g` individually. In other words, the sign function is multiplicative over the product of two permutations. This means that the sign of a permutation composed of two others is the product of their signs, which is essentially a property of parity: the composition of two even permutations is even, and the composition of an even and an odd permutation (in any order) is odd.

For any finite type `α` with decidable equality, the sign of the product of two permutations on `α` is equal to the product of their individual signs.


DenseRange.separableSpace

/-- If `α` is a separable space and `f : α → β` is a continuous map with dense range, then `β` is
a separable space as well. E.g., the completion of a separable uniform space is separable.  -/
theorem DenseRange.separableSpace :
    ∀ {α : Type u} {β : Type u_1} [t : TopologicalSpace α] [inst : TopologicalSpace.SeparableSpace α]
      [inst : TopologicalSpace β] {f : α → β}, DenseRange f → Continuous f → TopologicalSpace.SeparableSpace β :=
  by sorry

The theorem states that if `α` is a separable space and if there exists a continuous function `f` from `α` to `β` such that the range of `f` is dense in `β`, then `β` is also a separable space. In other words, the separability of a topological space is preserved under continuous maps with dense range. For example, the completion of a separable uniform space is also separable.

If `α` is a separable topological space and `f: α → β` is a continuous function with a dense range, then `β` is separable.


theorem Ordinal.right_le_opow : ∀ {a : Ordinal.{u_1}} (b : Ordinal.{u_1}), 1 < a → b ≤ a ^ b := by sorry

The theorem `Ordinal.right_le_opow` states that for any well-ordered set `a` and any well-ordered set `b`, if `a` is strictly greater than 1, then `b` is less than or equal to `a` raised to the power `b`. This theorem is defined for well-ordered sets in the same universe `u_1`.

For any well-ordered sets `a` in universe `u_1` with `a > 1` and `b` in the same universe, `b` is less than or equal to `a^b`.


theorem Mathlib.NumberTheory.Divisors._auxLemma.2 : ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) := by sorry

This theorem states that for any two natural numbers `n` and `m`, `m` is an element in the set of natural numbers less than `n` (denoted as `Finset.range n`), if and only if `m` is less than `n`. This is essentially a characterization of the set of natural numbers less than a given natural number.

For any natural numbers `n` and `m`, `m` is in the set of natural numbers less than `n` if and only if `m < n`.


theorem Mathlib.NumberTheory.Divisors._auxLemma.3 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
      (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) :=
  by sorry

This theorem states that for any type `α` equipped with a preorder and a locally finite order, and for any elements `a`, `b`, and `x` of type `α`, `x` is in the finite set of elements that are greater than or equal to `a` and less than `b` (represented as `Finset.Ico a b`), if and only if `x` is greater than or equal to `a` and less than `b`. This result formalizes the idea that membership in the set defined by an interval is equivalent to satisfying the inequalities that define the interval.

For any preorder and locally finite type `α`, an element `x` belongs to the interval `[a, b]` if and only if `a ≤ x` and `x < b`.


/-- `⊤`, coerced to a set, is the whole set of points.  -/
theorem AffineSubspace.top_coe :
    ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P], ↑⊤ = Set.univ :=
  by sorry

The theorem `AffineSubspace.top_coe` states that, for any field `k`, additive commutative group `V`, and module `P` over `k` and `V`, where `V` acts on `P` by addition (making `P` a "torso" under `V`), the top element (denoted by `⊤`) coerced to a set equals the universal set (`Set.univ`). This means that the entirety of `P` is encapsulated by the top affine subspace, when viewed as a set. In other words, when we consider the whole affine subspace, it covers all possible points in our space `P`.

For any additive commutative group `V`, field `k`, and `k`-module `P` with `V` acting on `P` by addition, the top element `⊤` of the affine subspace of `P` coincides with the universal set `Set.univ`.


theorem MeasureTheory.Measure.measurable_dirac :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], Measurable MeasureTheory.Measure.dirac := by sorry

The theorem `MeasureTheory.Measure.measurable_dirac` states that for any type `α` equipped with a measurable space structure, the Dirac measure function is measurable. In mathematical terms, this means that for any set `α` where we can define what it means for a subset to be measurable, the function that assigns to each point in `α` the Dirac measure at that point, is itself a measurable function. This means that the preimage of any measurable set under the Dirac measure function is also a measurable set.

The Dirac measure function, which maps each point in a measurable space to the Dirac measure at that point, is a measurable function.


theorem LocalRing.isField_iff_maximalIdeal_eq :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : LocalRing R], IsField R ↔ LocalRing.maximalIdeal R = ⊥ := by sorry

This theorem states that for any type `R`, under the condition that `R` is equipped with a structure of commutative semiring and that `R` is a local ring, `R` is a field if and only if the maximal ideal of the local ring `R` is trivial, meaning it contains only the zero element. In mathematical terms, for any ring that is operational under addition and multiplication (commutative semiring) and in which there exists one and only one maximal ideal (local ring), that ring is a field (a commutative ring with a multiplicative identity and each non-zero element has a multiplicative inverse) iff the set of elements of the ring that do not have a multiplicative inverse (maximal ideal) only contains the additive identity (zero).

A commutative semiring that is a local ring is a field if and only if its maximal ideal is the trivial ideal.


theorem invOf_mul_self_assoc : ∀ {α : Type u} [inst : Monoid α] (a b : α) [inst_1 : Invertible a], ⅟a * (a * b) = b :=
  by sorry

This theorem states that, for any type `α` that forms a monoid (an algebraic structure with a single, associative binary operation and an identity element), given any elements `a` and `b` of this type, where `a` is invertible, multiplying the inverse of `a` (`⅟a`) with the product of `a` and `b` (`a * b`) is equal to `b`. This theorem leverages the property of monoids where each element has an inverse such that the product of an element and its inverse is the identity element. In other words, `⅟a * a = 1` for any invertible `a`.

For any monoid `α` with invertible element `a`, `a^-1 * (a * b) = b`.


theorem List.monotone_sum_take :
    ∀ {M : Type u_5} [inst : CanonicallyOrderedAddCommMonoid M] (L : List M),
      Monotone fun i => List.sum (List.take i L) :=
  by sorry

The theorem `List.monotone_sum_take` states that for any type `M` which is a canonically ordered additive commutative monoid, and for any list `L` of type `M`, the function that takes an integer `i` and returns the sum of the first `i` elements of `L` (using the function `List.take`) is monotone. In other words, if `i` and `j` are integers such that `i` is less than or equal to `j`, then the sum of the first `i` elements of `L` is less than or equal to the sum of the first `j` elements of `L`. This is a formal way of saying that if you take more terms from the beginning of a list and sum them, you will get a number that is greater or equal to the sum of a lesser number of terms.

For any additive commutative monoid M with a canonical order and any list L of length n in M, the function summing the first i elements of L is monotone, i.e., the sum of the first i elements is less than or equal to the sum of the first j elements for all i ≤ j.


theorem Monotone.seq_pos_lt_seq_of_lt_of_le :
    ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x y : ℕ → α},
      Monotone f →
        ∀ {n : ℕ}, 0 < n → x 0 ≤ y 0 → (∀ k < n, x (k + 1) < f (x k)) → (∀ k < n, f (y k) ≤ y (k + 1)) → x n < y n :=
  by sorry

The theorem `Monotone.seq_pos_lt_seq_of_lt_of_le` states that, for any type `α` which has a preorder, a function `f` from `α` to `α`, and two sequences `x` and `y` of elements of `α` indexed by natural numbers, if `f` is monotone, then under certain conditions, `x n` is less than `y n` for any given natural number `n` greater than `0`. The conditions are: `x 0` is less than or equal to `y 0`; for each `k` less than `n`, `x` at `k+1` is less than `f` applied to `x` at `k`; and for each `k` less than `n`, `f` applied to `y` at `k` is less than or equal to `y` at `k+1`.

If `α` is a type with a preorder, `f` is a monotone function from `α` to `α`, and `x` and `y` are sequences in `α` such that `x 0 ≤ y 0` and for all `k < n`, `x k < f(x k)` and `f(y k) ≤ y k+1`, then `x n < y n` for any `n > 0`.


theorem hausdorffMeasure_of_dimH_lt :
    ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {s : Set X}
      {d : NNReal}, dimH s < ↑d → ↑↑(MeasureTheory.Measure.hausdorffMeasure ↑d) s = 0 :=
  by sorry

This theorem, `hausdorffMeasure_of_dimH_lt`, states that for a set `s` in a space `X`, which is equipped with an eMetric space structure, a measurable space structure, and a Borel space structure, if the Hausdorff dimension of `s` is strictly less than a nonnegative real number `d`, then the Hausdorff measure of `s` with associated dimension `d` is zero. In other words, if the Hausdorff dimension of a set is less than a certain value, the Hausdorff measure of the set at that value reduces to zero.

If a measurable set in a metric space has Hausdorff dimension strictly less than a given number, then its Hausdorff measure with that dimension is zero.


theorem vadd_zero_add :
    ∀ {M : Type u_10} {N : Type u_11} [inst : AddZeroClass N] [inst_1 : VAdd M N] [inst_2 : VAddAssocClass M N N]
      (x : M) (y : N), x +ᵥ 0 + y = x +ᵥ y :=
  by sorry

This theorem, `vadd_zero_add`, states that for any types `M` and `N`, where `N` has an instance of the `AddZeroClass` (meaning it has a zero element and addition operation), and there are vector addition operations (`VAdd`) defined on `M` and `N`, and the vector addition operation is associative (`VAddAssocClass`), then adding the zero element of `N` to the vector sum of an element `x` of `M` and another element `y` of `N` is equivalent to just adding `x` and `y`. In mathematical terms, it's saying that `x +ᵥ 0 + y = x +ᵥ y` for any `x` in `M` and `y` in `N`, where `+ᵥ` represents the vector addition operation.

For types `M` and `N` with `AddZeroClass` instances, and associative vector addition `VAdd` on `M` and `N`, `x +ᵥ (y +ᵥ 0) = x +ᵥ y` for all `x` in `M` and `y` in `N`.


theorem IsLinearMap.isLinearMap_neg :
    ∀ {R : Type u_1} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
      IsLinearMap R fun z => -z :=
  by sorry

This theorem states that for any semiring `R` and any additive commutative group `M` that is also a `R`-module, the function that maps every element `z` of `M` to its negation is a linear map. In mathematical terms, if `M` is a module over the semiring `R`, then the function `f: M -> M` defined by `f(z) = -z` for all `z` in `M` is a linear map.

The negation function on an additive commutative group `M` that is an `R`-module over a semiring `R` is a linear map.


theorem MeasureTheory.Measure.le_restrict_apply :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s t : Set α),
      ↑↑μ (t ∩ s) ≤ ↑↑(μ.restrict s) t :=
  by sorry

The theorem, `MeasureTheory.Measure.le_restrict_apply`, states that for any given type `α`, a measurable space `m0` on `α`, a measure `μ` on the measurable space `α`, and any two sets `s` and `t` of type `α`, the measure of the intersection of sets `t` and `s` is less than or equal to the measure of `t` when `μ` is restricted to `s`. In mathematical terms, this can be written as: `μ(t ∩ s) ≤ (μ restricted to s)(t)`. This theorem basicallly confines the measure to the specified set `s`.

For any measurable space `(α, m0)`, measure `μ` on `α`, and sets `s` and `t` of `α`, we have `μ(t ∩ s) ≤ μ(s)(t)`.


theorem Finset.coe_cons : ∀ {α : Type u_1} {a : α} {s : Finset α} {h : a ∉ s}, ↑(Finset.cons a s h) = insert a ↑s := by
  sorry

The theorem `Finset.coe_cons` states that for all types `α`, elements `a` of type `α`, and for all finite sets `s` of type `α` where `a` does not belong to `s`, the Coercion of the finite set created by the "cons" operation, which adds `a` to `s`, is equal to the set obtained by inserting `a` into the Coercion of `s`. In mathematical terms, this means that the operation of adding an element to a finite set in Lean 4 (using `Finset.cons`) is equivalent to the operation of inserting an element into the set (using `insert`) in the context of set theory.

For all types `α` and finite sets `s` of `α` not containing `a` in `α`, the coercion of `Finset.cons a s` equals the coercion of `insert a s`.


theorem Finset.subset_iff : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁ ⊆ s₂ ↔ ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ := by sorry

This theorem, `Finset.subset_iff`, states that for all sets `s₁` and `s₂` of a certain type `α`, `s₁` is a subset of `s₂` if and only if for any element `x` of type `α`, if `x` is in `s₁` then `x` must also be in `s₂`. This theorem is defining the subset relationship in terms of individual element membership in the sets.

A set `s₁` is a subset of set `s₂` if and only if every element in `s₁` is also an element of `s₂`.


theorem CategoryTheory.ShortComplex.rightHomologyι_descOpcycles_π_eq_zero_of_boundary :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) {A : C} (k : S.X₂ ⟶ A)
      [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S] (x : S.X₃ ⟶ A)
      (hx : k = CategoryTheory.CategoryStruct.comp S.g x),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyι S)
          (CategoryTheory.ShortComplex.descOpcycles S k ⋯) =
        0 :=
  by sorry

This theorem is a statement in a category theory context. It declares that for any type `C` within a category that has zero morphisms, and given a short complex `S` of type `C`, if there exists a morphism `k` from `S.X₂` to another object `A`, and another morphism `x` from `S.X₃` to `A` such that `k` is the composition of `S.g` and `x`, then the composition of `CategoryTheory.ShortComplex.rightHomologyι S` and `CategoryTheory.ShortComplex.descOpcycles S k` is a zero morphism.

In other words, this theorem is about the composition of two specific morphisms in a category, and states that under certain conditions, the composition of these two morphisms is the zero morphism. This theorem is a key result in the theory of short complexes in category theory, which is a fundamental construct in algebraic topology and homological algebra.

Given a short complex in a category with zero morphisms, if there exist morphisms `k` and `x` such that `k = g × x` and `k` factors through `x`, then the composition of the right homology invariant and the descendant cycle map with respect to `k` is the zero morphism.


theorem MeasureTheory.Memℒp.mono_measure :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ ν : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] {f : α → E}, ν ≤ μ → MeasureTheory.Memℒp f p μ → MeasureTheory.Memℒp f p ν :=
  by sorry

The theorem `MeasureTheory.Memℒp.mono_measure` states that for any types `α` and `E`, any measurable space `m0` on `α`, any extended nonnegative real number `p`, and any two measures `μ` and `ν` on `α`, if `ν` is less than or equal to `μ` (in the sense of measures), then if the function `f` from `α` to `E` belongs to the space `L^p(μ)` (i.e., `f` is almost everywhere strongly measurable and `(∫ ‖f a‖^p dμ)^(1/p)` is finite if `p < ∞`, or the essential supremum of `f` is finite if `p = ∞`), then `f` also belongs to the space `L^p(ν)`. This theorem is a kind of monotonicity property of the `L^p` spaces with respect to the underlying measure.

If `μ` is a measure larger than or equal to `ν` on a measurable space `(α, ℒ)` and `f` is an `L^p(μ)` function, then `f` is also an `L^p(ν)` function.


theorem EMetric.exists_real_pos_lt_infEdist_of_not_mem_closure :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {E : Set α},
      x ∉ closure E → ∃ ε, 0 < ε ∧ ENNReal.ofReal ε < EMetric.infEdist x E :=
  by sorry

The theorem `EMetric.exists_real_pos_lt_infEdist_of_not_mem_closure` states that for any type `α` equipped with a pseudo-emetric space structure, and for any element `x` of type `α` and any set `E` of type `α`, if `x` is not in the closure of `E`, then there exists a real number `ε` such that `ε` is greater than zero and the extended non-negative real number corresponding to `ε` is less than the infimum extended distance from `x` to `E`. In simpler terms, if a point is not in the closure of a set, then there is a positive distance between the point and the set.

If `α` is a pseudo-metric space, `x` is not in the closure of `E ⊆ α`, then there exists `ε > 0` such that inf{d(x, y) : y ∈ E} > ε.


theorem zpow_bit1_nonpos_iff : ∀ {α : Type u_1} [inst : LinearOrderedField α] {a : α} {n : ℤ}, a ^ bit1 n ≤ 0 ↔ a ≤ 0 :=
  by sorry

The theorem `zpow_bit1_nonpos_iff` states that for any type `α` which is an instance of `LinearOrderedField`, and for any elements `a` of type `α` and `n` of type `ℤ` (integer), `a` raised to the power `bit1 n` (which is `2*n + 1`) is less than or equal to zero if and only if `a` itself is less than or equal to zero.

For any `α` an instance of `LinearOrderedField` and `a : α` and `n : ℤ`, `a^(2*n+1) ≤ 0` if and only if `a ≤ 0`.


IsGenericPoint.mem

theorem IsGenericPoint.mem :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {S : Set α}, IsGenericPoint x S → x ∈ S := by sorry

This theorem states that for any type `α` equipped with a topological space structure, any point `x` of type `α`, and any set `S` of elements of type `α`, if `x` is a generic point of `S`, then `x` is an element of `S`. Here, a point `x` being generic means that the closure of the singleton set containing `x` equals `S`. In mathematical notation, this is saying that if `S` is the closure of `{x}`, then `x` belongs to `S`.

If a point is the generic element of a set in a topological space, then it belongs to that set.


theorem Finset.prod_eq_one_iff_of_one_le' :
    ∀ {ι : Type u_1} {N : Type u_5} [inst : OrderedCommMonoid N] {f : ι → N} {s : Finset ι},
      (∀ i ∈ s, 1 ≤ f i) → ((Finset.prod s fun i => f i) = 1 ↔ ∀ i ∈ s, f i = 1) :=
  by sorry

The theorem `Finset.prod_eq_one_iff_of_one_le'` states that for any type `ι`, any ordered commutative monoid `N`, any function `f` from `ι` to `N`, and any finite set `s` of type `ι`, if all elements `i` of `s` satisfy the condition `1 ≤ f i` (i.e., the value of the function `f` at `i` is greater than or equal to 1), then the product of all the function values `f i` for `i` in `s` is equal to 1 if and only if all the function values `f i` for `i` in `s`, are equal to 1. In mathematical terms, it says that if $\forall i \in s, 1 \leq f(i)$, then $\prod_{i \in s} f(i) = 1 \iff \forall i \in s, f(i) = 1$.

For any ordered commutative monoid N, function f from a finite set ι to N with 1 ≤ fi for all i ∈ ι, if and only if all fi are equal to 1, then the product of all fi is equal to 1.


theorem MeasureTheory.StronglyMeasurable.integral_kernel_prod_right' :
    ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
      {κ : ↥(ProbabilityTheory.kernel α β)} {E : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : CompleteSpace E] [inst_3 : ProbabilityTheory.IsSFiniteKernel κ] ⦃f : α × β → E⦄,
      MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable fun x => ∫ (y : β), f (x, y) ∂κ x :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.integral_kernel_prod_right'` states that for any types `α`, `β`, `E`, given the measurable spaces `mα` and `mβ` on `α` and `β` respectively, a probability kernel `κ` from `α` to `β`, and a function `f` from the product space `α × β` to `E` (where `E` is a complete normed additive commutative group and also a normed space over the real numbers), if `f` is strongly measurable (i.e., it is the limit of simple functions), then the function that maps each element `x` of `α` to the integral over `β` of `f` applied to the pair `(x, y)`, with respect to the measure `κ x`, is also strongly measurable. A kernel `κ` is said to be `ProbabilityTheory.IsSFiniteKernel` if it is sigma-finite, which means that the space can be partitioned into a countable union of measurable sets with finite measure.

If `α`, `β`, `E` are types, `mα` and `mβ` are measurable spaces, `κ` is a probability kernel from `α` to `β`, `f : α × β → E` is a strongly measurable function, and `κ` is sigma-finite, then the function `x ↦ ∫ₐβ f(x, y) d(κ x)` is strongly measurable.


theorem Primrec₂.const :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] (x : σ), Primrec₂ fun x_1 x_2 => x :=
  by sorry

The theorem `Primrec₂.const` states that for any types `α`, `β`, and `σ` which have a `Primcodable` instance, and for any specific value `x` of type `σ`, the function that ignores its two inputs of types `α` and `β` and always returns the constant `x` is a binary primitive recursive function. This simply means that constant functions are considered primitive recursive regardless of the types of their inputs.

For any types `α`, `β`, and `σ` with `Primcodable` instance, and any constant function `f : σ -> α -> β -> σ`, the function `f _ _ = x` is primitive recursive.


IsIdempotentElem.one

theorem IsIdempotentElem.one : ∀ {M₁ : Type u_5} [inst : MulOneClass M₁], IsIdempotentElem 1 := by sorry

This theorem states that, for any type `M₁` that is endowed with a multiplication and identity element (`MulOneClass M₁`), the number 1 is an idempotent element. In other words, when 1 is multiplied by itself, the result is 1. This is expressed mathematically as `1 * 1 = 1`.

For any type `M₁` with multiplication and identity element, the identity element 1 is idempotent, i.e., `1 * 1 = 1`.


/-- Any matrix `A` can be expressed as the evaluation of `Matrix.mvPolynomialX`.

This is of particular use when `MvPolynomial (m × n) R` is an integral domain but `S` is
not, as if the `MvPolynomial.eval₂` can be pulled to the outside of a goal, it can be solved in
under cancellative assumptions.  -/
theorem Matrix.mvPolynomialX_map_eval₂ :
    ∀ {m : Type u_1} {n : Type u_2} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
      (f : R →+* S) (A : Matrix m n S),
      Matrix.map (Matrix.mvPolynomialX m n R) (MvPolynomial.eval₂ f fun p => A p.1 p.2) = A :=
  by sorry

This theorem states that any given matrix `A` can be expressed as the evaluation of `Matrix.mvPolynomialX` using the `MvPolynomial.eval₂` function. In particular, this is useful when `MvPolynomial (m × n) R` is an integral domain but `S` is not. In such scenarios, if `MvPolynomial.eval₂` can be pulled to the outer layer of a goal, it can assist with solving the goal under cancellative assumptions. Specifically, for any commutative semirings `R` and `S`, a ring homomorphism from `R` to `S`, and a matrix `A` with elements in `S`, the theorem verifies that mapping the function `MvPolynomial.eval₂` to `Matrix.mvPolynomialX` yields the original matrix `A`.

For any commutative semirings R and S, a ring homomorphism from R to S, and a matrix A with elements in S, the evaluation of `Matrix.mvPolynomialX` using `MvPolynomial.eval₂` equals matrix A.


/-- `b.toMatrix b'` and `b'.toMatrix b` are inverses.  -/
theorem Basis.toMatrix_mul_toMatrix_flip :
    ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (b : Basis ι R M) (b' : Basis ι' R M) [inst_3 : DecidableEq ι] [inst_4 : Fintype ι'],
      Basis.toMatrix b ⇑b' * Basis.toMatrix b' ⇑b = 1 :=
  by sorry

The theorem `Basis.toMatrix_mul_toMatrix_flip` states that for any commutative semiring `R`, additive commutative monoid `M`, `R`-module `M`, basis `b` of type `ι`, basis `b'` of type `ι'`, given a decision procedure for equality on `ι` and that `ι'` is a finite type, the matrix representation `b.toMatrix b'` of basis `b'` in terms of basis `b` and the matrix representation `b'.toMatrix b` of basis `b` in terms of basis `b'` are inverses. In other words, multiplying these two matrix representations yields the identity matrix.

For any commutative semiring `R`, additive commutative monoid `M`, `R`-module `M`, finite types `ι` and `ι'`, bases `b` and `b'` of `ι` and `ι'` respectively, if there exists a decision procedure for equality on `ι` and `ι'`, then `b'.toMatrix b` and `b.toMatrix b'` are inverses.


theorem MeasureTheory.condexp_condexp_of_le :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {f : α → F'} {m₁ m₂ m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
      m₁ ≤ m₂ →
        ∀ (hm₂ : m₂ ≤ m0) [inst_3 : MeasureTheory.SigmaFinite (μ.trim hm₂)],
          MeasureTheory.condexp m₁ μ (MeasureTheory.condexp m₂ μ f) =ᶠ[MeasureTheory.Measure.ae μ]
            MeasureTheory.condexp m₁ μ f :=
  by sorry

The theorem `MeasureTheory.condexp_condexp_of_le` states that for any types `α` and `F'` with `F'` a complete normed addition-commutative group with a `ℝ` normed space structure, and any function `f` from `α` to `F'`, given three measurable spaces `m₁`, `m₂`, and `m0`, and a measure `μ` on `α`, if `m₁` is a sub-σ-algebra of `m₂`, and `m₂` is also a sub-σ-algebra of `m0` such that `μ` is σ-finite with respect to the trimmed measure space `m₂`, the conditional expectation of the conditional expectation of `f` on `m₁` with respect to `μ` is almost everywhere (with respect to the measure `μ`) equal to the conditional expectation of `f` on `m₁` with respect to `μ`. This essentially says that we can "pull back" the conditional expectation through another conditional expectation under these conditions, and the result will still be equal almost everywhere to the original conditional expectation.

For measurable spaces `m₁`, `m₂`, and `m0`, and a σ-finite measure `μ` on a complete normed additive-commutative group `F'`, if `m₁` is a sub-σ-algebra of both `m₂` and `m0`, and `f` is a function from a type `α` to `F'`, then the conditional expectation of the conditional expectation of `f` with respect to `μ` and `m₂` is almost everywhere equal to the conditional expectation of `f` with respect to `μ` and `m₁`.


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

This theorem states that for any type `α` and for any three lists `l₁`, `l₂`, and `l₃` of type `α`, `l₂` is a suffix of the concatenation of `l₁`, `l₂`, and `l₃`. In mathematical terms, if you append `l₂` and `l₃` to the end of `l₁`, `l₂` will always be a part of the resulting list starting from some point towards the end.

For any type `α` and lists `l₁`, `l₂`, `l₃` of type `α`, `l₂` is a suffix of the concatenation of `l₁` and `l₃`.


theorem Equiv.refl_symm : ∀ {α : Sort u}, (Equiv.refl α).symm = Equiv.refl α := by sorry

The theorem `Equiv.refl_symm` states that for any type `α`, the symmetric (or inverse) of the identity equivalence on `α` (denoted by `Equiv.refl α`) is the same as the identity equivalence on `α` itself. In other words, the inverse of the identity function is the identity function itself for any given type.

For any type α, the symmetric equivalence Equiv.refl α equals the identity equivalence on α.


theorem Finset.one_lt_card : ∀ {α : Type u_1} {s : Finset α}, 1 < s.card ↔ ∃ a ∈ s, ∃ b ∈ s, a ≠ b := by sorry

This theorem states that for any finite set `s` of some type `α`, the cardinality of `s` is greater than one if and only if there exist two distinct elements `a` and `b` in `s`. In other words, a set has more than one element if and only if it contains at least two elements that are not the same.

A finite set `s` of type `α` has cardinality greater than one if and only if there exist distinct elements `a` and `b` in `s`.


theorem pow_eq_one_iff :
    ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : LinearOrder M]
      [inst_2 : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {x : M} {n : ℕ},
      n ≠ 0 → (x ^ n = 1 ↔ x = 1) :=
  by sorry

This theorem states that for any type `M` with the structures of a monoid and a linear order, and the covariant class property (indicating that multiplication is monotonically increasing), for any element `x` of `M` and any natural number `n` not equal to zero, the statement "`x` to the power of `n` equals 1" is logically equivalent to "`x` equals 1". In other words, in such a structure, the only way for a non-zero power of `x` to equal 1 is if `x` itself is 1.

For any monoid with a covariant linear order structure where multiplication is monotonic, the power `x^n` equals 1 if and only if `x` equals 1.


theorem IsLocallyConstant.iff_continuous :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {x : TopologicalSpace Y} [inst_1 : DiscreteTopology Y]
      (f : X → Y), IsLocallyConstant f ↔ Continuous f :=
  by sorry

This theorem states that for any function `f` from a topological space `X` to another topological space `Y` (where `Y` has a discrete topology), `f` is locally constant if and only if `f` is a continuous function. In other words, a function between topological spaces is locally constant (i.e., the preimage of any set is open) if and only if it is continuous, given that the codomain has a discrete topology.

A function from a topological space to a discrete topological space is locally constant if and only if it is continuous.


theorem Embedding.t3Space :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T3Space Y]
      {f : X → Y}, Embedding f → T3Space X :=
  by sorry

The theorem states that for any two types `X` and `Y`, each with an associated topological space, and given `Y` is a T3 space (also known as a regular T1 space, which means any two disjoint closed sets can be separated by two disjoint open sets), if there exists an embedding function `f` from `X` to `Y` (that is, `f` is injective and the topology on `X` is the initial topology with respect to `f` and the topology on `Y`), then `X` is also a T3 space.

If `X` and `Y` are types with topologies, `Y` is a T3 space, and there exists an embedding `f : X ↪ Y`, then `X` is also a T3 space.


theorem Real.Angle.coe_nsmul : ∀ (n : ℕ) (x : ℝ), ↑(n • x) = n • ↑x := by sorry

This theorem states that for any natural number `n` and any real number `x`, the real number representation of `n` multiplied by `x` is equal to `n` multiplied by the real number representation of `x`. In other words, it asserts that the process of scalar multiplication can be interchanged with the process of converting between natural numbers and real numbers. This is a property of the embedding of natural numbers into the reals.

For any natural number `n` and real number `x`, the conversion of `n` to a real number and multiplication by `x` is equal to multiplication by `x` of the real number representation of `n`.


theorem Cardinal.one_lt_iff_nontrivial : ∀ {α : Type u}, 1 < Cardinal.mk α ↔ Nontrivial α := by sorry

This theorem states that for any type `α`, the cardinality of `α` is greater than 1 if and only if `α` is nontrivial. Here, a nontrivial type is one that has at least two distinct elements. In the context of cardinality, this means that there are at least two distinguishable "sizes" or "amounts" within the type. This is expressed mathematically as $1 < |α|$ if and only if `α` is nontrivial.

For any type `α`, the cardinality `|α|` is greater than 1 if and only if `α` has at least two distinct elements.


theorem Set.isSimpleOrder_Iic_iff_isAtom :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsSimpleOrder ↑(Set.Iic a) ↔ IsAtom a := by
  sorry

This theorem states that for any partially ordered type `α` that also has a bottom element, and for any element `a` of type `α`, the condition of the interval from negative infinity to `a` (inclusive) being a simple order is equivalent to the element `a` being an atom. In the context of ordered types, a simple order is an order with no elements in between, and an atom is an element with no other element between it and the bottom element, and it itself is not the bottom element. Essentially, this theorem connects the properties of an individual element and the order structure on the entire interval leading up to that element.

For any partially ordered type with a bottom element, an element is an atom if and only if the interval from negative infinity to that element forms a simple order.


theorem Finset.mem_cons_self : ∀ {α : Type u_1} (a : α) (s : Finset α) {h : a ∉ s}, a ∈ Finset.cons a s h := by sorry

The theorem `Finset.mem_cons_self` states that for any type `α`, any element `a` of type `α`, and any finite set `s` of elements of type `α`, if `a` is not an element of `s`, then `a` is an element of the finite set that results from the operation `Finset.cons a s h`. The `Finset.cons` operation creates a new finite set by adding the element `a` to the set `s`. Here, `h` is the proof that `a` is not in `s`. Therefore, this theorem essentially states that an element is in the set that results from adding it to another set.

If `a` is not an element of finite set `s`, then `a` is an element of the set obtained by adding `a` to `s`.


theorem ENNReal.top_ne_coe : ∀ {r : NNReal}, ⊤ ≠ ↑r := by sorry

This theorem states that for any nonnegative real number `r`, the extended nonnegative real number representation of `r` (denoted by `↑r`) is never equal to infinity (denoted by `⊤`). In other words, no matter what nonnegative real number we choose, its corresponding extended nonnegative real number is always finite.

For all non-negative real numbers r, ↑r ≠ ⊤.


CauSeq.bounded'

theorem CauSeq.bounded' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] (f : CauSeq β abv) (x : α), ∃ r > x, ∀ (i : ℕ), abv (↑f i) < r :=
  by sorry

This theorem states that for any Cauchy sequence `f` of type `β` with respect to an absolute value function `abv`, and for any arbitrary number `x` of type `α`, there exists a number `r` greater than `x` such that the absolute value of the `i`-th term of the sequence `f` is less than `r` for all natural numbers `i`. In other words, every term of the Cauchy sequence `f` is bounded above by some number `r` that is greater than a given number `x`.

For any Cauchy sequence `f` of type `β` with respect to an absolute value function `abv`, and for any `x` of type `α`, there exists a number `r > x` such that `|f i| < r` for all natural numbers `i`.


theorem List.dlookup_kerase_ne :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a a' : α} {l : List (Sigma β)},
      a ≠ a' → List.dlookup a (List.kerase a' l) = List.dlookup a l :=
  by sorry

This theorem states that for any types `α` and `β`, assuming `α` has decidable equality, for any elements `a` and `a'` of type `α` and any list `l` of pairs where the first element is of type `α` and the second element's type depends on the first element, if `a` and `a'` are not equal, then looking up the element `a` in the list `l` after removing the first pair with key `a'` yields the same result as looking up `a` in the original list `l`. In other words, removing a pair with a different key does not affect the result of looking up `a`.

Given types `α` with decidable equality, lists `l` of pairs `(α × β)` such that the first component is of type `α`, and elements `a` and `a'` of type `α`, if `a ≠ a'`, then looking up `a` in list `l` after removing the first pair with key `a'` is equal to looking up `a` in the original list `l`.


/-- Urysohn's lemma: if `s` and `t` are two disjoint closed sets in a normal topological space `X`,
then there exists a continuous function `f : X → ℝ` such that

* `f` equals zero on `s`;
* `f` equals one on `t`;
* `0 ≤ f x ≤ 1` for all `x`.
 -/
theorem exists_continuous_zero_one_of_isClosed :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : NormalSpace X] {s t : Set X},
      IsClosed s →
        IsClosed t → Disjoint s t → ∃ f, Set.EqOn (⇑f) 0 s ∧ Set.EqOn (⇑f) 1 t ∧ ∀ (x : X), f x ∈ Set.Icc 0 1 :=
  by sorry

Urysohn's Lemma states that given a normal topological space `X` and two disjoint closed sets `s` and `t` within that space, there exists a continuous function `f` from `X` to the real numbers with the following properties:

- `f` equals zero for all points in set `s`;
- `f` equals one for all points in set `t`;
- For all points `x` in the topological space `X`, the value of `f(x)` lies in the closed interval from 0 to 1, inclusive.

In other words, we can always find a function that smoothly transitions from 0 to 1 across the space, separating the two sets.

Given a normal topological space and two disjoint closed sets, there exists a continuous function mapping every point in the first set to 0, every point in the second set to 1, and with values in between for all other points.