CategoryTheory.leOfHom

/-- Extract the underlying inequality from a morphism in a preorder category.
 -/
theorem CategoryTheory.leOfHom : ∀ {X : Type u} [inst : Preorder X] {x y : X}, (x ⟶ y) → x ≤ y := by sorry

This theorem states that for any given types `X` in a preorder category, where `X` is equipped with a preorder relation, if there exists a morphism from `x` to `y` (written as `x ⟶ y`), then `x` is less than or equal to `y` (written as `x ≤ y`). In other words, in the context of a preorder category, the existence of a morphism from `x` to `y` guarantees that `x` is at most `y` according to the preorder relation.

In a preorder category, the existence of a morphism from `x` to `y` implies `x ≤ y`.


/-- Any two morphisms from an initial object are equal.  -/
theorem CategoryTheory.Limits.IsInitial.hom_ext :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C},
      CategoryTheory.Limits.IsInitial X → ∀ (f g : X ⟶ Y), f = g :=
  by sorry

This theorem states that in any category `C`, if `X` is an initial object, then any two morphisms from `X` to another object `Y` in the category must be equal. Here, "initial object" refers to an object in the category for which there exists exactly one morphism to every object in the category.

In any category, if there exists a unique morphism from the initial object to every object, then any two morphisms from the initial object to an arbitrary object are equal.


theorem WithBot.coe_lt_coe : ∀ {α : Type u_1} {a b : α} [inst : LT α], ↑a < ↑b ↔ a < b := by sorry

This theorem, `WithBot.coe_lt_coe`, states that for any type `α` and any two elements `a` and `b` of that type, where the type has a less-than (`LT`) relation defined on it, the proposition "`a` is less than `b`" is equivalent to the proposition "the coerced value of `a` is less than the coerced value of `b`". Here, the coercion refers to the process of embedding `α` into the type `WithBot α`, which adjoins an additional 'bottom' element to `α`.

For any type `α` with a less-than relation and any `a` and `b` in `α`, `a < b` if and only if `coe (WithBot.coerce a) < coe (WithBot.coerce b)` in the type `WithBot α`.


theorem Mathlib.Algebra.Order.ZeroLEOne._auxLemma.1 :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [inst_3 : ZeroLEOneClass α], (0 ≤ 1) = True := by
  sorry

This theorem, named `Mathlib.Algebra.Order.ZeroLEOne._auxLemma.1`, states that for any type `α` which is equipped with a zero element, a one element, a less than or equal to (`LE`) operation, and belongs to the `ZeroLEOneClass` (which requires that zero is less than or equal to one in the type), the proposition that zero is less than or equal to one (`0 ≤ 1`) is always true. Essentially, this theorem formalizes the common mathematical understanding that 0 is less than or equal to 1.

For any type with a zero, one, and the `ZeroLEOne` structure, zero is less than or equal to one.


theorem Pi.zero_apply : ∀ {I : Type u} {f : I → Type v₁} (i : I) [inst : (i : I) → Zero (f i)], 0 i = 0 := by sorry

This theorem, `Pi.zero_apply`, states that for any type `I`, any function `f` mapping elements of `I` to some other type, and any element `i` of `I`, if each `f i` is equipped with a zero element, then applying the zero function to `i` results in the zero of `f i`. In mathematical terms, if we have a function `f` from `I` to some other type such that each `f(i)` has a zero, then the zero at `f(i)` is the same as the zero element of `f(i)`.

For any type `I` and function `f` from `I` to a type with zero elements, the application of the zero function to an element `i` of `I` results in the zero of `f i`. In other words, `zero_apply f i = f i zero`.


theorem inf_eq_right : ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b = b ↔ b ≤ a := by sorry

This theorem states that for any semilattice of type `α` and any elements `a` and `b` of type `α`, the infimum (greatest lower bound) of `a` and `b` equals to `b` if and only if `b` is less than or equal to `a`. In other words, `b` is the infimum of `α` and `b` precisely when `b` is less than or equal to `a`.

For any semilattice `α`, the infimum of `a` and `b` equals `b` if and only if `b` is less than or equal to `a`.


theorem Filter.HasBasis.tendsto_right_iff :
    ∀ {α : Type u_1} {β : Type u_2} {ι' : Sort u_5} {la : Filter α} {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β}
      {f : α → β},
      Filter.HasBasis lb pb sb → (Filter.Tendsto f la lb ↔ ∀ (i : ι'), pb i → ∀ᶠ (x : α) in la, f x ∈ sb i) :=
  by sorry

The theorem `Filter.HasBasis.tendsto_right_iff` states that for any types `α` and `β`, any type of indexing `ι'`, any filter on `α` denoted by `la`, any filter on `β` denoted by `lb`, any property `pb` indexed by `ι'`, any set `sb` of `β` indexed by `ι'`, and any function `f` from `α` to `β`, if `lb` has a basis described by the property `pb` and the corresponding sets `sb`, then the function `f` tends towards the filter `lb` from `la` if and only if for every index `i` of type `ι'` where the property `pb` holds, almost all elements `x` from `α` in the filter `la` satisfy the condition that `f(x)` belongs to the set `sb` at index `i`.

In more mathematical terms, this theorem provides a characterization for the convergence of a function towards a particular filter in terms of the basis of that filter.

A function from a filter to another filter converges to the second filter from the first if and only if almost all elements in the first filter map to elements in the corresponding sets of the basis of the second filter.


Function.Bijective.injective

theorem Function.Bijective.injective :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → Function.Injective f := by sorry

This theorem states that for any types `α` and `β`, and for any function `f` from `α` to `β`, if `f` is bijective (which means it is both injective and surjective), then `f` is also injective. In other words, if a function maps distinct elements of the domain to distinct elements of the codomain and every element of the codomain is the image of some element of the domain, then it must be the case that the same output from the function implies that the inputs were the same.

If `f` is a function from type `α` to type `β` that is bijective, then `f` is injective.


theorem Finset.coe_Icc :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : α), ↑(Finset.Icc a b) = Set.Icc a b :=
  by sorry

The theorem `Finset.coe_Icc` states that for any type `α` that has both a preorder and a locally finite order, and for any two elements `a` and `b` of this type, the coercion of the finite set interval (Finset.Icc) from `a` to `b` is equal to the set interval (Set.Icc) from `a` to `b`. In other words, it asserts that the set of elements in the interval from `a` to `b` (inclusive) as a finite set is the same as the interval from `a` to `b` (inclusive) as a set, under the conditions specified.

For any type `α` with a preorder and locally finite order, the coercion of the finite set interval `Finset.Icc` from `a` to `b` equals the set interval `Set.Icc` from `a` to `b`.


theorem MeasureTheory.subset_toMeasurable :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
      s ⊆ MeasureTheory.toMeasurable μ s :=
  by sorry

This theorem states that for any type `α` that is equipped with a `MeasurableSpace` structure, any measure `μ` on this measurable space, and any set `s` of elements of type `α`, the set `s` is a subset of the set `MeasureTheory.toMeasurable μ s`. In other words, every element of `s` is also an element of `MeasureTheory.toMeasurable μ s`. This is a crucial property in measure theory, which ensures that we can always find a measurable set that contains a given set.

For any measurable space `(α, Σ)`, measure `μ : MeasurableSpace.Measure Σ α`, and set `s ∈ Σ`, we have `s ⊆ MeasurableTheory.toMeasurable μ s`.


theorem Finset.sum_eq_zero :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] {f : α → β} {s : Finset α},
      (∀ x ∈ s, f x = 0) → (Finset.sum s fun x => f x) = 0 :=
  by sorry

The theorem `Finset.sum_eq_zero` states that for any type `α`, any type `β` which forms an additive commutative monoid, a function `f` from `α` to `β`, and a finite set `s` of type `α`, if every element `x` in `s` maps to `0` under the function `f`, then the sum of the function `f` applied to each element in `s` equals `0`. In math terms, this could be written as: if for all $x \in s$, we have $f(x) = 0$, then $\sum_{x \in s} f(x) = 0$.

For any additive commutative monoid type `β`, function `f` from type `α` to `β`, and finite set `s` of type `α` with all elements mapping to `0` under `f`, we have $\sum_{x \in s} f(x) = 0$.


theorem Mathlib.Data.ENNReal.Basic._auxLemma.19 : ∀ {r q : NNReal}, (↑r ≤ ↑q) = (r ≤ q) := by sorry

This theorem, which belongs to the basic functions of the extended nonnegative real numbers module in Mathlib, states that for any two nonnegative real numbers `r` and `q`, the statement "the real number component of `r` is less than or equal to the real number component of `q`" is equivalent to "r is less than or equal to q". In other words, the ordering of their real components is the same as the ordering of the nonnegative real numbers themselves.

For all non-negative real numbers r and q, r ≤ q if and only if reals.r <= reals.q.


theorem Ordinal.type_lt : ∀ (o : Ordinal.{u_3}), (Ordinal.type fun x x_1 => x < x_1) = o := by sorry

This theorem, `Ordinal.type_lt`, states that for every ordinal `o`, the order type of the well-ordering relation "less than" is `o`. In other words, for every well-order `o`, the structure that arises by considering the "less than" relation as a well-ordering on `o` is essentially the same as `o` itself, in the sense of order isomorphism. This theorem is a crucial result in the study of ordinals, as it provides a connection between a specific well-ordering relation and the general class of all well-orders.

For every ordinal `o`, the well-ordering relation "less than" on `o` is order isomorphic to `o`.


theorem add_right_cancel :
    ∀ {G : Type u_1} [inst : Add G] [inst_1 : IsRightCancelAdd G] {a b c : G}, a + b = c + b → a = c := by sorry

This theorem, `add_right_cancel`, states that for any type `G` that is equipped with an addition operation and has the right cancellation property, if we have three elements `a`, `b`, and `c` in `G` such that `a + b` equals `c + b`, then `a` must equal `c`. In other words, if two sums are equal and they have the same right-hand addend, then their left-hand addends must be equal. This is the definition of the right cancellation property in an additive setting.

If `a + b = c + b` in an additive type `G` with right cancellation property, then `a = c`.


theorem HomologicalComplex.d_comp_d :
    ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) (i j k : ι),
      CategoryTheory.CategoryStruct.comp (C.d i j) (C.d j k) = 0 :=
  by sorry

This theorem, named "HomologicalComplex.d_comp_d", states that for any category 'V' with zero morphisms, and for any complex shape 'c' in a homological complex 'C', the composition of morphisms from 'i' to 'j' and from 'j' to 'k' (denoted as `C.d i j` and `C.d j k` respectively) is equal to zero. This is a fundamental property in homological algebra, as it reflects the fact that the composition of two consecutive boundary mappings in a chain complex is always zero.

In a homological complex with zero morphisms, the composition of two consecutive boundary morphisms is zero.


theorem lt_iff_le_and_ne : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a < b ↔ a ≤ b ∧ a ≠ b := by sorry

This theorem states that for any type `α` that has a defined partial order, and for any two elements `a` and `b` of that type, `a` is less than `b` if and only if both `a` is less than or equal to `b` and `a` is not equal to `b`. In other words, in the context of a partial order, strict less than (`a < b`) is equivalent to the conjunction of less than or equal (`a ≤ b`) and inequality (`a ≠ b`).

For any type `α` with a partial order, `a < b` if and only if `a ≤ b` and `a ≠ b`.


theorem MeasureTheory.measurableSet_toMeasurable :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
      MeasurableSet (MeasureTheory.toMeasurable μ s) :=
  by sorry

The theorem `MeasureTheory.measurableSet_toMeasurable` states that for any type `α` equipped with a `MeasurableSpace` structure, any measure `μ` on this space, and any set `s` of elements of type `α`, the set `MeasureTheory.toMeasurable μ s` is a measurable set. In other words, this theorem ensures that the operation `toMeasurable`, when applied to a measure and a set, always results in a measurable set, as defined in the associated measurable space.

For any measurable space `(α, Σ, μ)`, the image `toMeasurable μ s` of any set `s ∈ Σ` is measurable.


/-- `Quot.mk r` is a surjective function.  -/
theorem surjective_quot_mk : ∀ {α : Sort u_1} (r : α → α → Prop), Function.Surjective (Quot.mk r) := by sorry

The theorem `surjective_quot_mk` states that for any type `α` and any relation `r` on `α`, the function `Quot.mk r`, which maps an element of `α` to its equivalence class under `r` in the quotient set, is surjective. In other words, for every equivalence class in the quotient set, there exists an element in `α` such that `Quot.mk r` of that element produces the given equivalence class.

For any type `α` and relation `r` on `α`, the function `Quot.mk r` is a surjection from `α` to the quotient set by `r`.


AlternatingMap.ext

theorem AlternatingMap.ext :
    ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
      [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {f f' : M [⋀^ι]→ₗ[R] N},
      (∀ (x : ι → M), f x = f' x) → f = f' :=
  by sorry

This theorem, named `AlternatingMap.ext`, asserts that for any semiring `R`, additive commutative monoid `M`, and module `M` over `R`, and any other additive commutative monoid `N` and module `N` over `R`, along with a type `ι` and two linear maps `f` and `f'` from the tensor power of `M` indexed by `ι` to `N`, if `f` and `f'` are equal for all mappings from `ι` to `M`, then `f` and `f'` are indeed the same linear map. This is a form of extensionality for alternating maps in the setting of module theory.

If two linear maps between tensor powers of modules over a semiring, indexed by the same type, have the same value for all mappings from the type to the base modules, then they are equal.


theorem Mathlib.Order.SetNotation._auxLemma.4 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i := by sorry

This theorem states that for any type `α`, any index type `ι`, any element `x` of type `α`, and any indexed set `s` of elements of type `α`, the element `x` is a member of the intersection of all sets `s i` (for all `i` in `ι`) if and only if `x` is a member of each set `s i`. In mathematical terms, this can be represented as `x ∈ ⋂ i, s i` if and only if `∀ (i : ι), x ∈ s i`. Essentially, it formalizes the notion that an element belongs to the intersection of a collection of sets if and only if it belongs to each set in the collection.

For any type `α`, index type `ι`, set `s` of elements of type `α`, and element `x` of type `α`, `x` is in the intersection of all sets `s i` (for all `i` in `ι`) if and only if `x` is an element of each set `s i`. Equivalently, `x ∈ ⋂ i, s i` if and only if `∀ (i : ι), x ∈ s i`.


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

This theorem states that for any set `a` of some type `α`, the union of the empty set (`∅`) with `a` is equal to `a`. In other words, the operation of taking the union of any set with the empty set leaves the original set unchanged. This is a fundamental property of the union operation in set theory.

The empty set is a neutral element for set union, i.e., ∅ ∪ A = A for any set A.


theorem Complex.ofReal_add : ∀ (r s : ℝ), ↑(r + s) = ↑r + ↑s := by sorry

This theorem, `Complex.ofReal_add`, states that for any two real numbers `r` and `s`, the complex representation of the sum of `r` and `s` is equal to the sum of the complex representation of `r` and the complex representation of `s`. In other words, the process of converting a real number to a complex number commutes with the operation of addition.

For any real numbers r and s, Complex.ofReal r + Complex.ofReal s = Complex.ofReal (r + s).


theorem tsub_eq_zero_iff_le :
    ∀ {α : Type u_1} [inst : CanonicallyOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α] {a b : α},
      a - b = 0 ↔ a ≤ b :=
  by sorry

This theorem, `tsub_eq_zero_iff_le`, states that for any type `α` that has an instance of a canonically ordered additive commutative monoid, an instance of subtraction, and an instance of ordered subtraction, the subtraction of two elements `a` and `b` of type `α` results in zero if and only if `a` is less than or equal to `b`. This means that in the given structures, the only way subtraction can yield zero is when the subtrahend is less than or equal to the minuend.

For any type `α` with a canonically ordered additive commutative monoid, subtraction, and ordered subtraction, `a - b = 0` if and only if `a <= b`.


theorem Submodule.zero_mem :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M), 0 ∈ p :=
  by sorry

This theorem, `Submodule.zero_mem`, states that for any given submodule `p` of a module `M` over a semiring `R`, the zero element of the module is always an element of the submodule. Here, `R` is a semiring, `M` is an additive commutative monoid such that `M` is a module over `R`, and `p` is a submodule of `M`.

For any submodule `p` of an additive commutative monoid `M` over a semiring `R`, the additive identity of `M` belongs to `p`.


theorem dist_triangle : ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y z : α), dist x z ≤ dist x y + dist y z := by
  sorry

This theorem, known as the Triangle Inequality, applies to any pseudometric space. For any three points `x`, `y`, and `z` in this space, it asserts that the distance from `x` to `z` is less than or equal to the sum of the distances from `x` to `y` and from `y` to `z`. This is a fundamental property of distances in many mathematical spaces, including, for example, the Euclidean distance in real and complex spaces.

In any pseudometric space, the distance between any two points `x` and `y`, and the distance from `y` to a third point `z`, satisfies the inequality `d(x, z) ≤ d(x, y) + d(y, z)`.


theorem Set.image_neg : ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s : Set α}, Neg.neg '' s = -s := by sorry

This theorem, `Set.image_neg`, states that for any set `s` of elements of some type `α`, which has an associated operation `Neg.neg` that computes the negative or opposite of its members (i.e., `α` has an involutive negation operation), the image of `s` under this negation operation (`Neg.neg '' s`) is equal to the negative of set `s` (`-s`). The meaning of "negative of a set" is defined in the context of the theorem. Essentially, this theorem establishes a relationship between operations applied to individual elements of a set and operations applied to the set as a whole.

For any set `s` of elements in a type `α` with an involutive negation operation, `Neg.neg s` equals the negative of `s`, denoted `-s`.


theorem Cardinal.lift_le : ∀ {a b : Cardinal.{v}}, Cardinal.lift.{u, v} a ≤ Cardinal.lift.{u, v} b ↔ a ≤ b := by sorry

The theorem `Cardinal.lift_le` states that for any two cardinal numbers `a` and `b` in a certain type universe `v`, the universe lift operation `Cardinal.lift` to a larger type universe `u` preserves the order of these cardinal numbers. More specifically, the lifted cardinal `a` is less than or equal to the lifted cardinal `b` if and only if the original cardinal `a` is less than or equal to the original cardinal `b`.

For all cardinal numbers `a` and `b` in universe `v`, `Cardinal.lift a < Cardinal.lift b` if and only if `a <= b`.


Continuous.comp'

theorem Continuous.comp' :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] {f : X → Y} {g : Y → Z},
      Continuous g → Continuous f → Continuous fun x => g (f x) :=
  by sorry

This theorem states that if you have three types `X`, `Y` and `Z`, each with a topological space structure, and two functions `f` from `X` to `Y`, and `g` from `Y` to `Z`, then if `g` and `f` are both continuous functions, the composition function `g ∘ f` (that is, the function that first applies `f`, then applies `g` to the result) is also continuous. This is a formalization of the standard mathematical fact about the composition of continuous functions in topology.

If `f` is a continuous function from `X` to `Y` and `g` is a continuous function from `Y` to `Z`, then the composition `g ∘ f` is a continuous function from `X` to `Z`.


List.Sublist.subset

theorem List.Sublist.subset : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Sublist l₁ l₂ → l₁ ⊆ l₂ := by sorry

This theorem states that for all types `α` and for all lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then `l₁` is a subset of `l₂`. In other words, every element of `l₁` is also an element of `l₂`.

For all types `α` and lists `l₁` and `l₂` of type `α`, if `l₁` is a sublist of `l₂`, then `l₁ ⊆ l₂` (`l₁` is a subset of `l₂`).


Quotient.ind'

/-- A version of `Quotient.ind` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument.  -/
theorem Quotient.ind' :
    ∀ {α : Sort u_1} {s₁ : Setoid α} {p : Quotient s₁ → Prop},
      (∀ (a : α), p (Quotient.mk'' a)) → ∀ (q : Quotient s₁), p q :=
  by sorry

The theorem `Quotient.ind'` states that for any type `α`, any setoid `s₁` on `α`, and any property `p` that might hold for elements of the quotient of `α` by `s₁`, if the property `p` holds for each element `a` of `α` when considered as an element of the quotient (i.e., `Quotient.mk'' a`), then the property `p` holds for any element `q` of the quotient. In other words, if you can prove something about every representative of an equivalence class, you can prove it about the entire class in the quotient set.

Given a type `α`, a setoid `s₁` on `α`, and a property `p` such that `p` holds for `Quotient.mk '' a` for all `a` in `α`, then `p` holds for all elements of the quotient of `α` by `s₁`.


MeasurableSet.empty

theorem MeasurableSet.empty : ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSet ∅ := by sorry

The theorem `MeasurableSet.empty` states that for any type `α` in a measurable space, the empty set is a measurable set. In other words, regardless of the measurable space we are working in, the empty set is always considered measurable.

In any measurable space, the empty set is a measurable subset.


theorem continuous_induced_dom : ∀ {α : Type u} {β : Type v} {f : α → β} {t : TopologicalSpace β}, Continuous f := by
  sorry

This theorem states that for any two types `α` and `β`, and any function `f` from `α` to `β`, and any topological space `t` defined over `β`, the function `f` is continuous. In other words, in the context of topology, this theorem is asserting that under these conditions, the image of an open set under the function `f` will always be an open set in `β`.

Given any function `f` from type `α` to type `β` and any topology `t` on `β`, `f` is continuous if for every open set `U ∈ t`, the preimage `f⁻¹(U)` is an open set in `α`.


/-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`.  -/
theorem map_inv₀ :
    ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
      [inst_2 : FunLike F G₀ G₀'] [inst_3 : MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀), f a⁻¹ = (f a)⁻¹ :=
  by sorry

The theorem `map_inv₀` states that for any two types `G₀` and `G₀'` representing groups with zeros, and a type `F` representing a function-like entity from `G₀` to `G₀'`, if there is an instance of `F` being a monoid homomorphism with zeros from `G₀` to `G₀'`, then the function `f` of type `F` maps the inverse of an element `a` in `G₀` to the inverse of `f a` in `G₀'`. In other words, under a monoid homomorphism that preserves the zero element, the inverse of an element in the original group maps to the inverse of its image in the target group.

If `F` is a monoid homomorphism from group `G₀` to group `G₀'` preserving zeros, then `f(x⁻¹) = (f(x))⁻¹` for all `x` in `G₀`.


theorem Continuous.prod_map :
    ∀ {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : Z → X} {g : W → Y},
      Continuous f → Continuous g → Continuous fun p => (f p.1, g p.2) :=
  by sorry

This theorem, `Continuous.prod_map`, asserts that for any four types `X`, `Y`, `Z`, `W`, given that `X`, `Y`, `Z`, `W` are equipped with topological spaces, and given two functions `f : Z → X` and `g : W → Y`, if `f` and `g` are continuous, then the function that takes a pair `(z, w)` and maps it to `(f(z), g(w))` is also continuous. This implies that the continuity of individual functions is preserved under the formation of product functions in topological spaces.

If `f : Z → X` and `g : W → Y` are continuous functions between topological spaces, then the function `(z, w) ↦ (f(z), g(w))` from `Z × W` to `X × Y` is continuous.


theorem Ideal.mem_span_singleton : ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, x ∈ Ideal.span {y} ↔ y ∣ x := by
  sorry

This theorem states that for any commutative semiring `α`, and any elements `x` and `y` of `α`, `x` is in the ideal generated by the singleton set `{y}` if and only if `y` divides `x`. In mathematical notation, this is saying that for a given commutative semiring, $x$ is in the ideal generated by $y$ (denoted $(y)$) if and only if there exists another element in the semiring such that $x = y \times z$.

For any commutative semiring `α` and elements `x, y` in `α`, `x` is in the ideal generated by `{y}` if and only if there exists `z` in `α` such that `x = y * z`.


AddSubgroup.ext

/-- Two `AddSubgroup`s are equal if they have the same elements. -/
theorem AddSubgroup.ext :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, (∀ (x : G), x ∈ H ↔ x ∈ K) → H = K := by sorry

This theorem states that two additive subgroups of a given additive group are equal if and only if they contain the same elements. In other words, for any type `G` equipped with an additive group structure and any two additive subgroups `H` and `K` of `G`, if every element `x` in `G` satisfies the condition that `x` is in `H` if and only if `x` is in `K`, then `H` and `K` are equal as subgroups.

Two additive subgroups of an additive group are equal if and only if they have the same elements.


theorem left_distrib :
    ∀ {R : Type x} [inst : Mul R] [inst_1 : Add R] [inst_2 : LeftDistribClass R] (a b c : R),
      a * (b + c) = a * b + a * c :=
  by sorry

This is a theorem stating the property of left distributivity in a certain algebraic structure. Specifically, for any type `R` that has operations of multiplication (`Mul R`) and addition (`Add R`) and follows the left distributive law (`LeftDistribClass R`), the theorem states that for any three elements `a`, `b`, and `c` of `R`, the result of multiplying `a` by the sum of `b` and `c` is equal to the sum of `a` multiplied by `b` and `a` multiplied by `c`. In mathematical terms, this is the well-known property `a * (b + c) = a * b + a * c`.

For any element `a` in a commutative ring `R` with one and multiplicative identity, `a * (b + c) = a * b + a * c` holds for all `b, c` in `R`.


theorem add_left_cancel :
    ∀ {G : Type u_1} [inst : Add G] [inst_1 : IsLeftCancelAdd G] {a b c : G}, a + b = a + c → b = c := by sorry

The theorem `add_left_cancel` states that for any type `G` that has an addition operation and also has the property of left-cancellativity under addition, if `a`, `b`, and `c` are of type `G`, then if `a + b` equals `a + c`, it implies that `b` equals `c`. In other words, in an algebraic structure where addition is defined and is left-cancellable, adding the same quantity to two quantities and getting equal results means the original quantities were equal.

In a left-cancellative group, if `a + b = a + c`, then `b = c`.


theorem LinearMap.range_eq_top :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {τ₁₂ : R →+* R₂} {F : Type u_20} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂]
      [inst_8 : RingHomSurjective τ₁₂] {f : F}, LinearMap.range f = ⊤ ↔ Function.Surjective ⇑f :=
  by sorry

The theorem `LinearMap.range_eq_top` states that for any semirings `R` and `R₂`, commutative additive monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a type `F` which has a function-like structure from `M` to `M₂`, and a semilinear map from `M` to `M₂` over `τ₁₂`, where `τ₁₂` is surjective, a function `f : F` is such that the range of the linear map corresponding to `f` is the entire codomain (`⊤`) if and only if the function corresponding to `f` is surjective. In other words, the linear map `f` covers the entire codomain if and only if for every element in the codomain, there is a preimage in the domain of `f`.

Given a surjective ring homomorphism τ₁₂ from semiring R to R₂, a semilinear map f from module M over R to module M₂ over R₂, then the range of the linear map corresponding to f equals the entire codomain if and only if f is surjective.


/-- The `AddSubmonoid` generated by a set includes the set. -/
theorem AddSubmonoid.subset_closure :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M}, s ⊆ ↑(AddSubmonoid.closure s) := by sorry

The theorem `AddSubmonoid.subset_closure` states that for any type `M` that has an `AddZeroClass` instance (i.e., `M` is a type where addition and zero are defined), and for any set `s` of elements of type `M`, the set `s` is a subset of the `AddSubmonoid` generated by `s`. In other words, every element of the set `s` is included in the additive submonoid that is generated by `s`.

For any AddZeroClass type M and set s of its elements, s is contained in the AddSubmonoid generated by s.


theorem Set.coe_toFinset : ∀ {α : Type u_1} (s : Set α) [inst : Fintype ↑s], ↑(Set.toFinset s) = s := by sorry

The theorem `Set.coe_toFinset` states that for any type `α` and any set `s` of type `α` with a `Fintype` instance, the set obtained by coercing the finset derived from `s` using `Set.toFinset` is equal to the original set `s`. In other words, we can convert a set to a finset (in the context of a finite type) and back to a set without losing any elements.

For any type `α` with a `Fintype` instance and any set `s` of type `α`, the coercion of `s` to a finset and back is the identity function on `s`.


/-- **Alias** of `mul_div_cancel₀`. -/
theorem mul_div_cancel' : ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] {b : G₀} (a : G₀), b ≠ 0 → b * (a / b) = a :=
  by sorry

This theorem, named `mul_div_cancel'`, states that for any type `G₀` that forms a commutative group with zero, for any elements `a` and `b` of that type, if `b` is not equal to zero, then the result of multiplying `b` by the quotient of `a` divided by `b` is equal to `a`. Essentially, this is a formal proof of the well-known mathematical fact that for non-zero `b`, multiplication and division by `b` are inverse operations, or in mathematical symbols, `b * (a / b) = a`.

For any commutative group with zero `G₀` and non-zero elements `a` and `b` in `G₀`, `a = b * (a / b)`.


theorem Set.right_mem_Icc : ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b ∈ Set.Icc a b ↔ a ≤ b := by sorry

This theorem states that for any type `α` that has a preorder structure and for any two elements `a` and `b` of type `α`, `b` is an element of the closed interval from `a` to `b`, denoted `Set.Icc a b`, if and only if `a` is less than or equal to `b`. In other words, the right endpoint `b` of the interval `[a, b]` is part of the interval if `a` is not greater than `b`.

For any preordered type `α` and elements `a` and `b` of `α`, `b` belongs to the closed interval `Icc a b` if and only if `a` is less than or equal to `b`.


theorem ENNReal.toReal_nonneg : ∀ {a : ENNReal}, 0 ≤ a.toReal := by sorry

This theorem states that for any element `a` of the type `ENNReal` (which represents the extended nonnegative real numbers, including positive infinity), the real number representation of `a` is always nonnegative. Or in other words, the conversion of any extended nonnegative real number to a real number will always result in a number that is greater than or equal to zero. This makes sense because `ENNReal` is defined to only contain nonnegative numbers (ranging from zero to positive infinity).

For any `a` in `ENNReal`, the real number representation of `a` is nonnegative.


/-- **Alias** of `Rat.cast_intCast`. -/
theorem Rat.cast_coe_int : ∀ {α : Type u_3} [inst : DivisionRing α] (n : ℤ), ↑↑n = ↑n := by sorry

This theorem, `Rat.cast_coe_int`, serves as an alias for `Rat.cast_intCast`. It asserts that for any integer `n` and any type `α` that is a division ring, the double cast of `n` to a rational number and then to an element of `α` is the same as the direct cast of `n` to `α`. In mathematical notation, this can be written as ∀n ∈ ℤ, ∀α such that α is a division ring, ((n : ℚ) : α) = (n : α).

For any integer `n` and division ring `α`, the direct cast of `n` to `α` is equal to the double cast of `n` first to rational numbers and then to `α`.


theorem Mathlib.Data.Finset.Basic._auxLemma.92 : ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) := by sorry

This theorem, named Mathlib.Data.Finset.Basic._auxLemma.92, establishes the commutativity of logical conjunction in propositional logic. Specifically, it states that for any two propositions `a` and `b`, the statement "`a` and `b`" is equivalent to the statement "`b` and `a`". In LaTeX mathematics, this theorem can be written as: ∀ {a b : Prop}, (a ∧ b) = (b ∧ a).

The theorem asserts the equality of conjunction commutativity in propositional logic: for all propositions `a` and `b`, `(a ∧ b) = (b ∧ a)`.


theorem Finset.coe_Ico :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : α), ↑(Finset.Ico a b) = Set.Ico a b :=
  by sorry

This theorem states that for any type `α` equipped with a preorder and a locally finite order, and any elements `a` and `b` of this type, the set obtained by coercing (or converting) the finite set of elements `x` such that `a ≤ x` and `x < b` (which is what `Finset.Ico a b` denotes) to a 'regular' set is equal to the set of elements `x` satisfying the same inequalities (which is what `Set.Ico a b` denotes). In other words, the interval `[a, b)` considered as a finite set and as a 'regular' set are the same.

For any type `α` with a preorder and locally finite order, the finite interval `Finset.Ico a b` is equal to the regular interval `Set.Ico a b`.


theorem MeasureTheory.measure_toMeasurable :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} (s : Set α),
      ↑↑μ (MeasureTheory.toMeasurable μ s) = ↑↑μ s :=
  by sorry

This theorem, `MeasureTheory.measure_toMeasurable`, states that for any type `α` with a measurable space structure, any measure `μ` of type `MeasureTheory.Measure α`, and any set `s` of type `Set α`, the measure of the set obtained by applying the `MeasureTheory.toMeasurable` operation to `s` under the measure `μ` is equal to the measure of `s` under the same measure `μ`. In more informal terms, this theorem ensures that the operation `MeasureTheory.toMeasurable` does not change the measure of a set.

For any measurable space `(α, σ)`, measure `μ : MeasureTheory.Measure α`, and set `s : Set α`, the measure of `toMeasurable s` under `μ` equals the measure of `s` under `μ`.


theorem Nat.cast_inj : ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [inst_1 : CharZero R] {m n : ℕ}, ↑m = ↑n ↔ m = n :=
  by sorry

This theorem, `Nat.cast_inj`, states that for any type `R` that has both an addition operation with an identity element (a `AddMonoidWithOne`) and a characteristic of zero (`CharZero`), the equality of the casted natural numbers `m` and `n` into `R` implies the equality of `m` and `n` themselves, and vice versa. In other words, if two natural numbers `m` and `n` are equal after being cast to type `R`, then `m` and `n` were already equal in the natural numbers, and if `m` and `n` are equal in the natural numbers, they will remain equal after being cast to type `R`.

If `R` is a type with an additive monoid structure and characteristic zero, then the casted natural numbers `m` and `n` are equal if and only if the original natural numbers `m` and `n` are equal.


theorem csInf_le :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α}, BddBelow s → a ∈ s → sInf s ≤ a := by
  sorry

This theorem, `csInf_le`, states that for any type `α` that forms a conditionally complete lattice, for any set `s` of elements of this type, and for any element `a` of this type, if the set `s` is bounded below (i.e., there exists a lower bound for `s`) and if the element `a` is in `s`, then the greatest lower bound (or infimum) of `s`, denoted as `sInf s`, is less than or equal to `a`. In simple terms, it asserts that the infimum of any set that has a lower bound, is always less than or equal to any member of that set.

For any conditionally complete lattice type `α`, if `s` is a bounded below set in `α` containing an element `a`, then `sInf s ≤ a`.


theorem SetLike.coe_subset_coe : ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {S T : A}, ↑S ⊆ ↑T ↔ S ≤ T := by
  sorry

The theorem `SetLike.coe_subset_coe` establishes a connection between the subset relation and the less-than-or-equal-to relation for set-like objects. Specifically, for any two types `A` and `B` with `A` being set-like over `B`, and any two elements `S` and `T` of type `A`, `S` is a subset of `T` if and only if `S` is less-than-or-equal-to `T`, where the subset relation is defined in the context of the coe function (which coerces `S` and `T` to be sets).

For set-like objects `A` over `B` and `S` and `T` in `A`, `S ⊆ T` if and only if `S ≤ T` as sets, where `≤` is the subset relation defined via the coe function.


/-- A closed subset of a compact set is a compact set.  -/
theorem IsCompact.of_isClosed_subset :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsClosed t → t ⊆ s → IsCompact t := by sorry

This theorem states that a closed subset of a compact set is also a compact set. More specifically, given any type `X` with a topological space structure, and any two sets `s` and `t` of type `X`, if `s` is compact, `t` is closed, and `t` is a subset of `s`, then `t` is also compact. In mathematical terms, it encapsulates the property that compactness is hereditary with respect to taking closed subsets within topological spaces.

If a closed subset of a compact topological space is compact.


theorem Set.prod_mono :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β}, s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ×ˢ t₁ ⊆ s₂ ×ˢ t₂ := by sorry

The theorem `Set.prod_mono` states that for any types `α` and `β`, and any sets `s₁`, `s₂` of type `α` along with `t₁`, `t₂` of type `β`, if `s₁` is a subset of `s₂` and `t₁` is a subset of `t₂`, then the cartesian product of `s₁` and `t₁` is also a subset of the cartesian product of `s₂` and `t₂`. In mathematical terms, given $s₁, s₂ \subseteq \alpha$ and $t₁, t₂ \subseteq \beta$, if $s₁ \subseteq s₂$ and $t₁ \subseteq t₂$, then $s₁ \times t₁ \subseteq s₂ \times t₂$.

If `s₁ ⊆ s₂` and `t₁ ⊆ t₂`, then `s₁ × t₁ ⊆ s₂ × t₂`. (In mathematical notation: for any types `α` and `β`, if `s₁, s₂ ⊆ α` and `t₁, t₂ ⊆ β`, then `s₁ × t₁ ⊆ s₂ × t₂`. )


Subgroup.ext

/-- Two subgroups are equal if they have the same elements.  -/
theorem Subgroup.ext : ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G}, (∀ (x : G), x ∈ H ↔ x ∈ K) → H = K := by
  sorry

This theorem states that for any given group `G`, if there are two subgroups `H` and `K` of `G` such that a member `x` of group `G` belongs to `H` if and only if `x` also belongs to `K`, then the subgroups `H` and `K` are equal. In other words, two subgroups of a group are equal if and only if they contain exactly the same elements.

If two subgroups of a group have the same elements, then they are equal.


theorem le_csSup :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α}, BddAbove s → a ∈ s → a ≤ sSup s := by
  sorry

The theorem `le_csSup` states that for any type `α` which is a Conditionally Complete Lattice, any set `s` of type `α`, and any element `a` of type `α`, if the set `s` is bounded above (i.e., has an upper bound) and the element `a` is a member of the set `s`, then `a` is less than or equal to the supremum of the set `s`. Here, supremum (denoted as `sSup`) is the least upper bound of the set `s`.

If `α` is a Conditionally Complete Lattice, `s` is a bounded above subset of `α`, and `a` is an element of `s`, then `a ≤ sSup`.


theorem inf_top_eq : ∀ {α : Type u} [inst : SemilatticeInf α] [inst_1 : OrderTop α] (a : α), a ⊓ ⊤ = a := by sorry

This theorem states that for any type 'α' that is a semilattice with an operation of infimum (denoted as '⊓'), and also has a top element (denoted as '⊤'), the infimum of any element 'a' in 'α' and the top element is always 'a'. In simpler terms, it states that in such a structure, taking the "minimum" (infimum) between any element and the greatest possible element (top element) will always yield the original element.

For any semilattice 'α' with an infimum operation and top element, the infimum of any element 'a' with the top element is 'a'.


theorem LinearEquiv.apply_symm_apply :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
      {σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (c : M₂),
      e ((LinearEquiv.symm e) c) = c :=
  by sorry

This theorem, `LinearEquiv.apply_symm_apply`, states that for any semiring `R` and `S`, commutative additive monoid `M` and `M₂`, a module `M` over `R`, a module `M₂` over `S`, and two ring homomorphisms `σ: R →+* S` and `σ': S →+* R` that are inverses to each other, given a linear equivalence `e: M ≃ₛₗ[σ] M₂` and any element `c` from `M₂`, applying `e` on the result of applying the inverse of `e` on `c` will return `c`. This can be intuitively understood as reversing the transformation applied by `e` via its inverse and applying `e` again which will result in the original element `c`. Essentially, it is a way to express the property that the inverse of a linear equivalence undoes the mapping of the original linear equivalence.

For any semirings R and S, commutative additive monoids M and M₂, modules M over R and M₂ over S, ring homomorphisms σ : R →+* S and σ' : S →+* R that are inverses, and a linear equivalence e : M ≃ₛₗ[σ] M₂, e (σ' (e (x))) = x for all x in M₂.


/-- Additive group homomorphisms preserve negation. -/
theorem AddMonoidHom.map_neg :
    ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : SubtractionMonoid β] (f : α →+ β) (a : α),
      f (-a) = -f a :=
  by sorry

This theorem states that additive group homomorphisms preserve negation. Specifically, for any elements of types `α` and `β`, where `α` is an additive group and `β` is a subtraction monoid, if a function `f` is an additive monoid homomorphism from `α` to `β`, then the homomorphism of the negation of any element `a` in `α` is equal to the negation of the homomorphism of `a`. In simple terms, applying the homomorphism first and then negating is the same as negating first and then applying the homomorphism.

For any additive group homomorphism from an additive group to a subtraction monoid, negation is preserved: i.e., -(f(a)) = f(-a).


/-- Swapping the two vectors passed to `oangle` negates the angle.  -/
theorem Orientation.oangle_rev :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V),
      Orientation.oangle o y x = -Orientation.oangle o x y :=
  by sorry

The theorem `Orientation.oangle_rev` states that for a 2D vector space `V` with a real inner product and a given orientation `o`, swapping the order of the two vectors `x` and `y` in the `oangle` (oriented angle) function results in the negation of the original angle. In other words, the oriented angle from `y` to `x` is the negative of the oriented angle from `x` to `y`.

For a 2D vector space equipped with a real inner product and orientation, the oriented angle from vector `y` to vector `x` is the negative of the oriented angle from vector `x` to vector `y`.


theorem Function.bijective_iff_has_inverse :
    ∀ {α : Sort u} {β : Sort v} {f : α → β},
      Function.Bijective f ↔ ∃ g, Function.LeftInverse g f ∧ Function.RightInverse g f :=
  by sorry

This theorem states that for all types `α` and `β` and a function `f` from `α` to `β`, the function `f` is bijective if and only if there exists a function `g` such that `g` is a left inverse and a right inverse to `f`. In mathematical terms, a function is bijective - meaning it is both injective (or one-to-one) and surjective (or onto) - if and only if it has an inverse function that, when composed with the original function from both sides (left and right), yields the identity function.

A function `f` from type `α` to type `β` is bijective if and only if there exists a function `g` such that `f ∘ g = idα` and `g ∘ f = idβ`, where `idα` and `idβ` are the identity functions on types `α` and `β`, respectively.


theorem true_iff : ∀ (p : Prop), (True ↔ p) = p := by sorry

This theorem states that, for any given proposition `p`, the bi-conditional statement (indicated by `↔`) between the truth value `True` and `p` is equivalent to `p` itself. In other words, the equivalence of `p` and `True` is the same as stating `p` itself. More formally, this can be expressed as: If `p` is true, then `True` is equivalent to `p`, and if `p` is false, then `True` is not equivalent to `p`.

For all propositions `p`, `p ↔ True` is equivalent to `p`.


theorem MeasureTheory.Integrable.aestronglyMeasurable :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.AEStronglyMeasurable f μ :=
  by sorry

The theorem `MeasureTheory.Integrable.aestronglyMeasurable` states that for any type `α`, any measurable space `m` associated with that type, any measure `μ` on that space, any type `β` that forms a normed add commutative group, and any function `f` from `α` to `β`, if the function `f` is integrable with respect to the measure `μ` (meaning that `f` is measurable and the integral over `f` is finite), then `f` is almost everywhere strongly measurable with respect to `μ` (meaning that there exists a sequence of simple functions that leads to `f` almost everywhere).

If a function from a measurable space to a normed add commutative group is integrable with respect to a given measure, then it is almost everywhere strongly measurable.


theorem mul_invOf_self : ∀ {α : Type u} [inst : Mul α] [inst_1 : One α] (a : α) [inst_2 : Invertible a], a * ⅟a = 1 :=
  by sorry

This theorem, `mul_invOf_self`, states that for any type `α` that supports multiplication and has a multiplicative identity (denoted by `One α`), for any element `a` of this type that is invertible (i.e., has a multiplicative inverse), the result of multiplying `a` by its multiplicative inverse (denoted by `⅟a`) is equal to the multiplicative identity, `1`. This is a formalization of the fundamental property of multiplicative inverses in a multiplicative group.

For all types `α` with multiplication and an identity `One α`, and for all invertible elements `a` of `α`, `a * ⅟a = One α`.


Finset.induction

theorem Finset.induction :
    ∀ {α : Type u_4} {p : Finset α → Prop} [inst : DecidableEq α],
      p ∅ → (∀ ⦃a : α⦄ {s : Finset α}, a ∉ s → p s → p (insert a s)) → ∀ (s : Finset α), p s :=
  by sorry

This theorem, named `Finset.induction`, states a principle of induction for finite sets, or `Finset`s. Given any type `α` with decidable equality and a property `p` that applies to `Finset`s of type `α`, if the property holds for the empty set and if, for any element `a` of type `α` and any `Finset` `s` of type `α`, the property holding for `s` implies that it holds for the `Finset` resulting from inserting `a` into `s` (provided `a` was not already in `s`), then the property holds for all `Finset`s of type `α`.

If a property holds for the empty finite set and is closed under adding elements not in the set, then it holds for all finite sets.


theorem sub_eq_iff_eq_add : ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, a - b = c ↔ a = c + b := by sorry

This theorem, `sub_eq_iff_eq_add`, states that for any type G which is an instance of an additive group, and for any elements a, b, and c of type G, the statement "a subtract b equals c" is equivalent to "a equals c added to b". Essentially, it's expressing that subtraction can be rephrased as the addition of the negation in the context of an additive group.

For any additive group G and elements a, b, and c of G, the statements "a - b = c" and "a = b + c" are equivalent.


theorem Multiset.mem_cons_self : ∀ {α : Type u_1} (a : α) (s : Multiset α), a ∈ a ::ₘ s := by sorry

This theorem states that for any type `α`, any element `a` of type `α`, and any multiset `s` of type `α`, the element `a` is a member of the multiset formed by prepending `a` to `s`. In other words, if we add an element to the multiset, then that element is definitely in the multiset.

For any type `α`, any element `a` of type `α`, and any multiset `s` of type `α`, `a` is a member of the multiset obtained by adding `a` to `s`.


theorem Filter.eventually_ge_atTop : ∀ {α : Type u_3} [inst : Preorder α] (a : α), ∀ᶠ (x : α) in Filter.atTop, a ≤ x :=
  by sorry

The theorem `Filter.eventually_ge_atTop` asserts that for any type `α` that is equipped with a preorder, and for any element `a` from that type, all points `x` in the filter `atTop` (which represents the limit to infinity) will eventually (or at some point) satisfy the condition that `a` is less than or equal to `x`. In simple terms, beyond a certain point in the order, all elements are greater than or equal to `a`.

For any preordered type `α` and element `a` in `α`, all elements `x` in the filter of upper bounds `atTop` eventually satisfy `a ≤ x`.


SimpleGraph.ext

theorem SimpleGraph.ext : ∀ {V : Type u} (x y : SimpleGraph V), x.Adj = y.Adj → x = y := by sorry

This theorem, `SimpleGraph.ext`, states that for any type `V`, if we have two simple graphs `x` and `y`, and their adjacency relations `x.Adj` and `y.Adj` are the same, then the two simple graphs `x` and `y` are also the same. In the context of graph theory, this means that two simple graphs are considered equal if they have the same set of edges, as the adjacency relation defines the connections between vertices in a graph.

If two simple graphs have equal adjacency relations, then they are equal as graphs.


theorem norm_inv : ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a : α), ‖a⁻¹‖ = ‖a‖⁻¹ := by sorry

This theorem, titled "norm_inv", states that for any type `α` that forms a normed division ring, the norm of the inverse of any element `a` from `α` is equal to the inverse of the norm of `a`. In mathematical terms, this is saying that ‖a⁻¹‖ = ‖a‖⁻¹ for any `a` in `α`.

For any normed division ring `α`, the norm of the multiplicative inverse of any `a` in `α` is the reciprocal of the norm of `a`.


theorem GaloisConnection.l_le :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {a : α} {b : β}, a ≤ u b → l a ≤ b :=
  by sorry

This theorem states that for any types `α` and `β` which have preorder relations, and for any functions `l : α → β` and `u : β → α` which form a Galois connection, if an element `a` of type `α` is less than or equal to `u b` (where `b` is an element of type `β`), then `l a` is less than or equal to `b`. This is a part of the definition of a Galois connection which states that `l a ≤ b` if and only if `a ≤ u b`. In essence, this theorem captures one direction of this equivalence.

For any Galois connection between preordered types `α` and `β` and elements `a : α` and `b : β` with `a ≤ u b`, it holds that `l a ≤ b`.


theorem Sym2.ind : ∀ {α : Type u_1} {f : Sym2 α → Prop}, (∀ (x y : α), f s(x, y)) → ∀ (i : Sym2 α), f i := by sorry

The theorem `Sym2.ind` states that for any type `α` and any property `f` defined on unordered pairs of elements of `α` (expressed as `Sym2 α`), if the property `f` holds for any pair `(x, y)` of elements of `α`, then it holds for any unordered pair `i` in `Sym2 α`. This is a form of principle of mathematical induction tailored for the symmetric square of a type.

If `f` is a property of unordered pairs of elements in type `α`, and `f x y` holds for all pairs `(x, y)` in `Sym2 α`, then `f i` holds for all `i` in `Sym2 α`.


theorem star_zero : ∀ (R : Type u) [inst : AddMonoid R] [inst_1 : StarAddMonoid R], star 0 = 0 := by sorry

This theorem states that for any type `R` which has both an additive monoid structure and a 'star' additive monoid structure, if we apply the 'star' operation to the zero element of the additive monoid, we will get the zero element back. In mathematical terms, if `R` is an additive monoid and a star additive monoid, then the star of zero in `R` is equal to zero.

For any additive monoid and star additive monoid `R`, the star of its additive identity is equal to the additive identity itself.


HasFDerivWithinAt.fderivWithin

theorem HasFDerivWithinAt.fderivWithin :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {x : E} {s : Set E},
      HasFDerivWithinAt f f' s x → UniqueDiffWithinAt 𝕜 s x → fderivWithin 𝕜 f s x = f' :=
  by sorry

This theorem, named `HasFDerivWithinAt.fderivWithin`, states that for every nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F` (where `E` and `F` are also normed spaces over `𝕜`), a function `f` from `E` to `F`, a continuous linear map `f'` from `E` to `F`, a point `x` in `E`, and a set `s` of elements from `E`; if the function `f` has a derivative `f'` within the set `s` at the point `x`, and the set `s` has unique tangent vectors at `x` (indicated by `UniqueDiffWithinAt 𝕜 s x`), then the Frechet derivative of `f` within the set `s` at `x` (given by `fderivWithin 𝕜 f s x`) equals `f'`. This theorem provides a connection between having a derivative at a point within a set and the Frechet derivative at that point within the set.

If a function between normed spaces has a unique derivative within a set at a point and the set has the property of unique tangent vectors at that point, then the Frechet derivative of the function within the set at that point equals the derivative at that point.


theorem pure_le_nhds : ∀ {X : Type u} [inst : TopologicalSpace X], pure ≤ nhds := by sorry

This theorem states that for any type `X` endowed with a topology (i.e., `X` is a topological space), the pure filter is less than or equal to the neighborhood filter. In mathematical terms, for every point in the topological space `X`, the principal filter generated by that point is contained within the collection of all neighborhoods of that point.

For every point in a topological space, the principal filter generated by that point is contained in the neighborhood filter.


theorem Real.norm_of_nonneg : ∀ {r : ℝ}, 0 ≤ r → ‖r‖ = r := by sorry

This theorem, `Real.norm_of_nonneg`, asserts that in the real number system, for every real number `r` that is nonnegative (i.e., `r` is greater than or equal to 0), the norm (or absolute value) of `r` is equal to `r` itself. It reflects the property of the norm function where it returns the input value for nonnegative numbers.

For all real numbers `r`, if `r` is nonnegative, then the absolute value of `r` equals `r`.


theorem Submodule.mem_bot :
    ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
      x ∈ ⊥ ↔ x = 0 :=
  by sorry

This theorem states that for any semiring `R` and any additive commutative monoid `M` that is a module over `R`, any element `x` of `M` is in the bottom submodule (denoted by `⊥`) if and only if `x` is equal to zero. In other words, the bottom submodule only contains the zero element.

For any semiring `R` and additive commutative `R`-module `M`, the bottom submodule `⊥` equals the additive subgroup generated by the zero element.


Set.Nonempty.image

theorem Set.Nonempty.image :
    ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {s : Set α}, Set.Nonempty s → Set.Nonempty (f '' s) := by sorry

The theorem `Set.Nonempty.image` asserts that for all types `α` and `β`, and for any function `f` mapping elements from type `α` to `β`, if a set `s` of type `α` is non-empty (`Set.Nonempty s`), then the image of `s` under the function `f` (defined as `f '' s`) is also non-empty (`Set.Nonempty (f '' s)`). In other words, if we have a function and a set that isn't empty, when we apply this function to all elements in the set, the resulting set of output values is also not empty.

If `f` is a function from type `α` to type `β` and `s ≠ ∅` is a non-empty set of type `α`, then `f '' s ≠ ∅`.


theorem CategoryTheory.MonoidalCategory.whiskerLeft_comp :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (W : C) {X Y Z : C}
      (f : X ⟶ Y) (g : Y ⟶ Z),
      CategoryTheory.MonoidalCategory.whiskerLeft W (CategoryTheory.CategoryStruct.comp f g) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft W f)
          (CategoryTheory.MonoidalCategory.whiskerLeft W g) :=
  by sorry

This theorem states that for any objects `W`, `X`, `Y`, and `Z` in a monoidal category `C`, the whisker left operation with a morphism `f` from `X` to `Y` and a morphism `g` from `Y` to `Z` is the composition of the whisker left operations with `f` and `g` respectively. In other words, the operation of whiskering on the left respects composition of morphisms.

In mathematical terms, if we take two morphisms `f: X ⟶ Y` and `g: Y ⟶ Z` in the category `C`, the whisker left operation applied to the composition `f ≫ g` is equal to the composition of the whisker left operation applied to `f` and the whisker left operation applied to `g`. The whisker left operation is a kind of "action" of the category on morphisms, changing them in a way that depends on another object `W`. This theorem says that this action respects the composition of morphisms.

For any morphisms `f: X ⟶ Y` and `g: Y ⟶ Z` in a monoidal category `C`, the whisker left operation with their composition is equal to the composition of the whisker left operations with `f` and `g` respectively.


theorem
  ContinuousMultilinearMap.instAddCommGroupContinuousMultilinearMapToSemiringToAddCommMonoidToAddCommMonoid.proof_1 :
    ∀ {M₂ : Type u_1} [inst : AddCommGroup M₂] [inst_1 : TopologicalSpace M₂] [inst_2 : TopologicalAddGroup M₂],
      ContinuousAdd M₂ :=
  by sorry

This theorem states that for any type `M₂`, given that `M₂` forms an additive commutative group, has a defined topology, and is a topological additive group, the addition operation in `M₂` is continuous. In other words, the theorem asserts the continuity of addition in a topological additive commutative group.

In a topological additive commutative group, the addition operation is a continuous function.


theorem Fintype.card_ofFinset :
    ∀ {α : Type u_1} {p : Set α} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ x ∈ p), Fintype.card ↑p = s.card := by sorry

This theorem, `Fintype.card_ofFinset`, states that for any type `α`, any set `p` of type `α`, and any finite set `s` of type `α`, if each element `x` of type `α` belongs to `s` if and only if it belongs to `p`, then the cardinality (or the number of elements) of the type `p`, when `p` is considered as a `Fintype`, is equal to the cardinality of the finite set `s`. In other words, both `p` and `s` have the same number of elements under the condition that their membership relation is equivalent.

If `p` is a finite subset of type `α` such that `x ∈ p` if and only if `x ∈ s`, then `#p = #s`, where `#` denotes the cardinality.


OrderHom.monotone

theorem OrderHom.monotone :
    ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β), Monotone ⇑f := by sorry

This theorem states that for any two types `α` and `β` with preorder structures, any order-preserving function `f` from `α` to `β` is necessarily monotone. In other words, if `a` and `b` are elements of `α` such that `a` is less than or equal to `b`, then the image of `a` under `f` is less than or equal to the image of `b` under `f`.

For any type `α` and `β` with preorders, and any order-preserving function `f` from `α` to `β`, if `a ≤ b` in `α`, then `f(a) ≤ f(b)` in `β`.


theorem Nat.succ_mul : ∀ (n m : ℕ), Nat.succ n * m = n * m + m := by sorry

This theorem states that for any two natural numbers `n` and `m`, the product of the successor of `n` (i.e., `n + 1` in common mathematical notation) and `m` is equal to the sum of the product of `n` and `m`, and `m`. In standard mathematical notation, this is saying that for all natural numbers n and m, (n + 1) * m = n * m + m. This is a basic property of natural number arithmetic, reflecting the distributive law.

For all natural numbers n and m, (n + 1) * m = n * m + m.


theorem Order.succ_le_of_lt :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α}, a < b → Order.succ a ≤ b := by sorry

The theorem `Order.succ_le_of_lt` states that for any given preorder set `α` with a successor order and any two elements `a` and `b` from `α`, if `a` is less than `b`, then the successor of `a` is less than or equal to `b`. In other words, if `a` is strictly less than `b`, then the next element after `a` in the order (or `a` itself if `a` is the maximal element) is not greater than `b`.

For any preorder set with a successor order, if `a` is less than `b`, then `a.successor` is less than or equal to `b`.


Eq.symm

/-- Equality is symmetric: if `a = b` then `b = a`.

Because this is in the `Eq` namespace, if you have a variable `h : a = b`,
`h.symm` can be used as shorthand for `Eq.symm h` as a proof of `b = a`.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
theorem Eq.symm : ∀ {α : Sort u} {a b : α}, a = b → b = a := by sorry

This theorem states that equality is symmetric, meaning if `a` equals `b`, then `b` equals `a`. Here, `α` denotes any type or sort, and `a` and `b` are variables of this type. If you have a proof `h` that `a = b`, you can use `h.symm` or `Eq.symm h` to obtain a proof of `b = a`. This theorem is a fundamental property of equality in logic and mathematics.

If `a = b`, then `b = a`. (Equality is reflexive and symmetric.)


theorem CategoryTheory.Limits.limit.hom_ext :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      {F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] {X : C}
      {f f' : X ⟶ CategoryTheory.Limits.limit F},
      (∀ (j : J),
          CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.limit.π F j) =
            CategoryTheory.CategoryStruct.comp f' (CategoryTheory.Limits.limit.π F j)) →
        f = f' :=
  by sorry

The theorem `CategoryTheory.Limits.limit.hom_ext` states that for any category `J` with a functor `F` to another category `C` (where `C` is also a category) and any object `X` in `C`, if there exist two morphisms `f` and `f'` from `X` to the limit object of the functor `F`, then `f` equals `f'` if and only if, for every object `j` in `J`, the composition of `f` and the projection from the limit object to the image of `j` under `F` equals the composition of `f'` and the same projection. In other words, it shows the uniqueness of a morphism into the limit, up to precomposition with the morphisms from the limit cone.

For any functor from a category to another category and an object in the target category, if there exist two morphisms from the object to the limit of the functor, then they are equal if and only if their compositions with the projections from the limit to the images of objects under the functor are equal.


theorem Set.mem_Ioi : ∀ {α : Type u_1} [inst : Preorder α] {a x : α}, x ∈ Set.Ioi a ↔ a < x := by sorry

The theorem `Set.mem_Ioi` states that for any type `α` equipped with a preorder, and for any elements `a` and `x` of this type, `x` belongs to the interval `(a, +∞)` (denoted `Set.Ioi a` in Lean), if and only if `a` is strictly less than `x`. This sets up a correspondence between the membership of `x` in the interval `(a, +∞)` and the inequality `a < x`. This interval is a left-open right-infinite interval, meaning it includes all the elements greater than `a` but not `a` itself.

For any preordered type `α` and elements `a` and `x` of `α`, `x` belongs to the left-open right-infinite interval `(a, +∞)` if and only if `a` is strictly less than `x`.


theorem AlgHom.map_mul :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) (x y : A), φ (x * y) = φ x * φ y :=
  by sorry

This theorem states that for any commutative semiring `R` and any two semirings `A` and `B`, given an algebra structure over `R` on `A` and `B`, for any algebra homomorphism `φ` from `A` to `B` over `R`, the image of the product of two elements `x` and `y` in `A` under `φ` is equal to the product of the images of `x` and `y` under `φ`. This is a statement about the homomorphism preserving multiplication.

For any commutative semiring `R`, algebra structures over `R` on semirings `A` and `B`, and algebra homomorphism `φ` from `A` to `B` over `R`, the image of the product of elements `x` and `y` in `A` under `φ` equals the product of the images of `x` and `y` in `B`.


theorem sSup_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {s : Set β} {f : β → α}, sSup (f '' s) = ⨆ a ∈ s, f a :=
  by sorry

This theorem states that for any types `α` and `β`, given that `α` is a complete lattice, and given a set `s` of type `β` and a function `f` from `β` to `α`, the supremum (`sSup`) of the image of `s` under `f` (`f '' s`) is equivalent to the supremum over all elements `a` in `s` of `f(a)`. In other words, the supremum of the transformed set under the function `f` is the same as the supremum over the original set with the function applied to each element. This is expressed in Lean 4 using the notation `⨆ a ∈ s, f a`.

For any complete lattice `α`, function `f` from type `β` to `α`, and set `s` of type `β`, the supremum of `f''s` equals the supremum over all `a` in `s` of `f(a)`, i.e., `sSup = ⨆ a ∈ s, f(a)`.


theorem CategoryTheory.Preadditive.comp_sub :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C}
      (f : P ⟶ Q) (g g' : Q ⟶ R),
      CategoryTheory.CategoryStruct.comp f (g - g') =
        CategoryTheory.CategoryStruct.comp f g - CategoryTheory.CategoryStruct.comp f g' :=
  by sorry

The theorem `CategoryTheory.Preadditive.comp_sub` states that in any preadditive category `C`, for any three objects `P`, `Q`, and `R` in `C`, and for any morphisms `f : P ⟶ Q` and `g, g' : Q ⟶ R`, the composition of `f` with the difference of `g` and `g'` (denoted `g - g'`) is equivalent to the difference of the composition of `f` with `g` and the composition of `f` with `g'`. This property essentially shows the compatibility of the composition operation with the subtraction operation in a preadditive category.

In any preadditive category, for all objects P, Q, R and morphisms f : P ⟶ Q, g, g' : Q ⟶ R, the composition of f with g - g' is equivalent to f * g - f * g'.


theorem Nat.cast_lt :
    ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_3 : ZeroLEOneClass α]
      [inst_4 : CharZero α] {m n : ℕ}, ↑m < ↑n ↔ m < n :=
  by sorry

This theorem states that for any type `α` that satisfies certain properties, specifically being an additive monoid with a one element, having a partial order, satisfying the covariant class property with respect to addition and less than or equal to relation, having a zero element less than or equal to the one element, and having characteristic zero, the natural number cast of `m` is less than the natural number cast of `n` if and only if `m` is less than `n`. In other words, the less than relation is preserved under the casting from natural numbers to the type `α`.

For any additive monoid with one element, partial order, covariant class property for addition and less-than-or-equal relation, zero element less than one, and characteristic zero `α`, the natural number less-than relation is equivalent to the relation induced by natural number casts in `α`.


/-- A subgroup is closed under inverse.  -/
theorem Subgroup.inv_mem : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G}, x ∈ H → x⁻¹ ∈ H := by sorry

This theorem states that for any subgroup `H` of a group `G`, if an element `x` belongs to `H`, then the inverse of `x` (denoted as `x⁻¹`) also belongs to `H`. This is a property of subgroups in group theory, which states that subgroups are closed under the operation of taking inverses. In other words, every element in a subgroup has its inverse also in the same subgroup.

For any subgroup `H` of a group `G`, if `x` is an element of `H`, then `x⁻¹` (the inverse of `x`) is also an element of `H`.


Primrec.id

theorem Primrec.id : ∀ {α : Type u_1} [inst : Primcodable α], Primrec id := by sorry

The theorem `Primrec.id` states that for any type `α` that is primcodable (i.e., can be encoded as a natural number), the identity function `id` on `α` is primitive recursive. In other words, when the input and output of the identity function are encoded as natural numbers, the resulting function is primitive recursive.

The identity function on a primcodable type is primitive recursive.


theorem MeasureTheory.Measure.restrict_le_self :
    ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, μ.restrict s ≤ μ := by sorry

This theorem states that for any type `α`, any `MeasurableSpace` on `α`, any measure `μ` from the Measure Theory on `α`, and any set `s` of type `α`, the restriction of the measure `μ` to the set `s` is always less than or equal to the original measure `μ`. This is a fundamental property in measure theory expressing that the measure of a subset does not exceed the measure of the whole set.

For any MeasurableSpace $(X, \Sigma)$, any measure $\mu : \Sigma \rightarrow \mathbb{R}_{\ge 0}$, and any $s \in \Sigma$, we have $\mu(s) \le \mu(\Omega)$, where $\Omega$ is the universal set of $X$.


theorem Filter.eventually_gt_atTop :
    ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : NoMaxOrder α] (a : α), ∀ᶠ (x : α) in Filter.atTop, a < x := by sorry

The theorem `Filter.eventually_gt_atTop` states that for any given type `α`, which has a `Preorder` and `NoMaxOrder` instance, and for any element `a` of type `α`, eventually (for some point and all points beyond that), elements `x` of type `α` will satisfy the condition `a < x` when moving towards the limit `∞` (represented by the filter `Filter.atTop`). In other words, this theorem guarantees that given any element in an ordered set with no maximum element, there will always be elements greater than it as we approach infinity.

For any element `a` in an ordered set without a maximum element, there exists a point beyond which all elements are strictly greater than `a`.


theorem Option.some_inj : ∀ {α : Type u_1} {a b : α}, some a = some b ↔ a = b := by sorry

This theorem, `Option.some_inj`, asserts that for all types `α` and for any two elements `a` and `b` of the type `α`, the `Option.some` function applied to `a` equals the `Option.some` function applied to `b` if and only if `a` equals `b`. In other words, it states the injectivity of the `Option.some` function: distinct inputs produce distinct outputs.

For all types `α` and elements `a, b` of `α`, `Option.some a = Option.some b` if and only if `a = b`.


theorem tsub_le_iff_left :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b c : α}, a - b ≤ c ↔ a ≤ b + c :=
  by sorry

This theorem, `tsub_le_iff_left`, states that for any type `α` that has a preorder structure, an additive commutative semigroup structure, a subtraction operation, and an ordered subtraction operation, and given any three elements `a`, `b`, and `c` of type `α`, the relation "the difference of `a` and `b` is less than or equal to `c`" is equivalent to the relation " `a` is less than or equal to the sum of `b` and `c`". In LaTeX terms, this states that for all $a, b, c$ in the set `α`, $a - b \leq c$ if and only if $a \leq b + c$.

For any type `α` with preorder, additive commutative semigroup, subtraction, and ordered subtraction structures, the subtraction `a - b` is less than or equal to `c` if and only if `a` is less than or equal to the sum `b + c`.


/-- In a pseudometric space, the extended distance is always finite -/
theorem edist_lt_top : ∀ {α : Type u_3} [inst : PseudoMetricSpace α] (x y : α), edist x y < ⊤ := by sorry

This theorem states that in a pseudometric space, the extended distance between any two points is always finite. Specifically, for any type `α` that forms a pseudometric space (as indicated by the assumption `[inst : PseudoMetricSpace α]`), and for any two elements `x` and `y` of `α`, the extended distance `edist x y` is less than infinity (`< ⊤`). This captures the idea that no matter which two points you pick in a pseudometric space, you can always assign a meaningful, finite distance between them.

In a pseudometric space, the extended distance between any two points is finite.


/-- If two sets are equal modulo a set of measure zero, then `μ s = μ t`.  -/
theorem MeasureTheory.measure_congr :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
      s =ᶠ[MeasureTheory.Measure.ae μ] t → ↑↑μ s = ↑↑μ t :=
  by sorry

This theorem states that, given a measurable space and a measure on that space, if two sets are essentially equal (they only differ by a set of measure zero), then the measure of these two sets is also the same. In other words, for any measurable space `α`, measure `μ` on `α`, and sets `s` and `t` in `α`, if `s` and `t` are equal almost everywhere (ignoring a set of measure zero), then the measure of `s` is equal to the measure of `t`.

If two measurable sets have the same measure almost everywhere in a measurable space with respect to a given measure, then they have equal measures.


theorem add_tsub_cancel_left :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      [inst : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α), a + b - a = b :=
  by sorry

This theorem, `add_tsub_cancel_left`, states that for any type `α` that has a partial order, an additive commutative semigroup structure, a subtraction operation, and an ordered subtraction property, and where addition is a contravariant operation with respect to the order, if you have two elements `a` and `b` of this type, then adding `a` to `b` and then subtracting `a` results in `b`. In simple mathematical terms, it can be represented as `a + b - a = b`.

For any additive commutative semigroup with subtraction and ordered subtraction property, where addition is contravariant with respect to the order, the order of elements `a` and `b` does not matter, as `a + b = b + a` implies `a + b - a = b`.


ContinuousAt.tendsto

theorem ContinuousAt.tendsto :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {x : X},
      ContinuousAt f x → Filter.Tendsto f (nhds x) (nhds (f x)) :=
  by sorry

The theorem `ContinuousAt.tendsto` states that for all types `X` and `Y` endowed with topological space structure, and for any function `f` from `X` to `Y` and any point `x` in `X`, if `f` is continuous at `x`, then `f` has the property that for every neighborhood of `f(x)`, the pre-image under `f` of that neighborhood is a neighborhood of `x`. This is essentially stating that the limit of `f` at `x` in the source topological space equals `f(x)` in the target topological space, which is a generic way of expressing the concept of continuity in topology.

If `f` is a continuous function from a topological space `X` to a topological space `Y` at a point `x` in `X`, then for every neighborhood `V` of `f(x)` in `Y`, there exists a neighborhood `U` of `x` in `X` such that `f(U)` is a subset of `V`.


CovBy.lt

theorem CovBy.lt : ∀ {α : Type u_1} [inst : LT α] {a b : α}, a ⋖ b → a < b := by sorry

This theorem, `CovBy.lt`, states that for all types `α` that have a less-than (`<`) operation, if `a` is covered by `b` (denoted `a ⋖ b`), then `a` is less than `b`. This is a universal claim, holding for any possible values of `a` and `b` of type `α`.

For all types `α` with a less-than operation, if `a ⋖ b` holds, then `a < b`.


theorem Finset.coe_map : ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α), ↑(Finset.map f s) = ⇑f '' ↑s := by
  sorry

This theorem states that for any embedding `f` from a type `α` to a type `β`, and for any finset `s` of type `α`, the set representation (coe) of the mapped finset (`Finset.map f s`) is equal to the image of the set representation of `s` under `f`. In other words, if we apply the embedding to each element of the finset and form a new finset from the results, converting this new finset into a set yields the same result as first converting the original finset into a set and then applying the embedding to each element.

For any embedding `f` and finset `s`, the image of the set representation of `s` under `f` is equal to the set representation of the mapped finset `Finset.map f s`.


theorem List.get?_eq_get :
    ∀ {α : Type u_1} {l : List α} {n : ℕ} (h : n < List.length l),
      List.get? l n = some (List.get l { val := n, isLt := h }) :=
  by sorry

This theorem states that for any type `α`, any list `l` of type `α`, and any natural number `n`, if `n` is less than the length of the list `l`, then retrieving the `n`-th element of `l` using the function `List.get?` returns the same value as using the function `List.get` with `n` and the proof of `n < length l`. In other words, the two functions `List.get?` and `List.get` are equivalent in retrieving the `n`-th element of a list, provided `n` is a valid index within the list.

For any type `α`, list `l` of length `m` over `α`, and natural number `n` with `n < m`, `List.get? l n = List.get l n`.


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

This theorem, `Mathlib.Data.Nat.Cast.Order._auxLemma.11`, states that for any type `α` that is an instance of `OrderedSemiring` and `Nontrivial` and for any natural number `n` that is at least two, the statement that `0` is less than `n` when `n` is cast to the type `α` using the `OfNat.ofNat` function, is always true. In simpler terms, it ensures that when you cast a natural number `n` (which is at least two) to any nontrivial ordered semiring, the result is always greater than zero.

For any `α` an instance of `OrderedSemiring` and `Nontrivial`, and `n` a natural number greater than or equal to 2, `0 < OfNat.ofNat n : α`.


theorem Filter.Tendsto.mono_right :
    ∀ {α : Type u} {β : Type v} {f : α → β} {x : Filter α} {y z : Filter β},
      Filter.Tendsto f x y → y ≤ z → Filter.Tendsto f x z :=
  by sorry

The theorem `Filter.Tendsto.mono_right` states that for all types `α` and `β`, for any function `f` from `α` to `β`, and for any filters `x` on `α` and `y` and `z` on `β`, if the function `f` tends towards the filter `y` under the filter `x`, and if the filter `y` is a subset of the filter `z`, then the function `f` also tends towards the filter `z` under the filter `x`. In other words, if `f` maps every neighborhood of `x` to a neighborhood of `y`, and `y` is contained in `z`, then `f` maps every neighborhood of `x` to a neighborhood of `z`.

If a function tends towards a filter under another filter, and the smaller filter is a subset of a larger filter, then the function also tends towards the larger filter under the same domain filter.


CategoryTheory.Over.w

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

This theorem states that for any category `T` and any object `X` in `T`, if `A` and `B` are objects in the over category of `X` and `f` is a morphism from `A` to `B` in this over category, then the composition of the morphism `f` with the homomorphism of `B` is the same as the homomorphism of `A`. In other words, if we consider `A` and `B` as arrows in `T` with codomain `X`, this theorem guarantees that composing `f` with the arrow of `B` gives us the arrow of `A`. This description captures the commutativity of the triangle formed by `A`, `B`, and `X` in the over category of `X`.

Given a category T and an object X, for any objects A and B in the over category of X, and a morphism f from A to B in this over category, the composition of f with the structure morphism of B is equal to the structure morphism of A.


theorem tsum_congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α},
      (∀ (b : β), f b = g b) → ∑' (b : β), f b = ∑' (b : β), g b :=
  by sorry

This theorem states that for any two functions `f` and `g` from an arbitrary type `β` to a type `α`, given that `α` forms an additive commutative monoid and has a defined topological space, if all values of `f` and `g` are equal for every item in `β`, then the summation of `f` over all elements of `β` is equal to the summation of `g` over all elements of `β`. In other words, if two functions produce the same output for every input, then the infinite sum of their outputs will also be the same.

If two functions from an arbitrary type to an additive commutative monoid with a topological space have equal values for all elements, then their summations over the entire type are equal.


theorem Matrix.mul_assoc :
    ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalSemiring α]
      [inst_1 : Fintype m] [inst_2 : Fintype n] (L : Matrix l m α) (M : Matrix m n α) (N : Matrix n o α),
      L * M * N = L * (M * N) :=
  by sorry

This theorem, `Matrix.mul_assoc`, states that for any four types `l`, `m`, `n`, and `o`, and any type `α` that is a non-unital semiring, given three matrices `L`, `M`, and `N`, with `L` being a matrix from `l` to `m` with entries in `α`, `M` being a matrix from `m` to `n` with entries in `α`, and `N` being a matrix from `n` to `o` with entries in `α`, the matrix multiplication operation is associative. In other words, multiplying `L`, `M`, and `N` in the order `(L * M) * N` is the same as multiplying them in the order `L * (M * N)`. This property holds true regardless of the actual entries of the matrices.

For any non-unital semiring type α and matrices L from l to m, M from m to n, and N from n to o with entries in α, the associativity of matrix multiplication holds: (L * M) * N = L * (M * N).


theorem Nat.Linear.ExprCnstr.eq_true_of_isValid :
    ∀ (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr),
      Nat.Linear.PolyCnstr.isValid (Nat.Linear.ExprCnstr.toNormPoly c) = true →
        Nat.Linear.ExprCnstr.denote ctx c = True :=
  by sorry

The theorem `Nat.Linear.ExprCnstr.eq_true_of_isValid` states that for any context `ctx` of type `Nat.Linear.Context` and an expression constraint `c` of type `Nat.Linear.ExprCnstr`, if the polynomial constraint obtained by converting `c` to a normalized polynomial is valid (as determined by the function `Nat.Linear.PolyCnstr.isValid`), then the denotation of the expression constraint `c` in the context `ctx` is true. This essentially means that if the polynomial version of an expression constraint is valid, then the expression constraint itself is also valid or holds true in its context.

If a normalized polynomial constraint derived from a Nat.Linear.ExprCnstr in a given context is valid, then the expression constraint holds true in that context.


Eq.substr

theorem Eq.substr : ∀ {α : Sort u} {p : α → Prop} {a b : α}, b = a → p a → p b := by sorry

This is a theorem in the Lean 4 theorem prover about substituting equals with equals in logical expressions. In more detail, given a type α, a predicate p over α, and two elements a and b of type α, if b equals a, and if p holds for a, then p also holds for b. This theorem follows from the principle of substitutability, which states that if two values are equal, one can be substituted for the other in any formula without changing the truth of the formula.

If a = b and p(a) is a proposition, then p(b) is propositionally equal to p(a).


theorem Filter.eventually_atTop :
    ∀ {α : Type u_3} [inst : SemilatticeSup α] [inst_1 : Nonempty α] {p : α → Prop},
      (∀ᶠ (x : α) in Filter.atTop, p x) ↔ ∃ a, ∀ b ≥ a, p b :=
  by sorry

The theorem `Filter.eventually_atTop` states that for any type `α` which is a semilattice and is nonempty, and for any predicate `p` on `α`, the property `p` holds eventually as `x` approaches infinity (i.e., for all `x` beyond some point) if and only if there exists a value `a` in `α` such that `p` holds for all `b` greater than or equal to `a`. In other words, it provides an equivalence between "eventually for all `x` in the limit towards infinity, `p x` holds" and "there exists an `a` such that for all `b` that are greater than or equal to `a`, `p b` holds".

For any semilattice type `α` and predicate `p` on `α`, ` Filter.eventually_atTop α p` holds if and only if there exists an element `a` in `α` such that for all `b` greater than or equal to `a`, `p b` holds.


theorem Polynomial.eval₂_C :
    ∀ {R : Type u} {S : Type v} {a : R} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S),
      Polynomial.eval₂ f x (Polynomial.C a) = f a :=
  by sorry

This theorem states that for any semirings `R` and `S`, any ring homomorphism `f` from `R` to `S`, any element `a` of `R`, and any element `x` of `S`, the evaluation of the constant polynomial `a` at `x` under the homomorphism `f` equals the image of `a` under `f`. In other words, performing a polynomial evaluation on a constant polynomial simply maps the constant through the given ring homomorphism.

For any semirings R and S, ring homomorphism f : R -> S, element a in R, and element x in S, f(a) = (eval\_poly f a x) (constant\_poly a).


theorem Filter.image_mem_map :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {s : Set α}, s ∈ f → m '' s ∈ Filter.map m f := by sorry

This theorem states that for any types `α` and `β`, any filter `f` on `α`, any function `m` from `α` to `β`, and any set `s` of type `α`, if `s` is a member of the filter `f`, then the image of `s` under the function `m` is a member of the filter obtained by applying the map function on `m` and `f`. In mathematical terms, if `s` is in the filter `f`, then the image of `s` under `m` is in the forward map of `f` under `m`.

If `f` is a filter on type `α`, `m` is a function from `α` to `β`, and `s` is a subset of `α` that belongs to `f`, then the image of `s` under `m` belongs to the filter obtained by applying the map function to `m` and `f`.


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

This theorem, called `Finset.insert_erase`, states that for any type `α` that has decidable equality (`DecidableEq α`), for any finite set `s` of type `α` (`Finset α`), and for any element `a` of type `α`, if `a` is an element of `s` (`a ∈ s`), then inserting `a` into the set obtained from `s` by erasing `a` (`insert a (Finset.erase s a)`) results in the original set `s`. In other words, if you remove an element from a set and then add it back, you get the original set.

For any type `α` with decidable equality and any finite set `s` of type `α`, `insert a (Finset.erase s a) = s`, where `a` is an element of `s`.


theorem intervalIntegral.integral_of_le :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {f : ℝ → E}
      {μ : MeasureTheory.Measure ℝ}, a ≤ b → ∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in Set.Ioc a b, f x ∂μ :=
  by sorry

This theorem states that for any normed additive commutative group `E` and any normed space over the real numbers `ℝ` with elements `a` and `b` such that `a` is less than or equal to `b`, and any function `f` from the real numbers to `E`, and any measure `μ`, the definite integral of `f` with respect to `μ` over the interval from `a` to `b` is equal to the integral of `f` with respect to `μ` over the left-open right-closed interval from `a` to `b` - denoted `Set.Ioc a b`. In other words, the theorem asserts the equality of two different ways of defining the integral of a function on an interval in the real numbers.

For any normed additive commutative group `E`, any normed space over the real numbers with elements `a` and `b` such that `a ≤ b`, any function `f` from the real numbers to `E`, and any measure `μ`, the definite integrals of `f` with respect to `μ` over the interval `[a, b]` and the left-open right-closed interval `Set.Ioc a b` are equal.


theorem if_false : ∀ {α : Sort u_1} {h : Decidable False} (t e : α), (if False then t else e) = e := by sorry

This theorem states that for any type `α` and any two instances `t` and `e` of `α`, the result of the conditional expression "if False then `t` else `e`" is always `e`. It doesn't matter how we decide on "False," because the "if" part of the conditional is never true by definition, so we always get the "else" part.

For all types `α` and instances `t` and `e` of `α`, the conditional expression `if False then t else e` equals `e`.


theorem MeasureTheory.Measure.sum_apply :
    ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} (f : ι → MeasureTheory.Measure α) {s : Set α},
      MeasurableSet s → ↑↑(MeasureTheory.Measure.sum f) s = ∑' (i : ι), ↑↑(f i) s :=
  by sorry

The theorem `MeasureTheory.Measure.sum_apply` states that for any given type `α` and index type `ι`, along with a measurable space `α` and a function `f` that maps `ι` to a measure on `α`, if `s` is a measurable set of `α`, then the measure of `s` under the sum of the measures defined by `f` is equal to the sum of the measures of `s` under each individual measure defined by `f`. This is an important property that keeps the behavior of measures consistent when dealing with indexed families of measures. Essentially, it says that the sum of measures of a set under different measures is equivalent to the measure of the set under the sum of those measures.

For any measurable space `(α, Σ, μ)` and index type `ι`, if `f : ι → μ(α)` is a family of measures on `α`, then for any measurable set `s ∈ Σ`, we have `∑ i : ι, mu s i = mu (∑ i : ι, s)`.


theorem add_add_add_comm :
    ∀ {G : Type u_3} [inst : AddCommSemigroup G] (a b c d : G), a + b + (c + d) = a + c + (b + d) := by sorry

This theorem states that for any type `G` that has an addition operation (and where this operation is commutative and associative, i.e., forms an addition commutative semigroup), for any four elements `a`, `b`, `c`, and `d` of `G`, the sum of `a`, `b`, `c`, and `d` is the same regardless of whether `b` and `c` are grouped together or `c` and `d` are grouped together. In other words, `a + b + (c + d)` is equal to `a + c + (b + d)`.

For any commutative and associative addition semigroup `G`, the order of adding two elements does not affect the sum: `a + b + c = a + c + b` for all `a, b, c` in `G`.


Asymptotics.IsBigOWith.isBigO

theorem Asymptotics.IsBigOWith.isBigO :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E} {g : α → F}
      {l : Filter α}, Asymptotics.IsBigOWith c l f g → f =O[l] g :=
  by sorry

The theorem `Asymptotics.IsBigOWith.isBigO` states that for any types `α`, `E`, `F` and any normed spaces `E` and `F`, for any real number `c`, and for any functions `f: α → E` and `g: α → F`, and for any filter `l` on `α`, if it is true that the function `f` is Big-O of `g` with respect to the filter `l` and constant `c` (in the sense of the definition `Asymptotics.IsBigOWith`), then `f` is Big-O of `g` with respect to the filter `l` (in the sense of the relation `=O[l]`). In simpler terms, if the norms of `f` are eventually bounded by `c` times the norms of `g` for `l`, then `f` is Big-O of `g` for `l`.

If `f` is Big-O of `g` with respect to filter `l` and constant `c` according to the definition `Asymptotics.IsBigOWith`, then `f = O(g)` with respect to filter `l`.


theorem Set.insert_eq : ∀ {α : Type u} (x : α) (s : Set α), insert x s = {x} ∪ s := by sorry

This theorem states that for any type `α`, any element `x` of type `α`, and any set `s` of elements of type `α`, the set obtained by inserting the element `x` into the set `s` is equal to the union of the singleton set containing `x` and the set `s`. In other words, adding an element to a set can also be seen as taking the union of the original set with a new set that contains only the element to be added.

For any type `α`, and for any set `s` of elements from `α` and any element `x` in `α`, the set `{x} ∪ s` equals `{x} ⋃ s`. (Here, `{x}` denotes the singleton set containing `x`.)


theorem le_sInf :
    ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] {s : Set α} {a : α}, (∀ b ∈ s, a ≤ b) → a ≤ sInf s := by sorry

The theorem `le_sInf` states that for any type `α` that has an instance of a complete semilattice with an infimum (`CompleteSemilatticeInf α`), for any set `s` of this type `α`, and for any element `a` of type `α`, if `a` is less than or equal to every element `b` in the set `s`, then `a` is less than or equal to the infimum (`sInf`) of the set `s`. In simpler terms, if `a` is less than or equal to all elements of a set, then it is also less than or equal to the greatest lower bound of the set.

If `α` is a complete semilattice with an infimum and `a` is in `α` such that `a ≤ b` for all `b` in a set `s` of `α`, then `a ≤ sInf s`.


theorem Finsupp.sum_single_index :
    ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] {a : α} {b : M}
      {h : α → M → N}, h a 0 = 0 → Finsupp.sum (fun₀ | a => b) h = h a b :=
  by sorry

The theorem `Finsupp.sum_single_index` states that for all types α, M and N, where M is equipped with a Zero structure and N has an Additive Commutative Monoid structure, for any elements 'a' of type α and 'b' of type M, and a function 'h' from pairs of type α and M to N, if applying 'h' to 'a' and 0 yields 0, then the sum (using the `Finsupp.sum` definition) of the function 'h' applied to elements of the support of the singleton function (which maps 'a' to 'b' and everything else to 0) is equal to the result of applying 'h' to 'a' and 'b'. In simpler terms, this theorem relates the sum over a singleton set to a direct application of the function in question.

For any type α, M with Zero structure, and N with Additive Commutative Monoid structure, if the function h from α × M to N satisfies h(a, 0) = 0 for all a ∈ α, then Σ(x : α) h(x, m) = h(a, m) for any singleton function {a} → M mapping to m.


theorem Real.exp_zero : Real.exp 0 = 1 := by sorry

This theorem states that the value of the exponential function `Real.exp`, when evaluated at 0, is equal to 1. In mathematical terms, it's saying that $e^0 = 1$, where $e$ is the base of the natural logarithm.

The base of the natural logarithm raised to the power of 0 equals 1. (equivalent to $e^0 = 1$)


MeasureTheory.VectorMeasure.ext

theorem MeasureTheory.VectorMeasure.ext :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      {s t : MeasureTheory.VectorMeasure α M}, (∀ (i : Set α), MeasurableSet i → ↑s i = ↑t i) → s = t :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.ext` states that for any measurable space `α` and any type `M` that has an additive commutative monoid structure and a topological space structure, two vector measures `s` and `t` on `α` with values in `M` are equal if and only if they assign the same measure to every measurable set `i`. In other words, if for every measurable set `i`, the measure of `i` according to `s` is equal to the measure of `i` according to `t`, then `s` and `t` are the same vector measure.

Two vector measures on a measurable space with values in an additive commutative monoid and topological space have equal values on all measurable sets if and only if they are equal.


theorem Array.data_toArray : ∀ {α : Type u_1} (as : List α), (List.toArray as).data = as := by sorry

This theorem, named `Array.data_toArray`, states that for any type `α` and any list `as` of type `α`, the data of the array obtained by converting the list `as` to an array using the `List.toArray` function, is equal to the original list `as`. In other words, the function `List.toArray` preserves the data of the list when it is converted into an array.

For any list `as` of type `α`, the array obtained by converting `as` to an array using `List.toArray` has the same elements as the original list.