/-- The kernel of `S.normedMk` is `S`.  -/
theorem AddSubgroup.ker_normedMk :
    ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M),
      NormedAddGroupHom.ker (AddSubgroup.normedMk S) = S :=
  by sorry

This theorem states that for any given seminormed additive commutative group `M` and any additive subgroup `S` of `M`, the kernel of the morphism from `M` to the quotient group `M / S` (generated by the `normedMk` function applied to `S`) is exactly `S` itself. Here, the kernel of a group homomorphism is the set of all elements in the domain that map to the identity in the codomain.

The kernel of the quotient homomorphism from a seminormed additive commutative group to its quotient by an additive subgroup equals the subgroup itself.


theorem Summable.sigma_factor :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [inst_2 : UniformAddGroup α]
      [inst_3 : CompleteSpace α] {γ : β → Type u_5} {f : (b : β) × γ b → α},
      Summable f → ∀ (b : β), Summable fun c => f { fst := b, snd := c } :=
  by sorry

The theorem `Summable.sigma_factor` states that for any types `α` and `β`, any additive commutative group structure on `α`, and a uniform space and uniform additive group structure on `α` where `α` is complete, given a function `f` from the cartesian product of `β` and a type `γ` dependent on `β` to `α` that is summable (i.e., the infinite sum of `f` exists), then for each fixed `b` in `β`, the function `f` applied to the pair `(b, c)` is also summable over all `c` in the type `γ b`. Essentially, it asserts that if an infinite sum over a dependent pair type exists, then the infinite sum over each "slice" of the dependent pair type also exists.

For any additive commutative group `α` with a complete uniform structure, and a summable function `f : β × γ → α`, the function `f` is summable for each fixed `b ∈ β` over the dependent type `γ b`.


theorem NegMemClass.coe_neg :
    ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_6} {H : S} [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G]
      (x : ↥H), ↑(-x) = -↑x :=
  by sorry

This theorem states that for any type `G` that has an `AddGroup` structure, any type `S`, any `H` of type `S` that has a `SetLike` structure and is an `AddSubgroupClass` of `G`, and any element `x` from `H`, the inverse of `x` in `H` is equal to the inverse of the coerced `x` in `G`. In mathematical terms, this means that if `H` is a subgroup of an additive group `G`, then the negation of an element in `H` is the same as the negation of that element in `G` when both are considered in the context of `G`.

For any additive group `G`, subgroup `H` of `G` with `AddSubgroupClass` structure, and element `x` in `H`, the negation of `x` in `H` equals the negation of `x` in `G` as elements of `G`.


theorem Set.indicator_eq_zero :
    ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {s : Set α} {f : α → M},
      (Set.indicator s f = fun x => 0) ↔ Disjoint (Function.support f) s :=
  by sorry

The theorem `Set.indicator_eq_zero` states that for any set `s` of elements of type `α`, and any function `f` from `α` to any Type `M` with a defined `Zero`, the indicator function `Set.indicator s f` is identically zero if and only if the support of `f`, i.e., the set of points `x` where `f(x)` is not zero, is disjoint from the set `s`. Here, two elements (or sets) are defined to be disjoint if their infimum (greatest lower bound) is the bottom element of the lattice.

The indicator function of a set with respect to a function is equal to the zero function if and only if the support of the function is disjoint from the set.


ImplicitFunctionData.hasStrictFDerivAt

theorem ImplicitFunctionData.hasStrictFDerivAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
      [inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
      [inst_8 : NormedSpace 𝕜 G] [inst_9 : CompleteSpace G] (φ : ImplicitFunctionData 𝕜 E F G),
      HasStrictFDerivAt (ImplicitFunctionData.prodFun φ)
        (↑(ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv ⋯ ⋯ ⋯)) φ.pt :=
  by sorry

The theorem `ImplicitFunctionData.hasStrictFDerivAt` states that for any scalar field 𝕜 (that is a nontrivial normed field), normed additive commutative groups E, F, and G (with E, F, and G also being complete normed spaces over 𝕜), and any Implicit Function Data φ, the function `ImplicitFunctionData.prodFun φ` has a strict Frechet derivative at the point φ.pt. The Frechet derivative is represented by the continuous linear map obtained by applying the function `ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl` to φ's left and right derivatives.

For any nontrivial normed field 𝕜 and Implicit Function Data φ over complete normed spaces E, F, and G, the function `ImplicitFunctionData.prodFun φ` has a strict Frechet derivative at φ.pt represented by the product of its left and right derivatives as continuous linear maps.


theorem iSup_ge_eq_iSup_nat_add :
    ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ), ⨆ i, ⨆ (_ : i ≥ n), u i = ⨆ i, u (i + n) := by
  sorry

This theorem states that for any type `α` that forms a complete lattice, and for any function `u` mapping natural numbers to elements of `α`, and for any natural number `n`, the supremum (greatest lower bound) of `u i` for all `i` greater than or equal to `n` is equal to the supremum of `u(i + n)` for all `i`. In other words, shifting the indices of the function by `n` doesn't change the supremum of the function values.

For any complete lattice `α` and function `u` mapping natural numbers to `α`, the supremum of `u i` for all `i ≥ n` equals the supremum of `u(i + n)` for all `i` in `ℕ`.


theorem MeasureTheory.AnalyticSet_def :
    ∀ {α : Type u_3} [inst : TopologicalSpace α] (s : Set α),
      MeasureTheory.AnalyticSet s = (s = ∅ ∨ ∃ f, Continuous f ∧ Set.range f = s) :=
  by sorry

The theorem `MeasureTheory.AnalyticSet_def` states that for any set `s` of a certain type `α` in a topological space, `s` is an analytic set if and only if `s` is either an empty set or there exists a continuous function `f` such that its range is `s`. Here, topological space refers to a set endowed with the structure that allows the definition of continuity of functions, and continuous function is a function where small changes in the input result in small changes in the output. The range of a function is the set of all possible output values.

A set in a topological space is analytic if and only if it is empty or the range of a continuous function.


theorem Finset.coe_div :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Div α] (s t : Finset α), ↑(s / t) = ↑s / ↑t := by sorry

This theorem, `Finset.coe_div`, states that for any type `α` that has decidable equality and a division operation, for any two finite sets `s` and `t` of type `α`, the operation of dividing the co-domain of `s` by the co-domain of `t` is the same as the co-domain of the result of dividing `s` by `t`. In other words, division distributes over the co-domain operation for finite sets in this context.

For any type `α` with decidable equality and division operation, the co-domain of `s / t` equals the co-domain of `s` divided by the co-domain of `t` for finite sets `s` and `t` of type `α`.


theorem Filter.prod_atBot_atBot_eq :
    ∀ {β₁ : Type u_6} {β₂ : Type u_7} [inst : Preorder β₁] [inst_1 : Preorder β₂],
      Filter.atBot ×ˢ Filter.atBot = Filter.atBot :=
  by sorry

This theorem states that for any two types `β₁` and `β₂` that have preorder relationships, the product of filters `atBot` (which represents the limit towards negative infinity on an ordered set) over both types is the same as the `atBot` filter. In mathematical terms, this means that the limit as both variables approach negative infinity in a Cartesian product space of two preordered sets is the same as the limit as a single variable approaches negative infinity in a single preordered set.

For any preordered types `β₁` and `β₂`, the filter of limits towards negative infinity on their product equals the filter of limits towards negative infinity on each type.


List.Sublist.filterMap

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

This theorem states that for any two lists `l₁` and `l₂` of any type `α`, and any function `f` from `α` to `Option β`, if `l₁` is a sublist of `l₂`, then the result of applying `filterMap` with `f` to `l₁` is also a sublist of the result of applying `filterMap` with `f` to `l₂`. In other words, the `filterMap` function preserves the sublist relation between `l₁` and `l₂`.

For any lists `l₁` and `l₂` of type `α` and any function `f : α → Option β`, if `l₁` is a sublist of `l₂`, then `filterMap f l₁` is a sublist of `filterMap f l₂`.


theorem CategoryTheory.Functor.map_dite :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} {P : Prop}
      [inst_2 : Decidable P] (f : P → (X ⟶ Y)) (g : ¬P → (X ⟶ Y)),
      F.map (if h : P then f h else g h) = if h : P then F.map (f h) else F.map (g h) :=
  by sorry

This is a theorem in category theory which states that, given any two categories `C` and `D`, along with a functor `F` from `C` to `D`, and two morphisms `f` and `g` from object `X` to `Y` in `C` that depend on a proposition `P`, the map of `F` applied to the disjunction `f` or `g` (depending on `P`) is equal to the disjunction of the map of `F` applied to `f` or `g` (again, depending on `P`). In simpler terms, it says that the functor `F` preserves the logical disjunction operation on morphisms.

Given any functor F between categories C and D, and objects X, Y in C, morphisms f, g : X → Y, and proposition P, the diagram F(f ⊎ g) ≅ F(f) ⊎ F(g) commutes, where ⊎ denotes disjunction.


theorem Continuous.quotient_liftOn' :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Setoid X} {f : X → Y},
      Continuous f → ∀ (hs : ∀ (a b : X), Setoid.r a b → f a = f b), Continuous fun x => Quotient.liftOn' x f hs :=
  by sorry

The theorem `Continuous.quotient_liftOn'` states that for any types `X` and `Y` endowed with topological spaces, a setoid `s` on `X`, and a continuous function `f` from `X` to `Y`, if `f` respects the equivalence relation of the setoid (i.e., `f` maps equivalent elements to the same element), then the function defined by lifting `f` to the quotient of `X` by the setoid, `Quotient.liftOn' x f hs`, is also continuous. This is essentially stating a property about the preservation of continuity under the operation of taking quotients by an equivalence relation.

If `f : X → Y` is a continuous function between topological spaces `X` and `Y`, respecting the equivalence relation of a setoid `s` on `X`, then the function `Quotient.liftOn' x f hs` obtained by lifting `f` to the quotient `X/s` is also continuous.


theorem Polynomial.aeval_modByMonic_eq_self_of_root :
    ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {p q : Polynomial R},
      Polynomial.Monic q →
        ∀ {x : S}, (Polynomial.aeval x) q = 0 → (Polynomial.aeval x) (p %ₘ q) = (Polynomial.aeval x) p :=
  by sorry

The theorem `Polynomial.aeval_modByMonic_eq_self_of_root` states that for any commutative ring `R`, ring `S`, and an algebra structure on `S` over `R`, given two polynomials `p` and `q` over `R`, if `q` is monic (its leading coefficient is 1), then for any valuation `x` in `S` that is a root of `q` (i.e., `q` evaluated at `x` equals 0), evaluating `p` modulo `q` at `x` is the same as directly evaluating `p` at `x`. This theorem is a reflection of the fact that if `x` is a root of a monic polynomial `q`, then `x` "behaves as if `q` is zero" when evaluating any polynomial modulo `q`.

For any commutative rings R, ring S with an algebra structure over R, monic polynomial q over R, and root x of q in S, the evaluation of p modulo q at x equals the direct evaluation of p at x.


theorem Set.mem_compl_singleton_iff : ∀ {α : Type u} {a x : α}, x ∈ {a}ᶜ ↔ x ≠ a := by sorry

This theorem states that for any given type `α` and any two instances `a` and `x` of that type, `x` is a member of the complement of the singleton set `{a}` if and only if `x` is not equal to `a`. In other words, an element belongs to the complement of a singleton set if it is different from the single element in the original set.

For any type `α` and its elements `a` and `x`, `x ∈ ∉{a} ↔ x ≠ a`.


theorem Polynomial.degree_monomial_le :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (a : R), Polynomial.degree ((Polynomial.monomial n) a) ≤ ↑n := by sorry

This theorem states that for any semiring `R`, any natural number `n`, and any element `a` of `R`, the degree of the monomial `a * X^n` is less than or equal to `n`. In other words, the highest power of `X` that appears in the polynomial `a * X^n` is at most `n`. This is a characteristic property of monomials in any polynomial algebra over a semiring.

For any semiring `R`, the degree of the monomial `a * X^n` with `a` in `R` and `n` a natural number, is bounded by `n`.


theorem Filter.lift'_principal :
    ∀ {α : Type u_1} {β : Type u_2} {h : Set α → Set β} {s : Set α},
      Monotone h → Filter.lift' (Filter.principal s) h = Filter.principal (h s) :=
  by sorry

The theorem `Filter.lift'_principal` states that for all types `α` and `β`, a function `h` from sets of `α` to sets of `β`, and a set `s` of type `α`, if `h` is monotone (i.e., preserves the order), then lifting the principal filter of `s` via `h` is equivalent to the principal filter of the set `h(s)`. In simpler terms, applying `h` to each element of the principal filter of `s` (a collection of all supersets of `s`) and then creating a new filter from the results gives the same filter as if we simply applied `h` to `s` and took the principal filter of the result.

For all types `α` and `β`, if `h : ℙ(α) → ℙ(β)` is monotone and `s : α`, then `filter.lift h (filter.principal s) = filter.principal (h s)`.


theorem CategoryTheory.Limits.biprod.inr_map_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X]
      [inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z) {Z_1 : C} (h : Y ⊞ Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g) h) =
        CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inr h) :=
  by sorry

The theorem `CategoryTheory.Limits.biprod.inr_map_assoc` states that for any category `C` that has zero morphisms, and for any four objects `W, X, Y, Z` in this category `C` with binary biproducts `W ⊞ X` and `Y ⊞ Z`, given morphisms `f : W ⟶ Y`, `g : X ⟶ Z`, and another morphism `h : Y ⊞ Z ⟶ Z_1`, the composition of the inclusion into the second summand `biprod.inr` followed by the composition of the map `biprod.map f g` with `h` is equal to the composition of `g` with the composition of `biprod.inr` and `h`. In more intuitive terms, this theorem expresses a commutative property of certain mappings associated with binary biproducts in a category.

For any morphisms `f : W ⟶ Y`, `g : X ⟶ Z`, and `h : Y ⊞ Z ⟶ Z_1` in a category `C` with zero morphisms and binary biproducts, `h ∘ biprod.map f g ∘ biprod.inr = g ∘ h ∘ biprod.inr` for objects `W, X, Y, Z` in `C`.


/-- A constructor for `PosSMulReflectLT` requiring you to prove `a • b₁ < a • b₂ → b₁ < b₂` only
when `0 < a` -/
theorem PosSMulReflectLT.of_pos :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
      [inst_3 : PartialOrder α] [inst_4 : Preorder β],
      (∀ (a : α), 0 < a → ∀ (b₁ b₂ : β), a • b₁ < a • b₂ → b₁ < b₂) → PosSMulReflectLT α β :=
  by sorry

The theorem `PosSMulReflectLT.of_pos` is a constructor for `PosSMulReflectLT`. It requires a proof that, for all types `α` and `β` where `α` has a zero, `β` has a zero, `α` can be scalar multiplied with `β` with zero, `α` has a partial order, and `β` has a preorder, if a scalar `a` is greater than zero, then for any `b₁` and `b₂` in `β`, if `a` scalar multiplied with `b₁` is less than `a` scalar multiplied with `b₂`, then `b₁` is less than `b₂`.

Given types `α` and `β` with zeroes, scalar multiplication `α × β → α`, partial order on `α`, and preorder on `β`, if `a` is a positive scalar, then `a * b₁ < a * b₂` implies `b₁ < b₂`.


theorem Filter.Tendsto.finset_sup_nhds_apply :
    ∀ {L : Type u_1} [inst : TopologicalSpace L] {ι : Type u_3} {α : Type u_4} {s : Finset ι} {f : ι → α → L}
      {l : Filter α} {g : ι → L} [inst_1 : SemilatticeSup L] [inst_2 : OrderBot L] [inst_3 : ContinuousSup L],
      (∀ i ∈ s, Filter.Tendsto (f i) l (nhds (g i))) →
        Filter.Tendsto (fun a => Finset.sup s fun x => f x a) l (nhds (Finset.sup s g)) :=
  by sorry

This theorem states that for a given topological space `L`, a finset `s` with elements of type `ι`, a function `f` mapping `ι` to a function from `α` to `L`, a filter `l` over `α`, a function `g` mapping `ι` to `L`, if `L` is equipped with a semilattice structure, a bottom element, and a continuity property for the supremum operation, then if for each element `i` in `s`, the function `f i` tends to the neighborhood filter of `g i` under the filter `l`, then the function that takes an element of `α` and maps it to the supremum of the set `{f x a | x ∈ s}` also tends to the neighborhood filter of the supremum of the set `{g x | x ∈ s}` under the filter `l`.

The theorem is about the convergence of a function mapping to the supremum of a set of functions within a topological space that has a semilattice structure with a bottom element and a continuous supremum operation. It essentially says that if each individual function in the set converges to a point, then the function mapping to the supremum of these functions also converges to the supremum of these points.

Given a topological space equipped with a semilattice structure, a bottom element, and continuous supremum operation, if for each element in a finite set and corresponding functions from the set to the space, the functions converge to their respective neighborhood filters under a filter, then the function mapping each element to the supremum of the set of functions for that element converges to the supremum of the neighborhood filters under the filter.


theorem CategoryTheory.NonPreadditiveAbelian.sub_self :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
      (a : X ⟶ Y), a - a = 0 :=
  by sorry

This theorem states that for any category `C` that is also a `NonPreadditiveAbelian` category, and for any two objects `X` and `Y` in `C`, if `a` is a morphism from `X` to `Y`, then subtracting `a` from itself results in the zero morphism. This is the analogue in category theory of the algebraic property that any number minus itself equals zero.

For any object `X`, `Y` in a `NonPreadditiveAbelian` category `C` and morphism `a` from `X` to `Y`, `a` equals its negative, i.e., `a + (-a) = 0`.


theorem instPartialOrderAntisymmetrization.proof_1 :
    ∀ {α : Type u_1} [inst : Preorder α] (x x_1 x_2 x_3 : α),
      Setoid.r x x_2 → Setoid.r x_1 x_3 → (x ≤ x_1) = (x_2 ≤ x_3) :=
  by sorry

This theorem states that for any type `α` that is preordered (denoted as `inst : Preorder α`), and for any four elements `x`, `x_1`, `x_2`, `x_3` of this type, if `x` is equivalent to `x_2` and `x_1` is equivalent to `x_3` (as per the equivalence relation of a setoid, denoted as `Setoid.r`), then the statement "`x` is less than or equal to `x_1`" (denoted as `x ≤ x_1`) is equivalent to the statement "`x_2` is less than or equal to `x_3`" (denoted as `x_2 ≤ x_3`). In other words, the order relationship between `x` and `x_1` is the same as the order relationship between `x_2` and `x_3` when `x` is equivalent to `x_2` and `x_1` is equivalent to `x_3`.

For any preordered type `α` and elements `x`, `x_1`, `x_2`, `x_3` of `α` such that `x ≈ x_2` and `x_1 ≈ x_3` (where `≈` is the equivalence relation of a setoid), the order relationship `x ≤ x_1` holds if and only if `x_2 ≤ x_3`.


theorem SimpleGraph.Iso.apply_mem_neighborSet_iff :
    ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ≃g G') {v w : V},
      f w ∈ SimpleGraph.neighborSet G' (f v) ↔ w ∈ SimpleGraph.neighborSet G v :=
  by sorry

The theorem `SimpleGraph.Iso.apply_mem_neighborSet_iff` states that for any types `V` and `W` and for any simple graphs `G` of type `V` and `G'` of type `W`, if there is a graph isomorphism `f` between `G` and `G'`, then for any vertices `v` and `w` of `G`, `w` is in the neighbor set of `v` in `G` if and only if the image of `w` under `f` is in the neighbor set of the image of `v` under `f` in `G'`. In other words, the graph isomorphism `f` preserves the adjacency relationship between vertices.

For simple graphs G of type V and G' of type W, if there is a graph isomorphism f between them, then v and w are adjacent in G if and only if the images of v and w under f are adjacent in G'.


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

This theorem states that for any type `β`, any indexing type `ι`, any set `s` of type `β`, and any indexed family of sets `t` of type `β` indexed by `ι`, the difference between the union of all `t i` and `s` is equal to the union of the differences between each `t i` and `s`. In mathematical notation, it says that $(\bigcup_i t_i) \setminus s = \bigcup_i (t_i \setminus s)$. This is a property about the interaction between the operations of union and set difference.

For any type `β`, indexing type `ι`, set `s` of type `β`, and indexed family `t` of sets of type `β` indexed by `ι`, the difference between the union of `t` and `s` is equal to the union of the differences between each `t i` and `s`. In mathematical notation, $(\bigcup_i t_i) \setminus s = \bigcup_i (t_i \setminus s)$.


AffineSubspace.SSameSide.wSameSide

theorem AffineSubspace.SSameSide.wSameSide :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y : P},
      AffineSubspace.SSameSide s x y → AffineSubspace.WSameSide s x y :=
  by sorry

This theorem states that for any strict ordered commutative ring `R`, additive commutative group `V`, module `V` over `R`, additive torsor `P` over `V`, affine subspace `s` of `P`, and points `x` and `y` in `P`, if `x` and `y` are strictly on the same side of `s` (which means they are on the same side of `s` and both are not in `s`), then `x` and `y` are weakly on the same side of `s`.

In the weak sense, `x` and `y` being on the same side of `s` means that there exist points `p₁` and `p₂` in `s` such that `x - p₁` and `y - p₂` are in the same ray in `R` (they are scalar multiples of each other where the scalar is non-negative).

For any strict ordered commutative ring `R`, additive commutative group `V` with `R`-module structure, additive torsor `P` over `V`, affine subspace `s` of `P`, and points `x, y` in `P` not lying in `s`, if `x` and `y` are strictly on the same side of `s`, then `x - y` and `y - x` generate the same ray in `R^+`, the set of non-negative elements of `R`.


theorem CategoryTheory.Functor.mapIso_trans :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
      (F : CategoryTheory.Functor C D) {X Y Z : C} (i : X ≅ Y) (j : Y ≅ Z),
      F.mapIso (i ≪≫ j) = F.mapIso i ≪≫ F.mapIso j :=
  by sorry

In the context of category theory, this theorem states that for any category `C` and `D`, and any functor `F` mapping `C` to `D`, if we have isomorphisms `i` and `j` for objects `X`, `Y`, and `Z` in `C` such that `X ≅ Y` and `Y ≅ Z`, then the isomorphism induced by the functor `F` on the composition of the isomorphisms `i` and `j` is the same as the composition of the isomorphisms induced by `F` on `i` and `j` individually. In other words, functor preserves the transitivity of isomorphisms.

For any functor F between categories C and D, if X iso Y and Y iso Z in C imply F(X) iso F(Y) iso F(Z) in D, then F preserves the transitivity of isomorphisms.


/-- A set `s` is compact if for every open cover of `s`, there exists a finite subcover.  -/
theorem isCompact_of_finite_subcover :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
      (∀ {ι : Type u} (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ t, s ⊆ ⋃ i ∈ t, U i) →
        IsCompact s :=
  by sorry

This theorem states that a set `s` is compact in a given topological space, if for every open cover of `s`, there exists a finite subcover. In other words, if for any collection of open sets `U` indexed by `ι` (where each `U i` is an open set) that covers `s` (i.e., `s` is a subset of the union of these open sets), there exists a finite index set `t` such that `s` is also a subset of the union of the `U i` for `i` in `t`, then `s` is a compact set. This is a common formulation of compactness in topology, and one of its main uses is in proving the Heine-Borel theorem.

A set is compact in a topological space if every open cover has a finite subcover.


theorem IsPreconnected.subset_left_of_subset_union :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s u v : Set α},
      IsOpen u → IsOpen v → Disjoint u v → s ⊆ u ∪ v → Set.Nonempty (s ∩ u) → IsPreconnected s → s ⊆ u :=
  by sorry

This theorem states that for any type `α` equipped with a topological space structure, given sets `s`, `u`, and `v` such that `u` and `v` are open sets and disjoint, if `s` is a subset of the union of `u` and `v`, and the intersection of `s` and `u` is nonempty, then if `s` is a preconnected set, it must be a subset of `u`. In essence, if a preconnected set `s` lies within the union of two disjoint open sets `u` and `v` and overlaps with `u`, then `s` must be entirely contained within `u`.

If `α` is a topological space, `s` is a preconnected subset of `α`, `u` and `v` are disjoint open sets such that `s ⊆ u ∪ v` and `s ∩ u` is nonempty, then `s ⊆ u`.


theorem AddSubgroup.eq_bot_of_subsingleton :
    ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [inst_1 : Subsingleton ↥H], H = ⊥ := by sorry

This theorem states that for any additive group 'G' and an additive subgroup 'H' of 'G', if 'H' is a subsingleton (meaning it contains at most one element), then 'H' is equal to the trivial group (denoted by ⊥, the bottom element). In other words, an additive subgroup of a group is trivial if and only if it is a subsingleton.

An additive subgroup of a group is the trivial subgroup if and only if it contains at most one element.


theorem BoundedContinuousFunction.dist_le_two_norm' :
    ∀ {β : Type v} {γ : Type w} [inst : SeminormedAddCommGroup β] {f : γ → β} {C : ℝ},
      (∀ (x : γ), ‖f x‖ ≤ C) → ∀ (x y : γ), dist (f x) (f y) ≤ 2 * C :=
  by sorry

This theorem states that for any type `β` which is a seminormed add commutative group and a function `f` from type `γ` to `β`, given a real number `C`, if the norm of `f(x)` is less than or equal to `C` for all `x` of type `γ`, then the distance between `f(x)` and `f(y)` for any `x` and `y` of type `γ` is less than or equal to `2*C`. It essentially establishes a bound on the distance between the image points of any two elements under a function in terms of a constant `C` that bounds the norm of the function.

Given a seminormed add commutative group `β` and a function `f` from type `γ` to `β`, if the norm of `f(x)` is bounded by `C` for all `x` in `γ`, then the norm of `f(x) - f(y)` is less than or equal to `2*C` for all `x` and `y` in `γ`.


theorem CategoryTheory.Functor.sections_property :
    ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w)}
      (s : ↑(CategoryTheory.Functor.sections F)) {j j' : J} (f : j ⟶ j'), F.map f (↑s j) = ↑s j' :=
  by sorry

This theorem states that for any category `J` and any functor `F` from `J` to the category of Types, if `s` is a section of the functor `F`, then for every morphism `f` from `j` to `j'` in `J`, the image of `f` under the functor `F`, applied to `s(j)`, equals `s(j')`. In simpler terms, this theorem establishes that the sections of a functor `F` have the property that they map morphisms in `J` to morphisms in the category of Types in a way that is consistent with the action of the functor `F`.

Given a category J and a functor F from J to Types, if s is a section of F, then for all morphisms f from j to j' in J, F(f)(s(j)) = s(j').


theorem PMF.support_pure : ∀ {α : Type u_1} (a : α), PMF.support (PMF.pure a) = {a} := by sorry

This theorem states that for any type `α` and any element `a` of type `α`, the support of the pure probability mass function (PMF) at `a` is the set consisting only of `a`. In other words, the pure PMF, which assigns a probability of 1 to `a` and a probability of 0 to all other points, has its support (the set where it is nonzero) at just the one point `a`.

For any type `α` and element `a` of type `α`, the support of the pure probability mass function at `a` is the singleton set `{a}`.


/-- A subring is closed under subtraction  -/
theorem Subring.sub_mem : ∀ {R : Type u} [inst : Ring R] (s : Subring R) {x y : R}, x ∈ s → y ∈ s → x - y ∈ s := by
  sorry

This theorem states that a subring of a ring is closed under subtraction. In more detail, given any ring `R`, and any `Subring` `s` of `R`, if `x` and `y` are any two elements of `s`, then the result of subtracting `y` from `x` (i.e., `x - y`) is also an element of `s`.

If `s` is a subring of a ring `R`, then for all `x, y ∈ s`, `x - y ∈ s`.


/-- See also `Fintype.card_zpowers`.  -/
theorem Nat.card_zpowers : ∀ {α : Type u_3} [inst : Group α] (a : α), Nat.card ↥(Subgroup.zpowers a) = orderOf a := by
  sorry

The theorem `Nat.card_zpowers` states that for any group `α` and any element `a` of this group, the cardinality of the subgroup generated by `a` (obtained using the `Subgroup.zpowers` function on `a`) is equal to the order of the element `a` (obtained using the `orderOf` function). In other words, the number of distinct elements in the subgroup generated by an element is the same as the order of that element. The order of an element is the smallest positive integer `n` such that raising the element to the power `n` gives the identity of the group. If such an `n` does not exist (the element has infinite order), both the cardinality of the subgroup and the order of the element are defined to be `0`.

The cardinality of the subgroup generated by an element in a group equals the order of that element.


theorem Complex.norm_real : ∀ (r : ℝ), ‖↑r‖ = ‖r‖ := by sorry

This theorem states that for all real numbers `r`, the norm of `r` when it is considered as a complex number (denoted by `↑r`) is equal to the norm of `r` as a real number. In other words, the magnitude of a real number remains the same whether it is considered in the real number space or the complex number space.

For all real numbers r, the norm of the complex number ↑r equals the absolute value of r.


theorem Mathlib.Data.List.Cycle._auxLemma.9 : ∀ {α : Type u_1} (l : List α), (↑l = Cycle.nil) = (l = []) := by sorry

This theorem states that for any type `α` and a list `l` of type `α`, the list `l` casted to a `Cycle` type is equal to the unique empty cycle if and only if the list `l` is an empty list. In other words, a list is empty if and only if its corresponding cycle representation is also empty.

For any type `α`, the list `l` of type `α` is empty if and only if the associated `Cycle` type representation of `l` is the empty cycle.


theorem pow_bit0 : ∀ {M : Type u} [inst : Monoid M] (a : M) (n : ℕ), a ^ bit0 n = a ^ n * a ^ n := by sorry

The theorem `pow_bit0` states that for any type `M` that is a monoid, for any element `a` of `M` and any natural number `n`, the power of `a` raised to `bit0 n` equals the product of `a` raised to `n` and `a` raised to `n`. In mathematical terms, it means that a^(2n) = a^n * a^n for any monoid element `a` and any natural number `n`. Here, `bit0 n` represents the operation of doubling `n` in Lean.

For any monoid `M` and element `a` in `M`, the power `a^(2n)` equals the product `a^n * a^n` for any natural number `n`.


/-- Proof follows from "The trace Cayley-Hamilton theorem" by Darij Grinberg, Section 5.3
 -/
theorem Matrix.adjugate_mul_distrib :
    ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A B : Matrix n n α),
      Matrix.adjugate (A * B) = Matrix.adjugate B * Matrix.adjugate A :=
  by sorry

This theorem, `Matrix.adjugate_mul_distrib`, states that for any two matrices `A` and `B` of the same dimensions, where the entries of the matrices are elements of a commutative ring, and the indices of the matrices have decidable equality and finite type, the adjugate of the product of `A` and `B` is equal to the product of the adjugate of `B` and the adjugate of `A`. This is a property of the adjugate operation related to matrix multiplication, essentially saying that adjugate operation distributes over matrix multiplication, but in a reversed order. This result is a consequence of the trace Cayley-Hamilton theorem, as referred to in the work by Darij Grinberg.

For matrices A and B of equal dimensions over a commutative ring with decidable entries and finite type indices, the adjugate of their product is equal to the product of their adjugates.


OrderIso.bijective

theorem OrderIso.bijective :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β), Function.Bijective ⇑e := by sorry

This theorem states that for any two types `α` and `β` that have a less than or equal to order (`LE`), if there exists an order isomorphism (`≃o`) `e` between `α` and `β`, then the function represented by `e` (denoted by `⇑e` in Lean) is bijective. In mathematical terms, an order isomorphism between two ordered sets is a bijective function that preserves the ordering, meaning if `x ≤ y` in `α`, then `f(x) ≤ f(y)` in `β`, and vice versa.

If `α` and `β` are ordered types with a less than or equal to order relation (`LE`) and there exists an order isomorphism (`≃o`) between them, then the function `f : α → β` represented by `e : α ≃o β` is a bidirectional, order-preserving bijection.


theorem Set.le_einfsep :
    ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {d : ENNReal},
      (∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y) → d ≤ Set.einfsep s :=
  by sorry

This theorem states that for any type `α` equipped with an "extended" distance function, any set `s` of elements of type `α`, and any extended nonnegative real number `d`, if for every pair of distinct elements `x` and `y` in `s` the distance between `x` and `y` is at least `d`, then `d` is less than or equal to the "extended infimum separation" of the set `s`. The "extended infimum separation" of a set is defined as the infimum of the distances between distinct pairs of elements in the set.

Given a type `α` with an extended distance function, if `s` is a set of distinct elements of `α` such that the distance between any two elements is at least `d`, then `d` is less than or equal to the infimum of the distances between distinct pairs in `s`.


IsIntegral.add

theorem IsIntegral.add :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {x y : A},
      IsIntegral R x → IsIntegral R y → IsIntegral R (x + y) :=
  by sorry

The theorem `IsIntegral.add` states that for any commutative ring `R` and any commutative ring `A` with an algebra structure over `R`, if elements `x` and `y` of `A` are both integral over `R`, then their sum `x + y` is also integral over `R`. In other words, the property of being integral is preserved under the operation of addition.

If `R` is a commutative ring, `A` is a commutative `R`-algebra, and `x` and `y` are integral elements of `A` over `R`, then `x + y` is also integral over `R`.


theorem borel_eq_generateFrom_Ioi :
    ∀ (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : SecondCountableTopology α] [inst_2 : LinearOrder α]
      [inst_3 : OrderTopology α], borel α = MeasurableSpace.generateFrom (Set.range Set.Ioi) :=
  by sorry

This theorem states that for any type `α` which has a topological space structure, a second countable topology structure, a linear order structure, and an order topology structure, the Borel `MeasurableSpace` on `α` is equal to the `MeasurableSpace` generated from the range of the function `Set.Ioi`. In other words, the smallest sigma algebra (measurable space) that contains all the open sets (generated by the topological space structure on `α`) is the same as the smallest sigma algebra that contains all the sets of the form "(a, +∞)", where `a` is any element of `α`. This is a fundamental result linking the concepts of measure theory and topology.

The Borel measurable space on a type `α` with a topological space, second countable topology, linear order, and order topology structures is equal to the sigma algebra generated by the ranges of `Set.Ioi` for any element `a` in `α`.


theorem compl_singleton_mem_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {x y : X}, y ≠ x → {x}ᶜ ∈ nhds y := by sorry

The theorem `compl_singleton_mem_nhds` states that for any topological space `X` that is also a T1 space and for any two distinct elements `x` and `y` in `X`, the complement of the singleton set containing `x` is a neighborhood of `y`. This means that there exists an open set around `y` that does not include `x`.

In a T1 topological space `X`, for distinct elements `x` and `y` in `X`, the complement of the singleton set `{x}` is a neighborhood of `y`.


theorem isRelPrime_mul_unit_left_left :
    ∀ {α : Type u_1} [inst : CommMonoid α] {x y z : α}, IsUnit x → (IsRelPrime (x * y) z ↔ IsRelPrime y z) := by sorry

This theorem states that for any commutative monoid `α`, and for any elements `x`, `y`, and `z` in `α`, if `x` is a unit (that is, it has a two-sided inverse), then `y` and `z` are relatively prime if and only if the product of `x` and `y` and `z` are relatively prime. In other words, multiplying a factor of `y` by a unit does not change the relative primality of `y` and `z`.

In mathematical terms, we say that for any elements `x`, `y`, and `z` of a commutative monoid, if `x` is a unit, then `y` and `z` are relatively prime if and only if `xy` and `z` are relatively prime. Here, two elements are called relatively prime if their greatest common divisor is a unit.

If `x` is a unit in a commutative monoid `α`, then `y` and `z` are relatively prime if and only if `xy` and `z` are relatively prime.


/-- Expressing `HasFDerivAtFilter f f' x L` in terms of `HasDerivAtFilter`  -/
theorem hasFDerivAtFilter_iff_hasDerivAtFilter :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {L : Filter 𝕜} {f' : 𝕜 →L[𝕜] F},
      HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (f' 1) x L :=
  by sorry

The theorem `hasFDerivAtFilter_iff_hasDerivAtFilter` states that, given a nontrivial normed field `𝕜`, a normed add commutative group `F`, and a normed space `F` over `𝕜`, for any function `f` from `𝕜` to `F`, any point `x` in `𝕜`, any filter `L` on `𝕜`, and any continuous linear map `f'` from `𝕜` to `F`, the property `f` having the Fréchet derivative `f'` at the point `x` as `x` goes along the filter `L` is equivalent to `f` having the derivative `(f' 1)` at the point `x` as `x` goes along the filter `L` (where `1` is the multiplicative identity in `𝕜`).

In mathematical terms, it says that `f` has Fréchet derivative `f'` at `x` along `L` if and only if `f` has the derivative `(f' 1)` at `x` along `L`.

Given a nontrivial normed field 𝕜, a normed add commutative group F, and a normed space F over 𝕜, for any function f from 𝕜 to F, point x in 𝕜, filter L on 𝕜, and continuous linear map f': 𝕜 → F, the Fréchet derivative f' has the same value as the derivative (f' 1) at x along L.


theorem Multiset.erase_cons_tail :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} (s : Multiset α),
      b ≠ a → Multiset.erase (b ::ₘ s) a = b ::ₘ Multiset.erase s a :=
  by sorry

The theorem `Multiset.erase_cons_tail` states that for any type `α` that has decidable equality (meaning that equality between any two elements of the type can be decided), and for any two elements `a` and `b` of type `α`, and a multiset `s` of type `α`, if `b` is not equal to `a`, then erasing `a` from the multiset that results from adding `b` to `s` (denoted `b ::ₘ s`) is the same as adding `b` to the multiset that results from erasing `a` from `s`. In other words, if `b` is not equal to `a`, then the order of adding `b` and erasing `a` does not matter.

For any type `α` with decidable equality and any multisets `s` of type `α` and elements `a, b` not equal to each other, `b ::ₘ (a ::ₘ s) = b ::ₘ (erase a (s ::ₘ b))`.


/-- `exp (-a * x) = o(x ^ s)` as `x → ∞`, for any positive `a` and real `s`.  -/
theorem isLittleO_exp_neg_mul_rpow_atTop :
    ∀ {a : ℝ}, 0 < a → ∀ (b : ℝ), (fun x => Real.exp (-a * x)) =o[Filter.atTop] fun x => x ^ b := by sorry

This theorem states that for any positive real number `a` and any real number `b`, the function `exp(-a * x)` is little-o of the function `x^b` as `x` approaches infinity. In mathematical notation, this is saying that `exp(-a * x) = o(x^b)` as `x → ∞`. The little-o notation represents the asymptotic behavior of functions, and `exp(-a * x) = o(x^b)` means that the function `exp(-a * x)` grows at a slower rate than the function `x^b` as `x` approaches infinity.

As `x` approaches infinity, the function `exp(-a * x)` is asymptotically smaller than `x^b`.


/-- `f : α →+* β` doesn't map `1` to `0` if `β` is nontrivial  -/
theorem RingHom.map_one_ne_zero :
    ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β)
      [inst : Nontrivial β], f 1 ≠ 0 :=
  by sorry

This theorem states that for any ring homomorphism `f` from a type `α` to another type `β` (both of which are non-associative semirings), if `β` is nontrivial (i.e., it has at least two distinct elements), then `f` does not map the multiplicative identity `1` of `α` to the additive identity `0` of `β`. In other words, `f(1)` is not equal to `0` when `β` is nontrivial.

If `α` and `β` are non-associative semirings, `f` is a ring homomorphism from `α` to `β`, and `β` is nontrivial, then `f(1) ≠ 0`.


theorem PrimeSpectrum.subset_zeroLocus_iff_le_vanishingIdeal :
    ∀ {R : Type u} [inst : CommSemiring R] (t : Set (PrimeSpectrum R)) (I : Ideal R),
      t ⊆ PrimeSpectrum.zeroLocus ↑I ↔ I ≤ PrimeSpectrum.vanishingIdeal t :=
  by sorry

This theorem states that for any given commutative semiring `R`, a set `t` of its prime spectrum, and an ideal `I` of `R`, the set `t` is a subset of the zero locus of `I` if and only if `I` is less than or equal to the vanishing ideal of `t`. Here, `PrimeSpectrum.zeroLocus` refers to the set of points in the prime spectrum where a given ideal vanishes and `PrimeSpectrum.vanishingIdeal` is the ideal associated with a set in the prime spectrum. The symbols `⊆` and `≤` denote subset and less than or equal to, respectively. This theorem is essentially describing a relationship between the algebraic and geometric notions in terms of ideals and the prime spectrum of a ring.

For any commutative semiring R, set t of its prime spectrum, and ideal I, t is a subset of the zero locus of I if and only if I is less than or equal to the vanishing ideal of t.


theorem NumberField.InfinitePlace.card_real_embeddings :
    ∀ (K : Type u_2) [inst : Field K] [inst_1 : NumberField K],
      Fintype.card { φ // NumberField.ComplexEmbedding.IsReal φ } = NumberField.InfinitePlace.NrRealPlaces K :=
  by sorry

This theorem states that for any number field `K`, the number of complex embeddings of `K` into `ℂ` that are real (i.e., they are fixed by complex conjugation) is equal to the number of infinite real places of `K`. The number of such embeddings is calculated using the `Fintype.card` function which provides the number of elements in a finite type. The infinite real places of a number field are a notion from algebraic number theory, giving a count of the "real parts" of the number field.

The number of real complex embeddings of a number field `K` equals the number of its infinite real places.


theorem borel_eq_generateFrom_Iic :
    ∀ (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : SecondCountableTopology α] [inst_2 : LinearOrder α]
      [inst_3 : OrderTopology α], borel α = MeasurableSpace.generateFrom (Set.range Set.Iic) :=
  by sorry

This theorem states that for any type `α` equipped with a Topological Space structure, a Second Countable Topology structure, a Linear Order structure, and an Order Topology structure, the Borel measurable space generated by the topological space structure is equivalent to the smallest measurable space containing the collection of sets that are left-infinite right-closed intervals. In other words, the Borel σ-algebra, a sigma algebra generated by the open sets in a topological space, is the same as the smallest sigma algebra that contains all sets of the form `(-∞, b]` where `b` is a real number.

The Borel sigma-algebra of a second countable topological space equipped with a linear order is equal to the sigma-algebra generated by left-infinite right-closed intervals.


CategoryTheory.Limits.HasImageMap.mk

theorem CategoryTheory.Limits.HasImageMap.mk :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C}
      [inst_1 : CategoryTheory.Limits.HasImage f.hom] [inst_2 : CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g},
      CategoryTheory.Limits.ImageMap sq → CategoryTheory.Limits.HasImageMap sq :=
  by sorry

This theorem states that for any category `C`, given two objects `f` and `g` in the arrow category of `C` (which means `f` and `g` are morphisms in `C`), and a morphism `sq` from `f` to `g` (which translates to a commutative square in `C`), if the image of homomorphisms of both `f` and `g` exist and there's an image mapping for `sq`, then the image mapping for `sq` exists. This is a concept in category theory, where the image of a morphism is a sort of "minimal" subobject through which the morphism factors, while an image map captures the idea of morphing one image to another.

Given any commutative square in a category with existing image homomorphisms for the morphisms involved, the image mapping for the morphism between the objects exists.


theorem Mathlib.GroupTheory.Coset._auxAddLemma.3 :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : Set α} {x : α} (a : α), (x ∈ AddOpposite.op a +ᵥ s) = (x + -a ∈ s) := by
  sorry

This theorem is a statement about additive groups and sets in the context of group theory. For any type `α` that forms an additive group, any set `s` of elements of `α`, any element `x` of `α`, and any element `a` of `α`, it states that `x` is an element of the set obtained by adding the opposite of `a` (`AddOpposite.op a`) to every element of `s` (denoted `AddOpposite.op a +ᵥ s`) if and only if the result of adding the additive inverse of `a` to `x` (denoted `x + -a`) is an element of `s`. The `+ᵥ` operation signifies a translation of the set `s` by the element `AddOpposite.op a`. In simple terms, the theorem states that translating a set by some element is equivalent to translating the element by its opposite in the opposite direction.

For any additive group `α`, set `s` of elements in `α`, and element `a` in `α`, the set `s` and `AddOpposite.op a + s` (translation of `s` by `AddOpposite.op a`) are equal if and only if `x + -a` is an element of `s` for all `x` in `s`.


theorem nsmul_eq_mul' : ∀ {α : Type u_1} [inst : NonAssocSemiring α] (a : α) (n : ℕ), n • a = a * ↑n := by sorry

This theorem states that for any type `α` that forms a non-associative semiring and for any element `a` of type `α` and `n` of type `ℕ` (natural number), the `n`-fold repetition of the operation on `a` (denoted by `n • a`) is equal to the product of `a` and the natural number `n` (denoted by `a * ↑n`). Here, `↑n` denotes the coercion of natural number `n` into type `α`. This theorem basically connects the concept of repeated addition (n-fold operation) with multiplication in a non-associative semiring.

For any non-associative semiring type `α` and its element `a` of type `α` and natural number `n`, the `n`-fold repetition of the operation on `a`, `n • a`, is equivalent to the product of `a` and the natural number `n`, `a * ↑n`.


theorem Mathlib.GroupTheory.Coset._auxAddLemma.2 :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : Set α} {x : α} (a : α), (x ∈ a +ᵥ s) = (-a + x ∈ s) := by sorry

This theorem states that for any type `α` with an addition group structure, for any set `s` of elements of type `α`, and for any elements `x` and `a` of type `α`, the statement that `x` belongs to the coset formed by adding `a` to every element in `s` (denoted as `a +ᵥ s`) is logically equivalent to the statement that the result of adding the additive inverse of `a` to `x` belongs to the set `s` (denoted as `-a + x ∈ s`).

In simple mathematical terms, it states that if `x` is in the set formed by adding `a` to every element in `s`, then subtracting `a` from `x` will result in an element that is in the original set `s`.

For any type `α` with an addition group structure, and for any set `s` and element `a` of type `α`, the coset `a +ᵥ s` is equal to the set `{x | -a + x ∈ s}` (i.e., the set of elements obtained by adding `a` to every element in `s` is equal to the set of elements in `s` whose additive inverse is also in `s`).


theorem Set.bounded_le_inter_lt :
    ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
      Set.Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b}) ↔ Set.Bounded (fun x x_1 => x ≤ x_1) s :=
  by sorry

This theorem states that for any type `α` endowed with a linear order, a set `s` of elements of this type, and a particular element `a` of this type, the set `s` is bounded by the relation "less than or equal to" if and only if the intersection of `s` and the set of elements greater than `a` is also bounded by the same relation. In other words, a set is bounded (in the sense that every element is less than or equal to some fixed element) if its subset of elements strictly greater than a given value is also bounded in this way.

A set of elements from a linearly ordered type is bounded if and only if its subset of elements strictly greater than a given element is also bounded.


theorem Cardinal.beth.proof_2 : ∀ (a : Ordinal.{u_1}) (b : ↑(Set.Iio a)), ↑b ∈ Set.Iio a := by sorry

This theorem, `Cardinal.beth.proof_2`, states that for any ordinal `a` and any element `b` from the set of all elements strictly less than `a` (denoted by `Set.Iio a`), the element `b` indeed belongs to the set `Set.Iio a`. In other words, if we take an element `b` from the set of values strictly less than an ordinal `a`, then `b` is confirmed to be strictly less than `a`.

For any ordinal `a` and `b` with `b` in `Set.Iio a` (the set of elements strictly less than `a`), we have `b < a`.


theorem inv_comp_inv : ∀ (G : Type u_3) [inst : InvolutiveInv G], Inv.inv ∘ Inv.inv = id := by sorry

The theorem `inv_comp_inv` states that for any type `G` that has an involutive inverse structure, the composition of the inverse operation performed twice (`Inv.inv ∘ Inv.inv`) is equivalent to the identity function (`id`). In other words, applying the inverse operation twice to any element returns the original element, which is a property characteristic of involutive operations.

For any type `G` with an involutive inverse structure, `Inv.inv ∘ Inv.inv` equals the identity function `id`.


theorem Complex.arg_of_im_pos : ∀ {z : ℂ}, 0 < z.im → Complex.arg z = Real.arccos (z.re / Complex.abs z) := by sorry

The theorem `Complex.arg_of_im_pos` states that for any complex number `z` with a positive imaginary part, the argument of `z` (denoted as `Complex.arg z`) is equal to the arccosine of the ratio of the real part of `z` to the absolute value of `z` (denoted as `Real.arccos (z.re / Complex.abs z)`). The "argument" of a complex number is the angle it makes with the positive real axis, the "arccosine" function is the inverse of the cosine function restricted to [0, π], and the "absolute value" of a complex number is the square root of the sum of the squares of its real and imaginary parts.

For complex numbers `z` with a positive imaginary part, `Complex.arg z` equals the arccosine of the real part divided by the absolute value of `z`. That is, `Complex.arg z = Real.arccos (z.re / Complex.abs z)`.


/-- In a dense order, nothing covers anything.  -/
theorem not_covBy : ∀ {α : Type u_1} [inst : LT α] {a b : α} [inst_1 : DenselyOrdered α], ¬a ⋖ b := by sorry

This theorem states that in a densely ordered set, no element 'a' strictly covers another element 'b'. In other words, there is no element 'a' such that it is less than 'b' and no element exists strictly between 'a' and 'b'. The term "DenselyOrdered" refers to an ordered set where between any two elements there is another element.

In a densely ordered set, there exist no strictly increasing sequences of length 2.


theorem Nat.cast_div : ∀ {α : Type u_1} [inst : DivisionSemiring α] {m n : ℕ}, n ∣ m → ↑n ≠ 0 → ↑(m / n) = ↑m / ↑n := by
  sorry

This theorem, `Nat.cast_div`, states that for any type `α` that forms a division semiring, given natural numbers `m` and `n` such that `n` divides `m` and `n` is not zero, the casting of the division of `m` by `n` to type `α` is equal to the division of the castings of `m` and `n` to type `α`. In other words, if you divide `m` by `n` first and then cast the result to type `α`, you get the same result as if you cast `m` and `n` to `α` first and then perform the division.

For any type `α` that forms a division semiring and natural numbers `m`, `n` with `n` dividing `m` non-zero, `(m / n).to α = m.to α / n.to α`.


theorem MeasureTheory.Integrable.coeFn_toL1 :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β} (hf : MeasureTheory.Integrable f μ),
      ↑↑(MeasureTheory.Integrable.toL1 f hf) =ᶠ[MeasureTheory.Measure.ae μ] f :=
  by sorry

This theorem states that for any measurable space `α`, any normed additively commutative group `β`, any measure `μ` on `α`, and any function `f` from `α` to `β`, if `f` is integrable with respect to `μ`, then `f` is "equal almost everywhere" (which is denoted by `=ᶠ[MeasureTheory.Measure.ae μ]`) to the function that we get when we first convert `f` into its equivalence class in the space of integrable functions (i.e., `MeasureTheory.Integrable.toL1 f hf`), and then apply the canonical embedding of that space into the space of all functions from `α` to `β` (i.e., the double coercion `↑↑`). In simpler terms, the function `f` and its integrable representation are the same almost everywhere with respect to the measure `μ`.

For any measurable space `α`, measurable function `f` from `α` to a normed additively commutative group `β`, and measure `μ` on `α`, if `f` is integrable with respect to `μ`, then `f =ᶠ[MeasureTheory.Measure.ae μ] MeasureTheory.Integrable.toL1 f`.


theorem WithTop.add_left_cancel_iff :
    ∀ {α : Type u} [inst : Add α] {a b c : WithTop α} [inst_1 : IsLeftCancelAdd α], a ≠ ⊤ → (a + b = a + c ↔ b = c) :=
  by sorry

This theorem states that for any type `α` equipped with an addition operation and the property that addition is left-cancellable (i.e., for any `x`, `y`, and `z` in `α`, if `x + y = x + z` then `y = z`), and any three values `a`, `b`, and `c` in the type `α` extended with a top element (denoted `WithTop α`), if `a` is not the top element, then the equality `a + b = a + c` holds if and only if `b = c`. In other words, addition is also left-cancellable in the extended type `WithTop α`, as long as we're not adding to the top element.

For any type `α` with left-cancellative addition and a top element, the equality `a + b = a + c` in `WithTop α` holds if and only if `b = c`, provided `a` is not the top element.


theorem Decidable.not_iff : ∀ {b a : Prop} [inst : Decidable b], ¬(a ↔ b) ↔ (¬a ↔ b) := by sorry

This theorem states that for any two propositions `a` and `b`, where `b` is decidable, the negation of the equivalence between `a` and `b` is equivalent to the equivalence between the negation of `a` and `b`. In simpler terms, it says that if `a` is not equivalent to `b`, then this is the same as saying that `b` is equivalent to `a` being false.

For decidable propositions `a` and `b`, `~(a ↔ b)` is equivalent to `a ↔ ~b`.


theorem Set.image2_mk_eq_prod :
    ∀ {α : Type u_1} {β : Type u_3} {s : Set α} {t : Set β}, Set.image2 Prod.mk s t = s ×ˢ t := by sorry

This theorem states that for all types `α` and `β`, and for all sets `s` of type `α` and `t` of type `β`, the image of the binary function `Prod.mk` (which creates pairs `(a, b)` of elements `a` from `s` and `b` from `t`) is equal to the Cartesian product of the sets `s` and `t`. In other words, applying `Prod.mk` to each pair of elements from `s` and `t` produces exactly the same set as the Cartesian product of `s` and `t`.

For all types `α` and `β`, and sets `s` of type `α` and `t` of type `β`, the set of pairs `{ Prod.mk a b | a ∈ s, b ∈ t }` is equal to the Cartesian product `s × t`.


theorem pow_bit1_nonpos_iff : ∀ {R : Type u_3} [inst : LinearOrderedRing R] {a : R} {n : ℕ}, a ^ bit1 n ≤ 0 ↔ a ≤ 0 :=
  by sorry

This theorem, `pow_bit1_nonpos_iff`, states for any linearly ordered ring `R` and any elements `a` from `R` and `n` from the natural numbers, that `a` raised to the power of `bit1 n` (which is `2n+1`) is less than or equal to zero if and only if `a` is less than or equal to zero. This theorem provides an equivalence relation between the non-positivity of an odd-powered element in a ring and the non-positivity of the element itself.

For any element `a` in a linearly ordered ring `R` and natural number `n`, `a` raised to the power of `2n+1` is non-positive if and only if `a` is non-positive.


/-- A function is `C^∞` on a domain with unique derivatives if and only if it is differentiable
there, and its derivative (formulated with `derivWithin`) is `C^∞`.  -/
theorem contDiffOn_top_iff_derivWithin :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f₂ : 𝕜 → F} {s₂ : Set 𝕜},
      UniqueDiffOn 𝕜 s₂ → (ContDiffOn 𝕜 ⊤ f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂) :=
  by sorry

The theorem `contDiffOn_top_iff_derivWithin` states that for any nontrivially normed field `𝕜`, any normed additive commutative group `F` that is also a normed space over `𝕜`, any function `f₂` from `𝕜` to `F`, and any set `s₂` of `𝕜`, assuming that `s₂` has unique derivatives, the function `f₂` is infinitely continuously differentiable on `s₂` if and only if `f₂` is differentiable on `s₂` and the derivative of `f₂` (formulated with `derivWithin`) is also infinitely continuously differentiable on `s₂`. Here, continuous differentiability of order `⊤` means that the function is differentiable and its derivatives of all orders exist and are continuous.

A function from a nontrivially normed field to a normed space over that field, with unique derivatives on a set, is infinitely continuously differentiable on that set if and only if it is differentiable and its derivative is also infinitely continuously differentiable on that set.


theorem fderivWithin_of_isOpen :
    ∀ {𝕜 : 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}
      {x : E} {s : Set E}, IsOpen s → x ∈ s → fderivWithin 𝕜 f s x = fderiv 𝕜 f x :=
  by sorry

The theorem `fderivWithin_of_isOpen` asserts that for any non-trivially normed field `𝕜`, and any normed additive commutative group `E` and `F` over `𝕜`, given a function `f` from `E` to `F`, element `x` in `E`, and a set `s` of elements of `E`, if the set `s` is open in the ambient topological space and `x` is an element of `s`, then the derivative of the function `f` within the set `s` at the point `x` is equivalent to the derivative of the function `f` at the point `x`.

If `f` is a function from a normed additive commutative group `E` over a non-trivially normed field `𝕜` to another such group `F`, `x` is an element of an open set `s` in `E`, and `f` is differentiable at `x`, then the derivative of `f` within `s` at `x` equals the derivative of `f` at `x`.


theorem tendsto_gauge_nhds_zero :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} [inst_2 : TopologicalSpace E]
      [inst_3 : ContinuousSMul ℝ E], s ∈ nhds 0 → Filter.Tendsto (gauge s) (nhds 0) (nhds 0) :=
  by sorry

This theorem states that for any set `s` in a real vector space `E` (where `E` is a topological space and the scalar multiplication in `E` is continuous), if `s` is a neighborhood of the origin (0), then the Minkowski functional (or `gauge`) of `s` tends towards 0 as the input approaches 0. In other words, for small vectors `x` in the neighborhood of the origin, the smallest real number `r` such that `x` lies in the scaled set `r • s` is also close to 0.

Given a real vector space `E` with a continuous scalar multiplication, if `s` is a neighborhood of the origin in `E`, then the Minkowski functional of `s` approaches 0 as the input approaches the origin.


theorem Equiv.piCongrLeft_apply_eq_cast :
    ∀ {β : Sort u_2} {α : Sort u_1} {P : β → Sort v} {e : α ≃ β} (f : (a : α) → P (e a)) (b : β),
      (Equiv.piCongrLeft P e) f b = cast ⋯ (f (e.symm b)) :=
  by sorry

The theorem `Equiv.piCongrLeft_apply_eq_cast` states that for any sorts `α` and `β`, for any function `P` from `β` to another sort, for any equivalence `e` between `α` and `β`, and for any dependent function `f` from `α` to `P` of `e a`, if we apply the function `f` after the equivalence transformation `Equiv.piCongrLeft P e`, we obtain the same result as if we first applied the inverse of the equivalence `e` to `b` and then applied the function `f` (up to a proof-irrelevant cast). This cast acts as a "transport" across types, allowing us to treat the two sides as equal even though their type-level form might differ due to the application of equivalence `e`.

For any equivalence between types `e : α ≈ β`, function `P : β → Sort`, dependent function `f : α → P`, and elements `a : α` and `b : β` related by `e`, `f (Equiv.piCongrLeft P e a) ≈ f (e.inverse b)`.


theorem Function.IsPeriodicPt.apply_iterate :
    ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ},
      Function.IsPeriodicPt f n x → ∀ (m : ℕ), Function.IsPeriodicPt f n (f^[m] x) :=
  by sorry

The theorem `Function.IsPeriodicPt.apply_iterate` states that for any type `α`, function `f` from `α` to `α`, element `x` of `α`, and natural number `n`, if `x` is a periodic point of `f` with period `n`, then for any natural number `m`, the `m`-th iteration of `f` on `x` is also a periodic point of `f` with period `n`. In other words, if applying `f` `n` times to `x` gives back `x`, then applying `f` `n` times to the result of applying `f` `m` times to `x` also gives back the result of applying `f` `m` times to `x`.

If `x` is a periodic point of degree `n` for the function `f` in `α`, then for any natural number `m`, `f^(m+n)` applied to `x` equals `f^m` applied to `x`.


theorem UniformSpace.le_sInf :
    ∀ {α : Type ua} {tt : Set (UniformSpace α)} {t : UniformSpace α}, (∀ t' ∈ tt, t ≤ t') → t ≤ sInf tt := by sorry

The theorem `UniformSpace.le_sInf` is a statement about uniform spaces. Given a type `α` and a set `tt` of uniform spaces on `α`, as well as a particular uniform space `t` on `α`, this theorem states that if `t` is less than or equal to every uniform space in set `tt`, then `t` is also less than or equal to the infimum (greatest lower bound) of the set `tt`. In other words, this theorem ensures that `t` respects the order defined by the set `tt` in the context of the infimum operation.

If `t` is a uniform space on `α` that is less than or equal to every uniform space `u` in a set `tt` of uniform spaces on `α`, then `t` is less than or equal to the infimum of `tt`.


theorem CategoryTheory.Mat_.hom_ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C]
      {M N : CategoryTheory.Mat_ C} (f g : M ⟶ N), (∀ (i : M.ι) (j : N.ι), f i j = g i j) → f = g :=
  by sorry

The theorem `CategoryTheory.Mat_.hom_ext` states that for any type `C` which is endowed with a category structure and a preadditive structure, and for any two objects `M` and `N` in the category of matrices over `C`, if two morphisms `f` and `g` from `M` to `N` agree on all entries (i.e., `f i j = g i j` for all indices `i` and `j`), then `f` and `g` are equal.

For any preadditive category `C` with types `M` and `N` as objects, and morphisms `f` and `g` from `M` to `N` of matrices, if their entries are equal for all indices `i` and `j`, then `f` is equal to `g`.


spectrum.isCompact

theorem spectrum.isCompact :
    ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
      [inst_3 : CompleteSpace A] [inst_4 : ProperSpace 𝕜] (a : A), IsCompact (spectrum 𝕜 a) :=
  by sorry

The theorem `spectrum.isCompact` states that for any normed field `𝕜`, any normed ring `A` that is also a `𝕜`-algebra, where `A` is a complete space and `𝕜` is a proper space, the spectrum of any element `a` of `A` is a compact set. In other words, for every nontrivial filter that contains the spectrum, there exists an element in the spectrum such that every set of the filter meets every neighborhood of that element.

The spectrum of any complete, compact, normed `𝕜`-algebra over a proper normed field `𝕜` is a compact set.


theorem BoundedContinuousFunction.dist_set_exists :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      {f g : BoundedContinuousFunction α β}, ∃ C, 0 ≤ C ∧ ∀ (x : α), dist (f x) (g x) ≤ C :=
  by sorry

This theorem states that for any two bounded continuous functions `f` and `g`, which map from a topological space `α` to a pseudo metric space `β`, there exists a non-negative real number `C` such that the distance between the images of any point `x` in `α` under functions `f` and `g` (i.e., `f(x)` and `g(x)`) is less than or equal to `C`. In other words, the difference between the outputs of these two functions is always bounded by some constant `C` for all inputs from the topological space `α`.

Given any two bounded continuous functions `f` and `g` from a topological space `α` to a pseudo metric space `β`, there exists a constant `C` such that `d(f(x), g(x)) ≤ C` for all `x ∈ α`, where `d` denotes the distance function in `β`.


theorem Ideal.map_jacobson_of_surjective :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] {I : Ideal R} {f : R →+* S},
      Function.Surjective ⇑f → RingHom.ker f ≤ I → Ideal.map f (Ideal.jacobson I) = Ideal.jacobson (Ideal.map f I) :=
  by sorry

The theorem `Ideal.map_jacobson_of_surjective` states that for any rings `R` and `S`, any ideal `I` of `R`, and any surjective ring homomorphism `f` from `R` to `S`, if the kernel of `f` is a subset of the ideal `I`, then mapping the Jacobson radical of `I` under `f` is equal to the Jacobson radical of the image of `I` under `f`. In other words, under these conditions, the process of taking the Jacobson radical commutes with the process of mapping under a surjective ring homomorphism.

If `R` is a ring, `S` is another ring, `I` is an ideal of `R`, and `f : R -> S` is a surjective ring homomorphism with kernel contained in `I`, then `J(f(I)) = f(J(I))`, where `J(X)` denotes the Jacobson radical of `X`.


theorem Computability.Encoding.encode_injective :
    ∀ {α : Type u} (e : Computability.Encoding α), Function.Injective e.encode := by sorry

This theorem states that for any type `α` and any computability encoding `e` of that type, the `encode` function of `e` is injective. In other words, if `e.encode x = e.encode y` for any two elements `x` and `y` of the type `α`, then it must be the case that `x = y`. This is a property of the `encode` function in the context of computability theory, ensuring that different elements are encoded to different values, allowing a clear distinction between them.

For any type `α` and computability encoding `e` of that type, if `e.encode x = e.encode y`, then `x = y`.


theorem Real.abs_cos_le_one : ∀ (x : ℝ), |Real.cos x| ≤ 1 := by sorry

This theorem states that for all real numbers `x`, the absolute value of the cosine of `x` is less than or equal to 1. In mathematical terms, this can be written as: ∀ (x : ℝ), |cos(x)| ≤ 1. This is a foundational result in trigonometry that sets the range of the cosine function, ensuring that it never exceeds the limits of the unit circle, i.e., -1 to 1.

For all real numbers x, the absolute value of cos(x) is bounded by 1, that is, |cos(x)| ≤ 1.


theorem Set.add_subset_add_left : ∀ {α : Type u_2} [inst : Add α] {s t₁ t₂ : Set α}, t₁ ⊆ t₂ → s + t₁ ⊆ s + t₂ := by
  sorry

This theorem states that for any type `α` that supports addition, and any sets `s`, `t₁`, and `t₂` of elements of type `α`, if `t₁` is a subset of `t₂`, then the set of elements obtained by adding each element of `s` to each element of `t₁` is a subset of the set obtained by adding each element of `s` to each element of `t₂`. In other words, for all `α` in `Type u_2` with an addition operation and for all sets `s`, `t₁`, `t₂` of `α`, set addition preserves subset relationships.

For any type `α` with an addition operation and for all sets `s` and `t₁` subset `t₂` of `α`, the set `{a + b | a ∈ s, b ∈ t₁}` is a subset of `{a + b | a ∈ s, b ∈ t₂}`.


FiniteDimensional.proper

/-- Any finite-dimensional vector space over a locally compact field is proper.
We do not register this as an instance to avoid an instance loop when trying to prove the
properness of `𝕜`, and the search for `𝕜` as an unknown metavariable. Declare the instance
explicitly when needed.  -/
theorem FiniteDimensional.proper :
    ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] (E : Type v) [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : LocallyCompactSpace 𝕜] [inst : FiniteDimensional 𝕜 E], ProperSpace E :=
  by sorry

The theorem `FiniteDimensional.proper` states that any finite-dimensional vector space over a locally compact field is a proper space. This means that for any vector space `E` over a field `𝕜` where `𝕜` is a non-trivially normed field and a locally compact space, and `E` is a normed add commutative group as well as a normed space over `𝕜`, if the vector space `E` is also finite-dimensional over `𝕜`, then `E` has the property of being a proper space. This theorem is not registered as an instance to prevent instance loops when attempting to prove the properness of `𝕜`, and the search for `𝕜` as an unknown metavariable. The instance needs to be declared explicitly when it is necessary.

A finite-dimensional vector space over a locally compact, non-trivially normed field is a proper space.


IsGreatest.unique

theorem IsGreatest.unique :
    ∀ {α : Type u} [inst : PartialOrder α] {s : Set α} {a b : α}, IsGreatest s a → IsGreatest s b → a = b := by sorry

This theorem states that for any set `s` of elements of a given type `α` under a partial order, if `a` and `b` are both greatest elements of `s`, then `a` and `b` must be the same element. In other words, in a partial order, the greatest element of a set, if it exists, is unique.

In a partial order, if two elements are both maximum elements of a set, then they are equal.


ContDiffBump.contDiff

theorem ContDiffBump.contDiff :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E] {c : E}
      (f : ContDiffBump c) {n : ℕ∞}, ContDiff ℝ n ↑f :=
  by sorry

This theorem states that for any type `E` that is a normed additive commutative group and a normed space over the real numbers `ℝ`, if `E` also has a continuously differentiable bump function, then for any point `c` in `E` and any `f` which is a continuously differentiable bump function at `c`, `f` is continuously differentiable at all orders `n` (where `n` can be any natural number or infinity).

If a normed additive commutative group `E` over the real numbers `ℝ` has a continuously differentiable bump function and is equipped with a norm making it a normed space, then every continuously differentiable bump function at any point in `E` is infinitely differentiable.


theorem CategoryTheory.MonoOver.image.proof_1 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
      (f : CategoryTheory.Over X), CategoryTheory.Limits.HasImage f.hom :=
  by sorry

This theorem states that for any category 'C' and object 'X' in 'C', if 'C' has limits and 'f' is an object in the over category of 'X', then the morphism 'f.hom' from 'f' has an image. In category theory, the over category 'CategoryTheory.Over X' is defined as the category whose objects are arrows in 'C' with codomain 'X' and morphisms are commutative triangles. The morphism 'f.hom' from an object 'f' in this over category therefore has a codomain of 'X'. The image of a morphism is a generalization of the concept of image in set theory. This theorem thus asserts the existence of such an image for the morphism 'f.hom' given the stated conditions.

For any category 'C' with limits and object 'X', the morphism 'f.hom' in the over category 'CategoryTheory.Over X' of 'X' has an image.


theorem IsLUB.frequently_mem :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      IsLUB s a → Set.Nonempty s → ∃ᶠ (x : α) in nhdsWithin a (Set.Iic a), x ∈ s :=
  by sorry

This theorem, `IsLUB.frequently_mem`, states that for any type `α` that has a topological space structure, a linear order, and an order topology, any set `s` of this type `α`, and any element `a` of type `α`, if `a` is a least upper bound of the set `s` and the set `s` is not empty, then there frequently exists an element `x` in the intersection of the left-closed right-infinite interval up to `a` and a neighborhood of `a`, such that `x` is an element of the set `s`. In other words, if `a` is the least upper bound of a non-empty set, then there are many elements in `s` arbitrarily close to `a` but not greater than `a`.

For any non-empty set `s` of a type `α` with a topological space structure, linear order, and order topology, if `a` is the least upper bound of `s`, then there exists an element `x` in the intersection of the left-closed right-infinite interval up to `a` and a neighborhood of `a` that belongs to `s`.


theorem Matrix.submatrix_one_equiv :
    ∀ {l : Type u_1} {m : Type u_2} {α : Type v} [inst : Zero α] [inst_1 : One α] [inst_2 : DecidableEq m]
      [inst_3 : DecidableEq l] (e : l ≃ m), Matrix.submatrix 1 ⇑e ⇑e = 1 :=
  by sorry

This theorem asserts that for any given types `l`, `m`, and `α`, where `α` is a type with zero and one elements, and `l` and `m` have decidable equality, if we have a bijection `e` from `l` to `m`, then the submatrix of the one-matrix (a matrix filled with ones), transformed according to `e`, is equal to the original one-matrix. This essentially means that the structure of the one-matrix is preserved under such transformation, regardless of the bijection used.

For any types `l` and `m` with decidable equality, and a bijection `e` from `l` to `m` between types with zero and one elements, the submatrix of the one-matrix transformed according to `e` is equal to the original one-matrix.


/-- The definition of `Collinear`.  -/
theorem collinear_iff_rank_le_one :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
      [inst_2 : Module k V] [inst_3 : AddTorsor V P] (s : Set P), Collinear k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 1 :=
  by sorry

The theorem `collinear_iff_rank_le_one` states that for any division ring `k`, additive commutative group `V`, and `P` an additive torsor over `V`, the set of points `s` is collinear if and only if the rank of the submodule spanning the differences of the set of points (i.e., `vectorSpan`) is less than or equal to one. In mathematical terms, this means that the points in a set are in a straight line if the dimension of the space spanned by the vectors formed by their differences is at most one.

For any additive torsor P over a commutative group V in a division ring k, the points in P are collinear if and only if the rank of the submodule spanned by the differences of these points is at most 1.


theorem lp.norm_apply_le_norm :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)],
      p ≠ 0 → ∀ (f : ↥(lp E p)) (i : α), ‖↑f i‖ ≤ ‖f‖ :=
  by sorry

This theorem is stating that for any type `α`, any function `E` from `α` to another type, and any extended nonnegative real number `p` that is not zero, if each `E i` is a normed additive commutative group, then for every function `f` in the LP space and every `i` in `α`, the norm of `f i` is less than or equal to the norm of `f`. In other words, the norm of the value of a function at a point in an LP space is always less than or equal to the norm of the function itself.

For any function `f` in an LP space and any type `α` with each `E i` an additive commutative normed group, the norm of `f i` is less than or equal to the norm of `f` for all `i` in `α`.


theorem CategoryTheory.Presheaf.secondObj.proof_2 :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : Type u_4}
      [inst_1 : CategoryTheory.Category.{u_3, u_4} A] {U : C} (R : CategoryTheory.Presieve U)
      (P : CategoryTheory.Functor Cᵒᵖ A) [inst_2 : CategoryTheory.Limits.HasProducts A]
      [inst_3 : CategoryTheory.Limits.HasPullbacks C],
      CategoryTheory.Limits.HasLimit
        (CategoryTheory.Discrete.functor fun fg =>
          P.obj (Opposite.op (CategoryTheory.Limits.pullback ↑fg.1.snd ↑fg.2.snd))) :=
  by sorry

This theorem states that for a given category `C` and a presieve `R` on an object `U` of `C`, a functor `P` from the opposite category of `C` to another given category `A` (which has products), when the category `C` has pullbacks, there exists a limit for the functor that maps each element `fg` of the discrete category (formed from pairs of elements in the presieve `R`) to the object in `A` computed by the functor `P` evaluated at the pullback of the morphisms corresponding to `fg`. In other words, this theorem is a condition for the existence of limits of certain functors formed from a presheaf `P` and a presieve `R` within a category that has pullbacks and a target category that has products.

Given a category with pullbacks `C`, a presieve `R` on an object `U` of `C`, and a functor `P` from `C^{op}` to a category with products `A`, there exists a limit for the functor `P` over the discrete category formed from pairs in `R` if and only if `C` has pullbacks.


theorem iSup_const_mono :
    ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} [inst : CompleteLattice α] {a : α}, (ι → ι') → ⨆ x, a ≤ ⨆ x, a := by
  sorry

This theorem states that for any type `α` that forms a complete lattice, and any element `a` of `α`, the supremum of the set of elements `a` is less than or equal to itself. This is true regardless of the indexing types `ι` and `ι'`, and any function from `ι` to `ι'`. In simpler terms, it says that the supremum of a constant sequence in a complete lattice is less than or equal to the constant itself.

For any complete lattice `α` and its element `a`, the supremum of the singleton set `{a}` is less than or equal to `a`.


theorem ValuationSubring.le_ofPrime :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (P : Ideal ↥A) [inst_1 : Ideal.IsPrime P],
      A ≤ ValuationSubring.ofPrime A P :=
  by sorry

The theorem `ValuationSubring.le_ofPrime` states that for any field `K`, valuation subring `A` of the field `K` and a prime ideal `P` of the subring `A`, the valuation subring `A` is a subset of the valuation subring associated to the prime ideal `P`. In other words, this theorem establishes an order relationship between a valuation subring and the coarsening of this valuation ring associated to a prime ideal in that subring.

For any field `K`, valuation subring `A` of `K`, and prime ideal `P` of `A`, `A` is included in the valuation subring associated to `P`.


theorem Filter.mem_one : ∀ {α : Type u_2} [inst : One α] {s : Set α}, s ∈ 1 ↔ 1 ∈ s := by sorry

This theorem, `Filter.mem_one`, states that for any type `α` which has a `One` instance (that is, an instance of the multiplicative identity `1`), and any set `s` of elements of type `α`, `s` belongs to `1` if and only if `1` belongs to `s`. In other words, the membership of the set `s` in `1` is equivalent to the membership of `1` in the set `s`. This is a statement about the symmetry of membership between the multiplicative identity and any set of elements of a type that supports the concept of the multiplicative identity.

For any type `α` with a `One` instance and set `s` of elements from `α`, `1 ∈ s` if and only if `s ∈ 1`.


theorem deriv_mul :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_2} [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕜 𝔸] {c d : 𝕜 → 𝔸},
      DifferentiableAt 𝕜 c x →
        DifferentiableAt 𝕜 d x → deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x :=
  by sorry

The `deriv_mul` theorem states that for any non-trivial normed field `𝕜`, any point `x` in `𝕜`, any normed ring `𝔸` over `𝕜`, and any two functions `c` and `d` from `𝕜` to `𝔸`, if `c` and `d` are both differentiable at `x`, then the derivative at `x` of the function defined by multiplying `c` and `d` is equal to the product of the derivative of `c` at `x` and the value of `d` at `x`, plus the product of the value of `c` at `x` and the derivative of `d` at `x`. Essentially, this theorem is a formalization of the product rule from calculus in the context of differentiable functions on normed algebra.

For any non-trivial normed field `𝕜`, any point `x` in `𝕜`, and normed rings `𝔸` over `𝕜`, if functions `c` and `d` from `𝕜` to `𝔸` are differentiable at `x`, then `(dc/dx)(x) * d(x) = c(x) * (dd/dx)(x)`.


/-- Under the canonical linear map from a submodule `p` to the ambient space `M`, the image of the
maximal submodule of `p` is just `p`.  -/
theorem Submodule.map_subtype_top :
    ∀ {R : Type u_1} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      (p : Submodule R M), Submodule.map (Submodule.subtype p) ⊤ = p :=
  by sorry

The theorem `Submodule.map_subtype_top` states that for any semiring `R`, an additive commutative monoid `M`, and a module `M` over `R`, for any submodule `p` of `M`, the image of the maximal submodule (denoted as `⊤`) of `p` under the canonical linear map from `p` to `M` (defined by the function `Submodule.subtype`) is just `p` itself. In mathematical terms, this is saying that if we map every element of `p` to `M` using the canonical embedding, the resulting set is exactly `p`.

For any submodule `p` of an `R`-module `M`, the canonical embedding map from `p` to `M` maps the maximal submodule of `p` to `p` itself.


theorem MeasureTheory.ProbabilityMeasure.ennreal_coeFn_eq_coeFn_toMeasure :
    ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.ProbabilityMeasure Ω) (s : Set Ω),
      ↑((fun s => (↑↑↑ν s).toNNReal) s) = ↑↑↑ν s :=
  by sorry

This theorem is stating that for any type `Ω` that is equipped with a `MeasurableSpace` structure, any probability measure `ν` on `Ω`, and any set `s` of `Ω`, the real number part of the measure `ν` of the set `s` (obtained by applying three coercions to `ν s` and then taking the nonnegative real part) is equal to the measure `ν` of the set `s` itself. This is equivalent to saying that the measure of any set in a probability space, when considered as a nonnegative real number, is the same as the original measure value.

For any probability measure `ν` on a measurable space `(Ω, Σ)`, the real number `ℝ⁺(ν(s))` equal to the measure `ν` of any set `s ∈ Σ`.


/-- The span of the empty set is `⊥`.  -/
theorem AffineSubspace.span_empty :
    ∀ (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], affineSpan k ∅ = ⊥ :=
  by sorry

The theorem `AffineSubspace.span_empty` states that in any Affine space, the span of the empty set is the smallest possible Affine subspace (`⊥`). This holds for any scalar field `k`, vector space `V` over `k`, and Affine space `P` based on `V`, given that `k` forms a Ring, `V` forms an Additive Commutative Group, and `V` is a module over `k`.

In any Affine space based on a module over a ring, the span of the empty set is the trivial subspace.


theorem Set.subset_diff_singleton : ∀ {α : Type u} {x : α} {s t : Set α}, s ⊆ t → x ∉ s → s ⊆ t \ {x} := by sorry

The theorem `Set.subset_diff_singleton` states that for any type `α`, any element `x` of type `α`, and any sets `s` and `t` of the same type `α`, if `s` is a subset of `t` and `x` is not an element of `s`, then `s` is also a subset of the difference of `t` and the singleton set containing `x`. In other words, removing an element that is not in `s` from `t` does not affect the inclusion of `s` in `t`.

If `s` is a subset of `t` and `x ∉ s`, then `s` is a subset of `t \ {x}`.


theorem Trivialization.coe_coe :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj), ↑e.toPartialHomeomorph = ↑e :=
  by sorry

This theorem states that for any types B, F, and Z, where B, F, and Z are topological spaces, and a function `proj` from Z to B, the operation of converting a trivialization of F over proj to a partial homeomorphism and then taking its co-domain (indicated by `↑`) is equivalent to taking the co-domain of the original trivialization. In other words, the process of transforming a trivialization into a partial homeomorphism doesn't change its co-domain.

For any types B, F, and Z being topological spaces, and a function `proj` from Z to B, the co-domain of the partial homeomorphism obtained from a trivialization of F over `proj` is equal to the co-domain of the original trivialization.


theorem QuaternionAlgebra.self_add_star' :
    ∀ {R : Type u_3} [inst : CommRing R] {c₁ c₂ : R} (a : QuaternionAlgebra R c₁ c₂), a + star a = ↑(2 * a.re) := by
  sorry

This theorem states that for any instance `a` of the QuaternionAlgebra over a commutative ring `R` with coefficients `c₁` and `c₂`, the sum of `a` and its conjugate (denoted by `star a`) equals two times the real part of `a`. This is denoted as `↑(2 * a.re)`, where `↑` is the coercion function from `R` to QuaternionAlgebra. Essentially, this theorem formalizes a specific property of quaternion algebra concerning the sum of a quaternion and its conjugate in terms of its real part.

For any quaternion `a` in the QuaternionAlgebra over a commutative ring with real and imaginary parts `r` and `i`, respectively, the sum of `a` and its conjugate `(r + i * i − j * j − k * k) * a.conj` equals twice the real part `r` of `a`.


/-- The unbundled orthogonal projection is the unique point in `K`
with the orthogonality property.  This lemma is only intended for use
in setting up the bundled version and should not be used once that is
defined.  -/
theorem eq_orthogonalProjectionFn_of_mem_of_inner_eq_zero :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {K : Submodule 𝕜 E} [inst_3 : HasOrthogonalProjection K] {u v : E},
      v ∈ K → (∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0) → orthogonalProjectionFn K u = v :=
  by sorry

The theorem `eq_orthogonalProjectionFn_of_mem_of_inner_eq_zero` asserts that for any types `𝕜` and `E`, where `𝕜` is a ring-like structure (as defined by `RCLike`), `E` is a normed add commutative group and `E` is an inner product space over `𝕜`. If we have a submodule `K` of `E` which has an orthogonal projection and two elements `u` and `v` in `E`, then if `v` lies in `K` and for all `w` in `K`, the inner product of `u - v` and `w` is zero, then the orthogonal projection of `u` onto `K` is `v`. In simpler terms, it states that the orthogonal projection of a vector onto a subspace is the unique point in the subspace that is orthogonal to the original vector. This theorem is mainly used for setting up the bundled version of the orthogonal projection and should not be used once the bundled version is established.

If `u` is an element of a normed add commutative group `E` over a ring-like structure `𝕜`, `K` is a submodule of `E` with an orthogonal projection, `v` is an element of `K` such that `u - v` is orthogonal to every `w` in `K`, then `v` is the orthogonal projection of `u` onto `K`.


theorem Function.Embedding.nonempty_of_card_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β],
      Fintype.card α ≤ Fintype.card β → Nonempty (α ↪ β) :=
  by sorry

This theorem states that for any two types `α` and `β`, both of which have a finite number of elements (fintype), if the number of elements in `α` is less than or equal to the number of elements in `β` (`Fintype.card α ≤ Fintype.card β`), then there exists a function that can embed `α` into `β` without any collisions (i.e., it is an injective function from `α` to `β`). In mathematical notation, this means that if |α| ≤ |β|, then there exists a function f: α ↪ β.

If `α` and `β` are types with finite numbers of elements such that the cardinality of `α` is less than or equal to that of `β`, then there exists an injective function from `α` to `β`.


Associated.isUnit

theorem Associated.isUnit : ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, Associated a b → IsUnit a → IsUnit b := by
  sorry

The theorem `Associated.isUnit` states that for any type `α` that forms a `Monoid`, given any two elements `a` and `b` of this type, if `a` and `b` are `Associated` (i.e., `a` can be obtained by multiplying `b` by a unit on the right), and if `a` is a `Unit` (i.e., `a` has a two-sided inverse), then `b` is also a `Unit`. This essentially says that being a unit is a preserved property under the association relation in a monoid.

If `a` and `b` are associated elements in a monoid `α` with `a` being a unit, then `b` is also a unit.


theorem div_mul_div_cancel :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {b c : G₀} (a : G₀), c ≠ 0 → a / c * (c / b) = a / b := by sorry

This theorem states that for any type `G₀` that forms a group with zero, for any non-zero elements `a`, `b`, `c` of `G₀`, the multiplication of `a` divided by `c` and `c` divided by `b` equals `a` divided by `b`. In simpler terms, it describes a property of division and multiplication in the context of a group with zero, where if we divide `a` by `c` and multiply the result by `c` divided by `b`, we'll get the same result as simply dividing `a` by `b`, provided `c` is not zero.

In a group with zero, for any non-zero elements `a`, `b`, `c`, `(a / c) * (c / b) = a / b`.


theorem ValuationSubring.mem_or_inv_mem :
    ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (x : K), x ∈ A ∨ x⁻¹ ∈ A := by sorry

This theorem states that for any field `K` and any `ValuationSubring A` of `K`, and for any element `x` from `K`, either `x` is a member of `A` or its multiplicative inverse `x⁻¹` is a member of `A`. This means that in any given valuation subring of a field, every element or its reciprocal must be present.

For any field `K` and its valuation subring `A`, every element `x` in `K` or its multiplicative inverse `x⁻¹` belongs to `A`.


theorem mem_closure_zero_iff_norm : ∀ {E : Type u_6} [inst : SeminormedAddGroup E] {x : E}, x ∈ closure {0} ↔ ‖x‖ = 0 :=
  by sorry

The theorem `mem_closure_zero_iff_norm` states that for any seminormed additive group `E` and any element `x` of `E`, the element `x` is in the closure of the set containing only the zero element if and only if the norm of `x` is zero. In other words, any element `x` in the closure of a set that only contains the zero element in a seminormed additive group will have a norm of zero.

For any seminormed additive group E and element x of E, x is in the closure of {0} if and only if the norm of x is zero.


theorem Nat.two_le_iff : ∀ (n : ℕ), 2 ≤ n ↔ n ≠ 0 ∧ n ≠ 1 := by sorry

This theorem states that for any natural number 'n', 'n' is greater than or equal to 2 if and only if 'n' is not equal to 0 and 'n' is not equal to 1. In other words, any natural number 'n' being greater than or equal to 2 is equivalent to 'n' being different from both 0 and 1.

For any natural number n, n ≥ 2 if and only if n ≠ 0 ∧ n ≠ 1.


theorem MeasureTheory.Measure.empty_of_count_eq_zero :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α} [inst_1 : MeasurableSingletonClass α],
      ↑↑MeasureTheory.Measure.count s = 0 → s = ∅ :=
  by sorry

This theorem states that for any type `α` that has a measurable space structure, and any set `s` of `α` that has a measurable singleton class structure, if the counting measure of the set `s` is equal to zero, then the set `s` must be the empty set. Essentially, the theorem is saying that if there are no measurable elements in the set (hence, the measure is zero), the set must be empty.

If `α` is a type with a measurable space structure, `s` is a subset of `α` with a measurable singleton class structure, and the counting measure of `s` is zero, then `s` is the empty set.


theorem HomologicalComplex.toCycles_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι)
      [inst_2 : HomologicalComplex.HasHomology K j],
      CategoryTheory.CategoryStruct.comp (HomologicalComplex.toCycles K i j) (HomologicalComplex.iCycles K j) =
        K.d i j :=
  by sorry

This theorem, `HomologicalComplex.toCycles_i`, states that for any category `C` with zero morphisms, and any complex shape `c` indexed by `ι`, given a homological complex `K` of category `C` with shape `c`, and two indices `i` and `j` from `ι`, when `K` has homology at index `j`, the composition of the morphism `toCycles` from `i` to `j` in `K` and the inclusion morphism of the cycles at `j` in `K` is equal to the morphism `d` from `i` to `j` in `K`. In other words, in the language of category theory, the diagram involving the `toCycles`, `iCycles`, and `d` morphisms commutes.

For any homological complex in a zero-morphism category, the composition of `toCycles` from `i` to `j` and the inclusion of `j`-cycles is equal to the differential `d` from `i` to `j`.


theorem List.sorted_nil : ∀ {α : Type uu} {r : α → α → Prop}, List.Sorted r [] := by sorry

This theorem states that for any type `α` and any binary relation `r` on `α`, an empty list is `Sorted` with respect to `r`. In other words, an empty list is always sorted under any relation, since there are no elements to violate the sorting condition.

For any type `α` and binary relation `r` on `α`, the empty list is a sorted list with respect to `r`.


theorem Cardinal.aleph'_le_of_limit :
    ∀ {o : Ordinal.{u_1}},
      Ordinal.IsLimit o → ∀ {c : Cardinal.{u_1}}, Cardinal.aleph' o ≤ c ↔ ∀ o' < o, Cardinal.aleph' o' ≤ c :=
  by sorry

This theorem, `Cardinal.aleph'_le_of_limit`, states that for any limit ordinal `o` and any cardinal `c`, the cardinal number `aleph' o` is less than or equal to `c` if and only if every ordinal `o'` less than `o` has its corresponding cardinal `aleph' o'` less than or equal to `c`. Essentially, it relates the ordering of limit ordinals and their corresponding cardinals in the `aleph'` sequence to the ordering of all cardinals less than a given cardinal.

For any limit ordinal `o` and cardinal `c`, `aleph' o ≤ c` if and only if `aleph' α <= c` for all ordinals `α < o`.


theorem lt_of_lt_of_eq : ∀ {α : Type u} {a b c : α} [inst : LT α], a < b → b = c → a < c := by sorry

This theorem, `lt_of_lt_of_eq`, states that for any type `α` that has a less than (`<`) operation, if an element `a` of that type is less than another element `b`, and `b` is equal to a third element `c`, then `a` is less than `c`. Essentially, it is a statement about transitivity of the less than operation in the presence of equality.


theorem one_lt_mabs :
    ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a : α}, 1 < mabs a ↔ a ≠ 1 :=
  by sorry

The theorem `one_lt_mabs` states that for any type `α` which is a group and a linear order, and satisfies the covariant class property (that multiplication respects the order), the absolute value `mabs a` of an element `a` is greater than 1 if and only if `a` is not equal to 1. In other words, in such a structure, the absolute value of any element other than 1 is always greater than 1.

For any group and linear order type `α` satisfying the covariant class property, `mabs a > 1 if and only if a ≠ 1`.