theorem CategoryTheory.Arrow.iso_w' :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {W X Y Z : T} {f : W ⟶ X} {g : Y ⟶ Z}
      (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g),
      g = CategoryTheory.CategoryStruct.comp e.inv.left (CategoryTheory.CategoryStruct.comp f e.hom.right) :=
  by sorry

This theorem, `CategoryTheory.Arrow.iso_w'`, in category theory states that for any category `T` and any four objects `W, X, Y, Z` in `T` with morphisms `f: W ⟶ X` and `g: Y ⟶ Z`, if we have an isomorphism `e` between the arrows (which are simply morphisms in `T`) created by `f` and `g`, then `g` can be obtained by first applying the inverse of the left morphism of `e` and then applying the right morphism of `e` to `f`. In other words, `g` is the composition of `e.inv.left` and the composition of `f` and `e.hom.right`.

If `f: W ⟶ X`, `g: Y ⟶ Z` are morphisms in a category `T` and `e: f ≅ g` is an isomorphism, then `g = e.inv.left ∘ (f ∘ e.hom.right)`.


theorem Nat.ofDigits_one : ∀ (L : List ℕ), Nat.ofDigits 1 L = List.sum L := by sorry

This theorem states that for any list `L` of natural numbers, when the list is interpreted as the little-endian digits in base `1` using the function `Nat.ofDigits`, the result is the same as the sum of the numbers in the list `L` as computed by the `List.sum` function. In other words, when the base is `1`, the value of a number represented by a list of digits is simply the sum of the digits.

For any list of natural numbers `L`, the sum of the numbers in `L` equals the number represented by `L` as little-endian digits in base 1, using the function `Nat.ofDigits`.


theorem Commute.smul_right :
    ∀ {M : Type u_1} {α : Type u_6} [inst : SMul M α] [inst_1 : Mul α] [inst_2 : SMulCommClass M α α]
      [inst_3 : IsScalarTower M α α] {a b : α}, Commute a b → ∀ (r : M), Commute a (r • b) :=
  by sorry

This theorem, `Commute.smul_right`, states that for any types `M` and `α` with defined scalar multiplication and multiplication, given that the scalar multiplication commutes with the multiplication and the scalar multiplication satisfies the scalar tower property, if two elements `a` and `b` of type `α` commute (i.e., `a * b = b * a`), then for any scalar `r` of type `M`, `a` commutes with the scalar multiplication of `r` and `b` (i.e., `a * (r • b) = (r • b) * a`).

If `α` is a type with defined scalar multiplication and multiplication, and scalar multiplication commutes with multiplication and satisfies the scalar tower property, then for all `a, b ∈ α` with `a * b = b * a`, we have `a * (r • b) = (r • b) * a` for any scalar `r ∈ M`.


theorem Set.einfsep_pos_of_finite :
    ∀ {α : Type u_1} [inst : EMetricSpace α] {s : Set α} [inst_1 : Finite ↑s], 0 < Set.einfsep s := by sorry

The theorem `Set.einfsep_pos_of_finite` states that for any set `s` of a given type `α`, where `α` is an extended metric space and the set `s` is finite, the "extended infimum separation" of that set `s` is strictly greater than 0. The "extended infimum separation", denoted by `Set.einfsep s`, is defined as the infimum of the extended distances between all distinct pairs of elements from the set. In simpler terms, the theorem claims that in a finite set within an extended metric space, the smallest distance between any two distinct points is always a positive number.

In an extended metric space, the extended infimum separation of any finite set is positive.


theorem Set.mem_union_right : ∀ {α : Type u} {x : α} {b : Set α} (a : Set α), x ∈ b → x ∈ a ∪ b := by sorry

The theorem `Set.mem_union_right` states that for any type `α`, any element `x` of type `α`, and any sets `a` and `b` of elements of type `α`, if `x` is a member of the set `b`, then `x` is also a member of the union of sets `a` and `b`. Here, the union of two sets (denoted as `a ∪ b`) is the set containing all elements that are in `a`, in `b`, or in both.

If `x` is an element of set `b`, then `x` is an element of the set `a ∪ b`.


/-- **Alias** of `ssubset_of_subset_not_subset`. -/
theorem HasSubset.Subset.ssubset_of_not_subset :
    ∀ {α : Type u} [inst : HasSubset α] [inst_1 : HasSSubset α]
      [inst_2 : IsNonstrictStrictOrder α (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1] {a b : α},
      a ⊆ b → ¬b ⊆ a → a ⊂ b :=
  by sorry

This theorem, also known as an alias of `ssubset_of_subset_not_subset`, states that for any types `α` where `α` has both a subset and strict subset relationship, and where the subset relationship is a non-strict strict order, if `a` is a subset of `b` and `b` is not a subset of `a`, then `a` is a strict subset of `b`.

If $A$ is a subset of $B$ and $B$ is not a subset of $A$, then $A$ is a proper subset of $B$.


/-- If an integral domain has a primitive `k`-th root of unity, then it has `φ k` of them.  -/
theorem IsPrimitiveRoot.card_primitiveRoots :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R} {k : ℕ},
      IsPrimitiveRoot ζ k → (primitiveRoots k R).card = Nat.totient k :=
  by sorry

This theorem states that for any integral domain `R` that has a `k`-th root of unity, denoted as `ζ`, where `ζ` is a primitive root of `k`, the number of primitive `k`-th roots of unity in `R` is equal to the Euler's totient function of `k`. In other words, if `ζ` is a primitive `k`-th root of unity in an integral domain `R`, then `R` contains exactly `φ(k)` such primitive roots, where `φ` is the Euler's totient function. This function `φ(k)` counts the number of integers strictly less than `k` that are coprime with `k`.

In an integral domain with a primitive k-th root of unity, the number of such roots is equal to the Euler totient function of k.


theorem CategoryTheory.IsCoreflexivePair.common_retraction :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B)
      [inst_1 : CategoryTheory.IsCoreflexivePair f g],
      ∃ s,
        CategoryTheory.CategoryStruct.comp f s = CategoryTheory.CategoryStruct.id A ∧
          CategoryTheory.CategoryStruct.comp g s = CategoryTheory.CategoryStruct.id A :=
  by sorry

This theorem, `CategoryTheory.IsCoreflexivePair.common_retraction`, states that for any category `C` of a certain type `u` and for any two objects `A` and `B` in `C`, given two morphisms `f` and `g` from `A` to `B` such that `f` and `g` form a coreflexive pair, there exists a morphism `s` such that the composition of `f` with `s` equals the identity on `A` and, similarly, the composition of `g` with `s` equals the identity on `A`. In other words, `s` is a common retraction of `f` and `g` in the category `C`.

For any category `C` and objects `A`, `B` in `C`, if morphisms `f` and `g` from `A` to `B` form a coreflexive pair, then there exists a morphism `s` making both `fs = id_A` and `gs = id_A` in `C`.


theorem Nat.lt_succ_sqrt : ∀ (n : ℕ), n < Nat.succ (Nat.sqrt n) * Nat.succ (Nat.sqrt n) := by sorry

This theorem states that for any natural number `n`, `n` is strictly less than the square of the successor of the integer square root of `n`. In mathematical terms, for any natural number `n`, we have `n < (sqrt(n) + 1)^2`. This is using the integer square root function `Nat.sqrt`, which is implemented using Newton's method and takes a natural number as input. The successor function `Nat.succ` increments a natural number by one.

For every natural number `n`, `n` is strictly less than the square of the successor of the integer square root of `n`. In mathematical notation, `n < (1 + sqrt n)²`.


theorem Cardinal.ord_isLimit : ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → Ordinal.IsLimit (Cardinal.ord c) := by
  sorry

The theorem `Cardinal.ord_isLimit` states that for any cardinal `c` (from any type universe `u_1`), if `c` is greater than or equal to `ℵ₀` (the smallest infinite cardinal), then the ordinal corresponding to `c` is a limit ordinal. A limit ordinal is an ordinal which is not zero and not a successor. This theorem essentially links the concept of cardinality with ordinals, particularly in the context of infinite sets.

For any cardinal `c` greater than or equal to `ℵ₀`, the ordinal corresponding to `c` is a limit ordinal.


theorem IsIntegrallyClosed.isIntegral_iff :
    ∀ {R : Type u_1} [inst : CommRing R] [iic : IsIntegrallyClosed R] {K : Type u_3} [inst_1 : CommRing K]
      [inst_2 : Algebra R K] [ifr : IsFractionRing R K] {x : K}, IsIntegral R x ↔ ∃ y, (algebraMap R K) y = x :=
  by sorry

This theorem, `IsIntegrallyClosed.isIntegral_iff`, establishes a condition under which an element `x` of a field of fractions `K` of an integrally closed integral domain `R` is integral over `R`. Specifically, an element `x` is integral over `R` if and only if there exists an element `y` in `R` such that the algebraic embedding of `y` into `K` (given by the `algebraMap` function) equals `x`. In other words, `x` is a root of some monic polynomial with coefficients in `R` if and only if `x` can be obtained by embedding some element of `R` into `K`.

An element $x$ in the field of fractions $K$ of an integrally closed integral domain $R$ is integral over $R$ if and only if there exists an element $y$ in $R$ such that $x$ is the algebraic image of $y$ in $K$.


theorem IsCompact.mul_closedBall_one :
    ∀ {E : Type u_1} [inst : SeminormedCommGroup E] {δ : ℝ} {s : Set E},
      IsCompact s → 0 ≤ δ → s * Metric.closedBall 1 δ = Metric.cthickening δ s :=
  by sorry

This theorem states that for any set `s` of elements from a seminormed commutative group `E`, given a non-negative real number `δ`, if `s` is a compact set, then the product of `s` and the closed ball centered at `1` with radius `δ`, which consists of all the points in `E` whose distance from `1` is less than or equal to `δ`, is exactly the closed `δ`-thickening of `s`. Here, the closed `δ`-thickening of `s` is defined as the set of all points in `E` that are at most `δ` away from `s` in terms of the infimum extended metric distance.

For a compact set `s` in a seminormed commutative group `E` and a non-negative real number `δ`, the product of `s` and the closed ball with radius `δ` centered at `1` equals the closed `δ`-thickening of `s` in terms of the infimum extended metric distance.


Prod.mk.inj

theorem Prod.mk.inj :
    ∀ {α : Type u} {β : Type v} {fst : α} {snd : β} {fst_1 : α} {snd_1 : β},
      (fst, snd) = (fst_1, snd_1) → fst = fst_1 ∧ snd = snd_1 :=
  by sorry

This theorem, `Prod.mk.inj`, states that for any two pairs of types `(α, β)` and `(α, β)`, if a pair `(fst, snd)` is equal to another pair `(fst_1, snd_1)`, then the first element `fst` is equal to the first element `fst_1` of the second pair and the second element `snd` is equal to the second element `snd_1` of the second pair. In other words, it asserts that if two pairs are equal, their corresponding elements are also equal.


Squarefree.isRadical

theorem Squarefree.isRadical :
    ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [inst_1 : DecompositionMonoid R] {x : R},
      Squarefree x → IsRadical x :=
  by sorry

The theorem `Squarefree.isRadical` states that for any commutative monoid with zero `R` with the structure of a decomposition monoid, every squarefree element `x` in `R` is also radical. In other words, if an element `x` in `R` is such that the only squares that divide it are the squares of units, then `x` also has the property that it divides any element `y` if it divides a power of `y`.

In a commutative monoid with zero endowed with a decomposition structure, every squarefree element is radical.


theorem EuclideanDomain.mul_div_assoc :
    ∀ {R : Type u} [inst : EuclideanDomain R] (x : R) {y z : R}, z ∣ y → x * y / z = x * (y / z) := by sorry

This theorem, named `EuclideanDomain.mul_div_assoc`, asserts a specific property of division in the context of Euclidean Domains. Specifically, for any type `R` that forms a Euclidean Domain, and for any variables `x`, `y`, and `z` of type `R`, if `z` divides `y` then the result of first multiplying `x` and `y` and then dividing by `z` is equal to the result of first dividing `y` by `z` and then multiplying the result by `x`. In mathematical notation, `x * y / z = x * (y / z)` whenever `z` divides `y`.

For any Euclidean Domain `R` and elements `x, y, z` in `R`, if `z` divides `y`, then `x * (y / z) = (x * y) / z`.


CategoryTheory.ShortComplex.Hom.ext

theorem CategoryTheory.ShortComplex.Hom.ext :
    ∀ {C : Type u_1} {inst : CategoryTheory.Category.{u_3, u_1} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
      {S₁ S₂ : CategoryTheory.ShortComplex C} (x y : CategoryTheory.ShortComplex.Hom S₁ S₂),
      x.τ₁ = y.τ₁ → x.τ₂ = y.τ₂ → x.τ₃ = y.τ₃ → x = y :=
  by sorry

This theorem states that in a category `C` that has zero morphisms, given any two short complexes `S₁` and `S₂`, if two morphisms `x` and `y` from `S₁` to `S₂` have equal components `τ₁`, `τ₂`, and `τ₃`, then the morphisms `x` and `y` are identical. In other words, a morphism in a short complex is uniquely determined by its components `τ₁`, `τ₂`, and `τ₃`.

In a category with zero morphisms, two morphisms between short complexes have equal components if and only if they are identical.


theorem Set.finite_univ_iff : ∀ {α : Type u}, Set.Finite Set.univ ↔ Finite α := by sorry

This theorem states that, for any type `α`, the universal set `Set.univ` of `α` is finite if and only if the type `α` itself is finite. In other words, there exists a natural number `n` and an equivalence between `Set.univ` and `Fin n` if and only if such an `n` and equivalence exist for `α`. This tells us that the finiteness property is preserved between a type and its associated universal set.

The universal set of a type is finite if and only if the type itself is finite.


theorem AddLocalization.induction_on₂ :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → AddLocalization S → Prop}
      (x y : AddLocalization S),
      (∀ (x y : M × ↥S), p (AddLocalization.mk x.1 x.2) (AddLocalization.mk y.1 y.2)) → p x y :=
  by sorry

The theorem `AddLocalization.induction_on₂` states that for a given additive commutative monoid `M` and a submonoid `S` of `M`, if a property `p` holds for any two equivalence classes that are generated by `AddLocalization.mk` from pairs of elements in `M` and `S`, then the same property `p` holds for any two elements in the localization of `M` at `S`. In other words, this theorem provides a principle of induction for proving properties about pairs of elements in the localization.

Given an additive commutative monoid `M` and a submonoid `S`, if a property `p` holds for any pair of elements in the equivalence classes generated by `AddLocalization.mk` from elements in `M` and `S`, then `p` holds for any pair of elements in the localization of `M` at `S`.


theorem AntilipschitzWith.tendsto_cobounded :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal}
      {f : α → β}, AntilipschitzWith K f → Filter.Tendsto f (Bornology.cobounded α) (Bornology.cobounded β) :=
  by sorry

The theorem `AntilipschitzWith.tendsto_cobounded` states that for all types `α` and `β` which have a pseudo metric space structure, for a given nonnegative real number `K` and a function `f` mapping `α` to `β`, if `f` is `AntilipschitzWith K`, then `f` tends to the filter of cobounded sets in the bornology of `β` when the filter of cobounded sets in the bornology of `α` is considered. In other words, for any neighborhood of cobounded sets in `β`, the preimage of this neighborhood under `f` is a neighborhood of cobounded sets in `α`. This implies that the function `f` controls how points in `α` are spread out in `β` when considering cobounded sets.

If `f` is an `AntilipschitzWith` function from a pseudo metric space `(α, dα)` to another pseudo metric space `(β, dβ)` with constant `K`, then the preimages of neighborhoods of cobounded sets in `β` under `f` are neighborhoods of cobounded sets in `α`.


theorem MeasureTheory.upperCrossingTime_mono :
    ∀ {Ω : Type u_1} {ι : Type u_2} [inst : ConditionallyCompleteLinearOrderBot ι] {a b : ℝ} {f : ι → Ω → ℝ} {N : ι}
      {n m : ℕ} {ω : Ω},
      n ≤ m → MeasureTheory.upperCrossingTime a b f N n ω ≤ MeasureTheory.upperCrossingTime a b f N m ω :=
  by sorry

This theorem states that for any types `Ω` and `ι`, with `ι` equipped with a conditionally complete linear order bot structure, any two real numbers `a` and `b`, any function `f` from `ι` and `Ω` to real numbers, any value `N` of type `ι`, any natural numbers `n` and `m`, and any value `ω` of type `Ω`, if `n` is less than or equal to `m`, then the upper crossing time of `f` with respect to `a`, `b`, `N`, and `n` at `ω` is less than or equal to the upper crossing time of `f` with respect to `a`, `b`, `N`, and `m` at `ω`. In mathematical terms, this says that the upper crossing time is monotonic with respect to the natural numbers `n` and `m`.

For any function `f` from a conditionally complete linear order `(ι, ≤)` to the real numbers, and any `a`, `b` in the real numbers, `N` in `ι`, `n` and `m` natural numbers with `n ≤ m`, and `ω` in the domain of `f`, the upper crossing time of `f` with respect to `a`, `b`, `N`, and `n` at `ω` is less than or equal to the upper crossing time of `f` with respect to `a`, `b`, `N`, and `m` at `ω`.


theorem RingHom.map_rat_algebraMap :
    ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Algebra ℚ R]
      [inst_3 : Algebra ℚ S] (f : R →+* S) (r : ℚ), f ((algebraMap ℚ R) r) = (algebraMap ℚ S) r :=
  by sorry

This theorem states that for any two semirings `R` and `S`, both having an algebra structure over the rational numbers (`ℚ`), and given a ring homomorphism `f` from `R` to `S`, the application of `f` after mapping a rational number `r` into `R` using the algebra map is the same as directly mapping `r` into `S` using its respective algebra map. Symbolically, for all rational numbers `r`, `f((algebraMap ℚ R) r) = (algebraMap ℚ S) r`. This theorem essentially says that the algebraic structure of the semirings preserves the action of the ring homomorphism.

For any semirings `R` and `S` with algebra structures over the rational numbers, and for any ring homomorphism `f` from `R` to `S`, the algebra maps commute, i.e., `f(algebraMapℚ R r) = algebraMapℚ S r` for all rational numbers `r`.


theorem List.count_not_add_count : ∀ (l : List Bool) (b : Bool), List.count (!b) l + List.count b l = List.length l :=
  by sorry

This theorem states that for any list of Boolean values, the total count of occurrences of a Boolean value and its negation in the list equals the length of the list. In other words, if you sum the number of times a particular boolean (either `true` or `false`) and its opposite appear in a list, you will always get the total number of elements in the list.

For any list of Boolean values, the sum of the count of each Boolean value and its negation is equal to the length of the list.


theorem finprod_eq_prod_plift_of_mulSupport_subset :
    ∀ {M : Type u_2} {α : Sort u_4} [inst : CommMonoid M] {f : α → M} {s : Finset (PLift α)},
      Function.mulSupport (f ∘ PLift.down) ⊆ ↑s → (finprod fun i => f i) = Finset.prod s fun i => f i.down :=
  by sorry

This theorem states that for any function `f` mapping from a type `α` to a commutative monoid `M`, and any finite set `s` of plifted values from `α`, if the multiplicative support of `f` composed with the plift lowering function (`PLift.down`) is a subset of the set `s`, then the infinite product (given by `finprod`) of `f i` as `i` ranges over the domain of `f` equals the finite product (`Finset.prod`) of `f i.down` as `i` ranges over the elements in `s`.

In simpler terms, this theorem provides a condition under which the infinite product of a function over its entire domain can be reduced to a finite product over a subset of the domain. The condition is that the set of points where the function doesn't produce the identity element (i.e., the multiplicative support of `f`) must be a subset of the finite set `s` considered for the finite product.

If `f` is a function from type `α` to a commutative monoid `M`, `s` is a finite set of plifted values from `α`, and the multiplicative support of `f` composed with the plifting lowering function is a subset of `s`, then `finprod (f i) i in domain(f)` equals `Finset.prod (f i.down) i in s`.


theorem continuous_nndist : ∀ {α : Type u} [inst : PseudoMetricSpace α], Continuous fun p => nndist p.1 p.2 := by sorry

This theorem states that for any type `α` that has a `PseudoMetricSpace` structure, the non-negative distance function (`nndist`) is continuous. In other words, given any two points from the type `α`, the function that calculates the non-negative distance between these two points is a continuous function. This is a property that stems from metric spaces, where distances between points vary smoothly.

For any type `α` equipped with a `PseudoMetricSpace` structure, the non-negative distance function `nndist` is a continuous function.


theorem sdiff_inf_self_left : ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), a \ (a ⊓ b) = a \ b :=
  by sorry

This theorem states that for any type `α` that has a structure of a `GeneralizedCoheytingAlgebra`, and for any two elements `a` and `b` of type `α`, the set difference of `a` and the infimum (greatest lower bound) of `a` and `b` is equal to the set difference of `a` and `b`. In mathematical notation, this is equivalent to saying: $a \setminus (a \land b) = a \setminus b$.

For any type `α` with a `GeneralizedCoheytingAlgebra` structure and any elements `a` and `b` of type `α`, the set difference `a \ (a \aland b)` equals `a \ b`.


theorem QuotientAddGroup.rightRel_apply :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {x y : α}, Setoid.r x y ↔ y + -x ∈ s := by sorry

This theorem, `QuotientAddGroup.rightRel_apply`, states that for any type 'α' which is an additive group, and for any additive subgroup 's' of 'α', and for any elements 'x' and 'y' of 'α', the equivalence relation (denoted as `Setoid.r`) for 'x' and 'y' holds if and only if the result of adding the additive inverse of 'x' to 'y' belongs to the subgroup 's'. In other words, 'x' and 'y' are in the same equivalence class under the given setoid iff 'y - x' is an element of the subgroup 's'.

For any additive group 'α' and additive subgroup 's' of 'α', 'x' and 'y' are in the same equivalence class of the subgroup 's' if and only if 'y - x' is an element of 's'.


theorem Ordinal.card_zero : Ordinal.card 0 = 0 := by sorry

This theorem states that the cardinality of the ordinal zero is zero. In other words, a type that has a well-ordering relation equivalent to the order type of the ordinal zero has a cardinality, or size, of zero. In terms of set theory, it's saying that the set with no elements (the empty set) has a cardinality of zero.

The ordinal zero has cardinality 0. In set theory, the empty set has cardinality 0.


/-- If `s ⊆ t` modulo a set of measure `0`, then `μ s ≤ μ t`.  -/
theorem MeasureTheory.measure_mono_ae :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
      s ≤ᶠ[MeasureTheory.Measure.ae μ] t → ↑↑μ s ≤ ↑↑μ t :=
  by sorry

The theorem `MeasureTheory.measure_mono_ae` states that for any measurable space `α` and any measure `μ` on this space, if a set `s` is contained within another set `t` almost everywhere (i.e., outside of a set of measure `0`), then the measure of set `s` is less than or equal to the measure of set `t`. In other words, if a set is almost entirely contained in another, then its measure will not exceed the measure of the containing set.

If `s` is a measurable subset of measurable space `(α, Σ, μ)` and `μ(t \ s) = 0` for some `t ∈ Σ`, then `μ(s) ≤ μ(t)`.


theorem Set.image2_inter_union_subset :
    ∀ {α : Type u_1} {β : Type u_3} {f : α → α → β} {s t : Set α},
      (∀ (a b : α), f a b = f b a) → Set.image2 f (s ∩ t) (s ∪ t) ⊆ Set.image2 f s t :=
  by sorry

This theorem, `Set.image2_inter_union_subset`, states that for any two sets `s` and `t` of an arbitrary type `α`, and for any binary function `f : α → α → β` where `f` is commutative (i.e., `f a b = f b a` for any `a, b` in `α`), the image of the function `f` applied to the intersection of `s` and `t` and the union of `s` and `t` is a subset of the image of the function `f` applied to `s` and `t`. In mathematical notation, this is saying that if `f(a, b) = f(b, a)` for all `a, b` in `α`, then `f(s ∩ t, s ∪ t) ⊆ f(s, t)`.

For commutative binary function `f` on type `α`, `f(s ∩ t, s ∪ t) ⊆ f(s, t)` holds for any sets `s` and `t` in `α`.


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

This theorem states that for any types `α` and `σ`, and any function `f` from `α` to `σ`, if `α` and `σ` are both primcodable (i.e., they can be effectively encoded as natural numbers), then the function `f` is computable if and only if the function that applies `f` to an argument `a` and then encodes the result using `Encodable.encode` is also computable. In simpler terms, encoding the output of a computable function does not affect its computability.

For functions between primcodable types in Lean 4, computability is preserved under encoding: a computable function `f : α → σ` is computable if and only if the composed function ` Encodable.encode ∘ f` is computable.


theorem val_unitOfInvertible :
    ∀ {α : Type u} [inst : Monoid α] (a : α) [inst_1 : Invertible a], ↑(unitOfInvertible a) = a := by sorry

This theorem states that for any given type 'α' that has a Monoid structure, and for any 'a' in that type 'α' which is invertible, the value of the unit created from the invertible 'a' using the 'unitOfInvertible' function is equal to 'a' itself. In simple terms, it means that if an element is invertible in a particular mathematical structure called Monoid, then creating a unit from this invertible element and extracting its value returns the original element.

For any invertible element 'a' in a Monoid type 'α', the unit created from 'a' is equal to 'a' itself (unitOfInvertible 'a' = 'a').


theorem or_iff_not_and_not : ∀ {a b : Prop}, a ∨ b ↔ ¬(¬a ∧ ¬b) := by sorry

This theorem states that for all propositions `a` and `b`, the statement "either `a` or `b` is true" is logically equivalent to the statement "it is not the case that both `a` and `b` are false". In mathematical terms, \(a \lor b\) is equivalent to \(\neg(\neg a \land \neg b)\). This is a basic result in propositional logic known as De Morgan's law.

The logical equivalence of \(a \lor b\) and \(\neg(\neg a \land \neg b)\) holds in propositional logic.


theorem le_div_iff_of_neg :
    ∀ {α : Type u_2} [inst : LinearOrderedField α] {a b c : α}, c < 0 → (a ≤ b / c ↔ b ≤ a * c) := by sorry

This theorem states that for any type `α` that is a linearly ordered field, and for any three elements `a`, `b` and `c` of type `α`, if `c` is less than zero, then `a` is less than or equal to `b` divided by `c` if and only if `b` is less than or equal to `a` multiplied by `c`. In mathematical terms, given a < 0, we have a ≤ b/c if and only if b ≤ ac.

For any linearly ordered field `α` and elements `a, b, c` of type `α` with `c < 0`, we have `a ≤ b/c` if and only if `b ≤ a * c`.


theorem tsum_le_tsum_of_inj :
    ∀ {ι : Type u_1} {κ : Type u_2} {α : Type u_3} [inst : OrderedAddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderClosedTopology α] {f : ι → α} {g : κ → α} (e : ι → κ),
      Function.Injective e →
        (∀ c ∉ Set.range e, 0 ≤ g c) → (∀ (i : ι), f i ≤ g (e i)) → Summable f → Summable g → tsum f ≤ tsum g :=
  by sorry

This theorem states that for any types `ι`, `κ`, and `α`, where `α` has an ordered addition and a topology such that the order is closed, and given functions `f : ι → α` and `g : κ → α`, and an injective function `e : ι → κ`, if every element not in the range of `e` maps to a non-negative value under `g`, and each element in `ι` maps to a value in `α` under `f` that is less than or equal to the value mapped from the corresponding element under `g`, and if both `f` and `g` are summable, then the total sum of `f` is less than or equal to the total sum of `g`. In terms of mathematical notation, this can be written as: if $f : ι → α$ and $g : κ → α$ are functions, $e : ι → κ$ is an injective function, and $\forall c \notin range(e), 0 \leq g(c)$ and $\forall i \in ι, f(i) \leq g(e(i))$, and the series $\sum f$ and $\sum g$ are both convergent, then $\sum f \leq \sum g$.

If `ι` and `κ` are types with ordered additions and topologies where the order is closed, `f : ι → α`, `g : κ → α`, `e : ι → κ` is an injective function, `e("i") <-∞` for all `i ∈ ι`, `g(c) ≥ 0` for all `c ∉ range(e)`, and both `f` and `g` have convergent sums, then `∑(i ∈ ι) f(i) ≤ ∑(j ∈ κ) g(j)`.


theorem Polynomial.trailingDegree_zero : ∀ {R : Type u} [inst : Semiring R], Polynomial.trailingDegree 0 = ⊤ := by sorry

The theorem `Polynomial.trailingDegree_zero` states that for any type `R` that forms a semiring, the trailing degree of the zero polynomial equals `⊤`, which can be interpreted as infinity. Here, the trailing degree of a polynomial is defined as the smallest power of `X` that appears in the polynomial. For the zero polynomial, which does not have any terms with `X`, the smallest power of `X` is considered to be infinity.

For any semiring type R, the trailing degree of the zero polynomial is infinity.


theorem Submodule.map₂_le_map₂ :
    ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : Module R P] {f : M →ₗ[R] N →ₗ[R] P} {p₁ p₂ : Submodule R M} {q₁ q₂ : Submodule R N},
      p₁ ≤ p₂ → q₁ ≤ q₂ → Submodule.map₂ f p₁ q₁ ≤ Submodule.map₂ f p₂ q₂ :=
  by sorry

This theorem states that for all types R, M, N, P, where R is a commutative semiring, M, N, P are additive commutative monoids, and M, N, P are modules over R, and for all linear maps `f` from M to N to P, and for submodules p₁, p₂ of M and q₁, q₂ of N, if p₁ is a subset of p₂ and q₁ is a subset of q₂, then the submodule obtained by mapping p₁ and q₁ through `f` is a subset of the submodule obtained by mapping p₂ and q₂ through `f`. Essentially, it says that the mapping of submodules via a linear map respects the subset relation.

Given commutative semirings R, and additive commutative monoids M, N, P that are R-modules, for all submodules p₁ ⊆ p₂ of M and q₁ ⊆ q₂ of N, the image of p₁ under a linear map from M to N is contained in the image of p₂ under the same linear map, and similarly for N and P. In other words, the mapping of submodules via a linear map respects the subset relation.


theorem Finset.range_one : Finset.range 1 = {0} := by sorry

The theorem `Finset.range_one` states that the set of natural numbers less than 1 (`Finset.range 1`) is the set containing only the number 0. In other words, the range of 1 in the set of natural numbers, as defined in the `Finset.range` function, is simply the set `{0}`.

The set of natural numbers less than 1 is equal to the singleton set {0}.


theorem ProbabilityTheory.integrable_gaussianPDFReal :
    ∀ (μ : ℝ) (v : NNReal), MeasureTheory.Integrable (ProbabilityTheory.gaussianPDFReal μ v) MeasureTheory.volume := by
  sorry

This theorem states that for any real number `μ` and any nonnegative real number `v`, the probability density function of the Gaussian distribution with mean `μ` and variance `v` is integrable with respect to the Lebesgue measure. In other words, the function is measurable and its Lebesgue integral over the whole real line is finite. This is a fundamental property of the Gaussian distribution, which ensures that its total probability mass equals 1 and that it is well-defined as a probability distribution.

The Gaussian distribution with mean `μ` and variance `v` has an integrable probability density function with respect to the Lebesgue measure.


theorem List.get_append :
    ∀ {α : Type u_1} {l₁ l₂ : List α} (n : ℕ) (h : n < List.length l₁),
      List.get (l₁ ++ l₂) { val := n, isLt := ⋯ } = List.get l₁ { val := n, isLt := h } :=
  by sorry

The theorem `List.get_append` states that for any type `α`, any two lists `l₁` and `l₂` of this type, and any natural number `n` such that `n` is less than the length of `l₁`, the `n`-th element of the list obtained by appending `l₂` to `l₁` (i.e., `l₁ ++ l₂`) is the same as the `n`-th element of `l₁`. This essentially means that appending a list to another list does not affect the retrieval of elements from the original list at indices less than its length.

For any type `α`, lists `l₁` and `l₂` of length `|l₁| > n`, and natural number `n`, the `n`-th element of `l₁ ++ l₂` equals the `n`-th element of `l₁`.


theorem IsMinFilter.comp_tendsto :
    ∀ {α : Type u} {β : Type v} {δ : Type x} [inst : Preorder β] {f : α → β} {l : Filter α} {g : δ → α} {l' : Filter δ}
      {b : δ}, IsMinFilter f l (g b) → Filter.Tendsto g l' l → IsMinFilter (f ∘ g) l' b :=
  by sorry

The theorem `IsMinFilter.comp_tendsto` states that for any types `α`, `β`, and `δ`, and a preorder on `β`, if `f` is a function from `α` to `β` and `g` is a function from `δ` to `α`, and if `l` is a filter on `α` and `l'` is a filter on `δ`, then if `f` attains a minimum at `g b` for all `α` in the `l`-neighborhood of `g b`, and if `g` tends to `l` along `l'`, then the composition function `f ∘ g` attains a minimum at `b` for all `δ` in the `l'`-neighborhood of `b`.

In simpler words, if `f` has a minimum at the point `g b` under filter `l`, and `g` converges from filter `l'` to `l`, then the composed function `f ∘ g` has a minimum at the point `b` under the filter `l'`.

If `f` has a minimum at `g(b)` under filter `l` on `α` and `g` tends to `l` under filter `l'` on `δ`, then `f ∘ g` has a minimum at `b` under filter `l'` on `δ`.


theorem Real.sqrt_eq_zero' : ∀ {x : ℝ}, Real.sqrt x = 0 ↔ x ≤ 0 := by sorry

This theorem states that for any real number `x`, the square root of `x`, as defined by the function `Real.sqrt`, is equal to zero if and only if `x` is less than or equal to zero. In other words, the square root of a real number is zero exactly when that number is non-positive.

The square root of a real number is zero if and only if the number is non-positive.


theorem Path.Homotopic.pi_lift :
    ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i}
      (γ : (i : ι) → Path (as i) (bs i)), (Path.Homotopic.pi fun i => ⟦γ i⟧) = ⟦Path.pi γ⟧ :=
  by sorry

The theorem `Path.Homotopic.pi_lift` asserts that for any indexed type `ι`, any function `X` assigning a specific type to each index `ι`, any instances of topological spaces for each `X i`, and any two functions `as` and `bs` from index `ι` to the corresponding type, if we have a function `γ` assigning a path from `as i` to `bs i` for each index `i`, then the homotopy class of the pointwise product path (obtained from the product of homotopy classes of each path `γ i`) equals the homotopy class of the path obtained from the pointwise product of each path `γ i`. In other words, the process of forming the homotopy class commutes with the process of forming the pointwise product path.

The homotopy classes of pointwise product paths between functions from an indexed type to topological spaces equal the pointwise product of their individual homotopy classes.


theorem Cardinal.toENat_eq_top : ∀ {a : Cardinal.{u_1}}, Cardinal.toENat a = ⊤ ↔ Cardinal.aleph0 ≤ a := by sorry

This theorem states that for any cardinal number `a`, the function `Cardinal.toENat a` equals the value `⊤` (which represents infinity in the context of the natural number extension `ℕ∞`) if and only if `a` is greater than or equal to `ℵ₀` (the smallest infinite cardinal, represented by the function `Cardinal.aleph0`). In other words, this function sends all infinite cardinal numbers to `⊤`, and finite cardinal numbers to their corresponding natural number.

For any cardinal number `a`, `Cardinal.toENat a = ⊤` if and only if `a ≥ Cardinal.aleph0`.


/-- The hypotheses also imply that `G` is final, see `final_of_comp_full_faithful'`.  -/
theorem CategoryTheory.Functor.final_of_comp_full_faithful :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_3 : CategoryTheory.Full G]
      [inst_4 : CategoryTheory.Faithful G] [inst_5 : CategoryTheory.Functor.Final (CategoryTheory.Functor.comp F G)],
      CategoryTheory.Functor.Final F :=
  by sorry

This theorem, `CategoryTheory.Functor.final_of_comp_full_faithful`, states that given categories `C`, `D`, and `E`, if we have functors `F : C -> D` and `G : D -> E`, such that `G` is full and faithful, and the composition `F ∘ G` is final (meaning every morphism in `E` is essentially uniquely determined by its preimage under `F ∘ G`), then `F` is also final. In other words, every morphism in `D` is essentially uniquely determined by its preimage under `F`.

If functors `F : C -> D` and `G : D -> E` are such that `F` maps isomorphisms in `C` to isomorphisms in `D`, `G` is full and faithful, and `F ∘ G` is final, then `F` is final.


theorem AddMonoidHom.comap_bot :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N),
      AddSubgroup.comap f ⊥ = AddMonoidHom.ker f :=
  by sorry

The theorem `AddMonoidHom.comap_bot` states that for any additive group homomorphism `f` from an additive group `G` to another additive group `N`, the preimage of the bottom (trivial) subgroup under `f` is the kernel of `f`. In other words, the set of all elements in `G` that `f` maps to the identity element in `N` (which is the definition of the kernel of `f`) is the same as the set of all elements in `G` that get mapped to elements in the trivial subgroup of `N` under `f`.

The preimage of the trivial subgroup under an additive group homomorphism is equal to the kernel of the homomorphism.


theorem Prod.fst_mul_snd :
    ∀ {M : Type u_5} {N : Type u_6} [inst : MulOneClass M] [inst_1 : MulOneClass N] (p : M × N),
      (p.1, 1) * (1, p.2) = p :=
  by sorry

The theorem `Prod.fst_mul_snd` states that for any types `M` and `N` which have a multiplication and an identity operation (i.e., they are members of the `MulOneClass`), and for any pair `p` of type `M × N`, the product of the pair `(p.1, 1)` and `(1, p.2)` is equal to `p`. Here, `p.1` and `p.2` denote the first and second elements of the pair `p`, respectively. In other words, the multiplication operation distributes over the elements of the pair in a way that the identity elements do not affect the result.

For any types `M` and `N` in the `MulOneClass` and any `(m, n)` in `M × N`, `(m, 1) * (1, n) = (m, n)`.


theorem Real.contDiff_arctan : ∀ {n : ℕ∞}, ContDiff ℝ n Real.arctan := by sorry

The theorem `Real.contDiff_arctan` states that the function `Real.arctan`, which is the inverse of the tangent function and returns values in the range `-π / 2 < arctan x` and `arctan x < π / 2`, is continuously differentiable for all natural numbers `n`, including infinity. In other words, the arctan function has derivatives of all orders and these derivatives are continuous functions.

The arctan function, defined on the real numbers, is continuously differentiable for all natural numbers, including infinity.


theorem SetTheory.PGame.birthday_one : SetTheory.PGame.birthday 1 = 1 := by sorry

This theorem states that the "birthday" of the pre-game `1` in Set theory is `1`. Here, the birthday of a pre-game is defined inductively as the least strict upper bound of the birthdays of its left and right games, which can be thought of as the "step" in which a certain game is constructed. So in this case, the construction "step" of the pre-game `1` is `1`.

The birthday of the pre-game 1 in Set theory is 1.


theorem CliffordAlgebra.ι_mul_ι_mem_evenOdd_zero :
    ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (Q : QuadraticForm R M) (m₁ m₂ : M),
      (CliffordAlgebra.ι Q) m₁ * (CliffordAlgebra.ι Q) m₂ ∈ CliffordAlgebra.evenOdd Q 0 :=
  by sorry

The theorem `CliffordAlgebra.ι_mul_ι_mem_evenOdd_zero` states that for any commutative ring `R`, any additive commutative group `M`, and any `R`-module `M`, given a quadratic form `Q` on `M` and any two elements `m₁` and `m₂` of `M`, the product of the canonical linear maps of `m₁` and `m₂` under the quadratic form `Q` is an element of the even submodule of the Clifford algebra of `Q`. The even submodule is defined as the supremum of the even powers of the range of the canonical linear map.

For any commutative ring R, additive commutative group M, R-module structure on M, quadratic form Q on M, and elements m₁, m₂ in M, the product of the canonical linear maps of m₁ and m₂ under the quadratic form Q lies in the even submodule of the Clifford algebra of Q.


theorem Cardinal.powerlt_le : ∀ {a b c : Cardinal.{u}}, a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c := by sorry

The theorem `Cardinal.powerlt_le` is about cardinal numbers and their powers in set theory. It states that for any three cardinal numbers `a`, `b`, and `c`, the power of `a` to the cardinal less than `b` is less than or equal to `c` if and only if for all cardinal numbers `x` less than `b`, the power of `a` to `x` is less than or equal to `c`. In mathematical terms, it says that \(a^{<b} \leq c\) if and only if for all \(x < b\), \(a^x \leq c\).

For any cardinal numbers \(a, b, c\), \(a^{<b} \leq c\) if and only if for all \(x < b\), \(a^x \leq c\).


theorem MeasureTheory.upperCrossingTime_lt_bddAbove :
    ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N : ℕ} {ω : Ω},
      a < b → BddAbove {n | MeasureTheory.upperCrossingTime a b f N n ω < N} :=
  by sorry

The theorem `MeasureTheory.upperCrossingTime_lt_bddAbove` states that for any types `Ω` and real numbers `a` and `b`, any function `f` from natural numbers to a function from `Ω` to real numbers, any natural number `N`, and any value `ω` of type `Ω`, if `a` is less than `b`, then the set of natural numbers `n` for which the upper crossing time of `a` and `b` for the function `f` at `N` and `n` and `ω` is less than `N`, is bounded above. This essentially means that there is an upper limit to the "upper crossing time" values that are less than `N`.

For any types Ω, real numbers a < b, function f from natural numbers to Ω -> real numbers, natural number N, and value ω of type Ω, the set of natural numbers n with upper crossing time of a and b for f at N and n and ω less than N, is bounded above.


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

This theorem states that for any natural numbers `n`, `m`, and `k`, if `n` is less than or equal to `m`, then `n + k` is also less than or equal to `m + k`. In other words, adding the same number `k` to both sides of an inequality between natural numbers does not change the truth of the inequality.

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


theorem Equiv.sum_comp :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid α]
      (e : ι ≃ κ) (g : κ → α), (Finset.sum Finset.univ fun i => g (e i)) = Finset.sum Finset.univ fun i => g i :=
  by sorry

The theorem `Equiv.sum_comp` states that for any types `ι`, `κ`, and `α`, where `ι` and `κ` are finite types and `α` is a type with an additive commutative monoid structure, for any equivalence `e` between `ι` and `κ`, and any function `g` from `κ` to `α`, the sum of `g (e i)` over all elements `i` in the universal finite set of type `ι` is equal to the sum of `g i` over all elements `i` in the universal finite set of type `κ`. In other words, summing over a set of values transformed by an equivalence function gives the same result as summing over the original set of values.

For any equivolution `e` between finite types `ι` and `κ` and any additive commutative monoid `α`, and for any function `g` from `κ` to `α`, the sum of `g (e i)` over all elements `i` in `ι` equals the sum of `g i` over all elements `i` in `κ`.


ONote.NF.oadd

theorem ONote.NF.oadd :
    ∀ {e a : ONote}, ONote.NF e → ∀ (n : ℕ+), ONote.NFBelow a (ONote.repr e) → ONote.NF (ONote.oadd e n a) := by sorry

This theorem states that for any ordinal numbers 'e' and 'a', if 'e' is normal form (ONote.NF e) and 'n' is a positive natural number such that 'a' is below 'e' in the fast-growing hierarchy (ONote.NFBelow a (ONote.repr e)), then the ordinal notation 'oadd e n a' is also in normal form (ONote.NF (ONote.oadd e n a)).

In other words, it asserts that if an ordinal 'e' is in normal form, and 'a' is below 'e' in the fast-growing hierarchy, then the ordinal formed by the ordinal addition operation with 'e', 'n', and 'a' is also in normal form.

If an ordinal 'e' is in normal form and 'a' is below 'e' in the fast-growing hierarchy, then the ordinal obtained by adding 'n' to 'e' (where 'n' is a positive natural number) is also in normal form.


theorem MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range :
    ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : PartialOrder ι] {τ : Ω → ι}
      {f : MeasureTheory.Filtration ι m},
      MeasureTheory.IsStoppingTime f τ → Set.Countable (Set.range τ) → ∀ (i : ι), MeasurableSet {ω | τ ω = i} :=
  by sorry

The theorem `MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range` states that for any types `Ω` and `ι`, a measurable space `m` on `Ω`, a partial order on `ι`, a function `τ` from `Ω` to `ι`, and a filtration `f` on `m`, if `τ` is a stopping time with respect to the filtration `f` and if the range of `τ` is countable, then for every `i` in `ι`, the set of all `ω` in `Ω` such that `τ(ω) = i` is a measurable set with respect to the measurable space `m`.

In other words, if we have a stopping rule `τ` that can be decided using the information available at a given time, and this stopping rule only takes on countably many values, then the set of points in our space that stop at a given time `i` is a measurable set, which means it can be meaningfully assigned a measure (or "size") in our measure space.

If `τ: Ω → ι` is a measurable stopping time with a countable range in a measurable space `(Ω, m)` and filtration `f`, then for all `i ∈ ι`, the set `{ω ∈ Ω | τ(ω) = i}` is measurable.


theorem Mathlib.LinearAlgebra.Matrix.Circulant._auxLemma.3 :
    ∀ {α : Sort u_1} [inst : Subsingleton α] (x y : α), (x = y) = True := by sorry

This theorem, from the Mathlib's linear algebra library, asserts that for any type `α` that has a unique element (i.e., `α` is a subsingleton), and for any two elements `x` and `y` of that type, `x` is always equal to `y`. This is always True because in a subsingleton, there can only be one unique value. This is a fundamental property of types with a single inhabitant.

In a subsingleton type, any two elements are equal.


theorem MeasureTheory.levyProkhorovDist_self :
    ∀ {Ω : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : PseudoEMetricSpace Ω] (μ : MeasureTheory.Measure Ω),
      MeasureTheory.levyProkhorovDist μ μ = 0 :=
  by sorry

The theorem `MeasureTheory.levyProkhorovDist_self` states that for any measure space `Ω` equipped with a pseudometric, the Lévy-Prokhorov distance of any measure `μ` to itself is equal to zero. In mathematical terms, for all `μ`, we have `d(μ, μ) = 0`, where `d` denotes the Lévy-Prokhorov distance.

The Lévy-Prokhorov distance of a measure to itself is zero for any measure space equipped with a pseudometric.


IsLowerSet.compl

theorem IsLowerSet.compl : ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet s → IsUpperSet sᶜ := by sorry

This theorem states that for any type `α` equipped with a less than or equal to (`≤`) relation, and for any set `s` of elements of type `α`, if `s` is a lower set (i.e., for any elements `a` and `b` of type `α`, if `b` is less than or equal to `a` and `a` is in `s`, then `b` is also in `s`), then the complement of `s` (denoted as `sᶜ`) is an upper set (i.e., for any elements `a` and `b` of type `α`, if `a` is less than or equal to `b` and `a` is in `sᶜ`, then `b` is also in `sᶜ`). In other words, the complement of a lower set is an upper set.

If `s` is a lower set of type `α`, then the complement `sᶜ` is an upper set.


theorem CategoryTheory.le_of_op_hom : ∀ {X : Type u} [inst : Preorder X] {x y : Xᵒᵖ}, (x ⟶ y) → y.unop ≤ x.unop := by
  sorry

This theorem states that, given a type `X` with a preorder structure, and two elements `x` and `y` of the opposite type of `X` (notated as `Xᵒᵖ`), if there exists a morphism from `x` to `y` in the category-theoretic sense, then the underlying element of `y` (retrieved by applying the `unop` function) is less than or equal to the underlying element of `x`. This is the opposite of the usual order because `Xᵒᵖ` reverses the order of `X`.

Given a preordered type `X` and its opposite type `Xᵒᵖ`, if there is a morphism from `x : Xᵒᵖ` to `y : Xᵒᵖ`, then `unop y ≤ unop x` holds.


theorem Mathlib.Topology.Basic._auxLemma.7 :
    ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ := by sorry

This theorem states that for any given type `X` and a set `s` of `X` in the context of a topological space, the set `s` is closed if and only if the complement of `s` (`sᶜ`) is open. Here, `IsClosed` denotes that `s` is a closed set in the topological space, and `IsOpen` indicates that a set is open in the topological space. The complement of a set `s`, denoted `sᶜ`, is the set of all elements that are not in `s`. This theorem is a fundamental property of topological spaces in the field of topology.

A set is closed if and only if its complement is open in a topological space.


theorem MeasureTheory.AEEqFun.comp₂_toGerm :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α]
      {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ]
      [inst_3 : TopologicalSpace δ] (g : β → γ → δ) (hg : Continuous (Function.uncurry g)) (f₁ : α →ₘ[μ] β)
      (f₂ : α →ₘ[μ] γ),
      MeasureTheory.AEEqFun.toGerm (MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂) =
        Filter.Germ.map₂ g (MeasureTheory.AEEqFun.toGerm f₁) (MeasureTheory.AEEqFun.toGerm f₂) :=
  by sorry

The theorem `MeasureTheory.AEEqFun.comp₂_toGerm` states that for any types `α`, `β`, `γ`, and `δ` where `α` is a measurable space and `β`, `γ`, and `δ` are topological spaces, and for any measure `μ` over `α`, you can take a continuous binary function `g` from `β` and `γ` to `δ` and two almost everywhere-equivalent functions `f₁` and `f₂` from `α` to `β` and `γ` respectively. With these, you can compose `g` with `f₁` and `f₂` to get a new function, and then convert this to a germ (a representative of an equivalence class of functions that are equal almost everywhere). This operation is the same as first converting `f₁` and `f₂` to germs and then applying the binary function `g` to them within the germ space. In essence, it shows that transforming functions to germs and then applying a binary operation is the same as first applying the operation and then transforming the result to a germ.

Given measurable spaces `α`, topological spaces `β`, `γ`, and `δ`, measure `μ` over `α`, continuous binary function `g` from `β` and `γ` to `δ`, and almost everywhere-equivalent functions `f₁` and `f₂` from `α` to `β` and `γ` respectively, the germ of the composition `g ∘ (f₁, f₂)` is equal to the composition of the germs of `f₁` and `f₂` with `g` within the germ space.


theorem Order.Iio_succ_of_not_isMax :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α},
      ¬IsMax a → Set.Iio (Order.succ a) = Set.Iic a :=
  by sorry

The theorem `Order.Iio_succ_of_not_isMax` states that, for any preorder type `α` that also has a successor order and any element `a` of type `α`, if `a` is not a maximal element of `α` (meaning there exists an element in `α` that is strictly greater than `a`), then the left-infinite right-open interval less than the successor of `a` (denoted `Set.Iio (Order.succ a)`) is equal to the left-infinite right-closed interval less than or equal to `a` (denoted `Set.Iic a`). In other words, if `a` is not the highest value in the set, then all values less than the next highest value are also all the values less than or equal to `a`.

If `α` is a preorder type with a successor order and `a` is an element of `α` not maximally bounded above, then `Set.Iio (Order.succ a) = Set.Iic a`.


theorem CategoryTheory.sheafifyLift_unique :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C)
      {D : Type u_1} [inst_1 : CategoryTheory.Category.{u_2, u_1} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
      {P Q : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q) (hQ : CategoryTheory.Presheaf.IsSheaf J Q)
      (γ : CategoryTheory.sheafify J P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.toSheafify J P) γ = η →
        γ = CategoryTheory.sheafifyLift J η hQ :=
  by sorry

The theorem `CategoryTheory.sheafifyLift_unique` states that for any category type `C` with the category instance `inst`, Grothendieck topology `J`, category type `D` with the category instance `inst_1`, and the condition `inst_2` that the inclusion functor from sheaves to presheaves admits a left adjoint, given functors `P` and `Q` from the opposite of `C` to `D`, a natural transformation `η` from `P` to `Q`, where `Q` is a sheaf for the topology `J` and a natural transformation `γ` from the sheafification of `P` to `Q`. The theorem asserts that if the composition of the canonical map from `P` to its sheafification and `γ` equals `η`, then `γ` is equal to the lift of `η` to the sheafification of `P`. In other words, the lift of `η` is the unique morphism making the diagram commute if `Q` is a sheaf.

Given a category `C` with instance `inst`, Grothendieck topology `J`, category `D` with instance `inst_1`, and functors `P` and `Q` from `C°` to `D`, if `η: P ⟶ Q` is a natural transformation with `γ: Sh(P) ⟶ Q` such that the composition `P ➔ Sh(P) ⟶ Q` equals `η`, then `γ` is the lift of `η` to `Sh(P)`.


/-- A nonnegative multiple of a vector is in the same ray as that vector.  -/
theorem SameRay.sameRay_nonneg_smul_left :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {S : Type u_5} [inst_3 : OrderedCommSemiring S] [inst_4 : Algebra S R] [inst_5 : Module S M]
      [inst_6 : SMulPosMono S R] [inst_7 : IsScalarTower S R M] {a : S} (v : M), 0 ≤ a → SameRay R (a • v) v :=
  by sorry

The theorem `SameRay.sameRay_nonneg_smul_left` states that for any vector `v` and any nonnegative scalar `a` in a module `M` over a strictly ordered commutative semiring `R`, where `R` is an algebra over another ordered commutative semiring `S`, and where scalar multiplication by positive elements of `S` on `R` is monotonically increasing, and `S`, `R` and `M` form a scalar tower (i.e., scalar multiplication by an element of `S` followed by an element of `R` is the same as scalar multiplication by the product of those elements), then the vector which is the result of scaling `v` by `a`, is in the same ray as `v`. In other words, `a • v` and `v` are considered to be pointing in the same direction, or they are in the same "ray".

For any nonnegative scalar `a` in an ordered commutative semiring `S` over a module `M` over a strictly ordered commutative semiring `R`, where scalar multiplication by positive elements of `S` on `R` is monotonic and `S`, `R`, and `M` form a scalar tower, if `v` is a vector in `M`, then `a • v` and `v` lie on the same ray.


theorem lt_iff_lt_of_cmp_eq_cmp :
    ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α} {β : Type u_3} [inst_1 : LinearOrder β] {x' y' : β},
      cmp x y = cmp x' y' → (x < y ↔ x' < y') :=
  by sorry

The theorem `lt_iff_lt_of_cmp_eq_cmp` states that for any two types `α` and `β`, both equipped with a linear order, and for any elements `x` and `y` from `α` and `x'` and `y'` from `β`, if the comparative orderings of `x` and `y` and `x'` and `y'` are the same, then `x` is less than `y` if and only if `x'` is less than `y'`. This provides a link between the relative orderings of two pairs of elements in potentially different ordered sets.

For all types `α` and `β` with linear orders, and all elements `x` from `α`, `y` from `β`, `x'` from `α`, and `y'` from `β` such that `x` is related to `y` as `y` is to `x` if and only if `x'` is related to `y'` as `y'` is to `x'`, we have `x < y` if and only if `x' < y'`.


theorem Finset.sum_fin_eq_sum_range :
    ∀ {β : Type u_2} [inst : AddCommMonoid β] {n : ℕ} (c : Fin n → β),
      (Finset.sum Finset.univ fun i => c i) =
        Finset.sum (Finset.range n) fun i => if h : i < n then c { val := i, isLt := h } else 0 :=
  by sorry

This theorem, `Finset.sum_fin_eq_sum_range`, states that for any type `β` which is an additive commutative monoid and for any natural number `n`, if we have a function `c` which maps from a finite set of size `n` to `β`, then the sum of the function `c` over the entire universal finite set is equal to the sum of the function `c` over the range `n` with an additional condition: if a number `i` is less than `n`, then we consider `c` at `i`, otherwise we consider `0`. In other words, the sum of a function over a finite set is same as the sum of the function over all natural numbers less than the size of the set, where the function is zero for numbers not in the set.

For any additive commutative monoid type `β` and natural number `n`, the sum of a function from a finite set of size `n` to `β` equals the sum of applying the function to the first `n` natural numbers and zero for the remaining ones.


IsRelPrime.isCoprime

theorem IsRelPrime.isCoprime :
    ∀ {R : Type u} [inst : CommRing R] {x y : R} [inst_1 : Submodule.IsPrincipal (Ideal.span {x, y})],
      IsRelPrime x y → IsCoprime x y :=
  by sorry

The theorem `IsRelPrime.isCoprime` states that for any commutative ring `R` and any elements `x` and `y` of `R`, if the ideal generated by `x` and `y` is principal (i.e., can be generated by a single element), then if `x` and `y` are relatively prime (meaning any common divisor is a unit), it follows that `x` and `y` are coprime. In other words, there exist elements `a` and `b` in the ring such that `a * x + b * y = 1`. This theorem essentially connects the notions of relative primality and coprimality in the context of commutative rings with principal ideals.

If `x` and `y` are relatively prime elements of a commutative ring `R` with principal ideal generated by `x` and `y`, then there exist `a` and `b` in `R` such that `a * x + b * y = 1`.


StrictMonoOn.dual

/-- **Alias** of the reverse direction of `strictMonoOn_dual_iff`. -/
theorem StrictMonoOn.dual :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      StrictMonoOn f s → StrictMonoOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s :=
  by sorry

This theorem states that for all types `α` and `β` with preorders, a function `f` from `α` to `β`, and a set `s` of type `α`, if the function `f` is strictly monotone on the set `s`, then the function obtained by composing `f` with the identity functions `OrderDual.toDual` and `OrderDual.ofDual` (essentially a function equivalent to `f` but on the dual order) is also strictly monotone on the set `s`. In simpler terms, if a function is strictly increasing on a set, then the same function is also strictly increasing on the set when considering elements in reverse order.

If `f` is a strictly monotone function from type `α` to type `β` with preorders, then the function `OrderDual.ofDual ∘ f ∘ OrderDual.toDual` is also strictly monotone on any set `s` in `α`.


UniqueDiffWithinAt.eq

/-- `UniqueDiffWithinAt` achieves its goal: it implies the uniqueness of the derivative.  -/
theorem UniqueDiffWithinAt.eq :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' f₁' : E →L[𝕜] F} {x : E} {s : Set E},
      UniqueDiffWithinAt 𝕜 s x → HasFDerivWithinAt f f' s x → HasFDerivWithinAt f f₁' s x → f' = f₁' :=
  by sorry

This theorem, named `UniqueDiffWithinAt.eq`, asserts the uniqueness of derivatives within a given set. In more detail, given a nontrivial normed field `𝕜`, and normed additive commutative groups `E` and `F` over `𝕜`, along with the corresponding normed spaces. If a function `f` from `E` to `F` has two derivatives, `f'` and `f₁'`, at a point `x` within a set `s` such that `s` is uniquely differentiable at `x`, then `f'` and `f₁'` must be equal. This affirms the uniqueness of the derivative within the set at the point `x`.

Given a nontrivial normed field `𝕜`, normed additive commutative groups `E` and `F` over `𝕜`, and a function `f : E → F` that is twice differentiable at `x ∈ E` within a uniquely differentiable set `s ⊆ E`, then `f' (x) = f₁' (x)`.


theorem List.chain_map :
    ∀ {α : Type u} {β : Type v} {R : α → α → Prop} (f : β → α) {b : β} {l : List β},
      List.Chain R (f b) (List.map f l) ↔ List.Chain (fun a b => R (f a) (f b)) b l :=
  by sorry

The `List.chain_map` theorem states that for any types `α` and `β`, a binary relation `R` on elements of type `α`, a function `f` from `β` to `α`, and a list `l` of elements of type `β` with an element `b` of type `β`, there is an equivalence between the chain relation `R` applied to the function `f` at `b` and the mapping of `f` over the list `l`, and the chain relation applied to the function `f` in a way such that `R` takes `f a` and `f b` where `a` and `b` are elements from the list `l`. This means that applying a function to each element in the list and then forming a chain relation is the same as forming a chain relation where each pair of elements is first mapped through the function.

For any types `α` and `β`, relation `R` on `α`, function `f : β -> α`, and list `l : List β`, the chain relation `R` applied to `f` on elements from `l` is equivalent to applying `f` to each element in `l` and then applying `R` to the resulting pairs.


theorem CategoryTheory.Functor.final_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
      (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [hF : CategoryTheory.Functor.Final F]
      [hG : CategoryTheory.Functor.Final G], CategoryTheory.Functor.Final (CategoryTheory.Functor.comp F G) :=
  by sorry

This theorem is about functors in category theory. It states that for any three categories `C`, `D`, and `E`, and two functors `F` from `C` to `D` and `G` from `D` to `E`, if both `F` and `G` are "final" (a property that relates to how limits are preserved), then the composite functor `F` followed by `G` (notated as `CategoryTheory.Functor.comp F G`) is also final.

If functors `F: C -> D` and `G: D -> E` are both final, then their composition `F ∘ G` is also a final functor.


theorem Mathlib.Geometry.Manifold.ChartedSpace._auxLemma.10 : ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) := by sorry

This theorem asserts that for any type `α` and any elements `a` and `b` of that type, the statement "`a` is in the set containing only `b`" is equivalent to "`a` equals `b`". In mathematical terms, it's stating that for any `a` and `b` in some set `α`, `a` is an element of the singleton set `{b}` if and only if `a` equals `b`.

For any type `α` and any `a, b` in `α`, `a` is an element of the singleton set `{b}` if and only if `a = b`.


theorem Polynomial.exists_root_of_splits :
    ∀ {K : Type v} {L : Type w} [inst : Field K] [inst_1 : Field L] (i : K →+* L) {f : Polynomial K},
      Polynomial.Splits i f → Polynomial.degree f ≠ 0 → ∃ x, Polynomial.eval₂ i x f = 0 :=
  by sorry

This theorem states that for any fields `K` and `L` and a ring homomorphism `i` from `K` to `L`, if a polynomial `f` with coefficients in `K` splits according to `i` and the degree of `f` is not zero, then there exists a root `x` in `L` where `x` is such that when we evaluate the polynomial `f` at `x` using the ring homomorphism `i`, we get zero.

In other words, if a non-zero degree polynomial over one field splits when mapped to another field using a ring homomorphism, then there exist roots in the target field. Here, a polynomial is said to "split" if it is zero or all its irreducible factors have a degree of 1.

Given fields `K` and `L` and a ring homomorphism `i` from `K` to `L`, if a non-zero polynomial `f` in `K[x]` splits over `L` via `i`, then there exists a root of `f` in `L` when evaluated through `i`.


ContinuousOpenMap.ext

theorem ContinuousOpenMap.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α →CO β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two continuous open maps `f` and `g` from a topological space `α` to another topological space `β`, if they map every point in `α` to the same point in `β`, then `f` and `g` must be the same continuous open map. This means that continuous open maps are uniquely defined by how they map every individual point from `α` to `β`.

If two continuous open maps from one topological space to another map every point to the same image, then they are equal as functions.


theorem AddMonoidHom.coe_coe :
    ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      [inst_2 : FunLike F M N] [inst_3 : AddMonoidHomClass F M N] (f : F), ⇑↑f = ⇑f :=
  by sorry

This theorem, `AddMonoidHom.coe_coe`, states that for any types `M`, `N`, and `F`, where `M` and `N` have the structure of an `AddZeroClass` (i.e., they are additive monoids with zero), `F` is a function-like object from `M` to `N`, and `F` is an additive monoid homomorphism class, then for any object `f` of type `F`, the double coercion of `f` (first coercing `f` to a function from `M` to `N`, and then treating that function as a function from `M` to `N`) is equal to the single coercion of `f`. In simpler terms, adding an extra layer of coercion to `f` does not change its behavior as a function.

Given an additive monoid homomorphism class `F` from an additive monoid `M` to an additive monoid `N`, the double application of the coercion from `F` to a function from `M` to `N` is equal to the single application.


theorem FractionalIdeal.spanSingleton_one :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
      [loc : IsLocalization S P], FractionalIdeal.spanSingleton S 1 = 1 :=
  by sorry

This theorem states that for any commutative ring `R`, submonoid `S` of `R`, and another commutative ring `P` with `R` acting as an algebra on `P` such that `P` is a localization of `R` at `S`, the fractional ideal generated by the element `1` in `P` is the unit element in the ring of fractional ideals of `P`. In other words, if you generate a fractional ideal in `P` using just the element `1`, you would end up with the unit element in the ring of fractional ideals.

For any commutative ring `R`, submonoid `S` of `R`, and `R`-algebra `P` localized at `S`, the fractional ideal generated by `1` in `P` is the multiplicative identity in the ring of fractional ideals of `P`.


theorem Multiset.nsmul_singleton : ∀ {α : Type u_1} (a : α) (n : ℕ), n • {a} = Multiset.replicate n a := by sorry

This theorem states that for any type `α`, any value `a` of type `α`, and any natural number `n`, the scalar multiplication of `n` and the singleton multiset containing only `a` is equal to the multiset containing `a` with multiplicity `n`. In other words, multiplying a singleton multiset `{a}` by `n` results in a multiset with `n` copies of `a`.

For any type `α`, the scalar multiplication of a natural number `n` with the singleton multiset `{a : α}` is the multiset with `n` copies of `a`.


theorem Rel.core_mono : ∀ {α : Type u_1} {β : Type u_2} (r : Rel α β), Monotone (Rel.core r) := by sorry

The theorem `Rel.core_mono` asserts that for any relation `r` from a type `α` to a type `β`, the function `Rel.core r` is monotone. In other words, if we have two sets `s` and `t` of type `β` such that `s` is a subset of `t`, then the core of `s` with respect to the relation `r` is a subset of the core of `t` with respect to the same relation. Here, the "core" of a set `s` with respect to a relation `r` is defined as the set of elements in `α` that only relate to elements in `s` through `r`.

For any relation `r` from type `α` to type `β`, the function `Rel.core r` maps subset inclusion of `β` to subset inclusion of `α` in the sense that if `s` is a subset of `t`, then the core of `s` with respect to `r` is a subset of the core of `t` with respect to `r`.


theorem ZMod.coe_valMinAbs : ∀ {n : ℕ} (x : ZMod n), ↑(ZMod.valMinAbs x) = x := by sorry

This theorem states that for any natural number `n` and any integer modulo `n` (represented by `x : ZMod n`), the coercion of the integer that is closest to `0` in the same equivalence class as `x` (which is represented by `ZMod.valMinAbs x`) equals `x` itself. In other words, `x` is equal to its own minimum absolute value in its equivalence class when modded by `n`, following the appropriate coercion.

For any natural number `n` and integer `x` modulo `n` (represented by `x : ZMod n`), `ZMod.valMinAbs x = x`.


theorem Mathlib.Data.Nat.Cast.Order._auxLemma.4 :
    ∀ {α : Type u_3} [inst : OrderedSemiring α] (n : ℕ) [inst_1 : Nat.AtLeastTwo n], (0 ≤ OfNat.ofNat n) = True := by
  sorry

The theorem `Mathlib.Data.Nat.Cast.Order._auxLemma.4` states that for any type `α` which is an Ordered Semiring, and for any natural number `n` that is at least two, the result of casting `n` to `α` using the function `OfNat.ofNat` is always greater than or equal to zero. The equality to `True` signifies that this proposition is always true.

For any Ordered Semiring type `α` and natural number `n` ≥ 2, `OfNat.ofNat n ≥ 0`.


theorem Finset.map_eq_empty : ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α}, Finset.map f s = ∅ ↔ s = ∅ :=
  by sorry

This theorem states that for any types `α` and `β`, for any embedding `f` from `α` to `β`, and for any finite set `s` of type `α`, the image of `s` under `f` is the empty set if and only if `s` itself is the empty set. In other words, an embedding `f` does not map any non-empty finite set to the empty set.

For any types `α` and `β`, and any embedding `f` from `α` to `β`, if `s` is a finite non-empty set of type `α`, then `f(s)` is a non-empty set.


/-- The proof that `a` is a solution to the Pell equation `x^2 - d*y^2 = 1`  -/
theorem Pell.Solution₁.prop :
    ∀ {d : ℤ} (a : Pell.Solution₁ d), Pell.Solution₁.x a ^ 2 - d * Pell.Solution₁.y a ^ 2 = 1 := by sorry

The theorem `Pell.Solution₁.prop` asserts that for any integer `d` and any solution `a` to the Pell equation in the set `Pell.Solution₁ d`, the square of the x-component of `a` minus `d` times the square of the y-component of `a`, equals 1. In mathematical terms, it states that for every solution to the Pell equation, \(x^2 - d*y^2 = 1\), where `d` is an integer.

For any integer `d` and solution `a` in the set `Pell.Solution₁ d` of the Pell equation, `x^2 = d*y^2 + 1`, where `x` and `y` are the components of `a`.


theorem Multiset.noncommFold_coe :
    ∀ {α : Type u_3} (op : α → α → α) [assoc : Std.Associative op] (l : List α)
      (comm : Set.Pairwise {x | x ∈ ↑l} fun x y => op x y = op y x) (a : α),
      Multiset.noncommFold op (↑l) comm a = List.foldr op a l :=
  by sorry

This theorem establishes the equality between the noncommutative fold of a multiset and the right-to-left fold of a list. More specifically, for any type `α`, any binary operation `op` on `α` that is associative, any list `l` of `α`, and any element `a` of `α`, if the operation `op` is commutative for all distinct pairs of elements in the list `l`, then the noncommutative fold of a multiset obtained from `l` using the operation `op`, starting with `a`, is equal to the right-to-left fold of the list `l` using the operation `op`, starting with `a`.

For any commutative, associative binary operation `op` on type `α`, any list `l` of `α` with distinct elements, and any `a` in `α`, the noncommutative multiset fold of `a` and `l` using `op` equals the right-to-left list fold of `l` using `op` starting with `a`.


theorem nhds_top_basis :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTop α] [inst_3 : OrderTopology α]
      [inst_4 : Nontrivial α], Filter.HasBasis (nhds ⊤) (fun a => a < ⊤) fun a => Set.Ioi a :=
  by sorry

This theorem states that for any type `α` that is equipped with a topology, a linear order, a top element, an order topology, and is nontrivial, the neighborhood filter at the top element `⊤` has a basis consisting of the sets that are open intervals `(a, ∞)` where `a` is any element less than `⊤`. In other words, every neighbourhood of `⊤` contains such an interval for some `a`, and given `a < ⊤`, there is such a neighborhood.

For any nontrivial type `α` with a topology, a linear order, and a top element `⊤`, the neighborhood filter at `⊤` has a basis consisting of open intervals `(a, ∞)` for all `a` less than `⊤`.


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

This theorem states that for any given semiring 'R', commutative monoid 'M', and module 'M' over 'R', the application of the identity element (1) of the semiring to any element 'x' of the module is equal to 'x' itself. In simpler terms, multiplying any element by one in the context of a linear map results in the element itself.

For any semiring R, commutative monoid M with R-module structure, and all x in M, 1 \* x = x.


theorem Algebra.IsAlgebraic.algHom_bijective :
    ∀ {K : Type u_1} {L : Type u_2} [inst : CommRing K] [inst_1 : Field L] [inst_2 : Algebra K L]
      [inst_3 : NoZeroSMulDivisors K L], Algebra.IsAlgebraic K L → ∀ (f : L →ₐ[K] L), Function.Bijective ⇑f :=
  by sorry

The theorem `Algebra.IsAlgebraic.algHom_bijective` states that for any commutative ring `K` and any field `L` that is an algebra over `K` with no zero scalar multiplication divisors, if all elements of `L` are algebraic over `K` (i.e., `L` is an algebraic algebra over `K`), then for any algebra homomorphism `f` from `L` to `L` over `K`, the function `f` is bijective – that is, it is both injective (it maps distinct elements of its domain to distinct elements of its codomain) and surjective (every element of its codomain is the image of some element of its domain).

If `K` is a commutative ring, `L` is a field algebraically closed over `K` with no zero divisors in scalar multiplication, and `f` is an algebra homomorphism from `L` to `L` over `K`, then `f` is a bijective function.


LT.lt.lf

/-- **Alias** of `SetTheory.PGame.lf_of_lt`. -/
theorem LT.lt.lf : ∀ {x y : SetTheory.PGame}, x < y → SetTheory.PGame.LF x y := by sorry

This theorem, known as an alias of `SetTheory.PGame.lf_of_lt`, states that for any two pre-games `x` and `y` from set theory, if `x` is less than `y`, then the less or fuzzy relation `SetTheory.PGame.LF` holds between `x` and `y`. In other words, if `x` is a losing position for the first player, then Left can win the game `y` as the first player.

For any pre-games x and y in set theory, if x is less than y then there exists a winning strategy for the first player in game y starting from position x.


theorem LinearMap.sum_apply :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} {ι : Type u_9} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
      [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} (t : Finset ι) (f : ι → M →ₛₗ[σ₁₂] M₂) (b : M),
      (Finset.sum t fun d => f d) b = Finset.sum t fun d => (f d) b :=
  by sorry

The theorem `LinearMap.sum_apply` states that for any semiring `R`, any semiring `R₂`, any additively commutative monoids `M` and `M₂`, any module `M` over `R`, any module `M₂` over `R₂`, any ring homomorphism from `R` to `R₂`, any finite set `t` of elements of some type `ι`, any function `f` from `ι` to the type of linear maps from `M` to `M₂` under the ring homomorphism, and any element `b` of `M`, the linear map obtained by summing over `t` the linear maps given by `f`, when applied to `b`, is equal to the sum, over `t`, of the results of applying the linear map given by `f` to `b`. In mathematical notation, this can be expressed as $(∑_{d \in t} f(d))(b) = ∑_{d \in t} f(d)(b)$.

For any semirings R and R₂, additively commutative monoids M and M₂, module M over R, module M₂ over R₂, ring homomorphism r : R -> R₂, finite set ι, function f : ι -> LinMap(M -> M₂) under r, and b in M, (∑d in t. f(d))(b) = ∑d in t. f(d)(b).


theorem SetLike.lt_iff_le_and_exists :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p < q ↔ p ≤ q ∧ ∃ x ∈ q, x ∉ p := by sorry

This theorem is stating a condition for one set-like object to be less than another. Specifically, within the context of any two types `A` and `B` with a `SetLike` relationship, it holds that for any two instances `p` and `q` of type `A`, `p` is less than `q` if and only if `p` is less than or equal to `q` and there exists an element `x` in `q` that is not in `p`.

For any set-like types `A` and `B` and instances `p` of `A` and `q` of `B`, `p` is less than `q` if and only if `p` is subset of `q` and there exists an element in `q` not in `p`.


theorem Mathlib.Order.Filter.Basic._auxLemma.90 :
    ∀ {α : Type u} {p : α → Prop} {f : Filter α}, (¬∃ᶠ (x : α) in f, p x) = ∀ᶠ (x : α) in f, ¬p x := by sorry

This theorem states that for any type `α`, any property `p` of type `α`, and any filter `f` on `α`, the statement "there does not exist an `x` of type `α` in the filter `f` such that the property `p` holds for `x`" is equivalent to the statement "for all `x` of type `α` in the filter `f`, the property `p` does not hold for `x`". In other words, not having any element in a filter that satisfies a certain property is equivalent to all elements in that filter not satisfying the property.

For any filter `f` on type `α` and property `p` of `α`, the filter `f` does not contain any element satisfying `p` if and only if no element in `f` satisfies `p`.


theorem Mathlib.Order.Filter.Basic._auxLemma.92 :
    ∀ {α : Type u} (f : Filter α), (∃ᶠ (x : α) in f, True) = Filter.NeBot f := by sorry

This theorem, named `Mathlib.Order.Filter.Basic._auxLemma.92`, states that for every type `α` and a filter `f` on `α`, the proposition "there exists some `x` in `f` for which `True` holds" is equivalent to the filter `f` being not bottom (i.e., not the smallest filter or not empty). This essentially shows a condition under which a filter is considered non-empty.

For every type `α` and filter `f` on `α`, the proposition "there exists an element in `f`" is equivalent to `f` not being the bottom filter.


theorem ZMod.val_mul : ∀ {n : ℕ} (a b : ZMod n), ZMod.val (a * b) = ZMod.val a * ZMod.val b % n := by sorry

The theorem `ZMod.val_mul` states that for any natural number `n` and any two integers modulo `n`, say `a` and `b`, the value of the product `a * b` modulo `n` (as computed by the `Zmod.val` function), is equivalent to the value of `a` modulo `n` times the value of `b` modulo `n`, all modulo `n`. This theorem essentially expresses the property of congruence in modular arithmetic, showing that multiplication in the ring of integers modulo `n` is well-defined in terms of the equivalence classes of the integers modulo `n`.

For any natural number `n` and integers `a` and `b` modulo `n`, `ZMod.val (a * b) = ZMod.val (a % n) * ZMod.val (b % n)` modulo `n`.


theorem Mathlib.Order.Filter.Basic._auxLemma.80 :
    ∀ {α : Type u} {p : α → Prop} {f g : Filter α},
      (∀ᶠ (x : α) in f ⊔ g, p x) = ((∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in g, p x) :=
  by sorry

This theorem states that, for any type `α` and any predicate `p` on `α`, along with any two filters `f` and `g` on `α`, the property `p` holding eventually (meaning in the filter) in the sup (join or union) of `f` and `g` is equivalent to `p` holding eventually in both `f` and `g`. In mathematical terms, for all $x$ of type $α$, $p(x)$ holds eventually in the sup of the two filters if and only if $p(x)$ holds eventually in each of the filters separately.

For any type `α`, predicate `p` on `α`, and filters `f` and `g` on `α`, `p` eventually holds in the sup of `f` and `g` if and only if `p` eventually holds in both `f` and `g`.


theorem Mathlib.Order.Filter.Basic._auxLemma.71 :
    ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
      (∀ᶠ (x : α) in f, p x ∧ q x) = ((∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x) :=
  by sorry

This theorem, `Mathlib.Order.Filter.Basic._auxLemma.71`, states that, for any type `α`, any propositions `p` and `q` about the elements of `α`, and any filter `f` on `α`, the event "for all `x` in the filter `f`, `p(x)` and `q(x)` holds" is equivalent to the conjunction of the two events "for all `x` in the filter `f`, `p(x)` holds" and "for all `x` in the filter `f`, `q(x)` holds". This shows that the proposition about the conjunction of two events in a filter can be split into two separate propositions about each event in the same filter.

For any filter `f` on type `α`, proposition `p`, and proposition `q`, the statement "for all `x` in `f`, `p(x)` and `q(x)` hold" is equivalent to the conjunction of "for all `x` in `f`, `p(x)` holds" and "for all `x` in `f`, `q(x)` holds".


theorem Finset.mem_mul :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α} {x : α},
      x ∈ s * t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x :=
  by sorry

The theorem `Finset.mem_mul` states that for any type `α` that has decidable equality and a multiplication operation, for any two finite sets `s` and `t` of type `α`, and any element `x` of type `α`, `x` belongs to the product of `s` and `t` if and only if there exists an element `y` in `s` and an element `z` in `t` such that the product of `y` and `z` equals `x`. In other words, the theorem describes the distributive property of multiplication over finite sets.

For any type `α` with decidable equality and multiplication, and finite sets `s` and `t` of type `α`, an element `x` lies in the product of `s` and `t` if and only if there exist elements `y` in `s` and `z` in `t` such that `x = y * z`.


theorem Mathlib.Order.Filter.Basic._auxLemma.66 :
    ∀ {α : Type u} {f : Filter α} {s t : Set α}, (s ∈ f ⊓ Filter.principal t) = ({x | x ∈ t → x ∈ s} ∈ f) := by sorry

This theorem, named `Mathlib.Order.Filter.Basic._auxLemma.66`, states that for any given type `α`, any filter `f` on that type, and any two sets `s` and `t` of that type, the condition that `s` is in the intersection of `f` and the principal filter of `t` is equivalent to the condition that the set of elements `x` which are in `s` whenever they are in `t` is in the filter `f`. In simpler terms, it's saying that `s` being in the intersection of `f` and the filter of all supersets of `t` is the same as `f` containing all elements that are in `s` given that they are in `t`.

For any type `α`, filter `f` on `α`, and sets `s` and `t` in `α`, `s` is in the intersection of `f` and the principal filter of `t` if and only if the set of elements in `s` that are also in `t` is in `f`.


theorem Set.comp_rangeSplitting : ∀ {α : Type u} {β : Type v} (f : α → β), f ∘ Set.rangeSplitting f = Subtype.val := by
  sorry

The theorem `Set.comp_rangeSplitting` states that for all types `α` and `β`, and for any function `f` from `α` to `β`, the composition of the function `f` with the `rangeSplitting` of `f` is equal to the `Subtype.val` function. In other words, if we first take an element from the range of `f`, find a preimage of it using `rangeSplitting`, and then map it back to the range using `f`, we end up where we started. This formalizes the intuition that `rangeSplitting` chooses a preimage for each element in the range of `f`, and applying `f` to a preimage gives the original element.

For all types α and β, and for any function f from α to β, the composition of f with the range splitting of f is equal to the identity function on the image of f.


theorem Mathlib.Order.Filter.Basic._auxLemma.51 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the proposition "`a` and `b` implies `c`" is logically equivalent to the proposition "if `a` then `b` implies `c`". Essentially, it encapsulates the fact that we can rephrase a statement involving a conjunction (an "and" statement) and an implication (a "then" statement) as a statement involving nested implications, without changing the truth of the statement.

The theorem asserts that `(a ∧ b) → c` is logically equivalent to `a → (b → c)`.


theorem Mathlib.Order.Filter.Basic._auxLemma.37 :
    ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) := by sorry

This theorem from the Mathlib library titled "Order.Filter.Basic._auxLemma.37" states that for any type `α`, which has a partial ordering, and for any two elements 'a' and 'b' of type `α`, 'a' is equal to 'b' if and only if 'a' is less than or equal to 'b' and 'b' is less than or equal to 'a'. In other words, in a partial order, two elements are equal if, and only if, they are each less than or equal to the other.

In a partial ordering, two elements are equivalent if and only if they mutually satisfy the relation of being less than or equal to each other.


/-- See note [partially-applied ext lemmas].  -/
theorem FreeAlgebra.hom_ext :
    ∀ {R : Type u_1} [inst : CommSemiring R] {X : Type u_2} {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
      {f g : FreeAlgebra R X →ₐ[R] A}, ⇑f ∘ FreeAlgebra.ι R = ⇑g ∘ FreeAlgebra.ι R → f = g :=
  by sorry

The theorem `FreeAlgebra.hom_ext` establishes an extensionality criterion for morphisms from a free algebra to another algebra over a commutative semiring. Specifically, it states that for any commutative semiring `R`, type `X`, semiring `A`, algebra structure for `A` over `R`, and two algebra homomorphisms `f` and `g` from the free algebra over `R` on `X` to `A`, if these two algebra homomorphisms agree on the canonical injection from `X` to the free algebra (i.e., `⇑f ∘ FreeAlgebra.ι R = ⇑g ∘ FreeAlgebra.ι R`), then `f` and `g` must be the same. This theorem is useful when proving two algebra homomorphisms are equal, as it suffices to show that they agree on the canonical injection.

Given a commutative semiring `R`, a type `X`, a semiring `A`, an algebra structure for `A` over `R`, and two algebra homomorphisms `f` and `g` from the free algebra over `R` on `X` to `A`, if `f ∘ FreeAlgebra.ι R = g ∘ FreeAlgebra.ι R`, then `f = g`.


theorem EuclideanDomain.zero_div : ∀ {R : Type u} [inst : EuclideanDomain R] {a : R}, 0 / a = 0 := by sorry

This theorem states that in any Euclidean domain `R`, for each element `a` in `R`, the division of `0` by `a` equals `0`. That is, it generalizes the familiar property from number theory that zero divided by any number is zero to an abstract Euclidean domain.

In any Euclidean domain, the division of zero by any non-zero element is equal to zero.


theorem CategoryTheory.ShortComplex.LeftHomologyData.f'_π :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.f' h) h.π = 0 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.LeftHomologyData.f'_π` states that for any Type `C` that is a category `CategoryTheory.Category` and has zero morphisms `CategoryTheory.Limits.HasZeroMorphisms`, and any `CategoryTheory.ShortComplex` `S`, for any left homology data `h` of `S`, the composition of the morphism `CategoryTheory.ShortComplex.LeftHomologyData.f' h` with the morphism `h.π` is a zero morphism. In other words, it refers to a condition in the category theory where the composition of two specific morphisms results in a zero morphism.

For any category `C` with zero morphisms and any left homology data `h` of a short complex `S` in `C`, the composition of `CategoryTheory.ShortComplex.LeftHomologyData.f' h` and `h.π` is the zero morphism.


theorem AdjoinRoot.minpoly_root :
    ∀ {K : Type w} [inst : Field K] {f : Polynomial K},
      f ≠ 0 → minpoly K (AdjoinRoot.root f) = f * Polynomial.C (Polynomial.leadingCoeff f)⁻¹ :=
  by sorry

This theorem states that for any field `K` and any non-zero polynomial `f` over `K`, the minimal polynomial of the adjoined root of `f` is equal to `f` multiplied by the multiplicative inverse of the constant polynomial of the leading coefficient of `f`. Here, the minimal polynomial of an element over a field is the least degree monic polynomial which the element satisfies. The leading coefficient of a polynomial is the coefficient of the highest power of `X`. The constant polynomial of a number is the polynomial which is constantly that number.

For any field `K` and non-zero polynomial `f` over `K`, the minimal polynomial of the root of `f` is `f` multiplied by the multiplicative inverse of `f`'s leading coefficient.


/-- **Alias** of `ModelWithCorners.isClosed_range`. -/
theorem ModelWithCorners.closed_range :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H),
      IsClosed (Set.range ↑I) :=
  by sorry

This theorem, named `ModelWithCorners.closed_range`, states that for any non-trivially normed field `𝕜`, any normed additive commutative group `E` modeled over `𝕜`, and any topological space `H`, if `I` is a `ModelWithCorners` instance for these mathematical structures, then the range of the function `I` (the set of all possible output values of `I`) is a closed set in the topology of the output space.

For any non-trivially normed field `𝕜`, normed additive commutative group `E` over `𝕜`, and topological space `H`, if `I` is a `ModelWithCorners` instance for these structures, then the range of `I` is a closed set in the output space `H`.


theorem exists_pow_eq_self_of_coprime :
    ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, Nat.Coprime n (orderOf x) → ∃ m, (x ^ n) ^ m = x := by sorry

The theorem "exists_pow_eq_self_of_coprime" states that for any type `G` that forms a Monoid, any element `x` of this Monoid, and any natural number `n` such that `n` and the order of `x` are coprime (their greatest common divisor is 1), there exists a natural number `m` such that raising `x` to the power of `n` and then to the power of `m` gives `x` back. In mathematical notation, if gcd(`n`, order(`x`)) = 1, then there exists `m` such that `(x^n)^m = x`.

For any Monoid `G` and element `x` of `G` with coprime order `n`, there exists a natural number `m` such that `x^(nm) = x`.


theorem FirstOrder.Language.Theory.model_iff_subset_completeTheory :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M]
      {T : FirstOrder.Language.Theory L}, M ⊨ T ↔ T ⊆ FirstOrder.Language.completeTheory L M :=
  by sorry

This theorem states that for any first-order language `L`, structure `M` of language `L`, and theory `T` of language `L`, `M` is a model of `T` if and only if `T` is a subset of the complete theory of `M` in `L`. In other words, a structure `M` satisfies a theory `T` exactly when every sentence in `T` is also in the set of all sentences that `M` satisfies, that is, the complete theory of `M`.

A first-order structure modelally satisfies a theory if and only if the theory is a subset of its complete theory.


theorem Mathlib.RingTheory.Nilpotent._auxLemma.2 : ∀ {R : Type u_1} [inst : MonoidWithZero R], IsNilpotent 0 = True :=
  by sorry

This theorem states that for any type `R` that is a Monoid with zero (meaning that `R` is a set with a binary operation that is associative, has an identity element, and has an element which behaves as a zero), the zero element is nilpotent. In mathematical terms, this means there exists a natural number `n` such that `0^n = 0`. As this is always true, the result of the theorem is `True`.

For any monoid with zero, thezero element is nilpotent. (That is, there exists a natural number n such that 0^n = 0.)


/-- Transport a `HasLimitsOfShape` instance across an equivalence.  -/
theorem CategoryTheory.Adjunction.hasLimitsOfShape_of_equivalence :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [inst_2 : CategoryTheory.Category.{v, u} J]
      (E : CategoryTheory.Functor D C) [inst_3 : CategoryTheory.IsEquivalence E]
      [inst : CategoryTheory.Limits.HasLimitsOfShape J C], CategoryTheory.Limits.HasLimitsOfShape J D :=
  by sorry

This theorem states that for any categories `C`, `D` and `J`, if `C` has limits of shape `J` and we have a functor `E` that is an equivalence from `D` to `C`, then `D` also has limits of shape `J`. In other words, "limits of shape-ness" can be carried over to another category through an equivalence. This relates to an important concept in category theory, where certain properties can be transported across equivalent categories.

If `C` has limits of shape `J` and `E: D ⥤ C` is an equivalence of categories, then `D` has limits of shape `J`.


theorem himp_le_himp_left : ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, a ≤ b → c ⇨ a ≤ c ⇨ b :=
  by sorry

This theorem states that for any type `α` that forms a Generalized Heyting Algebra, given three elements `a`, `b`, and `c` of that type, if `a` is less than or equal to `b`, then the implication of `c` towards `a` is less than or equal to the implication of `c` towards `b`. In other words, increasing the consequent of an implication in a Heyting Algebra increases the implication itself.

For any type `α` forming a Generalized Heyting Algebra and elements `a`, `b`, `c` of `α`, if `a ≤ b`, then `(c → a) ≤ (c → b)`.


theorem ZFSet.mem_powerset : ∀ {x y : ZFSet}, y ∈ ZFSet.powerset x ↔ y ⊆ x := by sorry

This theorem, `ZFSet.mem_powerset`, states that for any two ZF sets `x` and `y`, `y` is an element of the powerset of `x` if and only if `y` is a subset of `x`. In other words, it sets up an equivalence between a ZF set `y` being in the powerset of `x` and `y` being a subset of `x`, which is a fundamental property of powersets in set theory.

For any ZF sets `x` and `y`, `y` is an element of the powerset of `x` if and only if `y` is a subset of `x`.


theorem List.pwFilter_cons_of_neg :
    ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] {a : α} {l : List α},
      (¬∀ b ∈ List.pwFilter R l, R a b) → List.pwFilter R (a :: l) = List.pwFilter R l :=
  by sorry

The theorem `List.pwFilter_cons_of_neg` states that for any type `α`, any decidable relation `R` on `α`, and any elements `a` of type `α` and `l` of type List `α`, if it is not the case that `R` holds for `a` and all elements in the pairwise filter of `l` with respect to `R`, then the pairwise filter of the list obtained by prepending `a` to `l` with respect to `R` is the same as the pairwise filter of `l` with respect to `R`. In other words, if `a` does not satisfy the relation `R` with every element in the pairwise filtered list `l`, then `a` is not included in the pairwise filtered list of `a :: l`.

If `α` is a type with decidable relation `R`, and `a` is not in the pairwise filter of `l` with respect to `R`, then `a` is not in the pairwise filter of `a :: l` with respect to `R`.


/-- If one affine subspace is less than or equal to another, the same applies to their
directions.  -/
theorem AffineSubspace.direction_le :
    ∀ {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] {s1 s2 : AffineSubspace k P},
      s1 ≤ s2 → AffineSubspace.direction s1 ≤ AffineSubspace.direction s2 :=
  by sorry

The theorem `AffineSubspace.direction_le` states that for any types `k`, `V`, and `P`, where `k` is a ring, `V` is an additive commutative group, `V` is a `k`-module, and `P` is an affine space over `V`, if we have two affine subspaces `s1` and `s2` of `P` such that `s1` is a subset of `s2` (denoted by `s1 ≤ s2`), then the direction of `s1` is also a subset of the direction of `s2`. In other words, if one affine subspace is contained within another, any vector that can be expressed as a difference of two points in the smaller subspace can also be expressed as a difference of two points in the larger subspace. The term "direction" of an affine subspace refers to the subspace of the vector space spanned by the differences of pairs of points in the affine subspace.

If `s1` is a subset of `s2` in the affine spaces `P` over a `k`-module `V`, then the direction of `s1` is contained in the direction of `s2`.


Inducing.continuousSMul

/-- Suppose that `N` acts on `X` and `M` continuously acts on `Y`.
Suppose that `g : Y → X` is an action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c • x) = f c • g x`.
Then the action of `N` on `X` is continuous as well.

In many cases, `f = id` so that `g` is an action homomorphism in the sense of `MulActionHom`.
However, this version also works for semilinear maps and `f = Units.val`.  -/
theorem Inducing.continuousSMul :
    ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
      [inst_2 : TopologicalSpace Y] [inst_3 : SMul M X] [inst_4 : ContinuousSMul M X] {g : Y → X} {N : Type u_5}
      [inst_5 : SMul N Y] [inst_6 : TopologicalSpace N] {f : N → M},
      Inducing g → Continuous f → (∀ {c : N} {x : Y}, g (c • x) = f c • g x) → ContinuousSMul N Y :=
  by sorry

This theorem, `Inducing.continuousSMul`, states that if we have two types `N` and `M` acting on types `X` and `Y` respectively, with both actions being continuous, and if there is a homomorphism `g : Y → X` such that there exists a continuous function `f : N → M` satisfying `g (c • x) = f c • g x` for any `c : N` and `x : Y`, then we can conclude that the action of `N` on `Y` is also continuous. This theorem is particularly useful in scenarios such as semilinear maps where `f` might equal `Units.val`.

If `N` and `M` are continuous actions on types `Y` and `X` respectively, and there exists a homomorphism `g : Y → X` and a continuous function `f : N → M` such that `g (c • y) = f c • g y` for all `c : N` and `y : Y`, then the action of `N` on `Y` is continuous.