Continuous.sup

theorem Continuous.sup :
    ∀ {L : Type u_1} {X : Type u_2} [inst : TopologicalSpace L] [inst_1 : TopologicalSpace X] [inst_2 : Sup L]
      [inst_3 : ContinuousSup L] {f g : X → L}, Continuous f → Continuous g → Continuous fun x => f x ⊔ g x :=
  by sorry

This theorem states that for any two functions `f` and `g` from a topological space `X` to another topological space `L` with a supremum operation `⊔` and continuity of this operation, if both `f` and `g` are continuous, then the function that maps each point `x` in the domain to the supremum of `f(x)` and `g(x)` is also continuous. This is a property of continuous functions in a topological space that have a supremum operation.

If `f` and `g` are continuous functions from a topological space `X` to a topological space `L` with a supremum operation `⊔`, then the function `x ↦ ⊔(f(x), g(x))` is also continuous.


theorem Matrix.range_cons :
    ∀ {α : Type u} {n : ℕ} (x : α) (u : Fin n → α), Set.range (Matrix.vecCons x u) = {x} ∪ Set.range u := by sorry

This theorem states that for any type `α` and any natural number `n`, given any element `x` of the type `α` and a function `u` from the finite set of size `n` to `α`, the range of the function that prepends `x` to the vector formed by `u` is the set containing `x` union the range of `u`. In other words, it's saying that if you prepend the element `x` to a vector, the set of possible values the vector can take includes `x` and all the values the original vector could take.

For any type `α` and natural number `n`, if `x` is an element of `α` and `u` is a function from a finite set of size `n` to `α`, then the range of the function `x :: u` (the function that prepends `x` to `u`'s range) equals `{x} ∪ u(`range(u)`)`.


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

The theorem `Set.mem_Ico` states that for any type `α` that has a preorder structure, and for any elements `a`, `b`, and `x` of `α`, `x` belongs to the left-closed right-open interval from `a` to `b` if and only if `x` is greater than or equal to `a` and less than `b`. In other words, a membership of `x` in the interval `[a, b)` (denoted as `Set.Ico a b` in Lean) is characterized by the inequalities `a ≤ x < b`.

For any preordered type `α` and elements `a`, `b` of `α`, an element `x` belongs to the left-closed right-open interval `[a, b)` if and only if `a ≤ x < b`.


theorem Set.singleton_unop : ∀ {α : Type u_1} (x : αᵒᵖ), Set.unop {x} = {x.unop} := by sorry

The theorem `Set.singleton_unop` states that for every type `α` and for any term `x` of the opposite type `αᵒᵖ`, the unary operation (unop) of a singleton set containing `x` is equal to the singleton set containing the unary operation of `x`. This essentially means that applying the unary operation to each member of a singleton set is the same as applying the unary operation to the singleton set itself.

For any type `α` and term `x` of opposite type `αᵒᵖ`, the unary operation of the singleton set `{x}´ is equal to the singleton set `{unop x}`.


theorem CategoryTheory.ShortComplex.HomologyData.exact_iff :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.HomologyData S),
      CategoryTheory.ShortComplex.Exact S ↔ CategoryTheory.Limits.IsZero h.left.H :=
  by sorry

This theorem states that for any type `C` that forms a category with zero morphisms and any short complex `S` of `C`, the short complex `S` is exact if and only if the left homology of homology data `h` of `S` is zero. Here, exactness of a short complex refers to the property that the image of one morphism is equal to the kernel of the next morphism, and "zero homology" indicates that the homology at a particular point is trivial, i.e., isomorphic to the zero object of the category.

For any short complex `S` in a category `C` with zero morphisms, `S` is exact if and only if its homology is zero.


theorem Bool.decide_and :
    ∀ (p q : Prop) [inst : Decidable p] [inst_1 : Decidable q], decide (p ∧ q) = (decide p && decide q) := by sorry

This theorem, `Bool.decide_and`, states that for any two propositions `p` and `q`, given that `p` and `q` are decidable, the decision procedure for the conjunction of `p` and `q` (i.e., `p ∧ q`) is equal to the boolean 'and' (`&&`) of the decision procedures for `p` and `q` separately. In simpler terms, it shows that deciding whether both `p` and `q` are true is the same as deciding if `p` is true and then deciding if `q` is true.

For decidable propositions `p` and `q`, `p ∧ q` is decidable and equivalent to `p && q`.


theorem dense_of_exists_between :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : Nontrivial α] {s : Set α}, (∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b) → Dense s :=
  by sorry

This theorem, `dense_of_exists_between`, states that for any type `α` equipped with a topological space structure, a linear order, an order topology, and is nontrivial, and for any set `s` of elements of this type, if for every pair of elements `a` and `b` from `α` such that `a` is less than `b` there exists an element `c` in the set `s` such that `c` is greater than `a` and less than `b`, then the set `s` is dense in the topological space.

In other words, if we have a topological space with a linear order and an order topology, and any two points in this space can be "sandwiched" by a point from a specific set, then this set is dense in the topological space.

If a non-empty subset `S` of a topological space `(α,τ)` with a linear order `≤` such that the order induces the given topology `τ`, and for all `a` and `b` in `α` with `a < b`, there exists `c` in `S` with `a < c < b`, then `S` is dense in `(α,τ)`.


theorem pow_left_inj :
    ∀ {R : Type u_3} [inst : LinearOrderedSemiring R] {a b : R} {n : ℕ},
      0 ≤ a → 0 ≤ b → n ≠ 0 → (a ^ n = b ^ n ↔ a = b) :=
  by sorry

This theorem, `pow_left_inj`, asserts that for any type `R` that is a `LinearOrderedSemiring`, and for any two elements `a` and `b` of `R` along with a natural number `n`, if `a` and `b` are both non-negative and `n` is not zero, then `a` to the power of `n` being equal to `b` to the power of `n` is equivalent to `a` being equal to `b`. Essentially, it formalizes the notion that, under these conditions, the n-th power function is injective.

For any non-zero natural number `n` and elements `a` and `b` in a LinearOrderedSemiring `R` with `a`, `b` non-negative, `a^n = b^n` if and only if `a = b`.


theorem Mathlib.Order.LocallyFinite._auxLemma.19 :
    ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s] {a : α}, (a ∈ Set.toFinset s) = (a ∈ s) := by sorry

This theorem, named as "Mathlib.Order.LocallyFinite._auxLemma.19", states that for any type `α` and any set `s` of that type that has a `Fintype` instance, and any element `a` of type `α`, `a` belongs to the finite set constructed from `s` (`Set.toFinset s`) if and only if `a` belongs to the original set `s`. Essentially, it guarantees that the process of converting a set `s` to a finite set does not change its membership.

For any type `α` with a `Fintype` instance, and any set `s` of type `α`, the element `a` belongs to `Set.toFinset s` if and only if it belongs to `s`.


theorem Rat.floor_cast : ∀ {α : Type u_1} [inst : LinearOrderedField α] [inst_1 : FloorRing α] (x : ℚ), ⌊↑x⌋ = ⌊x⌋ := by
  sorry

This theorem states that for any rational number `x` and for any type `α` that is a linear ordered field and has a floor function, the floor of the real number equivalent of `x` (denoted `↑x`) is equal to the floor of `x` itself. In other words, casting a rational number to a real number does not change the result of taking the floor of that number.

For any rational number `x` and linear ordered field `α` with a floor function, `⌊x⌋ = ⌊Reál x⌋`, where `x` is the rational number, `Reál x` is the real number equivalent of `x`, `⌊x⌋` is the floor of `x`, and `⌊Reál x⌋` is the floor of the real number `Reál x`.


theorem Mathlib.Order.LocallyFinite._auxLemma.38 : ∀ {a b : Prop}, (a ∧ b ↔ a) = (a → b) := by sorry

This theorem, from the Mathlib.Order.LocallyFinite library, states that for any two propositions 'a' and 'b', the statement that 'a' and 'b' are equivalent to 'a' is equivalent to the implication that 'a' implies 'b'. In other words, it expresses that if 'a' also implies 'b', then 'a' and 'b' together are no more informative than 'a' alone.

If two propositions 'a' and 'b' are equivalent, then 'a' implies 'b' and 'b' implies 'a'.


theorem Mathlib.Order.LocallyFinite._auxLemma.39 : ∀ {a b : Prop}, (a ∧ b ↔ b) = (b → a) := by sorry

This theorem states that for any two propositions `a` and `b`, the statement that `a` and `b` are equivalent to `b` is the same as saying that if `b` is true, then `a` is true. In logical terms, `(a ∧ b ↔ b)` is equivalent to `(b → a)`.

The theorem asserts that `(a ↔ b)` is equivalent to `(b → a)` for any propositions `a` and `b`.


theorem unitary.mul_star_self_of_mem :
    ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, U ∈ unitary R → U * star U = 1 := by sorry

This theorem states that for any type `R` that is a monoid and has a star multiplication operation, if an element `U` of `R` belongs to the submonoid of `R` called `unitary`, then the product of `U` and the star-multiplication of `U` is equal to 1. In other words, in any star-monoid, if a given element is in the unitary submonoid, then it satisfies the unitary property that its multiplication with its star-multiplication results in the multiplicative identity element (1).

Given a monoid `R` with star multiplication operation, if `U` is an element of the unitary submonoid of `R`, then `U * U^* = 1`.


theorem Set.Ioo_union_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a < b → Set.Ioo a b ∪ {b} = Set.Ioc a b := by sorry

This theorem states that for any type `α` that has a partial order, given two elements `a` and `b` in `α` such that `a < b`, the union of the open interval from `a` to `b` and the singleton set containing `b` equals the half-open interval from `a` to `b`. In other words, if we have a set of elements strictly between `a` and `b`, and another set containing only `b`, their union forms a set of elements that are strictly greater than `a` and less than or equal to `b`.

For any type `α` with a partial order, the union of the open interval from `a` to `b` (elements strictly between `a` and `b`) and the singleton set `{b}` equals the half-open interval from `a` to `b` (elements strictly greater than `a` and less than or equal to `b`).


theorem Turing.ListBlank.nth_zero :
    ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : Turing.ListBlank Γ),
      Turing.ListBlank.nth l 0 = Turing.ListBlank.head l :=
  by sorry

The theorem `Turing.ListBlank.nth_zero` states that for any type `Γ` that has an instance of `Inhabited` and any `ListBlank` of this type `l`, the element at the zeroth index of `l` (obtained using `Turing.ListBlank.nth`) is the same as the head of `l` (obtained using `Turing.ListBlank.head`). This is akin to stating that for an infinitely extended list, the first element is the same as the head of the list.

For any type `Γ` with an `Inhabited` instance and any `ListBlank Γ l`, the zeroth element of `l` equals the head of `l`.


theorem HomologicalComplex.to_single_hom_ext :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι)
      {K : HomologicalComplex V c} {j : ι} {A : V} {f g : K ⟶ (HomologicalComplex.single V c j).obj A},
      f.f j = g.f j → f = g :=
  by sorry

This theorem, named `HomologicalComplex.to_single_hom_ext`, states that for any category `V` with zero morphisms and a zero object, given a complex shape `c` indexed by a type `ι` with decidable equality, a homological complex `K` over `V` and `c`, an object `j` of type `ι`, and an object `A` of `V`, if we have two morphisms `f` and `g` from `K` to the single-object homological complex at `A` indexed by `j` and they are the same at the index `j`, then the morphisms `f` and `g` are identical.

For any homological complex `K` over a category `V` with zero morphisms and a zero object, two morphisms from `K` to the single-object complex at an object `A` indexed by `j` are equal if and only if they agree at the index `j`.


theorem TypeVec.appendFun_id_id : ∀ {n : ℕ} {α : TypeVec.{u_1} n} {β : Type u_1}, (TypeVec.id ::: id) = TypeVec.id := by
  sorry

The theorem `TypeVec.appendFun_id_id` states that for any natural number `n`, any `n`-tuple of types `α` (represented as a function from a finite set of size `n` to types), and any type `β`, appending the identity function to the end of the `TypeVec.id` function (which is the identity function on `n`-tuples of types) results in the `TypeVec.id` function itself. In other words, it shows that appending an identity function does not change the original function on `n`-tuples of types.

For any natural number `n` and any `n`-tuple of types `α`, the function `TypeVec.appendFun (λ i, α i) TypeVec.id` equals `TypeVec.id` where `TypeVec.id` is the identity function on `n`-tuples of types.


/-- Taking the affine span of a set, adding a point and taking the span again produces the same
results as adding the point to the set and taking the span.  -/
theorem affineSpan_insert_affineSpan :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p : P) (ps : Set P),
      affineSpan k (insert p ↑(affineSpan k ps)) = affineSpan k (insert p ps) :=
  by sorry

This theorem states that in the context of a ring `k`, an additive commutative group `V`, and an additive torsor `V P`, for any point `p` and any set of points `ps`, taking the affine span of `ps`, then inserting `p`, and taking the affine span again, is the same as first inserting `p` into `ps`, and then taking the affine span. Essentially, the order of inserting a point and taking the affine span does not affect the final result. This property is important for the manipulation and understanding of geometric and vector spaces in mathematics.

In the context of a ring `k`, an additive commutative group `V`, and an additive torsor `V/P`, the affine span of `P ∪ {p}` is equal to the affine span of `P` followed by the affine span of `{p}`.


/-- **Alias** of the reverse direction of `hasDerivWithinAt_Ioi_iff_Ici`. -/
theorem HasDerivWithinAt.Ioi_of_Ici :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} [inst_3 : PartialOrder 𝕜],
      HasDerivWithinAt f f' (Set.Ici x) x → HasDerivWithinAt f f' (Set.Ioi x) x :=
  by sorry

This theorem states that if a function `f` has a derivative `f'` at a point `x` within a left-closed, right-infinite interval `Set.Ici x` (that is, the set of all values greater than or equal to `x`), then `f` also has the same derivative `f'` at `x` within a left-open, right-infinite interval `Set.Ioi x` (that is, the set of all values strictly greater than `x`). Here, both `f` and `f'` are functions from a nontrivially normed field `𝕜` to a normed additive commutative group `F`, and `𝕜` is also a partial order.

If a function `f` with derivative `f'` at a point `x` in a nontrivially normed field `𝕜` has the property that `f'` exists in the left-closed, right-infinite interval `Set.Ici x` of `𝕜`, then `f'` also exists and is equal to `f'` in the left-open, right-infinite interval `Set.Ioi x`.


theorem CochainComplex.HomComplex.Cochain.comp_zero_cochain_v :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      {F G K : CochainComplex C ℤ} {n : ℤ} (z₁ : CochainComplex.HomComplex.Cochain F G n)
      (z₂ : CochainComplex.HomComplex.Cochain G K 0) (p q : ℤ) (hpq : p + n = q),
      (z₁.comp z₂ ⋯).v p q hpq = CategoryTheory.CategoryStruct.comp (z₁.v p q hpq) (z₂.v q q ⋯) :=
  by sorry

This theorem in Lean 4 states that for any category C with preadditive structure and for any three cochain complexes F, G, and K over C, along with an integer n, if there exist two cochains: z1 from F to G of degree n, and z2 from G to K of degree 0, then for any two integers p and q such that p + n equals q, the value at (p, q) for the composition of z1 and z2 is equal to the composition of the values at (p, q) and (q, q) for z1 and z2 respectively. This intuitively represents the idea that the composition of cochain morphisms in a cochain complex corresponds to the composition of the individual morphisms they represent.

For any cochain complexes F, G, K in a preadditive category C and integer n, if there exist cochains z1: F[n] -> G[0] and z2: G[0] -> K[n], then for all integers p and q with p + n = q, z1 ∘ z2(p) = z1(p) ∘ z2(q).


theorem Matrix.blockDiagonal'_apply :
    ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [inst : DecidableEq o] [inst_1 : Zero α]
      (M : (i : o) → Matrix (m' i) (n' i) α) (ik : (i : o) × m' i) (jk : (i : o) × n' i),
      Matrix.blockDiagonal' M ik jk = if h : ik.fst = jk.fst then M ik.fst ik.snd (cast ⋯ jk.snd) else 0 :=
  by sorry

The theorem `Matrix.blockDiagonal'_apply` states the following: Given an indexed family of matrices `M : (i : o) → Matrix (m' i) (n' i) α` where `o` is a type with decidable equality, `α` is a type with a zero element, and `m'` and `n'` are functions producing types indexed by `o`, for any index-paired values `ik : (i : o) × m' i` and `jk : (i : o) × n' i`, the matrix entry at `ik, jk` of the block diagonal matrix formed from `M`, namely `Matrix.blockDiagonal' M ik jk`, is determined as follows: If `ik.fst = jk.fst` (i.e., `ik` and `jk` belong to the same block), then the matrix entry is the corresponding entry in the matrix `M ik.fst`, otherwise it is zero.

The theorem `Matrix.blockDiagonal'_apply` asserts that the entry in the block diagonal matrix formed from an indexed family of matrices `M` at index-paired values `ik` and `jk` is `M ik.fst.(jk.fst)` if `ik.fst = jk.fst`, and zero otherwise.


theorem CategoryTheory.GrothendieckTopology.plusLift_unique :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
      [inst_1 : CategoryTheory.Category.{max v u, w} D]
      [inst_2 :
        ∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X),
          CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)]
      [inst_3 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.GrothendieckTopology.Cover J X)ᵒᵖ D]
      {P Q : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q) (hQ : CategoryTheory.Presheaf.IsSheaf J Q)
      (γ : CategoryTheory.GrothendieckTopology.plusObj J P ⟶ Q),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.toPlus J P) γ = η →
        γ = CategoryTheory.GrothendieckTopology.plusLift J η hQ :=
  by sorry

The theorem `CategoryTheory.GrothendieckTopology.plusLift_unique` in Lean 4 states that for any categories `C` and `D`, Grothendieck topology `J` on `C`, functors `P` and `Q` from the opposite of `C` to `D`, and a natural transformation `η` from `P` to `Q`, if `Q` is a sheaf with respect to `J`, and there exists a morphism `γ` from the plus construction of `P` with respect to `J` to `Q` such that the composition of the morphism from `P` to the plus construction of `P` with `γ` equals `η`, then `γ` must be the lift of `η` via the plus construction of `J`. This theorem asserts the uniqueness of the lift in the particular context of the plus construction in Grothendieck topologies. The plus construction is a way of associating a sheaf to a presheaf in a Grothendieck topology.

Given categories C, D, a Grothendieck topology J on C, functors P and Q from the opposite of C to D, and a natural transformation η from P to Q with Q being a sheaf and having a morphism γ from the plus construction of P with respect to J to Q such that the composite of the morphism from P to the plus construction of P and γ equals η, then γ is the unique lift of η via the plus construction of J.


theorem Ordinal.lift_succ :
    ∀ (a : Ordinal.{v}), Ordinal.lift.{u, v} (Order.succ a) = Order.succ (Ordinal.lift.{u, v} a) := by sorry

This theorem states that for any ordinal `a` in a certain universe `v`, lifting the successor of `a` to a larger universe (which universe is at least the maximum of `u` and `v`), is the same as first lifting `a` to the larger universe and then taking its successor. In other words, the operation of taking the successor commutes with the operation of lifting ordinals to a larger universe.

For any ordinal `a` and universes `u` and `v` with `v` at least `u`, the lift of the successor of `a` in `v` equals the successor of the lift of `a` in `v`.


theorem Filter.HasBasis.eq_bot_iff :
    ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → (l = ⊥ ↔ ∃ i, p i ∧ s i = ∅) :=
  by sorry

This theorem states that for any type `α` and an index type `ι`, given a filter `l` over `α`, a predicate `p` over `ι`, and a function `s` from `ι` to sets of `α` such that `l` has a filter basis characterized by `p` and `s`, then `l` is the bottom filter if and only if there exists an index `i` such that `p i` is true and the set `s i` is empty. In the context of filters, the bottom filter essentially represents the "smallest" or "trivial" filter, and filter basis is a method of specifying a filter using a collection of sets that satisfy certain properties.

For a filter `l` over type `α` with filter basis characterized by predicate `p` and function `s` from index type `ι` to sets of `α`, `l` is the bottom filter if and only if there exists an index `i` such that `p i` holds and `s i` is empty.


theorem Stream'.WSeq.destruct_flatten :
    ∀ {α : Type u} (c : Computation (Stream'.WSeq α)),
      Stream'.WSeq.destruct (Stream'.WSeq.flatten c) = c >>= Stream'.WSeq.destruct :=
  by sorry

The theorem `Stream'.WSeq.destruct_flatten` states that for any computation `c` that yields a weak sequence of type `α`, the process of destructing the flattened version of `c` is the same as the process of destructing the weak sequence resulting from computing and then destructing `c`. In other words, it asserts that the operation of destructing a computation after flattening it is equivalent to the operation of computing a weak sequence first and then destructing it.

For any computation `c` yielding a weak sequence of type `α`, destructing the flattened version of `c` is equivalent to first computing and then destructing the resulting weak sequence.


theorem nhdsSet_insert :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X) (s : Set X), nhdsSet (insert x s) = nhds x ⊔ nhdsSet s := by
  sorry

This theorem states that for any type `X` equipped with a topology (which makes `X` a topological space), any element `x` of this type, and any set `s` of elements of this type, the filter of neighborhoods of the set that is the union of `x` and `s` is equal to the join (supremum) of the filter of neighborhoods of `x` and the filter of neighborhoods of the set `s`. In mathematical terms, if `nhdsSet` denotes the filter of neighborhoods and `nhds` the neighborhood filter, we have `nhdsSet (insert x s) = nhds x ⊔ nhdsSet s` for all topological spaces `X`, all `x ∈ X`, and all sets `s` of elements of `X`.

For any topological space (X, tp), and any x ∈ X and set s ⊆ X, the filter of neighborhoods of the set {x ∪ s} equals the join (supremum) of the filters of neighborhoods of x and s. In mathematical notation, nhds({x ∪ s}) = nhds(x) ⊔ nhds(s).


theorem Finsupp.single_eq_single_iff :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] (a₁ a₂ : α) (b₁ b₂ : M),
      ((fun₀ | a₁ => b₁) = fun₀ | a₂ => b₂) ↔ a₁ = a₂ ∧ b₁ = b₂ ∨ b₁ = 0 ∧ b₂ = 0 :=
  by sorry

The theorem `Finsupp.single_eq_single_iff` states that for any types `α` and `M` with `M` being a type with zero, given any four elements `a₁`, `a₂` of type `α` and `b₁`, `b₂` of type `M`, the function `fun₀ | a₁ => b₁` is equal to the function `fun₀ | a₂ => b₂` if and only if either `a₁` equals `a₂` and `b₁` equals `b₂`, or `b₁` equals zero and `b₂` equals zero. This theorem essentially describes the conditions for equality between two functions constructed using the `Finsupp.single` function, which constructs a function that maps a single element to a nonzero value and all other elements to zero.

For functions `f` and `g` constructed as `Finsupp.single a b` with `a` from type `α` and `b` from type `M` with zero, `f = g` if and only if `a = a'` and `b = b'` or `b = 0` and `b' = 0`.


theorem IsAntichain.preimage_relEmbedding :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {t : Set β},
      IsAntichain r' t → ∀ (φ : r ↪r r'), IsAntichain r (⇑φ ⁻¹' t) :=
  by sorry

The theorem `IsAntichain.preimage_relEmbedding` states that for any types `α` and `β`, any relations `r` on `α` and `r'` on `β`, and any set `t` of type `β`, if `t` forms an antichain with respect to the relation `r'`, then for any relation embedding `φ` from `r` to `r'`, the preimage of `t` under `φ` forms an antichain with respect to the relation `r` on `α`. In other words, the preimage of an antichain under a relation-preserving function is also an antichain.

If `t` is an antichain of relation `r'` on type `β` and `φ` is a relation embedding from relation `r` on type `α` to `r'`, then the preimage of `t` under `φ` is an antichain of relation `r` on `α`.


theorem List.append_bind :
    ∀ {α : Type u_1} {β : Type u_2} (xs ys : List α) (f : α → List β),
      List.bind (xs ++ ys) f = List.bind xs f ++ List.bind ys f :=
  by sorry

The theorem `List.append_bind` states that for any types `α` and `β`, any two lists of type `α` (denoted as `xs` and `ys`), and any function `f` from `α` to a list of `β`, the bind operation on the concatenation of the lists `xs` and `ys` using the function `f` is equal to the concatenation of the bind operation on `xs` using `f` and the bind operation on `ys` using `f`. In more mathematical terms, this is the property that `List.bind (xs ++ ys) f = List.bind xs f ++ List.bind ys f`, showing an important property of the bind operation in the list monad related to list concatenation.

For any types `α` and `β`, and lists `xs` and `ys` of type `α`, the bind operation `List.bind` over the concatenation `xs ++ ys` of `xs` and `ys` using a function `f` from `α` to lists of `β` is equal to the concatenation of the bind operations on `xs` and `ys` using `f`. That is, `List.bind (xs ++ ys) f = List.bind xs f ++ List.bind ys f`.


theorem MeasureTheory.ae_eq_comp :
    ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
      {μ : MeasureTheory.Measure α} {f : α → β} {g g' : β → δ},
      AEMeasurable f μ →
        g =ᶠ[MeasureTheory.Measure.ae (MeasureTheory.Measure.map f μ)] g' →
          g ∘ f =ᶠ[MeasureTheory.Measure.ae μ] g' ∘ f :=
  by sorry

This theorem, `MeasureTheory.ae_eq_comp`, asserts that for any types `α`, `β`, and `δ`, a measurable space `α` denoted as `m0`, another measurable space `β`, a measure `μ` on `α`, a function `f` mapping from `α` to `β`, and two functions `g` and `g'` both mapping from `β` to `δ`, if `f` is almost everywhere measurable with respect to `μ`, and `g` is almost everywhere equal to `g'` with respect to the measure resulting from mapping `f` to `μ`, then the composition of `g` and `f` is almost everywhere equal to the composition of `g'` and `f` with respect to measure `μ`.

In essence, if the function `f` is almost everywhere measurable and two functions `g` and `g'` are almost everywhere equivalent under the measure transformed by `f`, then the compositions `g ∘ f` and `g' ∘ f` are also almost everywhere equivalent under the original measure.

If `f` is almost everywhere measurable with respect to `μ` on `α` and `g` is almost everywhere equal to `g'` with respect to the pushforward measure of `μ` by `f` on `β`, then `g ∘ f` is almost everywhere equal to `g' ∘ f` with respect to `μ` on `α`.


theorem Finset.le_inf_image₂ :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α}
      {t : Finset β} [inst_1 : SemilatticeInf δ] [inst_2 : OrderTop δ] {g : γ → δ} {a : δ},
      a ≤ Finset.inf (Finset.image₂ f s t) g ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ g (f x y) :=
  by sorry

The theorem `Finset.le_inf_image₂` states that for every types `α`, `β`, `γ` and `δ`, with `γ` having a decidable equality, a binary function `f` mapping `α` and `β` to `γ`, two finite sets `s` and `t` of types `α` and `β` respectively, a `SemilatticeInf δ` and `OrderTop δ` instance, a function `g` mapping `γ` to `δ`, and a value `a` of type `δ`, the condition that `a` is less than or equal to the infimum of the image set of `f` applied to `s` and `t` and then mapped through `g`, is equivalent to the condition that for every `x` in `s` and every `y` in `t`, `a` is less than or equal to `g` applied to `f` of `x` and `y`. Here, the infimum is the greatest lower bound of a set.

For types `α`, `β`, `γ`, and `δ` with decidable equality, a binary function `f` from `α` to `β`, finite sets `s` of type `α` and `t` of type `β`, a semilattice and ordered topology instance for `δ`, a function `g` from `γ` to `δ`, and a value `a` of type `δ`, the condition that `a <= inf (g . f "" s) ++ g . f "" t` holds if and only if for all `x in s` and `y in t`, `a <= g (f x y)`.


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

This theorem states that for any type `α`, any Matroid `M` of that type, and any set `I` of that type, if `I` is an independent set in `M` (`M.Indep I`), then `I` is a basis for itself in `M` (`M.Basis I I`). In other words, in the context of matroid theory, an independent set within a matroid is also a basis of itself within that matroid.

For any matroid M and any independent set I in its type α, I is a basis of I in M.


theorem Real.smoothTransition.one_of_one_le : ∀ {x : ℝ}, 1 ≤ x → Real.smoothTransition x = 1 := by sorry

This theorem states that for any real number 'x', if 'x' is greater than or equal to 1, the value of the infinitely smooth transition function at 'x' is 1. The smooth transition function referred to here is defined such that its value is 0 for all 'x' less than or equal to 0, 1 for 'x' greater than or equal to 1, and between 0 and 1 for 'x' in the open interval (0, 1).

For any real number x, the smooth transition function equals 1 if x ≥ 1.


Finset.Nonempty.mono

theorem Finset.Nonempty.mono : ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → s.Nonempty → t.Nonempty := by sorry

This theorem states that for any two finite sets `s` and `t` of any type `α`, if `s` is a subset of `t` and `s` is nonempty, then `t` is also nonempty. In other words, if a set `s` has at least one element and all elements of `s` also belong to `t`, then `t` must have at least one element. This is a basic property of subset relationships in set theory.

If `s` is a nonempty subset of `t`, then `t` is nonempty.


theorem SimpleGraph.Walk.map_isTrail_iff_of_injective :
    ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {f : G →g G'} {u v : V}
      {p : SimpleGraph.Walk G u v},
      Function.Injective ⇑f → (SimpleGraph.Walk.IsTrail (SimpleGraph.Walk.map f p) ↔ SimpleGraph.Walk.IsTrail p) :=
  by sorry

The theorem `SimpleGraph.Walk.map_isTrail_iff_of_injective` states that for any types `V` and `V'`, any simple graphs `G` and `G'` on `V` and `V'` respectively, any graph homomorphism `f` from `G` to `G'`, and any vertices `u` and `v` in `G`, if `f` is an injective function, then a walk `p` from `u` to `v` in `G` is a trail if and only if the mapped walk in `G'` is also a trail. A trail in a graph is a walk in which no edge is repeated. Graph homomorphisms map vertices to vertices and edges to edges, preserving the edge-vertex incidence relation.

Given simple graphs G and G' with graph homomorphism f, injectivity of f implies that a walk in G is a trail if and only if its image under f is a trail in G'.


theorem LipschitzWith.ediam_image_le :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
      LipschitzWith K f → ∀ (s : Set α), EMetric.diam (f '' s) ≤ ↑K * EMetric.diam s :=
  by sorry

This theorem states that for any two types `α` and `β` that are pseudo emetric spaces, for any nonnegative real number `K`, and for any function `f` from `α` to `β`, if `f` is Lipschitz continuous with constant `K`, then for any set `s` of type `α`, the pseudo emetric diameter of the image of `s` under `f` is less than or equal to `K` times the pseudo emetric diameter of `s`. In other words, a Lipschitz continuous function does not expand the pseudo emetric diameter of a set by more than its Lipschitz constant.

Given pseudo metric spaces `α` and `β`, if `f` is a Lipschitz continuous function from `α` to `β` with constant `K`, then the pseudo metric diameter of `f`'s image of a set `s` in `α` is less than or equal to `K` times the pseudo metric diameter of `s`.


/-- Sum over a sigma type equals the sum of fiberwise sums. For rewriting
in the reverse direction, use `Finset.sum_sigma'` -/
theorem Finset.sum_sigma :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {σ : α → Type u_6} (s : Finset α)
      (t : (a : α) → Finset (σ a)) (f : Sigma σ → β),
      (Finset.sum (Finset.sigma s t) fun x => f x) =
        Finset.sum s fun a => Finset.sum (t a) fun s => f { fst := a, snd := s } :=
  by sorry

The theorem `Finset.sum_sigma` states that for any finset `s` of elements of type `α`, and for any function `t` producing a finset of type `σ a` for each `a` in `α`, the sum over the finset of dependent pairs (sigma type) obtained from `s` and `t` of a function `f` is equal to the sum of the fiberwise sums over `s` and `t`. This means that the total sum of `f` applied to each pair is the same whether we first sum over each fiber (`t a`) for a fixed `a` in `s`, and then sum over `s`, or if we flatten all pairs into a single finset and then sum over it.

For any finset `s` and function `t` that maps each element of `s` to a finset of type `σ a`, the sum of `f` applied to the dependent pairs of `s` and `t` is equal to the sum of fiberwise sums of `f` over `s` and `t`.


Filter.Tendsto.vsub

theorem Filter.Tendsto.vsub :
    ∀ {α : Type u_1} {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] {l : Filter α} {f g : α → P} {x y : P},
      Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (f -ᵥ g) l (nhds (x -ᵥ y)) :=
  by sorry

This theorem states that for any types `α`, `V`, and `P`, given `V` is a seminormed add commutative group, `P` is a pseudometric space, and `V` is a normed add-torsor over `P`. If `f` and `g` are functions from `α` to `P`, and `l` is a filter on `α`; if `f` tends to `x` and `g` tends to `y` (in the sense that for every neighborhood of `x` and `y`, the preimage of that neighborhood under `f` and `g` respectively is eventually in `l`), then the difference `(f -ᵥ g)` tends to `(x -ᵥ y)` (in the same sense of "tends to" as before).

Given functions `f` and `g` from type `α` to a seminormed add commutative group `V`, which is a normed add-torsor over a pseudometric space `P`, if `f` converges to `x` and `g` converges to `y` (in the sense of having preimages of every neighborhood of `x` and `y` eventually in a given filter `l`), then their difference `f -ᵥ g` converges to `x -ᵥ y`.


/-- Congruence relations equal the smallest congruence relation in which they are contained.  -/
theorem Con.conGen_of_con : ∀ {M : Type u_1} [inst : Mul M] (c : Con M), conGen ⇑c = c := by sorry

This theorem states that for a given type `M` equipped with a multiplication operation, and a given congruence relation `c` on `M`, the smallest multiplicative congruence relation that contains `c` is `c` itself. In other words, any congruence relation on `M` is equal to the smallest congruence relation in which it is contained. This is a property of the `conGen` function, which generates the smallest congruence relation containing a given binary relation.

For any type `M` with a multiplication operation and a congruence relation `c` on `M`, the relation `c` is the smallest multiplicative congruence relation containing it.


/-- A homomorphism from an additive group to an additive monoid is injective iff its
kernel is trivial, stated as an iff on the triviality of the kernel. For the implication, see
`injective_iff_map_eq_zero`. -/
theorem injective_iff_map_eq_zero' :
    ∀ {F : Type u_8} {G : Type u_9} {H : Type u_10} [inst : AddGroup G] [inst_1 : AddZeroClass H]
      [inst_2 : FunLike F G H] [inst_3 : AddMonoidHomClass F G H] (f : F),
      Function.Injective ⇑f ↔ ∀ (a : G), f a = 0 ↔ a = 0 :=
  by sorry

The theorem `injective_iff_map_eq_zero'` states that for all types `F`, `G`, and `H`, where `G` is an additive group, `H` is an additive monoid with a zero, `F` is a function from `G` to `H`, and `F` is an additive monoid homomorphism between `G` and `H`, a function `f` of type `F` is injective if and only if the result of applying `f` to any element `a` of `G` is zero if and only if `a` itself is zero. This theorem connects the concept of function injectivity with the triviality of the kernel in the context of homomorphisms from additive groups to additive monoids.

A function from an additive group to an additive monoid with a zero is injective if and only if it maps the additive identity to the zero element of the codomain.


theorem Filter.Tendsto.finset_sup'_nhds :
    ∀ {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 : ContinuousSup L] (hne : s.Nonempty),
      (∀ i ∈ s, Filter.Tendsto (f i) l (nhds (g i))) →
        Filter.Tendsto (Finset.sup' s hne f) l (nhds (Finset.sup' s hne g)) :=
  by sorry

This theorem states that in a topological space `L` which is a join-semilattice and allows for a continuous supremum operation, for any nonempty finite set `s` and any filter `l` on `α`, if for each element `i` in `s`, the function `f i` tends from filter `l` to the neighborhood of `g i`, then the supremum of the images of `s` under `f` tends from filter `l` towards the neighborhood of the supremum of the images of `s` under `g`.

In a topological space endowed with a continuous supremum operation, if for each element of a finite set and for any filter, the functions map the set to neighborhoods of their respective images under another function, then the supremum of the functions' images under the first function tends to the supremum of their images under the second function as the filter approaches its limit.


theorem isPiSystem_Ixx :
    ∀ {α : Type u_1} {ι : Sort u_2} {ι' : Sort u_3} [inst : LinearOrder α] {Ixx : α → α → Set α} {p : α → α → Prop},
      (∀ {a b : α}, Set.Nonempty (Ixx a b) → p a b) →
        (∀ {a₁ b₁ a₂ b₂ : α}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)) →
          ∀ (f : ι → α) (g : ι' → α), IsPiSystem {S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S} :=
  by sorry

The theorem `isPiSystem_Ixx` states that for any type `α` with a linear order, for any two sorts `ι` and `ι'`, for any function `Ixx` from pairs of `α` to sets of `α`, and for any property `p` on pairs of `α`, if `p` holds for any pair `(a, b)` such that the set `Ixx(a, b)` is nonempty, and if the intersection of `Ixx(a₁, b₁)` and `Ixx(a₂, b₂)` is always `Ixx(max(a₁, a₂), min(b₁, b₂))` for any `a₁, b₁, a₂, b₂` in `α`, then for any functions `f` from `ι` to `α` and `g` from `ι'` to `α`, the set of sets `S` such that there exist `i` in `ι` and `j` in `ι'` where `p(f(i), g(j))` holds and `Ixx(f(i), g(j))` equals `S` forms a π-system.

In simpler terms, this theorem states that under certain conditions, a certain set of sets, constructed using the given `Ixx` and property `p`, forms a π-system, which is a family of sets that is closed under finite intersections.

Given a type with a linear order, a function from pairs of elements to sets of elements, and a property on pairs, if the property holds for pairs with nonempty sets and intersections follow the given order, then the sets defined by the property and function form a π-system.


theorem contDiffWithinAtProp_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {n : ℕ∞}
      (x : H), ContDiffWithinAtProp I I n id Set.univ x :=
  by sorry

The theorem `contDiffWithinAtProp_id` states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space `E` over `𝕜`, topological space `H`, and a model with corners `I` of `H` with values in `E` over `𝕜`, along with an arbitrary element `n` from the set of natural numbers plus infinity (`ℕ∞`), and an element `x` from the topological space `H`, the identity function is continuously differentiable within the universal set at the point `x`. In other words, the identity function is smooth at any point in the topological space `H`.

For any nontrivially normed field `𝕜`, normed additive commutative group `E` over `𝕜`, and a topological space `H` with a model of corners `I` in the normed space `E`, the identity function is continuously differentiable at every point `x` in `H`.


Nat.Primrec'.mul

theorem Nat.Primrec'.mul : Nat.Primrec' fun v => Vector.head v * Vector.head (Vector.tail v) := by sorry

The theorem `Nat.Primrec'.mul` states that the function taking a vector `v` to the product of its first element (i.e., the head of `v`) and the first element of the rest of the vector (i.e., the head of the tail of `v`), is primitive recursive. Here, primitive recursive means that the function can be computed using a finite number of steps, each of which may be an elementary arithmetic operation or a previously computed value.

The function that maps a vector `v` to the product of its first element and the first element of its tail is a primitive recursive function.


ContinuousAt.norm

theorem ContinuousAt.norm :
    ∀ {α : Type u_3} {E : Type u_6} [inst : SeminormedAddGroup E] [inst_1 : TopologicalSpace α] {f : α → E} {a : α},
      ContinuousAt f a → ContinuousAt (fun x => ‖f x‖) a :=
  by sorry

The theorem `ContinuousAt.norm` states that for any seminormed add group `E` and any topological space `α`, if a function `f : α → E` is continuous at a point `a` in `α`, then the function that takes `x` in `α` to the norm of `f x` is also continuous at `a`. In other words, if the function values `f x` approach `f a` as `x` approaches `a`, then the norms `‖f x‖` also approach `‖f a‖` as `x` approaches `a`.

If `f : α → E` is a continuous function at `a ∈ α` in the seminormed add group `E`, then the norm function `x ↦ ||f x||` is also continuous at `a`.


theorem Infinite.of_surjective :
    ∀ {α : Sort u_4} {β : Sort u_5} [inst : Infinite β] (f : α → β), Function.Surjective f → Infinite α := by sorry

The theorem `Infinite.of_surjective` states that for any two types `α` and `β`, if `β` is infinite and there exists a function `f` from `α` to `β` that is surjective (meaning that for every element `b` in `β`, there exists an element `a` in `α` such that `f(a) = b`), then `α` is also infinite. In other words, if we can map every element of an infinite type `β` to elements of another type `α` in a way that every element of `β` is the image of at least one element of `α`, then `α` must be infinite as well.

If `β` is an infinite type and there exists a surjective function `f` from `α` to `β`, then `α` is infinite.


theorem Set.ncard_image_of_injective :
    ∀ {α : Type u_2} {β : Type u_1} {f : α → β} (s : Set α), Function.Injective f → Set.ncard (f '' s) = Set.ncard s :=
  by sorry

The theorem `Set.ncard_image_of_injective` states that for any set `s` of type `α` and any function `f` from `α` to `β` that is injective (i.e., it never maps different elements to the same element), the cardinality (number of elements) of the image of the set `s` under the function `f` is equal to the cardinality of the original set `s`. In mathematical notation, if `f: α → β` is an injective function and `s` is a set of elements of type `α`, then the size of the set `f(s)` is equal to the size of the set `s`.

The cardinality of an injectively mapped set is equal to the cardinality of the original set.


theorem Mathlib.SetTheory.Cardinal.Basic._auxLemma.26 :
    ∀ {c : Cardinal.{u}}, (Cardinal.aleph0 < Cardinal.lift.{v, u} c) = (Cardinal.aleph0 < c) := by sorry

The theorem `Mathlib.SetTheory.Cardinal.Basic._auxLemma.26` states that, for any cardinal number `c`, the statement that the cardinal number `ℵ₀` (also known as aleph null, which represents the cardinality of the set of natural numbers and is the smallest infinite cardinal) is less than the lift of `c` to a possibly larger universe is equivalent to the statement that `ℵ₀` is less than `c` in the original universe. This means that lifting a cardinal to a larger universe does not change its comparison with `ℵ₀`.

For any cardinal number `c`, the lift of `c` to a larger universe maintains the strict inequality with `ℵ₀` if and only if `c` strictly precedes `ℵ₀` in the cardinal order of the original universe.


theorem Equiv.apply_ofInjective_symm :
    ∀ {α : Sort u_1} {β : Type u_2} {f : α → β} (hf : Function.Injective f) (b : ↑(Set.range f)),
      f ((Equiv.ofInjective f hf).symm b) = ↑b :=
  by sorry

The theorem `Equiv.apply_ofInjective_symm` states that for any injective function `f` mapping from a type `α` to a type `β`, and for any element `b` in the range of `f`, the inverse of the equivalence derived from `f` (due to its injectiveness), when applied to `b`, will give back `b` when `f` is applied to it. In other words, if we consider the inverse mapping of `b` back to the domain of `f` and then reapply `f` to it, we will end up with the original `b`. It confirms the correctness of the inverse operation in the context of the constructed equivalence.

For an injective function `f` from type `α` to type `β`, and for any `b` in the range of `f`, we have `f (Equiv.symm (Equiv.mk _ _ _ b)) = b`.


theorem Mathlib.SetTheory.Cardinal.Basic._auxLemma.23 :
    ∀ {ι : Type v} {f : ι → Cardinal.{w}},
      BddAbove (Set.range f) →
        ∀ {t : Cardinal.{max u w}}, (Cardinal.lift.{u, w} (iSup f) ≤ t) = ∀ (i : ι), Cardinal.lift.{u, w} (f i) ≤ t :=
  by sorry

The theorem `Mathlib.SetTheory.Cardinal.Basic._auxLemma.23` states that for any type `ι` and a function `f` from `ι` to Cardinal numbers, if the set of all function values (i.e., the range of `f`) is bounded above, then for any Cardinal number `t`, the statement "`t` is greater than or equal to the lifted supremum of `f`" is equivalent to the statement "for all `i` in `ι`, `t` is greater than or equal to the lift of `f(i)`". Here, "lifted supremum" refers to the supremum (i.e., least upper bound) of `f`'s range, lifted from one universe to another, and "lift of `f(i)`" refers to the Cardinal number `f(i)` lifted from one universe to another.

For any type ι and function f from ι to Cardinal numbers, if the range of f is bounded above, then the lifted supremum of f is equal to the least upper bound of the lifted images of f(i) for all i in ι.


/-- If a function `f` is continuous on a convex set `D ⊆ ℝ`, and `f'` is strictly monotone on the
interior, then `f` is strictly convex on `D`.
Note that we don't require differentiability, since it is guaranteed at all but at most
one point by the strict monotonicity of `f'`.  -/
theorem StrictMonoOn.strictConvexOn_of_deriv :
    ∀ {D : Set ℝ},
      Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → StrictMonoOn (deriv f) (interior D) → StrictConvexOn ℝ D f :=
  by sorry

The theorem states that if a function `f` is continuous on a convex subset `D` of real numbers, and the derivative of `f` is strictly increasing on the interior of `D`, then `f` is strictly convex on `D`. Notably, the theorem does not require `f` to be differentiable everywhere, because the strict increase of the derivative `f'` ensures differentiability at all but at most one point.

In mathematical terms, given a function `f: ℝ → ℝ` and a convex set `D ⊆ ℝ`, if `f` is continuous on `D` and `f'`(the derivative of `f`) is strictly monotone on the interior of `D`, then `f` is strictly convex on `D`. Strict convexity here means that for any two distinct points in `D`, the function value at any point inside the line segment connecting these two points is strictly less than the weighted average of the function values at the two points.

If a continuous real-valued function on a convex set has a strictly increasing derivative on the set's interior, then the function is strictly convex on the set.


theorem Real.sqrt_eq_iff_mul_self_eq : ∀ {x y : ℝ}, 0 ≤ x → 0 ≤ y → (Real.sqrt x = y ↔ y * y = x) := by sorry

This theorem is expressing a property of the square root function for real numbers. Specifically, it states that for any non-negative real numbers `x` and `y`, the square root of `x` is equal to `y` if and only if `y` squared is equal to `x`. In mathematical terms, given $x \geq 0$ and $y \geq 0$, $\sqrt{x} = y$ if and only if $y^2 = x$.

The square root of a non-negative real number x is equal to y if and only if y^2 = x.


theorem Ideal.span_singleton_mul_span_singleton :
    ∀ {R : Type u} [inst : CommSemiring R] (r s : R), Ideal.span {r} * Ideal.span {s} = Ideal.span {r * s} := by sorry

The theorem `Ideal.span_singleton_mul_span_singleton` states that for any commutative semiring `R` and any two elements `r` and `s` from `R`, the product of the ideals generated by `r` and `s` respectively, is equal to the ideal generated by the product of `r` and `s`. In other words, if we generate an ideal from a single element `r` in the ring, and another ideal from a single element `s` in the ring, and then multiply these two ideals together, we get the same ideal as if we had multiplied `r` and `s` together first and then generated an ideal from the result. This theorem thus describes a specific property of ideal generation and multiplication in the context of commutative semirings.

In a commutative semiring, the ideal generated by the product of two elements is equal to the product of the ideals generated by each element.


theorem Cardinal.power_mul : ∀ {a b c : Cardinal.{u_1}}, a ^ (b * c) = (a ^ b) ^ c := by sorry

The theorem `Cardinal.power_mul` states that for any three cardinal numbers `a`, `b`, and `c`, the cardinal number `a` raised to the power of the product of `b` and `c` equals the cardinal number `a` raised to the power `b` and then that result raised to the power `c`. This theorem effectively establishes the law of exponentiation for cardinal numbers, namely that $(a^{b})^{c} = a^{b \times c}$.

For any cardinal numbers `a`, `b`, and `c`, `a^(bc) = a^b ^ c`.


theorem Nat.Prime.dvd_iff_eq : ∀ {p a : ℕ}, Nat.Prime p → a ≠ 1 → (a ∣ p ↔ p = a) := by sorry

The theorem `Nat.Prime.dvd_iff_eq` states that for any natural numbers `p` and `a`, where `p` is a prime number and `a` is not equal to 1, `a` is a divisor of `p` if and only if `p` equals `a`. In other words, a prime number is only divisible by itself and 1, and this theorem reinforces that by stating if a prime number is divisible by a number that's not 1, then that number must be the prime number itself.

A natural number `p` is a prime if and only if for all `a` with `a ≠ 1`, `a` does not divide `p` if and only if `p` equals `a`.


theorem ContinuousMap.coe_smul :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_3} {M : Type u_5} [inst_1 : TopologicalSpace M]
      [inst_2 : SMul R M] [inst_3 : ContinuousConstSMul R M] (c : R) (f : C(α, M)), ⇑(c • f) = c • ⇑f :=
  by sorry

This theorem states that for any topological spaces `α` and `M`, a scalar multiplication operation `SMul` on `R` and `M`, and a continuity condition `ContinuousConstSMul` for this operation, the scalar multiplication of a continuous function `f` from `α` to `M` by a scalar `c` from `R` (`c • f`) is equivalent to the scalar multiplication of the function's output by `c` (`c • ⇑f`). In other words, scalar multiplication can be pulled outside of the function application.

For any topological spaces `α`, `M`, continuous scalar multiplication operation `SMul` on `R` and `M`, and continuous function `f : α → M`, the scalar multiplication of `f` by a scalar `c` commutes with function application: `c • f = ⇑(c • SMul) ∘ f`.


/-- If a bounded group homomorphism map is constructed from a group homomorphism via the constructor
`AddMonoidHom.mkNormedAddGroupHom`, then its norm is bounded by the bound given to the constructor
if it is nonnegative.  -/
theorem NormedAddGroupHom.mkNormedAddGroupHom_norm_le :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
      (f : V₁ →+ V₂) {C : ℝ},
      0 ≤ C → ∀ (h : ∀ (x : V₁), ‖f x‖ ≤ C * ‖x‖), ‖AddMonoidHom.mkNormedAddGroupHom f C h‖ ≤ C :=
  by sorry

The theorem `NormedAddGroupHom.mkNormedAddGroupHom_norm_le` states that if a bounded group homomorphism is created from a group homomorphism using the constructor `AddMonoidHom.mkNormedAddGroupHom`, the norm of the resulting homomorphism is bounded by the nonnegative constant C, provided to the constructor, i.e., for all `x` in the domain, the norm of the image of `x` under the homomorphism is less than or equal to `C` times the norm of `x`. This condition is valid if `C` is nonnegative.

For any non-negative constant C and a group homomorphism, the norm of the resulting bounded additive homomorphism obtained using `AddMonoidHom.mkNormedAddGroupHom` constructor is less than or equal to C times the norm of the input element.


theorem Mathlib.MeasureTheory.Integral.IntervalIntegral._auxLemma.3 :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
      [inst_1 : MeasureTheory.IsLocallyFiniteMeasure μ] {c : E}, IntervalIntegrable (fun x => c) μ a b = True :=
  by sorry

This theorem states that for any type `E` that forms a normed additive commutative group, for any real numbers `a` and `b`, for any measure `μ` which is a locally finite measure, and for any constant function `c` of type `E`, the function `c` is interval integrable with respect to the measure `μ` on the unordered interval between `a` and `b`. In simpler terms, it means that a constant function is always interval integrable on any real interval under any locally finite measure.

For any normed additive commutative group type `E`, constant function `c` of type `E`, and locally finite measure `μ`, the constant function `c` is interval integrable on any unordered real interval with respect to the measure `μ`.


theorem eventually_lt_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : ClosedIciTopology α] {a b : α},
      a < b → ∀ᶠ (x : α) in nhds a, x < b :=
  by sorry

This theorem states that for any type `α` that is a topological space with a linear order, and for which the topology is generated by right-closed intervals (expressed by `ClosedIciTopology α`), given any two elements `a` and `b` of `α` such that `a < b`, then eventually (meaning in the neighborhood filter or `nhds` of `a`), all elements `x` will be less than `b`. This is essentially a property about the limit behavior of elements in a topological space with these specific properties.

In a topological space `α` with a linear order and a topology generated by right-closed intervals, if `a < b` then every neighborhood of `a` contains only elements less than `b`.


/-- The norm of the projection is smaller or equal to the norm of the original element.  -/
theorem quotient_norm_mk_le :
    ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M) (m : M),
      ‖(QuotientAddGroup.mk' S) m‖ ≤ ‖m‖ :=
  by sorry

The theorem `quotient_norm_mk_le` states that, for any semi-normed additive commutative group `M` and any additive subgroup `S` of `M`, and for any element `m` of `M`, the norm of the projection of `m` onto the quotient group `M/S` (obtained using the additive group homomorphism `QuotientAddGroup.mk'` from `M` to `M/S`) is less than or equal to the norm of `m`. This means the norm does not increase when an element is projected from the group to a quotient group.

For any semi-normed additive commutative group M, additive subgroup S, and element m in M, the norm of the projection of m to the quotient group M/S using QuotientAddGroup.mk' is less than or equal to the norm of m.


theorem ContinuousWithinAt.preimage_mem_nhdsWithin'' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {x : α}
      {y : β} {s t : Set β},
      ContinuousWithinAt f (f ⁻¹' s) x → t ∈ nhdsWithin y s → y = f x → f ⁻¹' t ∈ nhdsWithin x (f ⁻¹' s) :=
  by sorry

This theorem states that for any types `α` and `β` that have topological space structures, any function `f` from `α` to `β`, any points `x` in `α` and `y` in `β`, and any sets `s` and `t` of `β`, if `f` is continuous at `x` within the preimage of `s` under `f`, and if `t` is in the neighborhood within `s` of `y`, and if `y` is the image of `x` under `f`, then the preimage of `t` under `f` is in the neighborhood within the preimage of `s` under `f` of `x`. In simpler terms, if a function is continuous at a point and a certain set is nearby, then the preimage of that set is also nearby.

If a continuous function maps a point to a neighboring image point in a topological space, then the preimage of a neighborhood of that image point is a neighborhood of the original point.


theorem Set.Icc_union_Icc_eq_Icc :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, a ≤ b → b ≤ c → Set.Icc a b ∪ Set.Icc b c = Set.Icc a c := by
  sorry

This theorem states that for any type `α` that has a linear order and any three elements `a`, `b`, and `c` of this type such that `a` is less than or equal to `b` and `b` is less than or equal to `c`, the union of the interval from `a` to `b` and the interval from `b` to `c` is equal to the interval from `a` to `c`. In mathematical terms, given $a \leq b \leq c$, we have $[a,b] \cup [b,c] = [a,c]$ where $[a,b]$ and $[b,c]$ denote the closed intervals from `a` to `b` and from `b` to `c`, respectively.

For any type `α` with a linear order, if `a ≤ b ≤ c` then `[a, b] ∪ [b, c] = [a, c]`, where `[a, b]` and `[b, c]` denote the closed intervals from `a` to `b` and from `b` to `c`, respectively.


theorem Commute.sub_left :
    ∀ {R : Type x} [inst : NonUnitalNonAssocRing R] {a b c : R}, Commute a c → Commute b c → Commute (a - b) c := by
  sorry

The theorem `Commute.sub_left` states that for any type `R` that forms a non-unital, non-associative ring, and for any three elements `a`, `b`, and `c` of this type, if `a` commutes with `c` and `b` commutes with `c`, then the difference of `a` and `b` also commutes with `c`. Here, two elements are said to commute if their multiplication is commutative, that is, `a * c = c * a` and `b * c = c * b` implies `(a - b) * c = c * (a - b)`.

If `R` is a non-unital, non-associative ring and `a`, `b`, and `c` are elements of `R` such that `a` commutes with `c` and `b` commutes with `c`, then `(a - b)` commutes with `c`, i.e., `c * (a - b) = (a - b) * c`.


Relation.TransGen.head

theorem Relation.TransGen.head :
    ∀ {α : Type u_1} {r : α → α → Prop} {a b c : α}, r a b → Relation.TransGen r b c → Relation.TransGen r a c := by
  sorry

This theorem, "Relation.TransGen.head", states that for any set `α`, any binary relation `r` on `α`, and any three elements `a`, `b`, and `c` from `α`, if `r` holds between `a` and `b` and there exists a transitive closure of `r` between `b` and `c`, then there also exists a transitive closure of `r` between `a` and `c`. In other words, this theorem entails that if `a` is related to `b`, and `b` is in some way related to `c` through a chain of relations, then `a` is also related to `c` through a similar chain of relations.

If `r` is a transitive relation on set `α`, and `a` is related to `b` by `r`, and there exists a chain of `r`-related elements from `b` to `c`, then `a` is related to `c` by `r`.


theorem Int.add_sub_assoc : ∀ (a b c : ℤ), a + b - c = a + (b - c) := by sorry

This theorem, `Int.add_sub_assoc`, states that for all integers `a`, `b`, and `c`, the operation of adding `b` to `a` and then subtracting `c` is equivalent to adding `b - c` directly to `a`. In mathematical notation, this is expressed as `a + b - c = a + (b - c)`. In other words, it says that addition and subtraction of integers are associative operations.

The theorem `Int.add_sub_assoc` asserts that for all integers `a`, `b`, and `c`, `a + (b - c)` is equal to `a + b - c`.


theorem Mathlib.Data.Real.Irrational._auxLemma.22 : ∀ {x : ℝ}, Irrational x⁻¹ = Irrational x := by sorry

The theorem `Mathlib.Data.Real.Irrational._auxLemma.22` states that for all real numbers `x`, `x` is irrational if and only if its reciprocal `1/x` is irrational. In other words, a real number and its reciprocal share the same irrationality status. If a real number is irrational, so is its reciprocal and vice versa.

For all real numbers x, x is irrational if and only if 1/x is irrational.


CategoryTheory.Under.w

theorem CategoryTheory.Under.w :
    ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {A B : CategoryTheory.Under X} (f : A ⟶ B),
      CategoryTheory.CategoryStruct.comp A.hom f.right = B.hom :=
  by sorry

This theorem is in the context of category theory and it states that for any category `T` with an object `X`, and any two objects `A` and `B` in the under category of `X` (meaning that the objects are arrows with domain `X`), any morphism `f` from `A` to `B` satisfies the property that the composition of `A.hom` and `f.right` is equal to `B.hom`. In other words, if we have a morphism from `A` to `B` in this under category, then the composition of the homomorphism of `A` and the right component of `f` will give us the homomorphism of `B`. This expresses a condition of commutativity in the under category.

For any category T with an object X and morphisms f from A to B in the under category of X, the composition of A.hom and f.right equals B.hom.


theorem ContinuousAt.comp_lowerSemicontinuousWithinAt :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {s : Set α} {γ : Type u_3} [inst_1 : LinearOrder γ]
      [inst_2 : TopologicalSpace γ] [inst_3 : OrderTopology γ] {δ : Type u_4} [inst_4 : LinearOrder δ]
      [inst_5 : TopologicalSpace δ] [inst_6 : OrderTopology δ] {g : γ → δ} {f : α → γ},
      ContinuousAt g (f x) → LowerSemicontinuousWithinAt f s x → Monotone g → LowerSemicontinuousWithinAt (g ∘ f) s x :=
  by sorry

The theorem `ContinuousAt.comp_lowerSemicontinuousWithinAt` states that, given a set `s` of elements of some type `α` in a topological space, a point `x` in `α`, and functions `f : α → γ` and `g : γ → δ`, where `γ` and `δ` are both linear orders equipped with a topological structure and an order topology. If `g` is continuous at the point `f(x)`, `f` is lower semicontinuous at the point `x` within the set `s`, and `g` is monotone, then the composition of `g` and `f` (i.e., `g ∘ f`), is also lower semicontinuous at the point `x` within the set `s`.

In simple terms, the continuity of a function `g` at `f(x)`, the lower semicontinuity of another function `f` at `x` within a set `s`, and the monotonicity of `g`, together preserve the property of lower semicontinuity for the composition of `g` and `f` at `x` within `s`.

If a function `f : α → γ` is lower semicontinuous at a point `x ∈ α` in a set `s ⊆ α`, `g : γ → δ` is continuous at `f(x)` and monotone, then their composition `g ∘ f` is lower semicontinuous at `x` within `s`.


theorem spectrum.norm_le_norm_of_mem :
    ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
      [inst_3 : CompleteSpace A] [inst_4 : NormOneClass A] {a : A} {k : 𝕜}, k ∈ spectrum 𝕜 a → ‖k‖ ≤ ‖a‖ :=
  by sorry

This theorem states that for any type 𝕜 which is a NormedField, and any type A which is a NormedRing and a NormedAlgebra over 𝕜, if the space A is complete and has a norm-one class, then for any element 'a' of type A and any element 'k' of type 𝕜, if 'k' belongs to the spectrum of 'a', the norm of 'k' is less than or equal to the norm of 'a'. In mathematical symbols, this can be written as: if $k \in spectrum(a)$, then $\|k\| \leq \|a\|$.

For any NormedField 𝕜, NormedRing and NormedAlgebra A over 𝕜 with a complete, norm-one class, the spectrum of any element 'a' in A contains only norms less than or equal to the norm of 'a'.


theorem Array.foldr_eq_foldr_data :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β → β) (init : β) (arr : Array α),
      Array.foldr f init arr (Array.size arr) = List.foldr f init arr.data :=
  by sorry

This theorem, `Array.foldr_eq_foldr_data`, states that for any types `α` and `β`, and for any function `f` from `α` to `β`, the "right-fold" function applied to an array `arr` using `f` and an initial value `init` produces the same result as applying the right-fold function to the data list of the array. In other words, the operation of right-folding over an array is equivalent to right-folding over its underlying list. The right-fold operation is defined as reducing the array or list from right to left, feeding each item and the cumulative result so far into the function `f`.

For any type `α`, type `β`, and function `f` from `α` to `β`, the right-fold application to an array `arr` using `f` and an initial value `init` equals the right-fold application to the data list of `arr` using `f`. In other words, `Array.foldr arr init f = List.foldr (List.fromArray arr) init f`.


theorem ENNReal.ofReal_pos : ∀ {p : ℝ}, 0 < ENNReal.ofReal p ↔ 0 < p := by sorry

The theorem `ENNReal.ofReal_pos` states that for any real number `p`, the statement that the extended nonnegative real representation of `p` (which maps `p` to itself if it's nonnegative, and to `0` otherwise) is greater than `0` is equivalent to the statement that `p` is greater than `0`. In other words, a real number `p` is positive if and only if its extended nonnegative real representation is also positive.

The theorem `ENNReal.ofReal_pos` asserts that for every real number `p`, `ENNReal p > 0` if and only if `p > 0`.


theorem LieSubmodule.lcs_succ :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
      [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (k : ℕ) (N : LieSubmodule R L M),
      LieSubmodule.lcs (k + 1) N = ⁅⊤, LieSubmodule.lcs k N⁆ :=
  by sorry

This theorem states that for any commutative ring `R`, Lie ring `L`, additive commutative group `M`, module `R M`, and Lie ring module `L M` along with a natural number `k` and a Lie submodule `N`, the Lie central series at (k + 1) for the Lie submodule N, denoted `LieSubmodule.lcs (k + 1) N`, is equivalent to the Lie bracket of the full module with the Lie central series at k for the Lie submodule N, denoted `⁅⊤, LieSubmodule.lcs k N⁆`. In other words, it tells us how to compute the next term in the Lie central series for a given Lie submodule.

For any commutative ring `R`, Lie ring `L`, additive commutative group `M`, module `RM`, Lie ring module `LM`, natural number `k`, and Lie submodule `N`, we have `LieSubmodule.lcs (k + 1) N = {x ∈ LM ∣ [x, LieSubmodule.lcs k N] ∈ LieSubmodule.lcs k N}`.


theorem Polynomial.zero_le_degree_iff :
    ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, 0 ≤ Polynomial.degree p ↔ p ≠ 0 := by sorry

This theorem states that for any given type `R` with a semiring structure and any polynomial `p` of type `R`, the degree of the polynomial `p` is greater than or equal to zero if and only if the polynomial `p` is not equal to zero. In other words, a polynomial has a non-negative degree if it is non-zero; conversely, if a polynomial has a non-negative degree, it must be non-zero.

A polynomial over a semiring is non-zero if and only if it has non-negative degree.


theorem Int.toNat_eq_max : ∀ (a : ℤ), ↑(Int.toNat a) = max a 0 := by sorry

This theorem states that for any integer 'a', the natural number obtained by converting 'a' using the 'Int.toNat' function is equal to the larger value between 'a' and '0'. In other words, for any integer, the natural number version of it is its maximum with zero. If 'a' is a positive integer or zero, the 'Int.toNat' function will give 'a' itself. But if 'a' is negative, the 'Int.toNat' function will give '0', which is the maximum of 'a' and '0'.

For any integer 'a', the natural number obtained by converting 'a' using the 'Int.toNat' function is the maximum of 'a' and '0'.


theorem Nat.le_floor :
    ∀ {α : Type u_2} [inst : LinearOrderedSemiring α] [inst_1 : FloorSemiring α] {a : α} {n : ℕ}, ↑n ≤ a → n ≤ ⌊a⌋₊ :=
  by sorry

This theorem, `Nat.le_floor`, states that for any type `α` which is a linear ordered semiring and also a floor semiring, and any elements `a` of type `α` and `n` of type natural numbers (`ℕ`), if `n` is less than or equal to `a` (when `n` is coerced to type `α`), then `n` is less than or equal to the nonnegative floor of `a`. In simpler terms, if a natural number `n` is not greater than a real number `a`, then `n` is not greater than the greatest whole number less than or equal to `a`.

For any linear ordered semiring and floor semiring type `α`, and any `a` of type `α` and natural number `n`, if `n ≤ a` then `n ≤ floor a`, where `floor` is the nonnegative floor function.


theorem TopologicalSpace.nhds_mkOfNhds_of_hasBasis :
    ∀ {α : Type u} {n : α → Filter α} {ι : α → Sort u_1} {p : (a : α) → ι a → Prop} {s : (a : α) → ι a → Set α},
      (∀ (a : α), Filter.HasBasis (n a) (p a) (s a)) →
        (∀ (a : α) (i : ι a), p a i → a ∈ s a i) →
          (∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x) → ∀ (a : α), nhds a = n a :=
  by sorry

The theorem `TopologicalSpace.nhds_mkOfNhds_of_hasBasis` states that for any type `α`, a mapping `n` from `α` to a filter on `α`, a dependent type `ι` indexed by `α`, a predicate `p` and a mapping `s` from `α` and `ι a` to a set of `α`, given that:

1. For every `a` in `α`, `n a` has a basis given by the predicate `p a` and the set function `s a`.

2. For every `a` in `α` and `i` in `ι a`, if the predicate `p a i` is true, then `a` belongs to the set `s a i`.

3. For every `a` in `α` and `i` in `ι a`, if the predicate `p a i` is true, then for every element `x` in `α` that eventually belongs to `n a`, `s a i` belongs to `n x`.

Then the neighborhood filter at `a`, denoted `nhds a`, is equal to `n a`. This theorem characterizes the neighborhood filter in terms of a filter and its basis, and provides conditions under which they are equal.

Given a filter `n` on a type `α`, a basis for `n` at each point `α` given by a predicate `p` and a set function `s`, if for all `a` in `α` and `i` in `ι a` such that `p a i` holds, `a` is in `s a i` and `s a i` is a neighborhood of `x` in `n x`, then `nhds a = n a`.


theorem MeasureTheory.VectorMeasure.neg_le_neg :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : OrderedAddCommGroup M]
      [inst_2 : TopologicalAddGroup M] (v w : MeasureTheory.VectorMeasure α M) {i : Set α},
      MeasurableSet i →
        MeasureTheory.VectorMeasure.restrict v i ≤ MeasureTheory.VectorMeasure.restrict w i →
          MeasureTheory.VectorMeasure.restrict (-w) i ≤ MeasureTheory.VectorMeasure.restrict (-v) i :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.neg_le_neg` states that for any measurable space `α`, topological space `M` that is also an ordered additive commutative group and topological additive group, if we have two vector measures `v` and `w`, and a measurable set `i`, then if the restriction of `v` to `i` is less than or equal to the restriction of `w` to `i`, then the restriction of the negation of `w` to `i` is less than or equal to the restriction of the negation of `v` to `i`. In mathematical terms, if $v|_i \leq w|_i$, then $-w|_i \leq -v|_i$.

For measurable sets i in a measurable space α, if vector measure v restriced to i is less than or equal to w's restriction, then the negation of w's restriction is less than or equal to the negation of v's restriction. In symbols: $-w|\_i \leq -v|\_i$ given $v|\_i \leq w|\_i$.


theorem Set.piecewise_eqOn :
    ∀ {α : Type u_1} {β : Type u_2} (s : Set α) [inst : (j : α) → Decidable (j ∈ s)] (f g : α → β),
      Set.EqOn (Set.piecewise s f g) f s :=
  by sorry

The theorem `Set.piecewise_eqOn` states that for any set `s` of elements of type `α` and any two functions `f` and `g` from `α` to `β`, the function that is defined by `Set.piecewise` to be `f` on the set `s` and `g` outside of `s`, is equal to the function `f` on the set `s`. In other words, if `x` is an element of `s`, then the value of the piecewise function at `x` is the same as the value of `f` at `x`.

For any set `s` and functions `f` and `g` from a type `α` to a type `β`, the function `Set.piecewise f g` equals `f` on the set `s`.


theorem MeasureTheory.integral_add_compl :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace ℝ E] {f : X → E} {s : Set X} {μ : MeasureTheory.Measure X},
      MeasurableSet s →
        MeasureTheory.Integrable f μ → ∫ (x : X) in s, f x ∂μ + ∫ (x : X) in sᶜ, f x ∂μ = ∫ (x : X), f x ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_add_compl` states that for any measurable space `X`, any normed additive commutative group `E`, any function `f` from `X` to `E`, any set `s` in `X`, and any measure `μ` on `X`: if `s` is a measurable set and `f` is integrable with respect to `μ`, then the integral of `f` over `s` with respect to `μ` plus the integral of `f` over the complement of `s` with respect to `μ` equals the integral of `f` over `X` with respect to `μ`. In mathematical notation, this can be written as:
\[\int_{s} f \, d\mu + \int_{s^c} f \, d\mu = \int_{X} f \, d\mu \]
This theorem emphasizes the idea that the integral over the whole space can be decomposed into the integral over a subset and its complement.

For any measurable space X, normed additive commutative group E, measurable set s, integrable function f from X to E, and measure μ on X, we have ∫s f dμ + ∫s^c f dμ = ∫X f dμ.


theorem IsCompl.le_sup_right_iff_inf_left_le :
    ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] {x y a b : α},
      IsCompl x y → (a ≤ b ⊔ y ↔ a ⊓ x ≤ b) :=
  by sorry

This theorem states that in the context of a bounded distributive lattice, for any elements `x`, `y`, `a`, `b` of this lattice, if `x` and `y` are complementary, then the inequality `a` is less than or equal to the join of `b` and `y` holds if and only if the inequality `a` meet `x` is less than or equal to `b` holds. In mathematical notation, if `x` and `y` are complementary (i.e., `x ⊔ y = 1` and `x ⊓ y = 0`), then `a ≤ b ⊔ y` is equivalent to `a ⊓ x ≤ b`.

In a bounded distributive lattice, for complementary elements x and y, the inequality a ≤ b holds if and only if a ∧ x ≤ b.


theorem GaloisConnection.l_comm_of_u_comm :
    ∀ {X : Type u_2} [inst : Preorder X] {Y : Type u_3} [inst_1 : Preorder Y] {Z : Type u_4} [inst_2 : Preorder Z]
      {W : Type u_5} [inst_3 : PartialOrder W] {lYX : X → Y} {uXY : Y → X},
      GaloisConnection lYX uXY →
        ∀ {lWZ : Z → W} {uZW : W → Z},
          GaloisConnection lWZ uZW →
            ∀ {lWY : Y → W} {uYW : W → Y},
              GaloisConnection lWY uYW →
                ∀ {lZX : X → Z} {uXZ : Z → X},
                  GaloisConnection lZX uXZ →
                    (∀ (w : W), uXZ (uZW w) = uXY (uYW w)) → ∀ {x : X}, lWZ (lZX x) = lWY (lYX x) :=
  by sorry

The theorem `GaloisConnection.l_comm_of_u_comm` states that for any four types `X`, `Y`, `Z`, and `W`, with `X`, `Y`, and `Z` being preordered and `W` being partially ordered, and four Galois connections given by functions `(lYX, uXY)`, `(lWZ, uZW)`, `(lWY, uYW)`, and `(lZX, uXZ)`, if for every element `w` in `W`, the composition of `uXZ` and `uZW` applied to `w` is equal to the composition of `uXY` and `uYW` applied to `w`, then for every element `x` in `X`, the composition of `lWZ` and `lZX` applied to `x` is equal to the composition of `lWY` and `lYX` applied to `x`. This theorem shows the interplay between multiple Galois connections under certain conditions.

If `uXZ ∘ uZW = uXY ∘ uYW` for all `w` in `W`, then `lWZ ∘ lZX = lWY ∘ lYX` for all `x` in `X`.


Set.Finite.isClosed

theorem Set.Finite.isClosed :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T1Space X] {s : Set X}, Set.Finite s → IsClosed s := by sorry

This theorem states that for any given type `X` that is a topological space and satisfies the T1 separation axiom, any finite set `s` of elements of type `X` is a closed set. In other words, in a T1 topological space, finite sets are always closed. In this context, being "closed" is a property of sets that relates to the concept of limit points in topology. Specifically, a set is closed if it contains all of its limit points.

In a T1 topological space, every finite subset is a closed set.


theorem Nat.add_le_of_le_sub : ∀ {a b c : ℕ}, b ≤ c → a ≤ c - b → a + b ≤ c := by sorry

This theorem, `Nat.add_le_of_le_sub`, states that for any natural numbers `a`, `b`, and `c`, if `b` is less than or equal to `c` (`b ≤ c`) and `a` is less than or equal to the difference of `c` and `b` (`a ≤ c - b`), then the sum of `a` and `b` is less than or equal to `c` (`a + b ≤ c`). In other words, if a natural number is at most the difference of two others, then its sum with one of those numbers is at most the larger number.

If `a` is a natural number and `b` and `c` are natural numbers with `b <= c` and `a <= c - b`, then `a + b <= c`.


theorem addRothNumber_spec :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] (s : Finset α),
      ∃ t, ∃ (_ : t ⊆ s), t.card = addRothNumber s ∧ AddSalemSpencer ↑t :=
  by sorry

The theorem `addRothNumber_spec` states that for any type `α` that has decidable equality and an addition operation, and for any finite set `s` of elements of the type `α`, there exists a subset `t` of `s` such that the cardinality of `t` is equal to the additive Roth number of `s` and `t` is a Salem-Spencer set. A Salem-Spencer set, in the context of an additive monoid, is a set in which the average of any two distinct elements is never in the set. The additive Roth number of a finite set is defined as the size of its largest Salem-Spencer subset.

For any finite additive monoid (α, +) with decidable equality, there exists a Salem-Spencer subset of cardinality equal to the size of its largest Salem-Spencer subset.


theorem Nat.le_of_pred_lt : ∀ {n : ℕ} {m : ℕ}, Nat.pred m < n → m ≤ n := by sorry

This theorem, `Nat.le_of_pred_lt`, states that for any two natural numbers `n` and `m`, if the predecessor of `m` (which is `m - 1` for non-zero `m` and `0` for `m = 0`) is less than `n`, then `m` is less than or equal to `n`. In other words, if `m - 1` is less than `n`, then it guarantees that `m` itself will not exceed `n`, which is a basic property of natural number ordering.

If `m - 1` is less than `n`, then `m` is less than or equal to `n` for all natural numbers `m` and `n`.


IsExtrOn.elim

theorem IsExtrOn.elim :
    ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α} {p : Prop},
      IsExtrOn f s a → (IsMinOn f s a → p) → (IsMaxOn f s a → p) → p :=
  by sorry

This theorem, `IsExtrOn.elim`, states that for any types `α` and `β` with a preorder on `β`, any function `f` from `α` to `β`, any set `s` of `α`, any element `a` of `α`, and any proposition `p`, if `f` has an extreme value at `a` on the set `s` (denoted by `IsExtrOn f s a`), then if `p` follows from `f` having a minimum at `a` on `s` (denoted by `IsMinOn f s a`) and `p` also follows from `f` having a maximum at `a` on `s` (denoted by `IsMaxOn f s a`), then `p` must hold. This theorem essentially allows us to draw conclusions from the fact that a function has an extreme value (either a maximum or minimum) at a certain point over a set.

If a function has an extreme value (minimum or maximum) at a point in a set, and this extreme value property implies a given proposition, then the proposition holds.


theorem ZNum.le_to_int : ∀ {m n : ZNum}, ↑m ≤ ↑n ↔ m ≤ n := by sorry

This theorem states that for any two arbitrary `ZNum` values `m` and `n`, the integer representation of `m` is less than or equal to the integer representation of `n` if and only if `m` is less than or equal to `n`. In other words, the relationship of less than or equal to between `m` and `n` is preserved when they are converted to integers.

For any `ZNum` values `m` and `n`, `int.to_nat m <= int.to_nat n` if and only if `m <= n`.


theorem Matrix.zpow_neg_coe_nat :
    ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
      (A : Matrix n' n' R) (n : ℕ), A ^ (-↑n) = (A ^ n)⁻¹ :=
  by sorry

This theorem states that for any type `n'` with decidable equality and finite number of elements, and any commutative ring `R`, if `A` is a matrix with entries in `R` and indices in `n'`, and `n` is a natural number, then the negative `n`-th power of `A`, which is `A` raised to the power of `-n`, is equal to the inverse of `A` raised to the power of `n`. In mathematical terms, this can be written as: \(A^{-n} = (A^n)^{-1}\).

For any commutative ring R, finite type n' with decidable equality, and matrix A with entries in R and indices in n', the negative n-th power of A equals the inverse of A raised to the power of n: i.e., A^(-n) = (A^n)^(-1).


theorem Function.Periodic.add_antiperiod_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c₁ c₂ : α} [inst : AddGroup α] [inst_1 : Neg β],
      Function.Periodic f c₁ → Function.Antiperiodic f c₂ → f (c₁ + c₂) = -f 0 :=
  by sorry

The theorem `Function.Periodic.add_antiperiod_eq` states that for any function `f` mapping from a type `α` to a type `β`, given two elements `c₁` and `c₂` of type `α` and assuming that the type `α` has a group structure under addition and the type `β` has a negation operation, if the function `f` is periodic with period `c₁` and antiperiodic with period `c₂`, then the value of the function at the point `c₁ + c₂` is equal to the negation of the value of the function at the origin (i.e., `f (c₁ + c₂) = -f 0`). In mathematical terms, this could be read as "For a function $f: \alpha \rightarrow \beta$, if $f$ is $c_1$-periodic and $c_2$-antiperiodic, then $f(c_1 + c_2) = -f(0)$".

If a function $f:\alpha \rightarrow \beta$ is $\alpha$-periodic with period $c\_1$ and $\alpha$-antiperiodic with period $c\_2$, then $f(c\_1 + c\_2) = -f(0)$.


theorem Complex.real_smul : ∀ {x : ℝ} {z : ℂ}, x • z = ↑x * z := by sorry

This theorem states that for every real number `x` and every complex number `z`, the action of scaling `z` by `x` (denoted `x • z`) is equal to the product of `x` and `z` (denoted `↑x * z`). Here, `↑x` represents the embedding of the real number `x` in the complex numbers. Therefore, this theorem links scalar multiplication in the field of complex numbers with multiplication by a real number.

For every real number x and complex number z, x • z = ↑x * z. (Scalar multiplication in the complex numbers equals multiplication by a real number.)


theorem Filter.eventually_and :
    ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
      (∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x :=
  by sorry

This theorem states that, for any type `α`, predicates `p` and `q`, and filter `f` on `α`, the property of `p` and `q` holding "eventually" (that is, at all points in the filter beyond a certain point) is equivalent to `p` holding eventually and `q` holding eventually individually. In other words, both `p` and `q` will be true for all elements in the filter `f` beyond a certain point if and only if each of `p` and `q` individually is true for all elements in the filter beyond a certain point.

For any type `α`, predicates `p` and `q`, and filter `f` on `α`, the properties of `p` and `q` holding eventually in `f` are equivalent.


theorem Set.iInter_comm :
    ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} (s : ι → ι' → Set α), ⋂ i, ⋂ i', s i i' = ⋂ i', ⋂ i, s i i' := by
  sorry

The theorem `Set.iInter_comm` states that for any type `α`, and any two sorts `ι` and `ι'`, the order of two nested intersection operations over sets `s` indexed by `ι` and `ι'`, does not change the resulting set. More concretely, for any function `s` that takes in two indices `i` from `ι` and `i'` from `ι'` and returns a set of type `α`, the intersection over all `i` of the intersections over all `i'` of `s i i'` is equal to the intersection over all `i'` of the intersections over all `i` of `s i i'`. This theorem essentially states the commutativity of multiple intersections over sets.

For any function giving sets indexed by types `ι` and `ι'`, the order of intersecting over `ι'` then `ι` is equal to intersecting over `ι` then `ι'`.


theorem isIrreducible_singleton : ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, IsIrreducible {x} := by sorry

The theorem `isIrreducible_singleton` states that for any type `X` equipped with a topological space structure and any element `x` of `X`, the singleton set containing just `x` is an irreducible set. In other words, this singleton set is non-empty and there is no pair of disjoint open sets within it, which are both non-empty when intersected with the singleton set.

For any topological space `(X,τ)` and element `x ∈ X`, the singleton set `{x} ⊆ X` is an irreducible set, i.e., there do not exist disjoint non-empty open sets `U,V ∈ τ` such that `x ∈ U ∩ V`.


theorem TopCat.Presheaf.germ.proof_2 : ∀ {X : TopCat} {U : TopologicalSpace.Opens ↑X} (x : ↥U), ↑x ∈ U := by sorry

This theorem states that for any topological space `X` and any open subset `U` of `X`, any point `x` in `U` (considered as a type of elements of `U`) is indeed an element of `U`. In mathematical terms, if `X` is a topological space and `U` is an open subset of `X`, then every point in `U` actually belongs to `U`. This might seem tautological, but it's an important base case in certain types of reasoning about topological spaces and presheaves.

For any topological space X and open subset U, every element of U is an element of U.


theorem addOrderOf_dvd_card :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Fintype G] {x : G}, addOrderOf x ∣ Fintype.card G := by sorry

This theorem states that for any finite additive group `G` and any element `x` in `G`, the order of the element `x` (denoted by `addOrderOf x`) divides the cardinality of the group `G` (denoted by `Fintype.card G`). In the context of group theory, the order of an element is the smallest positive integer such that the element, when added to itself that many times, results in the additive identity (usually zero). The cardinality of a group is just the number of elements in the group. Therefore, this theorem is a statement about the relationship between the order of an element and the size of the group it belongs to.

For any finite additive group `G` and its element `x`, the order of `x` divides the cardinality of `G`.


theorem Submodule.span_singleton_eq_span_singleton :
    ∀ {R : Type u_9} {M : Type u_10} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : NoZeroSMulDivisors R M] {x y : M}, Submodule.span R {x} = Submodule.span R {y} ↔ ∃ z, z • x = y :=
  by sorry

The theorem `Submodule.span_singleton_eq_span_singleton` states that for any ring `R`, additive commutative group `M`, and a module `M` over `R`, with no zero scalar multiplication divisors in `R` and `M`, and given any two elements `x` and `y` of `M`, the span of the singleton set `{x}` being equal to the span of the singleton set `{y}` in `R` is equivalent to the existence of an element `z` in `R` such that `z` multiplied by `x` equals `y`. In other words, the spans of `x` and `y` are the same if and only if `y` is a scalar multiple of `x`.

For any ring R, additive commutative group M, and element x, y in the module M with no zero scalar multiplication divisors, the spans of {x} and {y} in R are equal if and only if y is a scalar multiple of x.


theorem MeasureTheory.Measure.comap_apply₀ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace β] {s : Set α} [inst_1 : MeasurableSpace α] (f : α → β)
      (μ : MeasureTheory.Measure β),
      Function.Injective f →
        (∀ (s : Set α), MeasurableSet s → MeasureTheory.NullMeasurableSet (f '' s) μ) →
          MeasureTheory.NullMeasurableSet s (MeasureTheory.Measure.comap f μ) →
            ↑↑(MeasureTheory.Measure.comap f μ) s = ↑↑μ (f '' s) :=
  by sorry

This theorem states that for any types `α` and `β` equipped with measurable spaces, a set `s` of type `α`, a function `f` from `α` to `β`, and a measure `μ` on `β`, if the function `f` is injective, and every measurable set in `α` is also null measurable when its image under `f` is considered in `β` with respect to measure `μ`, then if the set `s` is null measurable in the measure space obtained by pulling back `μ` along `f`, the measure of `s` in the pulled back measure equals the measure of the image of `s` under `f` in `β` with respect to `μ`. In other words, pullback preserves the measure of null measurable sets under certain conditions.

If `f: α → β` is an injective function between measurable spaces `(α, Σα, μα)` and `(β, Σβ, μβ)`, and every null measurable set in `α` maps to a null measurable set in `β`, then the measure of a null measurable set `s` in `α` with respect to the pulled back measure equals the measure of `f(s)` in `β`.


theorem AddSubgroup.map_equiv_eq_comap_symm' :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G ≃+ N) (K : AddSubgroup G),
      AddSubgroup.map (AddEquiv.toAddMonoidHom f) K = AddSubgroup.comap (AddEquiv.toAddMonoidHom (AddEquiv.symm f)) K :=
  by sorry

The theorem `AddSubgroup.map_equiv_eq_comap_symm'` asserts that for every additive group isomorphism `f` from an additive group `G` to another additive group `N`, and for any additive subgroup `K` of `G`, the image of `K` under `f` is the same as the preimage of `K` under the inverse of `f`. In other words, applying `f` to `K` yields the same result as applying the inverse of `f` to `K` in the opposite group direction.

For every additive group isomorphism $f$ from an additive group $G$ to an additive group $N$, and for any additive subgroup $K$ of $G$, $f(K) = N[f^{-1}(K)]$.


theorem NormedAddGroupHom.comp_apply :
    ∀ {V₁ : Type u_2} {V₂ : Type u_3} {V₃ : Type u_4} [inst : SeminormedAddCommGroup V₁]
      [inst_1 : SeminormedAddCommGroup V₂] [inst_2 : SeminormedAddCommGroup V₃] (g : NormedAddGroupHom V₂ V₃)
      (f : NormedAddGroupHom V₁ V₂) (a : V₁), (NormedAddGroupHom.comp g f) a = g (f a) :=
  by sorry

This theorem states that for any three types `V₁`, `V₂`, and `V₃` which have a structure of seminormed additive commutative groups, if `g` is a normed additive group homomorphism from `V₂` to `V₃` and `f` is a normed additive group homomorphism from `V₁` to `V₂`, then for any element `a` of `V₁`, the result of applying the composition of `g` and `f` to `a` is the same as the result of applying `g` to the result of applying `f` to `a`. In other words, the theorem asserts the associativity of the application of composed normed additive group homomorphisms in the context of seminormed additive commutative groups.

Given three seminormed additive commutative groups `V₁`, `V₂`, and `V₃`, and normed additive group homomorphisms `f : V₁ → V₂` and `g : V₂ → V₃`, the composition `g ∘ f : V₁ → V₃` is a normed additive group homomorphism, and for all `a ∈ V₁`, `g(f(a)) = (g ∘ f)(a)`.


theorem MeasurableEquiv.measurable_comp_iff :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      [inst_2 : MeasurableSpace γ] {f : β → γ} (e : α ≃ᵐ β), Measurable (f ∘ ⇑e) ↔ Measurable f :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ`, each with an associated measurable space, a function `f` that maps `β` to `γ`, and an equivalence `e` between `α` and `β` (denoted `α ≃ᵐ β`), the function `f` composed with the inverse of `e` is measurable if and only if `f` itself is measurable. In other words, the measurability of the composed function `f ∘ ⇑e` is equivalent to the measurability of the function `f`. Measurability here means that the preimage of every measurable set under the function is also a measurable set.

For any measurable functions `f: β → γ` and `e: α ≃ᵐ β` with `α, β, γ` being measurable spaces, the composed function `f ∘ e⁻¹` is measurable if and only if `f` is measurable.


IsSelfAdjoint.all

/-- All elements are self-adjoint when `star` is trivial.  -/
theorem IsSelfAdjoint.all : ∀ {R : Type u_1} [inst : Star R] [inst_1 : TrivialStar R] (r : R), IsSelfAdjoint r := by
  sorry

The theorem `IsSelfAdjoint.all` states that for any type `R` equipped with a `Star` operation and a trivial `Star` operation (where the `Star` of any element is the element itself), any element `r` of `R` is self-adjoint. Being self-adjoint is defined as an element being equal to its star, i.e., the star of the element is the element itself. This makes sense in this case, as the `Star` operation is assumed to be trivial, and therefore always returns the original element.

For any type `R` with a trivial `Star` operation, every element `r` in `R` is self-adjoint.


theorem Mathlib.LinearAlgebra.Span._auxLemma.11 :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y : M},
      (x ∈ Submodule.span R {y}) = ∃ a, a • y = x :=
  by sorry

This theorem states that for all types `R` and `M`, where `R` is a semiring, `M` is an additive commutative monoid, and `M` is a module over `R`, and for all elements `x` and `y` of `M`, `x` is in the submodule spanned by the singleton set `{y}` if and only if there exists a scalar `a` from `R` such that `x` is equal to the scalar multiplication `a • y`.

For any semiring R, additive commutative monoid M (an R-module), and elements x, y in M, x lies in the submodule generated by {y} if and only if there exists an scalar a in R such that x = a • y.


theorem Mathlib.LinearAlgebra.Span._auxLemma.18 :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
      (p : Submodule R M), (Submodule.span R {m} ≤ p) = (m ∈ p) :=
  by sorry

This theorem, named `Mathlib.LinearAlgebra.Span._auxLemma.18`, states that for any semiring `R`, any additive commutative monoid `M`, any `R`-module structure on `M`, any element `m` of `M`, and any submodule `p` of `M`, the span of the set containing only `m` is a subset of `p` if and only if `m` is an element of `p`. In other words, the smallest submodule of `M` that contains `m` is contained in `p` exactly when `m` itself is contained in `p`.

The smallest R-submodule of an additive commutative monoid M that contains an element m is equal to M if and only if m is an element of the given submodule p.


theorem Commute.orderOf_mul_dvd_lcm :
    ∀ {G : Type u_1} [inst : Monoid G] {x y : G}, Commute x y → orderOf (x * y) ∣ Nat.lcm (orderOf x) (orderOf y) := by
  sorry

This theorem states that for any type `G` that has a monoid structure, given two elements `x` and `y` of `G` that commute (i.e., `x * y = y * x`), the order of the product `x * y` divides the least common multiple of the orders of `x` and `y`. Here, the order of an element `a` in a monoid is the smallest positive integer `n` such that `a^n = 1`, or zero if no such integer exists. The least common multiple of two natural numbers `m` and `n` is defined as the product of `m` and `n` divided by their greatest common divisor.

For any commuting elements `x` and `y` in a monoid `G` with finite orders, the order of their product `x * y` divides their least common multiple.


theorem Set.preimage_id : ∀ {α : Type u_1} {s : Set α}, id ⁻¹' s = s := by sorry

The theorem `Set.preimage_id` states that for any type `α` and any set `s` of type `α`, the preimage of `s` under the identity function `id` is the same as the set `s` itself. In other words, applying the identity function to each element of the set `s` does not change the set. The preimage of a set under a function is the collection of all elements that are mapped to the set by the function, and the identity function maps each element to itself. Therefore, every element of `s` is in the preimage, and every element of the preimage is in `s`, so the two sets are equal.

The preimage of a set under the identity function is equal to the set itself.


theorem midpoint_eq_smul_add :
    ∀ (R : Type u_1) {V : Type u_2} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
      [inst_3 : Module R V] (x y : V), midpoint R x y = ⅟2 • (x + y) :=
  by sorry

The theorem `midpoint_eq_smul_add` states that for any Ring `R`, and for any vectors `x` and `y` in an additive commutative group `V` that is also a module over `R`, the midpoint between `x` and `y` is equal to half the sum of `x` and `y`. In other words, the midpoint of two vectors is the scaled sum of the vectors, with the scale factor being the multiplicative inverse of 2. This theorem essentially formalizes the typical understanding of the "midpoint" of two points in a vector space.

For any additive commutative group `V` that is an `R`-module, and for all vectors `x` and `y` in `V` over a ring `R`, the midpoint of `x` and `y` is equal to (1/2) * (x + y).


theorem SimpleGraph.Subgraph.induce_mono :
    ∀ {V : Type u} {G : SimpleGraph V} {G' G'' : SimpleGraph.Subgraph G} {s s' : Set V},
      G' ≤ G'' → s ⊆ s' → SimpleGraph.Subgraph.induce G' s ≤ SimpleGraph.Subgraph.induce G'' s' :=
  by sorry

This theorem states that for any given type `V` and a simple graph `G` of type `V`, if `G'` and `G''` are subgraphs of `G`, and `s` and `s'` are sets of vertices in `V`, then if `G'` is a subgraph of `G''` and `s` is a subset of `s'`, the induced subgraph of `G'` with vertex set `s` is a subgraph of the induced subgraph of `G''` with vertex set `s'`. In other words, the process of inducing a subgraph preserves the relation of "being a subgraph of".

If `G'` is a subgraph of `G''` and `s` is a subset of `s'`, then the induced subgraph of `G'` on `s` is a subgraph of the induced subgraph of `G''` on `s'`.