IsPathConnected.isConnected

theorem IsPathConnected.isConnected :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {F : Set X}, IsPathConnected F → IsConnected F := by sorry

The theorem `IsPathConnected.isConnected` states that for any type `X` equipped with a topology and any set `F` of elements of type `X`, if `F` is a path-connected set, then it is also a connected set. Here, a set is path-connected if there exists a point within the set that can be connected to all other points in the set via a path entirely contained within the set. A connected set is a nonempty set where there is no non-trivial open partition, implying that the set cannot be separated into two nonempty open sets.

If a path-connected subset of a topological space is nonempty, then it is also a connected subset.


theorem Group.rank_spec :
    ∀ (G : Type u_3) [inst : Group G] [h : Group.FG G], ∃ S, S.card = Group.rank G ∧ Subgroup.closure ↑S = ⊤ := by sorry

The theorem `Group.rank_spec` states that for any group `G` that is finitely generated (`Group.FG G`), there exists a set `S` such that the cardinality of `S` is equal to the rank of the group (the minimum number of generators of the group as described by `Group.rank G`) and the closure of `S` (i.e., the smallest subgroup of `G` containing all elements of `S` as given by `Subgroup.closure ↑S`) is the entire group `G` (denoted by `⊤`). In other words, `S` is a set of generators for the group `G` and it is of minimal size.

For any finitely generated group $G$, there exists a set $S$ of generators for $G$ such that $S$ is of minimum size and the subgroup generated by $S$ is equal to $G$ (i.e., $S$ is a generating set of minimum cardinality for $G$).


AddEquiv.surjective

theorem AddEquiv.surjective :
    ∀ {M : Type u_6} {N : Type u_7} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N), Function.Surjective ⇑e := by sorry

The theorem `AddEquiv.surjective` states that for any two types `M` and `N` which have addition (`Add`) defined on them, any additive equivalence (`AddEquiv`) `e` from `M` to `N` is a surjective function. In other words, for every element `n` in `N`, there exists an element `m` in `M` such that applying the additive equivalence `e` to `m` yields `n`.

Given types `M` and `N` with addition and an additive equivalence `e` between them, `e` is a surjective function.


theorem Function.support_const :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {c : M}, c ≠ 0 → (Function.support fun x => c) = Set.univ := by
  sorry

This theorem, named `Function.support_const`, states that for any types `α` and `M`, given that `M` has a zero element and any constant `c` from `M` that is not equal to zero, the support of the function that maps any element of `α` to the constant `c` is the universal set. In other words, if a function always returns a nonzero constant, then its support (the set of all input values for which the function is nonzero) is the entire set of all possible input values.

For any type `α` and constant `c ≠ 0` in a type `M` with zero element, the function `λ x : α, c` has support equal to the universe `α`.


theorem Finset.erase_insert_eq_erase :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), Finset.erase (insert a s) a = Finset.erase s a := by
  sorry

This theorem states that for any type `α` which has decidable equality, and for any finite set `s` and element `a` of type `α`, the operation of first inserting the element `a` into the set `s` and then removing `a` is equivalent to simply removing `a` from `s`. In mathematical terms, given a set `s` and an element `a`, the operation `erase (insert a s) a` is equal to `erase s a`. This implies that if an element is added to a set and then removed, it has no net effect on the original set.

For any finite type `α` with decidable equality, the operation of inserting and then removing an element `a` from a set `s` equals the operation of just removing `a` from `s` (i.e., `erase (insert a s) a = erase s a`).


theorem Mathlib.Data.Nat.Factorization.Basic._auxLemma.8 :
    ∀ (n p : ℕ), ((Nat.factorization n) p = 0) = (¬Nat.Prime p ∨ ¬p ∣ n ∨ n = 0) := by sorry

This theorem states that for any two natural numbers `n` and `p`, the count of `p` in the prime factorization of `n` is zero if and only if `p` is not a prime number, or `p` does not divide `n`, or `n` is zero. In other words, a natural number `p` appears in the prime factorization of `n` if and only if `p` is a prime number that divides `n` and `n` is not zero.

A natural number `p` is in the prime factorization of `n` if and only if `p` is a prime number that divides `n` and `n` is non-zero.


SimpleGraph.Reachable.symm

theorem SimpleGraph.Reachable.symm :
    ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, SimpleGraph.Reachable G u v → SimpleGraph.Reachable G v u := by sorry

The theorem `SimpleGraph.Reachable.symm` states that for any vertices `u` and `v` of a given simple graph `G`, if `u` is reachable from `v`, then `v` is also reachable from `u`. In other words, the reachability relation in a simple graph is symmetric.

If vertices `u` and `v` in a simple graph are reachable from each other, then they are mutually reachable.


theorem MeasureTheory.AEStronglyMeasurable.const_smul :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {f : α → β} {𝕜 : Type u_5} [inst_1 : SMul 𝕜 β] [inst_2 : ContinuousConstSMul 𝕜 β],
      MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : 𝕜), MeasureTheory.AEStronglyMeasurable (c • f) μ :=
  by sorry

The theorem `MeasureTheory.AEStronglyMeasurable.const_smul` states that for any types `α` and `β`, a measurable space `m` over `α`, a measure `μ` over the measurable space, a function `f` from `α` to `β`, a type `𝕜`, and the assumptions that the type `β` has a topological space structure, `𝕜` and `β` have a scalar multiplication operation, and that the scalar multiplication operation is continuously constant, if the function `f` is almost everywhere strongly measurable with respect to the measure `μ`, then for any element `c` of type `𝕜`, the function `c • f` (which denotes the scalar multiplication of `c` and `f`) is also almost everywhere strongly measurable with respect to the measure `μ`. In simpler terms, the scalar multiplication of a measurable function remains measurable.

If a function between measurable spaces is almost everywhere strongly measurable and the scalar multiplication on its codomain is continuously constant, then the scalar multiplication of the function with any scalar is also almost everywhere strongly measurable.


theorem MeasureTheory.withDensity_add_left :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      Measurable f → ∀ (g : α → ENNReal), μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g :=
  by sorry

The theorem `MeasureTheory.withDensity_add_left` states that for any type `α` equipped with a measurable space structure `m0` and a measure `μ` defined on that space, for any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`) that is measurable, the measure `μ` with density `f + g` (where `g` is any function from `α` to `ENNReal`) is equal to the sum of the measure `μ` with density `f` and the measure `μ` with density `g`. In other words, the measure with the density of a sum of two functions is equal to the sum of measures with the densities of the individual functions, assuming that the function used in the former is measurable.

For any measurable function `f : α → ℝ∞±` and measurable sets `μ` on a measurable space `(α, m0)`, the measure `μ` with density `f + g` equals the sum of the measures `μ` with densities `f` and `g`, where `g : α → ℝ∞±` is any measurable function.


/-- In a complete lattice, the liminf of a function is the infimum over sets `s` in the filter
of the supremum of the function over `s`  -/
theorem Filter.liminf_eq_iSup_iInf :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : Filter β} {u : β → α},
      Filter.liminf u f = ⨆ s ∈ f, ⨅ a ∈ s, u a :=
  by sorry

In the context of a complete lattice, this theorem states that the lower limit (or `liminf`) of a function `u` as it approaches a filter `f` is equal to the supremum over all sets `s` in the filter `f` of the infimum of `u` over the set `s`. This means that for every set `s` in the filter `f`, we calculate the least value of the function `u` over the set `s`, and then among all these least values, we find the greatest one. This greatest least value is exactly the `liminf` of the function `u` with respect to the filter `f`.

In a complete lattice, the liminf of a function with respect to a filter is equal to the supremum of the infima of the function over each set in the filter.


theorem AddLocalization.mk_eq_addMonoidOf_mk' :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M},
      AddLocalization.mk = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) :=
  by sorry

The theorem `AddLocalization.mk_eq_addMonoidOf_mk'` states that for any additive commutative monoid `M` and any submonoid `S` of `M`, the function `AddLocalization.mk`, which takes an element of `M` and an element of `S` and sends them to their equivalence class in the localization of `M` at `S`, is equal to the function `AddSubmonoid.LocalizationMap.mk'` applied to the natural homomorphism `AddLocalization.addMonoidOf S`. This natural homomorphism sends an element of `M` to the equivalence class of `(x, 0)` in the localization of `M` at `S`. The theorem thereby associates the addition operation in the base monoid `M` with the addition operation in the localized monoid.

The theorem `AddLocalization.mk_eq_addMonoidOf_mk` asserts that for any additive commutative monoid `M` and submonoid `S`, the functions `AddLocalization.mk` and `AddSubmonoid.LocalizationMap.mk'` defining addition in the localization of `M` at `S` agree, i.e., `AddLocalization.mk (x, y) = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) (x, 0)` for all `x, y` in `M`.


theorem Finset.biUnion_subset :
    ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {s' : Finset β},
      Finset.biUnion s t ⊆ s' ↔ ∀ x ∈ s, t x ⊆ s' :=
  by sorry

The theorem `Finset.biUnion_subset` states that for any types `α` and `β`, a finite set `s` of type `α`, a function `t` mapping elements of type `α` to finite sets of type `β`, and a finite set `s'` of type `β` (with decidable equality), the bi-union of the finite set `s` and the function `t` (represented as `Finset.biUnion s t`) is a subset of `s'` if and only if for every element `x` in `s`, the finite set `t x` is a subset of `s'`. In other words, this theorem expresses a condition for a bi-union of a finite set and a function mapping elements to finite sets to be a subset of another finite set.

For any finite sets `s` of type `α` and `s'` of type `β` with decidable equality, and a function `t : α → Finset β`, the bi-union `Finset.biUnion s t` is a subset of `s'` if and only if for all `x` in `s`, `t x` is a subset of `s'`.


theorem Finset.image₂_assoc :
    ∀ {α : Type u_1} {β : Type u_3} {δ : Type u_7} {ε : Type u_9} {ε' : Type u_10} [inst : DecidableEq δ]
      [inst_1 : DecidableEq ε] [inst_2 : DecidableEq ε'] {s : Finset α} {t : Finset β} {γ : Type u_14} {u : Finset γ}
      {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'},
      (∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)) →
        Finset.image₂ f (Finset.image₂ g s t) u = Finset.image₂ f' s (Finset.image₂ g' t u) :=
  by sorry

This theorem asserts that for all types `α`, `β`, `δ`, `ε`, `ε'`, `γ`, given decidable equalities on `δ`, `ε`, and `ε'`, and given finsets `s` of type `α`, `t` of type `β`, and `u` of type `γ`, if we have binary functions `f : δ → γ → ε`, `g : α → β → δ`, `f' : α → ε' → ε`, and `g' : β → γ → ε'`, such that for all `a` in `α`, `b` in `β`, and `c` in `γ`, `f (g a b) c` is equal to `f' a (g' b c)`, then the image under `f` of the image under `g` of the cartesian product of `s` and `t`, and `u`, is equal to the image under `f'` of the cartesian product of `s` and the image under `g'` of the cartesian product of `t` and `u`. It is a kind of associativity property for the image of binary functions over finsets.

Given decidable equalities on `δ`, `ε`, and `ε'`, and binary functions `f`, `g`, `f'`, `g'`, if `f (g a b) c = f' a (g' b c)` for all `a` in `α`, `b` in `β`, and `c` in `γ`, then `f''(s ×_β t) u = f'(s ×_α t ×_β u)`, where `f'' = λ (s : Set α) (t : Set β) (u : Set γ), ⨄(f'' s t u) := ⨄(⨄(f s t) u)`, and `×_β` denotes the product of sets indexed by `β`.


theorem Hyperreal.Infinite.st_eq : ∀ {x : ℝ*}, Hyperreal.Infinite x → Hyperreal.st x = 0 := by sorry

This theorem states that for any hyperreal number `x`, if `x` is infinite (either infinitely positive or infinitely negative), then the standard part of `x` is equal to zero. The standard part of a hyperreal number, denoted `Hyperreal.st x`, is similar to rounding, but rounds to the nearest real number rather than the nearest integer. In the context of this theorem, it means that an infinitely large or small hyperreal number is rounded to zero.

For any hyperreal number `x`, if `x` is infinite then its standard part is equal to zero.


theorem AddSubgroup.coe_eq_univ : ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, ↑H = Set.univ ↔ H = ⊤ := by
  sorry

This theorem states that for any given type `G` that forms an additive group, and any `H` which is a subgroup of `G`, the coercion of `H` to a set is equal to the universal set if and only if `H` is the top element of the lattice of additive subgroups, i.e., `H` is the whole group `G`. In mathematical terms, this means that an additive subgroup `H` of a group `G` spans the entire group if and only if `H` is equal to `G` itself.

For an additive group `G` and its subgroup `H`, `coerce H to set = {-} : set G <=> H = G`.


theorem lowerSemicontinuousWithinAt_sum :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {s : Set α} {ι : Type u_3} {γ : Type u_4}
      [inst_1 : LinearOrderedAddCommMonoid γ] [inst_2 : TopologicalSpace γ] [inst_3 : OrderTopology γ]
      [inst_4 : ContinuousAdd γ] {f : ι → α → γ} {a : Finset ι},
      (∀ i ∈ a, LowerSemicontinuousWithinAt (f i) s x) →
        LowerSemicontinuousWithinAt (fun z => Finset.sum a fun i => f i z) s x :=
  by sorry

This theorem states that if we have a topological space `α`, a point `x` in `α`, a set `s` of `α`, a finite set `a` of indices of type `ι`, and a family of functions `f` from `ι` and `α` to a linear ordered additive commutative monoid `γ` that also has a topological structure, order topology and continuous addition, then if every function `f i` is lower semicontinuous at point `x` within set `s` for every index `i` in the finite set `a`, the sum function, which at each point `z` of `α` sums over all `f i z` for each `i` in `a`, is also lower semicontinuous at `x` within `s`.

In simple terms, the lower semicontinuity within a set is preserved when taking the sum of a finite number of lower semicontinuous functions.

If `α` is a topological space, `x` is a point in `α`, `s` is a set in `α`, `a` is a finite index set, and `f` is a family of lower semicontinuous functions from `α x ι` to a topological monoid `γ`, then the sum function from `α` to `γ` defined as the pointwise sum of `f i` is lower semicontinuous at `x` within `s`.


theorem Mathlib.Data.Set.Intervals.UnorderedInterval._auxLemma.13 :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (a ∈ Ι b c) = (b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b) := by sorry

This theorem states that for any set of elements of type α, where α has a linear order, and for any three elements a, b, and c of this type, a is in the unordered interval between b and c if and only if either b is less than a and a is less than or equal to c, or c is less than a and a is less than or equal to b.

For any set with a linear order, element a lies between b and c if and only if (b < a and a <= c) or (c < a and a <= b).


theorem TopologicalSpace.IsTopologicalBasis.exists_subset_of_mem_open :
    ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
      TopologicalSpace.IsTopologicalBasis b → ∀ {a : α} {u : Set α}, a ∈ u → IsOpen u → ∃ v ∈ b, a ∈ v ∧ v ⊆ u :=
  by sorry

This theorem states that for any type `α` having a topology `t` and a set `b` of sets of `α` that forms a topological basis, for any member `a` of `α` and any open set `u` of `α` that contains `a`, there exists a set `v` in the basis `b` such that `a` is a member of `v` and `v` is a subset of `u`. In other words, given any topological space, any point in an open set of the space lies within some basis element contained within that open set.

For any point in a topological space and open set containing it, there exists a basis element that contains the point and is a subset of the open set.


DifferentiableAt.inv

theorem DifferentiableAt.inv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type w} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {h : E → 𝕜} {z : E},
      DifferentiableAt 𝕜 h z → h z ≠ 0 → DifferentiableAt 𝕜 (fun x => (h x)⁻¹) z :=
  by sorry

The theorem `DifferentiableAt.inv` states that for any non-trivially normed field `𝕜` and normed additive commutative group `E` that is a normed space over `𝕜`, if we have a function `h : E → 𝕜` that is differentiable at a point `z` and the value of `h` at `z` is not zero, then the function that maps any `x` to the multiplicative inverse of `h(x)` (i.e., `(h x)⁻¹`) is also differentiable at `z`.

If `h : E → 𝕜` is differentiable at `z ∈ E` in the normed space `(E, 𝕜)` and `h(z) ≠ 0`, then the function `x ↦ h(x)⁻¹` is differentiable at `z`.


theorem CategoryTheory.Limits.PushoutCocone.IsColimit.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      {t : CategoryTheory.Limits.PushoutCocone f g},
      CategoryTheory.Limits.IsColimit t →
        ∀ {W : C} {k l : t.pt ⟶ W},
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PushoutCocone.inl t) k =
              CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PushoutCocone.inl t) l →
            CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PushoutCocone.inr t) k =
                CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PushoutCocone.inr t) l →
              k = l :=
  by sorry

This theorem, `CategoryTheory.Limits.PushoutCocone.IsColimit.hom_ext`, states that in any category `C`, for any objects `X`, `Y`, `Z`, and morphisms `f : X ⟶ Y` and `g : X ⟶ Z`, if `t` is a pushout cocone of `f` and `g` and is a colimit, then for any object `W` and any two morphisms `k, l : t.pt ⟶ W`, if the composition of `k` and `inl t` (the first inclusion of the pushout cocone) is equal to the composition of `l` and `inl t`, and the composition of `k` and `inr t` (the second inclusion of the pushout cocone) is equal to the composition of `l` and `inr t`, then `k` and `l` are the same morphism.

In other words, it says that in a category, if two morphisms `k` and `l` from the tip of a colimiting pushout cocone both compose to the same morphism with each of the cocone's inclusions, then those two morphisms must be equal.

In a category, if two morphisms from the tip of a colimiting pushout cocone have equal compositions with both inclusive morphisms of the cocone, then they are equal.


theorem MeasureTheory.integrableOn_const :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {s : Set α}
      {μ : MeasureTheory.Measure α} {C : E}, MeasureTheory.IntegrableOn (fun x => C) s μ ↔ C = 0 ∨ ↑↑μ s < ⊤ :=
  by sorry

The theorem `MeasureTheory.integrableOn_const` states that for any set `s` of type `α`, any measure `μ` on `α`, and any constant `C` of type `E`, the constant function that returns `C` for every input is integrable on the set `s` with respect to the measure `μ` if and only if `C` is zero or the measure of the set `s` is finite. This is a statement about the conditions under which the integral of a constant function over a set is defined and finite. In the context of measure theory, this theorem is a fundamental result connecting the concepts of integrability, constant functions, and finiteness of measures.

A constant function is integrable with respect to a measure on a set if and only if the constant is zero or the measure of the set is finite.


theorem Finset.left_not_mem_Ioc :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, a ∉ Finset.Ioc a b := by sorry

This theorem states that for any type `α` that has a preorder and is a locally finite order, and for any two elements `a` and `b` of type `α`, `a` is not a member of the finite set defined as the open-closed interval Ioc(a, b). In mathematical terms, if we have a set of elements `x` such that `a < x ≤ b`, then `a` is not included in this set.

For any locally finite preorder type `α` and elements `a` and `b` of `α` with `a < b`, `a` is not an element of the open-closed interval `Ioc(a, b)`.


theorem Ordinal.nadd_lt_nadd_left :
    ∀ {b c : Ordinal.{u}}, b < c → ∀ (a : Ordinal.{u}), Ordinal.nadd a b < Ordinal.nadd a c := by sorry

The theorem `Ordinal.nadd_lt_nadd_left` states that for any three ordinals `a`, `b`, and `c`, if `b` is less than `c`, then the natural addition of `a` and `b`, denoted as `Ordinal.nadd a b`, is also less than the natural addition of `a` and `c`, denoted as `Ordinal.nadd a c`. This theorem thus asserts the monotonicity of the natural addition of ordinals with respect to the second ordinal.

For all ordinals `a`, `b`, and `c`, if `b` < `c`, then `Ordinal.nadd a b` < `Ordinal.nadd a c`.


theorem Finset.left_not_mem_Ioo :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, a ∉ Finset.Ioo a b := by sorry

This theorem states that for any type `α` that has a preorder and a locally finite order, and for any two elements `a` and `b` of this type, the element `a` is not a member of the finite set of elements `x` such that `a < x` and `x < b`. In other words, the left endpoint `a` is not included in the open interval `(a, b)` in a finite order.

For any type with a preorder and locally finite order, there are no elements `a` and `b` such that `a < x` and `x < b` for some `x`. In other words, endpoints do not overlap in finite orders.


ContDiff.cexp

theorem ContDiff.cexp :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {E : Type u_2}
      [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {f : E → ℂ} {n : ℕ∞},
      ContDiff 𝕜 n f → ContDiff 𝕜 n fun x => Complex.exp (f x) :=
  by sorry

This theorem states that for any nontrivial normed field `𝕜`, which also has a normed algebra structure over the complex numbers, and for any normed additive commutative group `E` with a normed space structure over `𝕜`, if a function `f` from `E` to the complex numbers is `n` times continuously differentiable, then the function that sends `x` to the complex exponential of `f(x)` is also `n` times continuously differentiable.

If `𝕜` is a nontrivial normed field with a normed algebra structure over the complex numbers, `E` is a normed additive commutative group with a normed space structure over `𝕜`, and `f : E -> ℂ` is `n`-times continuously differentiable, then the function `x => exp(f(x))` is also `n`-times continuously differentiable.


theorem DFinsupp.extendWith_some :
    ∀ {ι : Type u} {α : Option ι → Type v} [inst : (i : Option ι) → Zero (α i)] (f : Π₀ (i : ι), α (some i))
      (a : α none) (i : ι), (DFinsupp.extendWith a f) (some i) = f i :=
  by sorry

The theorem `DFinsupp.extendWith_some` states that for any type `ι`, any function `α` from the option of `ι` to some other type, given that for every `i` which is an option of `ι`, the `α i` is a zero type, and for any `dfinsupp` `f` indexed by `ι` with values in `α (some i)` and any element `a` of type `α none`, if we apply the `DFinsupp.extendWith` function on `a` and `f` and then apply this result to `some i`, we get the original `f i`. In simpler terms, if we extend a dfinsupp `f` indexed by `ι` with an element `a` and then try to retrieve an element at `some i`, we get back the original element at `i` in `f`.

For any type `ι`, function `α` from the option of `ι` to a zero type, and `dfinsupp` `f` indexed by `ι` with values in `α (some i)`, `f (some i) = DFinsupp.extendWith some i a (DFinsupp.extendWith a none f)`.


theorem Equiv.Perm.zpow_apply_eq_self_of_apply_eq_self :
    ∀ {α : Type u_1} {f : Equiv.Perm α} {x : α}, f x = x → ∀ (n : ℤ), (f ^ n) x = x := by sorry

This theorem states that for any type `α`, given a permutation `f` (which is a bijection from `α` to itself), and an element `x` of `α`, if the permutation `f` applied to `x` gives `x` itself (i.e., `f` leaves `x` fixed), then for any integer `n`, the `n`-th iterated application of `f` (denoted by `f ^ n`) also leaves `x` fixed. In simpler terms, if a permutation does not change an element, repeated applications of this permutation won't change the element either, no matter how many times we apply it.

If a permutation leaves an element fixed, then repeated applications of that permutation also leave that element fixed.


theorem IsCompact.add_closedBall_zero :
    ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {δ : ℝ} {s : Set E},
      IsCompact s → 0 ≤ δ → s + Metric.closedBall 0 δ = Metric.cthickening δ s :=
  by sorry

This theorem states that for any given compact set 's' in a semi-normed additive commutative group 'E', and for any non-negative real number 'δ', the set obtained by adding 's' and the closed ball of radius 'δ' centered at 0 is equal to the closed δ-thickening of 's'. In other words, the sum of 's' and the closed ball of radius 'δ' centered at 0 expands 's' by a thickness of 'δ', without changing its essential structure.

For any compact set 's' in a semi-normed additive commutative group 'E' and real number 'δ'≥0, the sum of 's' and the closed ball of radius 'δ' centered at 0 equals the closed δ-thickening of 's'.


theorem Nat.mul_lt_mul_of_lt_of_le' : ∀ {a c b d : ℕ}, a < c → b ≤ d → 0 < b → a * b < c * d := by sorry

This theorem states that for any four natural numbers `a`, `c`, `b`, and `d`, if `a` is less than `c`, `b` is less than or equal to `d`, and `b` is greater than 0, then the product of `a` and `b` is less than the product of `c` and `d`. In other words, under these conditions, multiplying a smaller natural number by another natural number yields a result that is less than the product of two larger or equal natural numbers. This theorem is a special case of the more general principle that multiplication preserves the order of natural numbers.


/-- The value of `weightedVSubOfPoint`, where the given points are equal.  -/
theorem Finset.weightedVSubOfPoint_apply_const :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p b : P),
      (Finset.weightedVSubOfPoint s (fun x => p) b) w = (Finset.sum s fun i => w i) • (p -ᵥ b) :=
  by sorry

This theorem states that for any set `s` of indices of type `ι`, any weight function `w : ι → k` from the indices to a ring `k`, and any two points `p` and `b` in an affine space `P` over a vector space `V` with scalars from `k`, the weighted subtraction of point `b` from each point in the set `s`, where each point in the set is the same and equal to `p`, is equal to the sum of the weights of the elements in `s` scaled by the vector from `b` to `p`. This is under the assumptions that `V` forms an additive commutative group, and `V` is a `k`-module. The operation `p -ᵥ b` denotes the subtraction of the point `b` from `p` in the affine space `P`.

For any set `s` of indices, any weight function `w : ι → k`, and any point `p, b` in an additive commutative `k`-module `V`, the sum of weights of elements in `s` scaled by the vector `p - b` equals the weighted subtraction of `b` from each point `p` in `s` in the affine space over `V`.


theorem TrivSqZeroExt.norm_def :
    ∀ {R : Type u_3} {M : Type u_4} [inst : SeminormedRing R] [inst_1 : SeminormedAddCommGroup M]
      (x : TrivSqZeroExt R M), ‖x‖ = ‖TrivSqZeroExt.fst x‖ + ‖TrivSqZeroExt.snd x‖ :=
  by sorry

The theorem `TrivSqZeroExt.norm_def` states that for any type `R` which is a seminormed ring, and any type `M` which is a seminormed additive commutative group, the norm of an element `x` in the trivial square-zero extension of `M` over `R` is equal to the sum of the norms of the first and the second components of `x`. In other words, if `x` is an element from the trivial square-zero extension `R × M`, then `‖x‖ = ‖TrivSqZeroExt.fst x‖ + ‖TrivSqZeroExt.snd x‖`, where ‖ · ‖ denotes the norm, `TrivSqZeroExt.fst x` retrieves the `R` component of `x`, and `TrivSqZeroExt.snd x` retrieves the `M` component of `x`.

For any element `x` in the trivial square-zero extension of a seminormed additive commutative group `M` over a seminormed ring `R`, the norm of `x` is equal to the sum of the norms of its `R` and `M` components.


/-- **Alias** of the reverse direction of `Filter.tendsto_map'_iff`. -/
theorem Filter.tendsto_map' :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
      Filter.Tendsto (f ∘ g) x y → Filter.Tendsto f (Filter.map g x) y :=
  by sorry

This theorem, named `Filter.tendsto_map'`, states that for any types `α`, `β`, and `γ`, and any functions `f : β → γ` and `g : α → β`, along with any filters `x : Filter α` and `y : Filter γ`, if the function composed of `f` and `g` (i.e., `(f ∘ g)`) tends from filter `x` to filter `y`, then the function `f` tends from the filter mapped by `g` over `x` to filter `y`. In other words, if `(f ∘ g)` has a limit at some point in the context of filters `x` and `y`, then `f` also has a limit at that point in the context of the filters obtained by applying `g` to `x` and the original filter `y`.

If `f : β → γ` tends to a limit in `Filter.tendsto y (f ∘ g)` for filters `x : Filter α` and `y : Filter γ`, then `f` also tends to a limit in `Filter.tendsto (g ^-1 '[] y) f`, where `g : α → β`.


theorem Ordinal.mul_lt_mul_of_pos_left : ∀ {a b c : Ordinal.{u_4}}, a < b → 0 < c → c * a < c * b := by sorry

The theorem `Ordinal.mul_lt_mul_of_pos_left` states that for any three ordinal numbers `a`, `b`, and `c` from the same type, if `a` is less than `b` and `c` is greater than zero, then the product of `c` and `a` is less than the product of `c` and `b`. In other words, multiplying a smaller ordinal number by a positive ordinal number results in a smaller ordinal than when multiplying the larger ordinal number by the same positive ordinal number.

For all ordinal numbers `a`, `b`, and `c` of the same type, if `a` < `b` and `c` > 0, then `c * a` < `c * b`.


PartitionOfUnity.nonneg

theorem PartitionOfUnity.nonneg :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) (i : ι) (x : X),
      0 ≤ (f i) x :=
  by sorry

This theorem states that, for any types `ι` and `X`, with `X` being a topological space, and for any set `s` of elements from `X`, if `f` is a partition of unity indexed by `ι` over `X` restricted to `s`, then each function `f i` in the partition, evaluated at any point `x` in `X`, is non-negative. In simpler terms, all function values in a partition of unity of a topological space are non-negative.

For any topological space X and indexed family f i : ι → C^0(X) of continuous real-valued functions on X forming a partition of unity, ∀ i ∈ ι, ∀ x ∈ X, f i x ≥ 0.


theorem CategoryTheory.FinitaryExtensive.vanKampen :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.FinitaryExtensive C]
      {F : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C}
      (c : CategoryTheory.Limits.Cocone F), CategoryTheory.Limits.IsColimit c → CategoryTheory.IsVanKampenColimit c :=
  by sorry

The theorem `CategoryTheory.FinitaryExtensive.vanKampen` states that for any category `C`, that is finitarily extensive, and any functor `F` from the discrete category of a walking pair into `C`, if `c` is a cocone over `F` and is a colimit, then `c` is a Van Kampen colimit. In other words, in a finitarily extensive category, all colimits of functors from the discrete category of a walking pair are Van Kampen colimits.

In a finitarily extensive category, every colimit of functors from the discrete category of a walking pair is a Van Kampen colimit.


theorem Set.range_nonempty_iff_nonempty :
    ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, Set.Nonempty (Set.range f) ↔ Nonempty ι := by sorry

This theorem states that for any function `f` from a type `ι` to another type `α`, the range of the function `f` is nonempty if and only if the type `ι` is nonempty. In other words, the function `f` has a nonempty range if there exists at least one input of type `ι` for `f`. The theorem captures the concept that a function's range can only be nonempty if there are inputs to map from, i.e., the input type is nonempty.

A function from a nonempty type to another type has a nonempty range.


theorem Nat.Ico_insert_succ_left : ∀ {a b : ℕ}, a < b → insert a (Finset.Ico (Nat.succ a) b) = Finset.Ico a b := by
  sorry

This theorem states that for any two natural numbers `a` and `b`, if `a` is less than `b`, then when you insert `a` into the finite set of numbers from `a+1` to `b` (exclusive), you get the finite set of numbers from `a` to `b` (exclusive).

For all natural numbers `a` and `b` with `a < b`, the set `{x : ℕ | a < x < b}` is equal to `a :: {x : ℕ | a < x < b}`. (Here, `::` denotes the cons operation adding an element to the front of a list.)


theorem Polynomial.coe_mapRingHom :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
      ⇑(Polynomial.mapRingHom f) = Polynomial.map f :=
  by sorry

This theorem states that for any two types `R` and `S`, both equipped with a semiring structure, and any ring homomorphism `f` from `R` to `S`, the application of the `Polynomial.mapRingHom` function to `f` is equal to the `Polynomial.map` function applied to `f`. In other words, the `Polynomial.mapRingHom` and `Polynomial.map` functions are consistent with each other when dealing with ring homomorphisms.

For any semiring homomorphisms `f` between types `R` and `S`, `Polynomial.mapRingHom f = Polynomial.map f`.


/-- The closure of the interval `(-∞, a)` is the closed interval `(-∞, a]`, unless `a` is a bottom
element.  -/
theorem closure_Iio' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a : α}, Set.Nonempty (Set.Iio a) → closure (Set.Iio a) = Set.Iic a :=
  by sorry

This theorem states that for any type `α` which has structure of a topological space, a linear order, an order topology, and is densely ordered, for any element `a` of `α`, if the set of all elements less than `a` (denoted as `(-∞, a)` in interval notation) is not empty, then the topological closure of this set (the smallest closed set that contains this set) is the set of all elements less than or equal to `a` (denoted as `(-∞, a]` in interval notation) - unless `a` is a bottom element of the order.

For any densely ordered topological space `α` with order topology, if an element `a` has a non-empty set of elements strictly less than it, then the topological closure of this set equals the set of all elements less than or equal to `a`, except when `a` is the bottom element.


theorem Matrix.of_apply :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (f : m → n → α) (i : m) (j : n), Matrix.of f i j = f i j := by sorry

This theorem states that for any types `m`, `n`, and `α`, and for any function `f` from pairs of `m` and `n` to `α`, and any elements `i` of type `m` and `j` of type `n`, the result of applying the function `Matrix.of` to `f` and then indexing into the resulting matrix at `i` and `j` is equal to the result of directly applying `f` to `i` and `j`. In other words, creating a matrix from a function and then retrieving an element from the matrix is equivalent to directly applying the function to the indices of that element.

For any types `m`, `n`, and `α`, and for any function `f` from pairs of `m` and `n` to `α`, the application of `f` to `(i, j)` is equal to the `(i, j)`-th entry of the matrix `Matrix.of f`.


theorem Nat.clog_of_left_le_one : ∀ {b : ℕ}, b ≤ 1 → ∀ (n : ℕ), Nat.clog b n = 0 := by sorry

The theorem `Nat.clog_of_left_le_one` asserts that for any natural number `b` and `n`, if `b` is less than or equal to `1`, then the upper logarithm of `n` in base `b`, denoted here as `Nat.clog b n`, is equal to `0`. In other words, if the base of the logarithm is `1` or less, then the logarithm is `0`, regardless of the number for which the logarithm is taken.

For any natural number `n`, `Nat.clog 1 le n` implies `Nat.clog 1 n = 0`.


theorem Associates.mk_surjective : ∀ {α : Type u_1} [inst : Monoid α], Function.Surjective Associates.mk := by sorry

The theorem `Associates.mk_surjective` states that for any type `α` with a `Monoid` structure, the function `Associates.mk`, which maps an element of the monoid to its associate, is surjective. This means that for every element in the set of associates of `α`, there exists an element in the original monoid `α` such that when the `Associates.mk` function is applied to this element, it produces the given associate. In other words, every associate can be created from some element in the original monoid using the `Associates.mk` function.

For any monoid `α`, the function `Associates.mk` maps every element of its associates to some element in `α`.


theorem List.sorted_mergeSort :
    ∀ {α : Type uu} (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTotal α r] [inst_2 : IsTrans α r]
      (l : List α), List.Sorted r (List.mergeSort r l) :=
  by sorry

The theorem `List.sorted_mergeSort` states that for all types `α` and for any relation `r` on `α` that is decidable, total, and transitive, if we have a list `l` of type `α`, then the list obtained by sorting `l` using the merge sort algorithm with respect to the relation `r` is sorted according to the same relation `r`. Here, being sorted is defined as the pairwise satisfaction of the relation `r` for all elements in the list.

For any decidable, total, and transitive relation `r` on type `α`, the merge sort algorithm applied to a list `l` of `α` produces a sorted list according to `r`. That is, `∀x y in l, x r y ∧ mergeSort l r = l' ⟹ x r y' for all y' in l'`.


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

The theorem `Cardinal.lift_mul` states that for any two cardinal numbers `a` and `b` in a certain universe `u`, the cardinality of their product when lifted to a potentially larger universe `v`, is equal to the product of their individually lifted cardinalities. In other words, lifting the universe of the product of two cardinal numbers is the same as multiplying the lifted cardinal numbers. This theorem reflects the property of cardinal multiplication being preserved under universe lifting.

For any cardinal numbers `a` and `b` in universe `u`, the lifted product of `a` and `b` in universe `v` equals the product of their individual lifted cardinalities in `v`.


TopologicalSpace.PositiveCompacts.ext

theorem TopologicalSpace.PositiveCompacts.ext :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : TopologicalSpace.PositiveCompacts α}, ↑s = ↑t → s = t := by
  sorry

This theorem states that for any topological space `α`, and any two 'positive compacts' `s` and `t` in this space, if their underlying sets (obtained by applying the coercion function `↑`) are equal, then `s` and `t` themselves must be equal.

In other words, two 'positive compacts' in a given topological space are identical if and only if their underlying sets are identical. 'Positive compacts' are a type of subset of a topological space that are both compact and non-empty.

For any topological space `α`, two positive compacts `s` and `t` are equal if and only if their underlying sets are equal.


/-- A version of `AddCon.induction_on` for predicates which take
two arguments. -/
theorem AddCon.induction_on₂ :
    ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {c : AddCon M} {d : AddCon N}
      {C : AddCon.Quotient c → AddCon.Quotient d → Prop} (p : AddCon.Quotient c) (q : AddCon.Quotient d),
      (∀ (x : M) (y : N), C ↑x ↑y) → C p q :=
  by sorry

This theorem, `AddCon.induction_on₂`, is a more generalized version of `AddCon.induction_on` that allows for predicates with two arguments. Given two types `M` and `N` with defined addition operations, and two additive congruence relations `c` and `d` on `M` and `N` respectively, it states that for any predicate `C` taking two arguments from the quotient spaces of `M` and `N` by `c` and `d` respectively, if `C` holds for all pairs of representatives `(x, y)` from `M` and `N`, then `C` also holds for any two elements `p` and `q` from the quotient spaces. In mathematical terms, this theorem provides a principle of mathematical induction for two-variable predicates over quotients by additive congruence relations.

Given additive congruence relations `c` on type `M` and `d` on type `N`, if a predicate `C` holds for all pairs of representatives from the quotient spaces `M / c` and `N / d`, then `C` holds for any pair of elements from `M / c` and `N / d`.


theorem Finset.inter_eq_right : ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, t ∩ s = s ↔ s ⊆ t := by sorry

The theorem `Finset.inter_eq_right` states that for any type `α` with decidable equality, and for any two finite sets `s` and `t` of this type, the intersection of `t` and `s` being equal to `s` is equivalent to `s` being a subset of `t`. In other words, if the intersection of `t` and `s` yields `s`, then all elements of `s` must be within `t`. This theorem applies to any general type with decidable equality, meaning we can determine whether two elements of the type are equal or not.

For any type `α` with decidable equality, sets `s` and `t` in `Finset α`, the equality `s = t ∩ s` implies `s ⊆ t`.


theorem Real.exp_eq_exp : ∀ {x y : ℝ}, Real.exp x = Real.exp y ↔ x = y := by sorry

The theorem `Real.exp_eq_exp` states that for all real numbers `x` and `y`, the exponential function `Real.exp` of `x` and `y` are equal if and only if `x` and `y` themselves are equal. In other words, the real exponential function is injective (or one-to-one) on the set of real numbers.

The real exponential function is injective (one-to-one): for all real numbers x and y, Real.exp x = Real.exp y if and only if x = y.


/-- Given measures `μ` and `ν`, if `s` is a measure mutually singular to `ν` and `f` is a
measurable function such that `μ = s + fν`, then `s = μ.singularPart μ`.

This theorem provides the uniqueness of the `singularPart` in the Lebesgue decomposition theorem,
while `MeasureTheory.Measure.eq_rnDeriv` provides the uniqueness of the
`rnDeriv`.  -/
theorem MeasureTheory.Measure.eq_singularPart :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν s : MeasureTheory.Measure α} {f : α → ENNReal},
      Measurable f → MeasureTheory.Measure.MutuallySingular s ν → μ = s + ν.withDensity f → s = μ.singularPart ν :=
  by sorry

The theorem `MeasureTheory.Measure.eq_singularPart` states that for any measurable space `α` and measures `μ`, `ν`, and `s` on `α`, and a measurable function `f` from `α` to the extended nonnegative real numbers, if `s` is a measure mutually singular to `ν` and `μ` is the sum of `s` and `ν` multiplied by the density of `f`, then `s` is the singular part of `μ` with respect to `ν`. This theorem basically guarantees the uniqueness of the `singularPart` in the Lebesgue decomposition theorem, with the uniqueness of the `rnDeriv` or Radon-Nikodym derivative provided by the theorem `MeasureTheory.Measure.eq_rnDeriv`.

Given a measurable space with measures μ, ν, and s, and a measurable function f: α → [0, ∞], if s is the singular part of μ with respect to ν and μ = s + ν * f's density, then s is the unique singular part of μ with respect to ν.


theorem le_of_fin_injective :
    ∀ (R : Type u) [inst : Semiring R] [inst_1 : StrongRankCondition R] {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R),
      Function.Injective ⇑f → n ≤ m :=
  by sorry

This theorem, named `le_of_fin_injective`, states that for any semiring `R` with a strong rank condition, if we have a linear map `f` from functions from `Fin n` to `R` to functions from `Fin m` to `R`, and this map `f` is injective, then `n` is less than or equal to `m`. In other words, the dimension of the domain of an injective linear map cannot exceed the dimension of the codomain, when the coefficient ring has a strong rank condition.

For any semiring with a strong rank condition, an injective linear map from functions on a finite set of size n to the semiring to functions on a finite set of size m implies n <= m.


theorem LinearMap.det_id :
    ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M],
      LinearMap.det LinearMap.id = 1 :=
  by sorry

This theorem states that for any module `M` over a commutative ring `A`, the determinant of the identity linear map on `M` is `1`. The identity linear map is defined as the map that leaves every element of `M` unchanged. The determinant of a linear map is a generalization of the determinant of a matrix, and in this case, it's similar to how the determinant of the identity matrix is `1`.

For any commutative ring `A` and module `M` over `A`, the determinant of the identity linear map on `M` equals 1.


theorem CategoryTheory.Sieve.pullback_top :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : Y ⟶ X},
      CategoryTheory.Sieve.pullback f ⊤ = ⊤ :=
  by sorry

This theorem states that for any category `C`, and any two objects `X` and `Y` in `C`, and any morphism `f` from `Y` to `X`, the pullback of the top sieve (denoted as ⊤, which includes all morphisms into the object in the category) along `f` is still the top sieve. In other words, the pullback of the maximum (top) sieve through any morphism remains the maximum (top) sieve.

For any category C, any objects X and Y, and morphism f from Y to X, the pullback of the top sieve along f is equal to the top sieve.


theorem RatFunc.ofFractionRing_zero : ∀ {K : Type u} [inst : CommRing K], { toFractionRing := 0 } = 0 := by sorry

This theorem states that for any type `K` that is a commutative ring, the fraction ring of zero is zero. In more mathematical terms, if `K` is a commutative ring, then the rational function mapping to the fraction ring of zero is equal to zero. This is a fundamental property of fraction rings in ring theory.

For any commutative ring `K`, the constant map from `K` to its fraction ring mapping all elements to the fraction `0/1` is equal to the zero homomorphism.


theorem Int.mul_lt_mul_of_pos_left : ∀ {a b c : ℤ}, a < b → 0 < c → c * a < c * b := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `a` is less than `b` and `c` is positive, then the product of `c` and `a` is less than the product of `c` and `b`. In essence, it confirms that multiplication by a positive integer preserves the order of other integers.

For any integers `a` < `b` and positive integer `c`, `c` * `a` < `c` * `b`.


theorem List.nodup_sublists : ∀ {α : Type u} {l : List α}, List.Nodup (List.sublists l) ↔ List.Nodup l := by sorry

The theorem `List.nodup_sublists` states that for any type `α` and list `l` of type `α`, the list of all non-contiguous sublists of `l` has no duplicate elements if and only if the original list `l` has no duplicate elements. In other words, a list and its sublists share the property of either having no duplicate elements or not. This theorem connects the "no duplicates" property of a list to the "no duplicates" property of its sublists.

For any type `α` and list `l` of length `n` over `α`, the list of non-contiguous sublists of `l` has no duplicate elements if and only if `l` itself has no duplicate elements (has length equal to its cardinality).


theorem Polynomial.natTrailingDegree_monomial :
    ∀ {R : Type u} {a : R} {n : ℕ} [inst : Semiring R],
      a ≠ 0 → Polynomial.natTrailingDegree ((Polynomial.monomial n) a) = n :=
  by sorry

The theorem `Polynomial.natTrailingDegree_monomial` states that for any semiring `R`, and any element `a` of `R` and any natural number `n`, if `a` is not zero, then the trailing degree (calculated as a natural number) of the monomial `a * X^n` (represented by `((Polynomial.monomial n) a)`) is `n`. In other words, the natural trailing degree of a nonzero monomial is equal to the power of `X` in that monomial.

The trailing degree of a nonzero monomial `a * X^n` in a semiring equals the natural number `n`.


ContinuousLinearMap.differentiableAt

theorem ContinuousLinearMap.differentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      (e : E →L[𝕜] F) {x : E}, DifferentiableAt 𝕜 (⇑e) x :=
  by sorry

The theorem `ContinuousLinearMap.differentiableAt` states that for any point `x` in a normed vector space `E` over a nontrivially normed field `𝕜`, and for any continuous linear map `e` from `E` to another normed vector space `F` over the same field `𝕜`, the function represented by `e` is differentiable at `x`. In other words, it states that every continuous linear map is differentiable at every point of its domain.

Every continuous linear map between normed vector spaces is differentiable at every point in its domain.


theorem Real.le_toNNReal_iff_coe_le : ∀ {r : NNReal} {p : ℝ}, 0 ≤ p → (r ≤ Real.toNNReal p ↔ ↑r ≤ p) := by sorry

This theorem states that for any non-negative real number `r` and any real number `p` that is greater than or equal to zero, the non-negative real number `r` is less than or equal to the non-negative real number representation of `p` if and only if the real number equivalent of `r` is less than or equal to `p`. In mathematical terms, for all $r \in \text{NNReal}$ and $p \in \mathbb{R}$ with $p \geq 0$, we have $r \leq \text{Real.toNNReal}(p)$ if and only if $r \leq p$.

For any non-negative real number `r` and real number `p` with `p` greater than or equal to zero, `r` is less than or equal to the non-negative real representation of `p` if and only if `r` is less than or equal to `p`. In mathematical notation, for all $r \in \text{NNReal}$ and $p \in \mathbb{R}$ with $p \geq 0$, $r \leq \text{Real.toNNReal}(p) \Leftrightarrow r \leq p$.


theorem Metric.closedBall_diff_ball :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ},
      Metric.closedBall x ε \ Metric.ball x ε = Metric.sphere x ε :=
  by sorry

The theorem `Metric.closedBall_diff_ball` asserts that for any pseudometric space `α`, any point `x` in `α`, and any real number `ε`, the difference between the closed ball centered at `x` with radius `ε` and the open ball centered at `x` with radius `ε` equals the sphere centered at `x` with radius `ε`. In other words, it removes all points within a distance less than `ε` from `x` from the set of points within a distance less than or equal to `ε` from `x`, leaving only the set of points exactly `ε` distance from `x`.

The theorem asserts that in a pseudometric space, the difference between the closed and open balls centered at a point with equal radius is equal to the sphere centered at that point.


theorem Int.ediv_eq_of_eq_mul_right : ∀ {a b c : ℤ}, b ≠ 0 → a = b * c → a / b = c := by sorry

This theorem states that for any three integers 'a', 'b', and 'c', if 'b' is not zero and 'a' is equal to the product of 'b' and 'c', then the integer division of 'a' by 'b' is equal to 'c'. Essentially, it formalizes the intuitive property of division being the reverse operation of multiplication in the context of integers.

If integers $a$, $b$ have $b \neq 0$ and $a = b \cdot c$, then $\frac{a}{b} = c$.


theorem Set.Ioc_diff_right : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, Set.Ioc a b \ {b} = Set.Ioo a b := by
  sorry

The theorem `Set.Ioc_diff_right` states that for any type `α` which has a `PartialOrder` instance and any two elements `a` and `b` of this type, the difference between the left-open right-closed interval from `a` to `b` and the singleton set `{b}` is equal to the left-open right-open interval from `a` to `b`. In other words, if you remove the right endpoint `b` from the interval `(a, b]`, you get the open interval `(a, b)`.

For any type `α` with a `PartialOrder` structure and elements `a` and `b` of `α`, the interval `(a, b]` (left-open right-closed) equals the set difference between `(a, b)` (left-open right-open) and the singleton set `{b}`.


theorem bex_def : ∀ {α : Sort u_1} {p q : α → Prop}, (∃ x, ∃ (_ : p x), q x) ↔ ∃ x, p x ∧ q x := by sorry

This theorem states that for any type `α` and any two properties `p` and `q` that can apply to elements of this type, the assertion that there exists an element `x` of `α` such that `p(x)` holds and `q(x)` holds is logically equivalent to the assertion that there is an element `x` of `α` for which both `p(x)` and `q(x)` hold simultaneously. In other words, it claims that the nested existence quantifiers can be flattened into one existence quantifier followed by a conjunction of properties.

For any type `α` and properties `p` and `q` on `α`, the existence of an element `x` in `α` satisfying both `p(x)` and `q(x)` is logically equivalent to the existence of an element `x` in `α` such that `p(x)` and `q(x)` hold separately.


theorem CategoryTheory.Equivalence.counitInv_functor_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : C),
      CategoryTheory.CategoryStruct.comp (e.counitInv.app (e.functor.obj X)) (e.functor.map (e.unitInv.app X)) =
        CategoryTheory.CategoryStruct.id (e.functor.obj X) :=
  by sorry

This theorem expresses a property of equivalences in category theory. More specifically, given an equivalence `e` between two categories `C` and `D`, and an object `X` of category `C`, the composition of the morphism given by the application of the counit inverse of `e` to the object obtained by applying the functor of `e` to `X`, followed by the morphism obtained by mapping through the functor of `e` the application of the unit inverse of `e` to `X`, is equal to the identity morphism on the object obtained by applying the functor of `e` to `X`. In symbols, if $e : C \simeq D$ is an equivalence of categories and $X$ is an object of $C$, then the composition $e_{\text{counitInv}}(e_{\text{functor}}(X)) \circ e_{\text{functor}}(e_{\text{unitInv}}(X)) = id_{e_{\text{functor}}(X)}$.

Given an equivalence of categories $e : C \simeq D$ and an object $X$ in $C$, the composition of $e_{\text{counitInv}} \circ e_{\text{functor}}(X) \circ e_{\text{unitInv}}(X)$ equals the identity morphism $id_{e_{\text{functor}}(X)}$.


AffineSubspace.SSameSide.symm

/-- **Alias** of the forward direction of `AffineSubspace.sSameSide_comm`. -/
theorem AffineSubspace.SSameSide.symm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y : P},
      AffineSubspace.SSameSide s x y → AffineSubspace.SSameSide s y x :=
  by sorry

The theorem `AffineSubspace.SSameSide.symm` states that for any affine subspace `s` and points `x` and `y`, if `x` and `y` are strictly on the same side of `s`, then `y` and `x` are also strictly on the same side of `s`. This is conducted under the conditions that `R` is a strictly ordered commutative ring, `V` is an additive commutative group, `P` is an affine space over `V` with `R` as scalars, and both `x` and `y` are not in `s`. The theorem thus asserts the symmetry of the relation "being strictly on the same side of a subspace".

If `x` and `y` are strictly on the same side of an affine subspace `s` in an affine space `P` over a strictly ordered commutative ring `R`, then `y` and `x` are also strictly on the same side of `s`.


theorem Ordinal.sub_le_self : ∀ (a b : Ordinal.{u_4}), a - b ≤ a := by sorry

The theorem `Ordinal.sub_le_self` asserts that for any two ordinals `a` and `b` in any universe `u_4`, the difference of `a` and `b` (denoted as `a - b`) is less than or equal to `a`. In other words, subtracting any ordinal `b` from an ordinal `a` will always result in an ordinal that is less than or equal to `a`. This is a formalization of the common mathematical property that for any two numbers, the difference between them is always less than or equal to the original number, adapted for the context of ordinal numbers.

For all ordinals `a` and `b`, `a - b` is less than or equal to `a`.


theorem CategoryTheory.Limits.pullback.condition_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPullback f g] {Z_1 : C} (h : Z ⟶ Z_1),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.fst (CategoryTheory.CategoryStruct.comp f h) =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pullback.snd
          (CategoryTheory.CategoryStruct.comp g h) :=
  by sorry

The theorem `CategoryTheory.Limits.pullback.condition_assoc` states that for any given category `C` and objects `X`, `Y`, `Z`, and `Z_1` in `C`, along with morphisms `f : X ⟶ Z`, `g : Y ⟶ Z`, and `h : Z ⟶ Z_1`, and assuming that `f` and `g` have a pullback, the composition of `pullback.fst` and `(f ≫ h)` is equal to the composition of `pullback.snd` and `(g ≫ h)`. In other words, going from the pullback to `X` via `pullback.fst` and then to `Z_1` via `f ≫ h` is the same as going from the pullback to `Y` via `pullback.snd` and then to `Z_1` via `g ≫ h`. This captures the universal property of the pullback in category theory: it's the unique object that allows us to commute around the square formed by `f`, `g`, and `h`.

Given a category `C`, objects `X`, `Y`, `Z`, and `Z_1`, morphisms `f : X ⟶ Z`, `g : Y ⟶ Z`, and `h : Z ⟶ Z_1`, and assuming the pullback of `f` and `g` exists, then `(pullback.fst ∘ f ≫ h) = (pullback.snd ∘ g ≫ h)`.


theorem DirectSum.of_zero_pow :
    ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
      [inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] (a : A 0) (n : ℕ),
      (DirectSum.of A 0) (a ^ n) = (DirectSum.of A 0) a ^ n :=
  by sorry

The theorem `DirectSum.of_zero_pow` states that for any type `ι` with decidable equality, a function `A : ι → Type`, where each `A i` is an additive commutative monoid, an additive monoid structure on `ι`, a graded semiring structure on `A`, a value `a : A 0`, and a natural number `n`, the image of `a^n` under the natural inclusion map from `A 0` to the direct sum of `A` over `ι` is equal to the `n`-th power of the image of `a` under the same map. In simpler terms, it asserts that the direct sum operation respects the power operation for the zeroth element of the grading.

For any additive commutative monoid `A` indexed by a decidably equal type `ι`, the power `a^n` of the zeroth element `a` in `A` maps to the `n`-th power of its image under the natural inclusion map in the direct sum of `A` over `ι`.


theorem add_one_mul :
    ∀ {α : Type u} [inst : Add α] [inst_1 : MulOneClass α] [inst_2 : RightDistribClass α] (a b : α),
      (a + 1) * b = a * b + b :=
  by sorry

This theorem, `add_one_mul`, states that for any type `α` that has addition, multiplication with one, and right distributivity properties, for any two elements `a` and `b` of that type, the expression `(a + 1) * b` is equal to `a * b + b`. In mathematical terms, this is equivalent to stating the distributive property of multiplication over addition: `(a + 1) * b = a * b + b`.

For any type `α` with additions, multiplications with one, and right distributivity properties, `(a + 1) * b = a * b + b` for all `a, b` in `α`.


theorem map_div_rev :
    ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : Group α]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : GroupSeminormClass F α β] (f : F) (x y : α), f (x / y) = f (y / x) :=
  by sorry

The theorem `map_div_rev` states that for any types `F`, `α`, and `β`, if `F` is a function-like structure from `α` to `β` (`FunLike F α β`), `α` is a group, `β` is an ordered addition commutative monoid, and the class `GroupSeminormClass` is instantiated for `F`, `α`, `β`, then for any instance `f` of type `F` and any elements `x`, `y` of type `α`, the result of applying `f` to the division of `x` by `y` is equal to the result of applying `f` to the division of `y` by `x`. In mathematical terms, $f(x/y) = f(y/x)$ under the given conditions.

Given a function-like structure `F` from a group `α` to an ordered addition commutative monoid `β` with instantiated `GroupSeminormClass`, for all `x`, `y` in `α`, `f(x/y) = f(y/x)`.


theorem CategoryTheory.ShortComplex.exact_iff_of_iso :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C},
      (S₁ ≅ S₂) → (CategoryTheory.ShortComplex.Exact S₁ ↔ CategoryTheory.ShortComplex.Exact S₂) :=
  by sorry

This theorem states that for any category 'C', which has zero morphisms, if there are two short complexes 'S₁' and 'S₂' defined over this category such that 'S₁' is isomorphic to 'S₂', then 'S₁' is exact if and only if 'S₂' is exact. Here, 'exact' refers to the property of a short complex in Category Theory, where the image of each morphism equals the kernel of the next.

In any category with zero morphisms, two isomorphic short complexes are exact if and only if they both are.


theorem div_eq_iff_eq_mul' : ∀ {G : Type u_3} [inst : CommGroup G] {a b c : G}, a / b = c ↔ a = b * c := by sorry

This theorem, `div_eq_iff_eq_mul'`, states that for any type `G` that forms a Commutative Group, and for any elements `a`, `b`, and `c` of this type, the quotient of `a` divided by `b` being equal to `c` is logically equivalent to `a` being equal to the product of `b` and `c`. In mathematical terms, it's saying that $a / b = c$ if and only if $a = b * c$ in the context of a Commutative Group.

In a commutative group, for all elements a, b, and c, a / b = c if and only if a = b * c.


theorem Filter.HasBasis.nhds_closure :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : RegularSpace X] {ι : Sort u_3} {x : X} {p : ι → Prop}
      {s : ι → Set X}, Filter.HasBasis (nhds x) p s → Filter.HasBasis (nhds x) p fun i => closure (s i) :=
  by sorry

This theorem states that for any topological space `X` that is also a regular space, and for any index type `ι`, any point `x` in `X`, and any predicate `p` on `ι` and set-valued function `s` from `ι` to the set of points in `X`, if the neighborhood filter at `x`, `nhds x`, has a basis characterized by the predicate `p` and the set-valued function `s`, then the neighborhood filter at `x` also has a basis characterized by the predicate `p` and the set-valued function that maps each index to the closure of the set `s i`. In simple terms, if a basis of open sets around a point in a regular topological space is given, then the basis remains valid when each open set is replaced by its closure.

In a regular topological space, if the neighborhood filter at a point has a basis characterized by a predicate and a set-valued function, then the basis remains valid with each set replaced by its closure.


theorem Finset.sup'_induction :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α)
      {p : α → Prop},
      (∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)) → (∀ b ∈ s, p (f b)) → p (Finset.sup' s H f) :=
  by sorry

The `Finset.sup'_induction` theorem states that for all types `α` and `β`, where `α` is a join-semilattice, given a non-empty finite set `s` of type `β`, a function `f` mapping from `β` to `α`, and a property `p` that applies to elements of `α`, if `p` holds for all pairs of elements `a₁` and `a₂` such that `p` holds for both `a₁` and `a₂` separately and `p` holds for their supremum `a₁ ⊔ a₂`, and if `p` holds for all elements of the image of `s` under `f`, then `p` indeed holds for the supremum of the image of `s` under `f`. In simpler terms, the theorem provides a method of proof by induction on properties of the supremum of a function applied to elements of a finite set.

Given a join-semilattice `α`, a non-empty finite set `s` of type `β`, a function `f` from `β` to `α`, and a property `p` that respects the join operation, if `p` holds for all elements of `s` and their images under `f`, and for all pairs of elements in `s` whose supremum exists, then `p` holds for the supremum of the images of `s` under `f`.


theorem Ideal.map_eq_bot_iff_le_ker :
    ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
      [rc : RingHomClass F R S] {I : Ideal R} (f : F), Ideal.map f I = ⊥ ↔ I ≤ RingHom.ker f :=
  by sorry

The theorem `Ideal.map_eq_bot_iff_le_ker` states that for any semirings `R` and `S`, a function `f` of type `F` which behaves like a function from `R` to `S`, and a ring homomorphism class for `F`, `R`, and `S`, an ideal `I` of `R`, and the homomorphism `f`, the image of `I` under `f` is the trivial ideal if and only if `I` is a subset of the kernel of `f`. Here, the kernel of a ring homomorphism is the ideal consisting of all elements that map to the additive identity in the target ring.

For any semirings R and S, ring homomorphism f, and ideal I of R, the image of I under f is the trivial ideal if and only if I is contained in the kernel of f.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.19 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by
  sorry

This theorem, `Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.19`, states that for any three propositions `a`, `b`, and `c`, the proposition "`a` and `b` imply `c`" is equivalent to the proposition "`a` implies that `b` implies `c`". In other words, if `a` and `b` are true, then `c` must also be true; this is the same as stating that if `a` is true, then if `b` is also true, `c` must be true. This captures a fundamental property of logical implication.

The theorem `Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.19` in Lean 4 states that the implications `(a ⟹ b) ⟹ c` and `a ⟹ (b ⟹ c)` are logically equivalent.


theorem Nat.succ_ascFactorial : ∀ (n k : ℕ), n * Nat.ascFactorial (Nat.succ n) k = (n + k) * Nat.ascFactorial n k := by
  sorry

This theorem states that for any natural numbers `n` and `k`, the product of `n` and the ascending factorial of `n+1` and `k` equals the product of `n+k` and the ascending factorial of `n` and `k`. Here, the ascending factorial `Nat.ascFactorial n k` is defined as the product `n * (n + 1) * ... * (n + k - 1)`.

For all natural numbers `n` and `k`, the product of `n` with the ascending factorial of `n+1` and `k` equals the product of `n+k` with the ascending factorial of `n` and `k`. In other words, `n * Nat.ascFactorial (n+1) k = (n+k) * Nat.ascFactorial n k`.


theorem Mathlib.Combinatorics.SimpleGraph.Subgraph._auxLemma.23 :
    ∀ {V : Type u} {G : SimpleGraph V} (v : V) (H : SimpleGraph.Subgraph G),
      (SimpleGraph.singletonSubgraph G v ≤ H) = (v ∈ H.verts) :=
  by sorry

This theorem states that for any type `V`, any simple graph `G` of type `V`, any vertex `v` of type `V`, and any subgraph `H` of `G`, the singleton subgraph of `G` containing only the vertex `v` is a subgraph of `H` if and only if `v` is a vertex in `H`. In other words, it defines the condition for a one-vertex subgraph to be a subgraph of another given subgraph.

For any simple graph G of type V, vertex v of type V, and subgraph H of G, the singleton subgraph of G containing only vertex v is a subgraph of H if and only if v is a vertex in H.


theorem Fintype.card_option : ∀ {α : Type u_4} [inst : Fintype α], Fintype.card (Option α) = Fintype.card α + 1 := by
  sorry

The theorem `Fintype.card_option` states that for any type `α` (assumed to be a finite type, or `Fintype`), the cardinality of the type `Option α` (that is, the number of distinct elements it can have) is equal to the cardinality of `α` plus one. This makes sense because the `Option α` type includes all the values of `α` plus the additional `None` value.

The cardinality of `Option α` is equal to the cardinality of `α` plus one, where `α` is a finite type.


theorem CategoryTheory.MorphismProperty.RespectsIso.of_respects_arrow_iso :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C),
      (∀ (f g : CategoryTheory.Arrow C), (f ≅ g) → P f.hom → P g.hom) → CategoryTheory.MorphismProperty.RespectsIso P :=
  by sorry

The theorem `CategoryTheory.MorphismProperty.RespectsIso.of_respects_arrow_iso` states that for any category `C` and any morphism property `P` in `C`, if for every pair of objects `f` and `g` in the arrow category of `C`, the property `P` is preserved under isomorphism (that is, whenever `f` is isomorphic to `g`, the property `P` holding for the homomorphism of `f` implies that it also holds for the homomorphism of `g`), then the morphism property `P` respects isomorphisms in the original category `C`. In other words, if a property of morphisms holds when we move to isomorphic objects in the arrow category, then it will also hold when we compose with isomorphisms in the original category.

If a morphism property in a category is preserved under isomorphisms in the arrow category, then it is a morphism property in the original category.


LocallyBoundedMap.ext

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

This theorem states that for any two locally bounded maps `f` and `g` from a type `α` with a bornology to a type `β` also with a bornology, if the maps `f` and `g` are equal for all elements of type `α`, then `f` and `g` themselves are equal. In mathematical terms, if two locally bounded maps have the same effect on all elements of their domain, they are, in fact, the same map.

If two locally bounded maps from a bornology-equipped type to another bornology-equipped type agree on all elements, they are equal.


theorem compl_sup_distrib : ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a b : α), (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ := by sorry

This theorem, `compl_sup_distrib`, states that for any type `α` that has a structure of Heyting Algebra, and for any two elements `a` and `b` of that type, the complement of the supremum (or join) of `a` and `b`, denoted as `(a ⊔ b)ᶜ`, is equal to the infimum (or meet) of the complements of `a` and `b`, denoted as `aᶜ ⊓ bᶜ`. In simpler terms, it means that the negation of the logical 'or' of two propositions is equivalent to the logical 'and' of their negations. This is a formulation of De Morgan's law in the context of Heyting algebra.

In a Heyting algebra, the complement of the join (supremum) of two elements is equal to the meet (infimum) of their complements. (De Morgan's law)


theorem OmegaCompletePartialOrder.le_ωSup_of_le :
    ∀ {α : Type u} [inst : OmegaCompletePartialOrder α] {c : OmegaCompletePartialOrder.Chain α} {x : α} (i : ℕ),
      x ≤ c i → x ≤ OmegaCompletePartialOrder.ωSup c :=
  by sorry

This theorem states that for any type `α` that has an `OmegaCompletePartialOrder` structure, given a chain `c` from this type and an element `x` from the same type, if `x` is less than or equal to the `i`th element of the chain `c`, then `x` will also be less than or equal to the supremum of the chain `c`. Here, a chain is defined as a monotone (non-decreasing) sequence of elements from `α`, and the supremum of a chain is the least upper bound of all elements in that chain.

For any chain `c` in an `OmegaCompletePartialOrder` type `α`, and any `x` in `α` less than or equal to the `i`th element of `c`, we have `x ≤ sup c`.


/-- The closure of the interval `(a, +∞)` is the closed interval `[a, +∞)`, unless `a` is a top
element.  -/
theorem closure_Ioi' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst_3 : DenselyOrdered α] {a : α}, Set.Nonempty (Set.Ioi a) → closure (Set.Ioi a) = Set.Ici a :=
  by sorry

This theorem states that the closure of the interval `(a, +∞)` is equivalent to the closed interval `[a, +∞)`, unless `a` is a top element. The closure of a set in topology is the smallest closed set that contains the set. Here, the set is an interval of all real numbers greater than `a`. This is true given that the interval `(a, +∞)` is not empty, and under the conditions that we have a topological space, a linear order, an order topology, and a densely ordered set. A densely ordered set is one where between any two distinct elements there's always another one. In essence, no matter how close two elements in the set are, there's always another element in between.

The closure of the open interval (a, +∞) in a densely ordered topological space equals the closed interval [a, +∞) if and only if a is not the top element.


theorem UpperSet.coe_iSup :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → UpperSet α), ↑(⨆ i, f i) = ⋂ i, ↑(f i) := by sorry

This theorem states that for any type `α` and any type `ι`, given a function `f` from `ι` to the upper sets of `α`, the supremum of the image of `f` (`⨆ i, f i`) is equal to the intersection of the images of `f` (`⋂ i, ↑(f i)`). Here, `⨆` denotes the supremum, `⋂` denotes the intersection, and `↑` denotes the coe function which converts `UpperSet α` to `Set α`. This is in the context of `α` being a type with a less than or equal to relation (`LE α`).

For any type `α` with a less than or equal to relation and any function `f` from type `ι` to the upper sets of `α`, the supremum of `f` is equal to the intersection of the images of `f` taken pointwise and converted to sets.


theorem Function.id_def : ∀ {α : Sort u_1}, id = fun x => x := by sorry

This theorem states that for all types `α`, the identity function `id` is equivalent to the function that takes an input `x` and returns `x`. In other words, the theorem formalizes the definition of the identity function: a function that returns its input unchanged.

For all types `α`, the identity function `id : α → α` is equal to the function that maps each `x : α` to `x`.


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

This theorem, named `Function.Bijective.sum_comp`, states that for all types ι, κ, and α where ι and κ are finite types and α is a type with a commutative addition operation, for any bijective function `e` mapping elements of type ι to κ, and for any function `g` mapping elements of type κ to α, the sum of function `g` applied to the image of each element in the universal set of ι under `e` is equal to the sum of function `g` applied to each element in the universal set of κ. In other words, when `e` is a bijection, rearranging the elements of the finite sets using `e` doesn't change the total sum when applying the function `g`.

For any bijective function between finite types and a commutative additive type, the sum of the function applied to the images of the elements under the bijection equals the sum of the function applied to the elements themselves.


theorem Submodule.injective_subtype :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M), Function.Injective ⇑(Submodule.subtype p) :=
  by sorry

This theorem states that for any given semiring `R`, an additive commutative monoid `M` and a module `M` over `R`, any submodule `p` of `M`, the function that embeds the submodule `p` into the ambient space `M` is injective. In mathematical terms, if we denote this embedding function as `f`, then for any two elements `x` and `y` in `p`, if `f(x) = f(y)` then `x = y`. This means that the embedding perfectly retains the distinctness of the elements in the submodule when they are mapped to the larger ambient space `M`.

The embedding of a submodule of an `R`-module into the ambient space is an injective function.


theorem List.cons_union :
    ∀ {α : Type u_1} [inst : BEq α] (a : α) (l₁ l₂ : List α), a :: l₁ ∪ l₂ = List.insert a (l₁ ∪ l₂) := by sorry

This theorem, `List.cons_union`, asserts that for any given type `α` equipped with a boolean equality operation, and any element `a` of this type along with two lists `l₁` and `l₂` of the same type, the union of the list created by prepending `a` to `l₁` with `l₂` is equal to the result of first taking the union of `l₁` and `l₂`, and then inserting `a` into the resulting list (without duplication). The theorem takes into account the fact that inserting an element that is already present in the list doesn't change the list.

For any type `α` with equality, list `l₁`, list `l₂`, and element `a`, the list obtained by prepending `a` to `l₁` and then taking the union with `l₂` equals the union of `l₁` and `l₂` followed by the insertion of `a` without duplication.


theorem EReal.embedding_coe_ennreal : Embedding ENNReal.toEReal := by sorry

The theorem `EReal.embedding_coe_ennreal` asserts that the function `ENNReal.toEReal` is an embedding. In other words, it establishes that the function `ENNReal.toEReal`, which maps nonnegative extended real numbers to extended real numbers, is an injection (one-to-one) and preserves the structure of the set, i.e. if two elements in the domain are related, their images in the codomain are also related in the same way. This property plays a crucial role in preserving the mathematical structure when transitioning from the set of nonnegative extended real numbers to the set of extended real numbers.

The `ENNReal.toEReal` function is a strict monotonically increasing embedding from non-negative extended real numbers to extended real numbers.


/-- In a Banach-algebra `𝔸` over a normed field `𝕂` of characteristic zero, if `x` and `y` are
in the disk of convergence and commute, then `exp 𝕂 (x + y) = (exp 𝕂 x) * (exp 𝕂 y)`.  -/
theorem NormedSpace.exp_add_of_commute_of_mem_ball :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕂 𝔸] [inst_3 : CompleteSpace 𝔸] [inst_4 : CharZero 𝕂] {x y : 𝔸},
      Commute x y →
        x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸)) →
          y ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸)) →
            NormedSpace.exp 𝕂 (x + y) = NormedSpace.exp 𝕂 x * NormedSpace.exp 𝕂 y :=
  by sorry

The theorem `NormedSpace.exp_add_of_commute_of_mem_ball` states that in a Banach algebra 𝔸 over a normed field 𝕂 of characteristic zero, if two elements `x` and `y` commute (i.e., `x * y = y * x`) and both belong to the disc of convergence (i.e., the set of all points `z` for which the Euclidean distance from `z` to the origin is less than the radius of convergence of the exponential series), then the exponential of their sum is equal to the product of their exponentials. In other words, `exp 𝕂 (x + y) = (exp 𝕂 x) * (exp 𝕂 y)`.

In a Banach algebra over a characteristic zero normed field, if two commuting elements belong to the disc of convergence, then their exponentials commute and their product is the exponential of their sum.


theorem CategoryTheory.IsPushout.of_horiz_isIso :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P}
      {inr : Y ⟶ P} [inst_1 : CategoryTheory.IsIso f] [inst_2 : CategoryTheory.IsIso inr],
      CategoryTheory.CommSq f g inl inr → CategoryTheory.IsPushout f g inl inr :=
  by sorry

This theorem states that in any category `C` with objects `Z`, `X`, `Y`, and `P`, and morphisms `f : Z ⟶ X`, `g : Z ⟶ Y`, `inl : X ⟶ P`, and `inr : Y ⟶ P`, if `f` and `inr` are isomorphisms and the diagram composed of these morphisms commutes, then the diagram is a pushout in the category. In category theory, a pushout is a kind of limit which can be thought of as a way of "gluing" objects together along a shared part.

Given any commutative diagram of isomorphisms in a category with objects Z, X, Y, and P, where inl : X ⟶ P and inr : Y ⟶ P are the inclusion morphisms of a coproduct, if f : Z ⟶ X and g : Z ⟶ Y are the coproduct's unique coprojections, then this diagram is a pushout.


ContMDiffOn.continuousOn

theorem ContMDiffOn.continuousOn :
    ∀ {𝕜 : 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}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {s : Set M} {n : ℕ∞}, ContMDiffOn I I' n f s → ContinuousOn f s :=
  by sorry

This theorem states that if `f` is a function from a manifold `M` to another manifold `M'`, and `f` is continuously differentiable up to order `n` within a set `s` in `M`, then `f` is continuous on `s`. Here, `𝕜` represents the underlying field (which is a normed field), `E` and `E'` are the normed vector spaces associated with the manifolds, and `H` and `H'` are the model spaces of the manifolds. The manifolds `M` and `M'` are equipped with topologies and are also charted, meaning they have associated atlas of charts. The `ModelWithCorners` objects `I` and `I'` supply the differential structure on `M` and `M'`.

If `f` is a continuously differentiable up to order `n` function from a manifold `M` to another manifold `M'` over a normed field, then `f` is continuous on every set `s` in `M`.


theorem star_sub :
    ∀ {R : Type u} [inst : AddGroup R] [inst_1 : StarAddMonoid R] (r s : R), star (r - s) = star r - star s := by sorry

This theorem, `star_sub`, states that for any type `R` where `R` is an additive group and a star-additive monoid, for any elements `r` and `s` of `R`, the star of the difference between `r` and `s` is equal to the difference between the star of `r` and the star of `s`. In mathematical terminology, it says that the star operation, a kind of unary operation, distributes over subtraction in this specific algebraic structure.

For any additive group and star-additive monoid `R`, the star operation distributes over subtraction, that is, `*(r - s) = *r - *s` for all `r, s ∈ R`.


theorem Set.Ioc_subset_Iic_self : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b ⊆ Set.Iic b := by sorry

The theorem `Set.Ioc_subset_Iic_self` states that for any type `α` that has a preorder relation, and for any two elements `a` and `b` of this type, the left-open right-closed interval from `a` to `b` is a subset of the right-closed interval extending to negative infinity at `b`. In mathematical terms, this means that for all `x` such that `a < x ≤ b`, we also have `x ≤ b`.

For any type `α` with a preorder relation and any `a, b ∈ α` with `a < b`, the left-open right-closed interval `[a, b)` is subset of the right-closed interval `[a, b]`.


theorem Localization.add_mk :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (a : R) (b : ↥M) (c : R) (d : ↥M),
      Localization.mk a b + Localization.mk c d = Localization.mk (↑b * c + ↑d * a) (b * d) :=
  by sorry

The `Localization.add_mk` theorem states that for any commutative semiring `R` and any submonoid `M` of `R`, given elements `a` and `c` of `R`, and `b` and `d` from `M`, the sum of the localizations of `a` at `b` and `c` at `d` is the localization of `bc + da` at the product `bd`. In other words, the theorem articulates how addition works in the localization of a commutative ring at a submonoid.

For any commutative semiring R and submonoid M, the localization of (bc + da) at bd is the sum of the localizations of a at b and c at d in R.


/-- This is the same as `orderOf_pow'` and `orderOf_pow''` but with one assumption less which is
automatic in the case of a finite cancellative monoid. -/
theorem orderOf_pow :
    ∀ {G : Type u_1} [inst : LeftCancelMonoid G] [inst_1 : Finite G] {n : ℕ} (x : G),
      orderOf (x ^ n) = orderOf x / Nat.gcd (orderOf x) n :=
  by sorry

This theorem, `orderOf_pow`, states that for any type `G` that is a left cancelable monoid and finite, for any natural number `n`, and for any element `x` of type `G`, the order of `x` to the power of `n` is equal to the order of `x` divided by the greatest common divisor of the order of `x` and `n`. In simpler terms, raising an element of a finite cancelable monoid to a power changes the order of that element to the original order divided by the greatest common divisor of the original order and the exponent.

For any finite, left cancelable monoid `G` and its element `x` with finite order, the order of `x` raised to the power `n` equals the order of `x` divided by the greatest common divisor of their orders.


theorem Set.preimage_neg_Ioi : ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] (a : α), -Set.Ioi a = Set.Iio (-a) := by
  sorry

This theorem, `Set.preimage_neg_Ioi`, states that for any type `α` that has an ordered additive commutative group structure, for any element `a` of `α`, the negation of the set of all elements greater than `a` (`-Set.Ioi a`) is equal to the set of all elements less than `-a` (`Set.Iio (-a)`). In other words, if you take all the numbers greater than a certain value, negate them, you end up with all of the numbers less than the negation of that value.

For any ordered additive commutative group `α` and element `a` in `α`, `-Set.Ioi a = Set.Iio (-a)`. In other words, the negative of the set of elements strictly greater than `a` is equal to the set of elements strictly less than `-a`.


theorem Mathlib.Algebra.Function.Indicator._auxLemma.8 :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {s : Set α} {f : α → M} {a : α},
      (Set.mulIndicator s f a = 1) = (a ∈ s → f a = 1) :=
  by sorry

This theorem states that for any set `s` of type `α` and any function `f : α → M`, where `M` is a type with an identity element `1`, the `Set.mulIndicator` of `s`, `f`, and a particular element `a` of `α` equals `1` if and only if `a` is an element of `s` and the function `f` applied to `a` equals `1`. In other words, the `Set.mulIndicator` returns `1` when `a` is in `s` and `f(a)` is `1`, and otherwise it returns the value of `f` at `a`.

For any set `s` of type `α` and function `f : α → M` with `M` having an identity element `1`, `Set.mulIndicator s f a = 1` if and only if `a` is in `s` and `f a = 1`.


theorem symmetrizeRel_subset_self : ∀ {α : Type ua} (V : Set (α × α)), symmetrizeRel V ⊆ V := by sorry

This theorem states that for any type `α` and any set `V` of pairs of elements of type `α`, the symmetrized version of `V` is a subset of `V` itself. Here, "symmetrizing" a set of pairs means taking the intersection of the set with the set of pairs obtained by swapping the elements in each pair from the original set. In mathematical terms, given a set of ordered pairs `(a, b)`, its symmetrized version contains pairs `(a, b)` and `(b, a)` as long as both pairs are in the original set `V`.

For any set `V` of pairs of elements from type `α`, the symmetrized version of `V` (i.e., `V` intersect the set of swapped pairs) is a subset of `V`.


theorem Set.toFinset_diff :
    ∀ {α : Type u_1} (s t : Set α) [inst : DecidableEq α] [inst_1 : Fintype ↑s] [inst_2 : Fintype ↑t]
      [inst_3 : Fintype ↑(s \ t)], Set.toFinset (s \ t) = Set.toFinset s \ Set.toFinset t :=
  by sorry

The theorem `Set.toFinset_diff` states that for any type `α` and for any two sets `s` and `t` of this type, given that `α` has decidable equality, and that the sets `s`, `t`, and the difference `s \ t` are finite, the conversion to a finset of the difference set `s \ t` is equal to the difference of the finsets obtained from `s` and `t`. In other words, converting the difference of two sets to a finset gives the same result as taking the difference of the finsets obtained from the individual sets.

For types `α` with decidable equality and finite sets `s` and `t` of `α`, the conversion of `(s \ t)` to a finset is equal to `(finset.fromFunc (λ x => if h : x ∈ s then some x else none) s) `\` (finset.fromFunc (λ x => some x) t)`.


theorem Ordinal.derivFamily_zero :
    ∀ {ι : Type u} (f : ι → Ordinal.{max u v} → Ordinal.{max u v}), Ordinal.derivFamily f 0 = Ordinal.nfpFamily f 0 :=
  by sorry

This theorem states that for any type `ι` and any family of functions `f` from `ι` to the ordinals, the derivative of the family of functions at 0 is equal to the next common fixed point of the family of functions at 0. In other words, if you have a collection of functions (indexed by `ι`) that take ordinals to ordinals, then if you apply the derivative operator to this family at the ordinal 0, you get the same ordinal as if you had computed the next common fixed point of the family at 0.

For any type `ι` and family of ordinal-valued functions `f` from `ι` to ordinals, the derivative of `f` at 0 is equal to the next common fixed point of `f` at 0.


theorem Nat.testBit_bit_succ : ∀ (m : ℕ) (b : Bool) (n : ℕ), Nat.testBit (Nat.bit b n) (Nat.succ m) = Nat.testBit n m :=
  by sorry

This theorem states that for any natural numbers `m` and `n`, and any Boolean `b`, testing the `(m+1)`-th least significant bit of the number obtained by appending the digit `b` to the binary representation of `n`, is the same as testing the `m`-th least significant bit of `n` itself. This property reflects how binary numbers are constructed: adding a new least significant bit shifts the positions of all the other bits.

For all natural numbers m, n, and Boolean values b, the (m+1)th least significant bit of the binary representation of n with the digit b appended is equivalent to the mth least significant bit of n.


theorem Fintype.card_unique : ∀ {α : Type u_1} [inst : Unique α] [h : Fintype α], Fintype.card α = 1 := by sorry

The theorem `Fintype.card_unique` states that for any type `α` which is both unique and a finite type (i.e., it has a finite number of elements), the cardinality of `α` (denoted by `Fintype.card α`) is equal to 1. In other words, any type that is unique and finite has exactly one element.

For any unique and finite type `α`, its cardinality equals 1, i.e., `Fintype.card α = 1`.


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

The theorem `Disjoint.eq_bot_of_le` states that for any partial order with a bottom element, if two elements `a` and `b` are disjoint, and `a` is less than or equal to `b`, then `a` must be equal to the bottom element.

This theorem generalizes the concept of disjointness: in a lattice, two elements are considered disjoint if their greatest lower bound (infimum) is the bottom element. In this context, if one of the disjoint elements is also less than or equal to the other, it must be the bottom element itself.

In a partial order with a bottom element, if two disjoint elements `a` and `b` satisfy `a ≤ b`, then `a` is equal to the bottom element.


List.IsSuffix.isInfix

theorem List.IsSuffix.isInfix : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂ := by sorry

The theorem `List.IsSuffix.isInfix` states that for any type `α` and any two lists `l₁` and `l₂` of type `α`, if `l₁` is a suffix of `l₂` then `l₁` is also an infix of `l₂`. In other words, if list `l₁` appears at the end of `l₂`, then it is also true that `l₁` appears somewhere within `l₂` (including at the end).

If `l₁` is a suffix of `l₂`, then `l₁` is also an infix of `l₂`. In other words, if the list `l₁` appears at the end of the list `l₂`, then `l₁` also appears somewhere within `l₂`.


theorem mul_nsmul' : ∀ {M : Type u} [inst : AddMonoid M] (a : M) (m n : ℕ), (m * n) • a = m • n • a := by sorry

This theorem states that for any type `M` that forms an additive monoid, and for any element `a` of type `M` and any natural numbers `m` and `n`, the operation of scalar multiplication (denoted by `•`) satisfies the property that multiplying `m` and `n` and then scalar multiplying `a` is equivalent to first scalar multiplying `a` by `n` and then scalar multiplying the result by `m`. This can be viewed as a kind of associative law for scalar multiplication by natural numbers in an additive monoid.

For any additive monoid type `M` and its element `a`, and natural numbers `m` and `n`, the scalar multiplication operation `•` satisfies the property that `(m * n) • a = m • (n • a)`.


theorem Complex.arg_coe_angle_toReal_eq_arg : ∀ (z : ℂ), Real.Angle.toReal ↑(Complex.arg z) = Complex.arg z := by sorry

This theorem states that for any complex number `z`, when you take the argument of `z` (denoted as `Complex.arg z`), convert it to a `Real.Angle` and then convert it back to a real number using `Real.Angle.toReal`, you will get the original argument of `z`. In other words, the operations of converting from the argument of a complex number to a `Real.Angle` and then back to a real number is lossless, returning the initial argument of the complex number.

The theorem asserts that for any complex number `z`, the conversion `Real.Angle.toReal (Complex.arg z)` equals `Complex.arg z`.


theorem continuous_right_toIcoMod :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedAddCommGroup 𝕜] [inst_1 : Archimedean 𝕜] [inst_2 : TopologicalSpace 𝕜]
      [inst_3 : OrderTopology 𝕜] {p : 𝕜} (hp : 0 < p) (a x : 𝕜), ContinuousWithinAt (toIcoMod hp a) (Set.Ici x) x :=
  by sorry

This theorem states that for any linear ordered additive commutative group `𝕜` (which is also Archimedean and a topological space under an order topology) and any positive real number `p`, the function `toIcoMod` with parameters `hp` and `a`, is continuous at any point `x` within the interval from `x` to positive infinity (denoted by `Set.Ici x`).

In mathematical terms, as `x` approaches a certain value within the specified interval, the value of `toIcoMod hp a` (which reduces the input to the interval `[a, a+p)`) also approaches its value at that certain value. This essentially encapsulates the idea of continuity within a specific range in the context of topological spaces.

For any Archimedean, additively commutative, topological linear ordered group `𝕜` and positive real number `p`, the function `toIcoMod` with parameters `hp` and `a` is continuous on `Set.Ici x` for any `x`.


theorem inf_sdiff_self_left : ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], y \ x ⊓ x = ⊥ := by sorry

This theorem states that for any type `α` which forms a Generalized Boolean Algebra, and any elements `x` and `y` of this type, the infimum (greatest lower bound) of the difference of `y` and `x` and `x` itself is the bottom element of the algebra. In simpler terms, it's saying if you take `x` away from `y` and then take the intersection with `x`, you end up with the least possible value in the whole set.

For any type `α` forming a Generalized Boolean Algebra and any `x, y` in `α`, the infimum of `y - x` and `x` is the lattice bottom element.


theorem HomogeneousLocalization.one_val :
    ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : AddCommMonoid ι] [inst_1 : DecidableEq ι]
      [inst_2 : CommRing R] [inst_3 : CommRing A] [inst_4 : Algebra R A] {𝒜 : ι → Submodule R A}
      [inst_5 : GradedAlgebra 𝒜] {x : Submonoid A}, HomogeneousLocalization.val 1 = 1 :=
  by sorry

The theorem `HomogeneousLocalization.one_val` states that for any types `ι`, `R`, and `A`, where `ι` is an additive commutative monoid and `R` and `A` are commutative rings, and `A` is an `R`-algebra, and for any function `𝒜` from `ι` to the submodules of `R` in `A`, such that `𝒜` forms a graded algebra, and any submonoid `x` of `A`, the value function applied to the number one in the homogeneous localization of `𝒜` at `x` results in the number one. This theorem essentially asserts that the value function preserves the identity element under homogeneous localization.

For any graded algebra 𝒜 from an additive commutative monoid ι to the submodules of an R-algebra A over a commutative ring R, the value function applied to one in the homogeneous localization of 𝒜 at any submonoid x is the identity element.


/-- A null measurable set `t` is Carathéodory measurable: for any `s`, we have
`μ (s ∩ t) + μ (s \ t) = μ s`.  -/
theorem MeasureTheory.measure_inter_add_diff₀ :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {t : Set α} (s : Set α),
      MeasureTheory.NullMeasurableSet t μ → ↑↑μ (s ∩ t) + ↑↑μ (s \ t) = ↑↑μ s :=
  by sorry

The theorem `MeasureTheory.measure_inter_add_diff₀` states that for any type `α` equipped with a measurable space `m0` and a measure `μ`, and for any set `t` of this type that is null measurable, for all sets `s` of this type, the measure of the intersection of `s` and `t` plus the measure of the difference of `s` and `t` is equal to the measure of `s`. In mathematical terms, this is stating that a null measurable set `t` satisfies the property of Carathéodory measurability, which is expressed as `μ (s ∩ t) + μ (s \ t) = μ s` for any set `s`.

For any null measurable set `t` in a measurable space `(α, m0, μ)`, the measure of the intersection of `t` with any set `s` plus the measure of the difference between `s` and `t` equals the measure of `s`. That is, `μ (s ∩ t) + μ (s \ t) = μ s`.


theorem Set.preimage_inl_image_inr : ∀ {α : Type u_1} {β : Type u_2} (s : Set β), Sum.inl ⁻¹' (Sum.inr '' s) = ∅ := by
  sorry

The theorem `Set.preimage_inl_image_inr` states that for any set `s` of type `β`, the preimage of the image of `s` under the `Sum.inr` function with respect to the `Sum.inl` function is the empty set. In other words, there are no elements in any set of type `α` that, when the `Sum.inl` function is applied, result in an element in the image of `s` under `Sum.inr`. This is essentially saying that there is no overlap between the sets `Sum.inl α` and `Sum.inr s`.

For any set `s` of type `β`, the preimage of `Sum.image (Sum.inr : α × β → β) s` under `Sum.inl : α × β → α` is the empty set.