HasStrictFDerivAt.hasFDerivAt

theorem HasStrictFDerivAt.hasFDerivAt :
    ∀ {𝕜 : 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}, HasStrictFDerivAt f f' x → HasFDerivAt f f' x :=
  by sorry

The theorem `HasStrictFDerivAt.hasFDerivAt` states that for any field `𝕜` with a non-trivial norm structure, and for any normed additive commutative groups `E` and `F` that also have a normed space structure over `𝕜`, if a function `f : E → F` has a strict Fréchet derivative `f' : E →L[𝕜] F` at a point `x : E` (that is, the change in `f` at `x` is exactly described by `f'`), then `f` also has (the possibly weaker notion of) a Fréchet derivative `f'` at `x` (that is, the change in `f` at `x` can be approximated by `f'` plus a term that vanishes faster than the difference `x' - x` as `x'` tends to `x`).

If a function `f : E → F` between normed additive commutative groups endowed with a normed space structure over a field `𝕜` with a non-trivial norm structure has a strict Fréchet derivative `f' : E →L[𝕜] F` at a point `x : E`, then `f` has a Fréchet derivative `f'` at `x`.


theorem tsub_le_tsub_right :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
      {a b : α}, a ≤ b → ∀ (c : α), a - c ≤ b - c :=
  by sorry

This theorem states that for any type `α` which is a preorder, an additive commutative semigroup, has a subtraction operation, and supports ordered subtraction, if `a` and `b` are elements of this type such that `a` is less than or equal to `b`, then for any other element `c` of this type, `a - c` is less than or equal to `b - c`. In other words, subtracting the same quantity from two elements in an order does not change the order relation between them.

For any preorder type `α` that is an additive commutative semigroup with subtraction and ordered subtraction, if `a ≤ b`, then `a - c ≤ b - c` for all `c` in `α`.


theorem Set.inter_subset_inter_left : ∀ {α : Type u} {s t : Set α} (u : Set α), s ⊆ t → s ∩ u ⊆ t ∩ u := by sorry

The theorem `Set.inter_subset_inter_left` states that for any type `α` and any three sets `s`, `t`, and `u` of type `α`, if set `s` is a subset of set `t` then the intersection of set `s` and set `u` is a subset of the intersection of set `t` and set `u`. In terms of set theory, this theorem tells us that if we have a subset relationship between two sets, then that relationship is preserved when we intersect both sets with a third one.

If `s` is a subset of `t`, then `s ∩ u` is a subset of `t ∩ u`.


theorem MultilinearMap.map_smul :
    ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] (f : MultilinearMap R M₁ M₂) [inst_5 : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (c : R)
      (x : M₁ i), f (Function.update m i (c • x)) = c • f (Function.update m i x) :=
  by sorry

This theorem, `MultilinearMap.map_smul`, states that for any semiring `R`, an index type `ι`, and types `M₁` and `M₂` indexed by `ι` such that `M₁` and `M₂` are modules over `R`, a multilinear map `f` from `M₁` to `M₂`, a function `m` from `ι` to `M₁`, an index `i` in `ι`, and a scalar `c` in `R`, and a value `x` in `M₁ i`, if we update the value of `m` at `i` with `c` times `x`, and then apply the multilinear map `f`, we get the same result as if we first update the value of `m` at `i` with `x`, apply `f`, and then multiply by `c`. In mathematical terms, this theorem says that multilinear maps respect scalar multiplication, that is, $f(c \cdot x) = c \cdot f(x)$ for all scalars $c$ and all vectors $x$.

For any semiring `R`, multilinear maps `f` from `M₁` to `M₂` over `R`, functions `m` from `ι` to `M₁`, scalars `c` in `R`, and values `x` in `M₁ i`, we have `f (c * x) = c * f x`.


theorem Set.mapsTo_univ : ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ := by sorry

The theorem `Set.mapsTo_univ` asserts that for all types `α` and `β`, and for any function `f` from `α` to `β`, and for any set `s` of elements of type `α`, the function `f` maps the set `s` into the universal set of `β`. In other words, the image of any element in `s` under `f` is an element in `β`. This follows from the definition of `Set.univ`, which contains all elements of `β` and thus the image of any function into `β` must be contained in `Set.univ`.

For any type `α`, type `β`, set `s` of `α`, and function `f` from `α` to `β`, `f` maps `s` into the universal set `Set.univ` of `β`, that is, for all `x in s`, `f x isin Set.univ`.


theorem CategoryTheory.unop_comp :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
      (CategoryTheory.CategoryStruct.comp f g).unop = CategoryTheory.CategoryStruct.comp g.unop f.unop :=
  by sorry

The theorem `CategoryTheory.unop_comp` states that for any category `C` and any objects `X`, `Y`, and `Z` in the opposite category `Cᵒᵖ`, and morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the unopposite of the composition of `f` and `g` (i.e., `(CategoryTheory.CategoryStruct.comp f g).unop`) is equal to the composition of the unoppisite of `g` and the unopposite of `f` (i.e., `CategoryTheory.CategoryStruct.comp g.unop f.unop`). In terms of category theory, this theorem demonstrates that reversing the arrows in a category also reverses the order of composition of morphisms.

In the opposite category of any category C, the unopposites of morphism compositions are equal: `(f.unop ∘ g.unop) = g.unop ∘ f.unop`, for any morphisms `f: X ← Y` and `g: Y ← Z` in C.


theorem disjoint_sdiff_self_right : ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], Disjoint x (y \ x) :=
  by sorry

The theorem `disjoint_sdiff_self_right` states that for any type `α` that forms a Generalized Boolean Algebra, and any elements `x` and `y` of `α`, the element `x` and the difference of `y` and `x` (`y \ x`) are disjoint. In the context of this lattice-based structure, two elements being disjoint means that any element that is less than or equal to both of them is also less than or equal to the bottom element of the lattice.

For any type `α` forming a Generalized Boolean Algebra and elements `x, y` in `α`, `x` and `y \ x` are disjoint, i.e., there is no element less than or equal to both `x` and `y \ x`.


theorem Mathlib.Data.Finset.Basic._auxLemma.174 :
    ∀ {α : Type u_1} {x : α} {p : α → Bool} {as : List α}, (x ∈ List.filter p as) = (x ∈ as ∧ p x = true) := by sorry

This theorem states that for any type `α`, any element `x` of type `α`, any Boolean-valued function `p` on `α`, and any list `as` of type `α`, the proposition that `x` is an element of the list obtained by filtering `as` with `p` is equivalent to the conjunction of the propositions that `x` is an element of `as` and `p` applied to `x` returns `true`. In other words, an item is in the filtered list if and only if it is in the original list and it satisfies the filtering condition.

For any type `α`, any element `x` of type `α`, any Boolean-valued function `p` on `α`, and any list `as` of type `α`, the element `x` belongs to the filtered list `[x | x ∈ as | p x]` if and only if `x` belongs to `as` and `p x` evaluates to `true`.


/-- Two maps from a coequalizer are equal if they are equal when composed with the coequalizer
map  -/
theorem CategoryTheory.Limits.coequalizer.hom_ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      [inst_1 : CategoryTheory.Limits.HasCoequalizer f g] {W : C} {k l : CategoryTheory.Limits.coequalizer f g ⟶ W},
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) k =
          CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) l →
        k = l :=
  by sorry

The theorem `CategoryTheory.Limits.coequalizer.hom_ext` states that within a category `C`, for any objects `X`, `Y`, and `W`, and morphisms `f` and `g` from `X` to `Y`, given that `f` and `g` have a coequalizer, if there exist two morphisms `k` and `l` from the coequalizer of `f` and `g` to `W` such that composing the projection from `Y` to the coequalizer with `k` is equal to composing the same projection with `l`, then `k` and `l` are equal. In other words, in the context of category theory, it asserts the uniqueness property for morphisms out of the coequalizer.

In a category, if two morphisms have a coequalizer and there exists a morphism from the coequalizer to another object that equals the composition of the projection from the coequalizer to the coequalizer with each of the original morphisms, then these two morphisms from the original object to the coequalizer are equal.


MeasureTheory.StronglyMeasurable.mono

theorem MeasureTheory.StronglyMeasurable.mono :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {m m' : MeasurableSpace α} [inst : TopologicalSpace β],
      MeasureTheory.StronglyMeasurable f → m' ≤ m → MeasureTheory.StronglyMeasurable f :=
  by sorry

The theorem `MeasureTheory.StronglyMeasurable.mono` states that for any two types `α` and `β`, given a function `f` from `α` to `β`, and two `MeasurableSpace` instances `m` and `m'` on `α`, if `f` is strongly measurable (in the sense that `f` is the limit of simple functions) and `m'` is a subspace of `m`, then `f` is also strongly measurable with respect to `m'`. Here, the topological space structure is on `β` and the measurability of `f` is with respect to the measurable spaces on `α`. The ≤ symbol represents the subspace relation between two measurable spaces.

If `f` is a strongly measurable function from a measurable space `(α, m)` to another measurable space `(β, βTOP)`, and `(α, m')` is a subspace of `(α, m)`, then `f` is strongly measurable with respect to `(α, m')`.


TypeVec.Arrow.ext

/-- Extensionality for arrows  -/
theorem TypeVec.Arrow.ext :
    ∀ {n : ℕ} {α : TypeVec.{u_1} n} {β : TypeVec.{u_2} n} (f g : TypeVec.Arrow α β),
      (∀ (i : Fin2 n), f i = g i) → f = g :=
  by sorry

This theorem, `TypeVec.Arrow.ext`, states that for any two arrows (functions) 'f' and 'g' in the category of `TypeVec`, from 'α' to 'β', if they are point-wise equal (i.e., for every index 'i' in the finite set `Fin2 n`, 'f' at index 'i' equals 'g' at index 'i'), then the arrows 'f' and 'g' themselves are equal. In other words, it's an extensionality theorem for arrows in the category of `TypeVec`, asserting that two arrows are equal if they behave the same way on all inputs.

In the category of TypeVec, two functions with the same point-wise behavior at all indices are equal.


theorem Set.range_comp_subset_range :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → γ), Set.range (g ∘ f) ⊆ Set.range g := by sorry

The theorem `Set.range_comp_subset_range` states that for all types `α`, `β`, and `γ` and for any two functions `f` from `α` to `β` and `g` from `β` to `γ`, the range of the composition of `g` and `f` (denoted as `g ∘ f`) is a subset of the range of `g`. This means every element of the set that is the output of the composite function `g ∘ f` is also an element of the set that is the output of the function `g`.

For all types α, β, γ and functions f : α → β and g : β → γ, the range of their composition g ∘ f is a subset of the range of g. In mathematical notation, range(g ∘ f) ⊆ range(g).


theorem CategoryTheory.NatTrans.congr_app :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F G : CategoryTheory.Functor C D} {α β : F ⟶ G},
      α = β → ∀ (X : C), α.app X = β.app X :=
  by sorry

This theorem states that in the context of category theory, for any two categories `C` and `D`, and any two functors `F` and `G` from `C` to `D`, if two natural transformations `α` and `β` from `F` to `G` are equal, then their applications to any object `X` in `C` are also equal. In other words, if two natural transformations are the same, they behave the same way when applied to any object in the source category.

For any categories C, D, functors F and G from C to D, and natural transformations α and β from F to G, if α = β, then for all objects X in C, α(X) = β(X).


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

This theorem states that for any type `G` that forms an additive group, for any two elements `a` and `b` of `G`, the sum of `a` and `b` equals zero if and only if `a` equals the additive inverse of `b`. In mathematical terms, this is expressed as `a + b = 0` if and only if `a = -b`. This is a key property in the theory of additive groups.

For any additive group `G` and elements `a, b` in `G`, `a + b = 0` if and only if `a = -b`.


theorem ciSup_le' :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {f : ι → α} {a : α},
      (∀ (i : ι), f i ≤ a) → ⨆ i, f i ≤ a :=
  by sorry

This theorem states that for any type `α` under the condition that it is a conditionally complete linear order with a least element (also known as a "bottom"), a function `f` from some type `ι` to `α`, and a specific element `a` of type `α`, if all values of `f(i)` are less than or equal to `a` for any `i` of type `ι`, then the supremum (or least upper bound) of the set of all `f(i)` (symbolized by `⨆ i, f i`) is also less than or equal to `a`. Essentially, if every value a function produces is less than or equal to a certain number, then the maximum value that function can produce is also less than or equal to that number.

If `α` is a conditionally complete linear order with a least element, and `f: ι → α` is a function such that `f i ≤ a` for all `i`, then `⨆ i, f i ≤ a`.


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

The theorem `AddMonoidHom.map_sub` states that for any given additive group homomorphism `f` from a type `α` to a type `β`, both of which have subtraction structures, the homomorphism will preserve the subtraction operation. This means that applying the homomorphism `f` to the result of subtracting `h` from `g` (where `g` and `h` are elements of type `α`) will yield the same result as subtracting the image of `h` under `f` from the image of `g` under `f` in type `β`. In mathematical terms, this can be written as `f(g - h) = f(g) - f(h)`.

Given an additive group homomorphism \(f : \alpha \to \beta\) between additive groups, \(f(g - h) = f(g) - f(h)\) for all \(g, h \in \alpha\).


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

This theorem states that for any two propositions `a` and `b`, the statement "not `a` is equivalent to `b`" is itself equivalent to the statement "not `b` is equivalent to `a`". In other words, the logical not operation can be "transferred" across an equivalence (iff) from one side to the other, and this process is commutative.

The logical negation of an equivalence is equivalent to the reversed equivalence.


theorem succ_nsmul' : ∀ {M : Type u_2} [inst : AddMonoid M] (a : M) (n : ℕ), (n + 1) • a = a + n • a := by sorry

This theorem states that for any type `M` that is an instance of an Additive Monoid, and for any element `a` of this type `M` and natural number `n`, the scalar multiplication of `n + 1` with `a` is equal to `a` added to the scalar multiplication of `n` with `a`. This is essentially a property of distributivity in additive monoids.

For any additive monoid M and its element a, and natural number n, the operation of scaling by n+1 is equal to the operation of scaling by n followed by adding a to the result. (a.k.a. Distributivity of scaling over addition in additive monoids)


theorem Finset.coe_smul_finset :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] (a : α) (s : Finset β),
      ↑(a • s) = a • ↑s :=
  by sorry

The theorem `Finset.coe_smul_finset` states that for any types `α` and `β`, given that `β` has a decidable equality and that `α` can be multiplied with `β` (i.e., `α` is a scalar and `β` is a space that allows scalar multiplication), for any scalar `a` of type `α` and any finite set `s` of type `β`, the scalar multiplication of `a` and `s` (denoted as `a • s`) coerced to a set is equal to the scalar multiplication of `a` and the coerced set `s` (denoted as `a • ↑s`). In other words, scalar multiplication distributes over the coercion of a finite set to a set.

For any scalar `α` and finite set `β`, if `β` has decidable equality and `α` can be multiplied with `β`, then `a • s` equals `a • ↑s` for any scalar `a` of type `α` and finite set `s` of type `β`.


theorem Sum.inr_injective : ∀ {α : Type u} {β : Type v}, Function.Injective Sum.inr := by sorry

The theorem `Sum.inr_injective` states that for any types `α` and `β`, the function `Sum.inr : β → α ⊕ β` (which sends each element of `β` to itself in the right component of the sum type `α ⊕ β`) is injective. This means that if `Sum.inr b₁ = Sum.inr b₂` for some `b₁, b₂ : β`, then it must be the case that `b₁ = b₂`.

The function `Sum.inr : β -> α ⊕ β` is a injection (or equivalently, distinct elements of `β` map to distinct elements of `α ⊕ β` under `Sum.inr`).


theorem List.prod_append :
    ∀ {M : Type u_5} [inst : Monoid M] {l₁ l₂ : List M}, List.prod (l₁ ++ l₂) = List.prod l₁ * List.prod l₂ := by sorry

This theorem states that for any type `M` equipped with a monoid structure, and for any two lists `l₁` and `l₂` of elements of type `M`, the product of the elements in the concatenated list `l₁ ++ l₂` is equal to the product of the multiplication of the product of the elements in `l₁` and the product of the elements in `l₂`. In other words, if you compute the product of the elements in two separate lists and then multiply those results together, you get the same result as if you had first concatenated the two lists and then computed the product of all the elements in the combined list. This is essentially saying that the product operation over a list respects the monoid structure of the type of the elements in the list.

For any monoid `M` and lists `l₁` and `l₂` of `M`, the product of the concatenated list `l₁ ++ l₂` equals the product of the products of the lists `l₁` and `l₂`. In other words, `∀ (M : Type*) [Monoid M], (∀ i j, m i * m j = m (l₁ ++ l₂) i j)`.


theorem Int.add_le_add_right : ∀ {a b : ℤ}, a ≤ b → ∀ (c : ℤ), a + c ≤ b + c := by sorry

This theorem states that for any three integer values `a`, `b`, and `c`, if `a` is less than or equal to `b`, then the sum of `a` and `c` is also less than or equal to the sum of `b` and `c`. This is also known as the principle of preserving order under addition in the integers.

For all integers a, b, and c, if a ≤ b then a + c ≤ b + c.


theorem ne_eq : ∀ {α : Sort u_1} (a b : α), (a ≠ b) = ¬a = b := by sorry

This theorem, `ne_eq`, states that for all types `α` and for any two elements `a` and `b` of that type, the assertion that `a` is not equal to `b` (`a ≠ b`) is equivalent to the negation of the assertion that `a` is equal to `b` (`¬a = b`). In other words, it formally encodes the intuitive notion that saying "A is not equal to B" is the same as saying "It is not the case that A is equal to B".

The theorem `ne_eq` asserts that for all types `α` and elements `a` and `b` of type `α`, the propositions `a ≠ b` and `¬a = b` are logically equivalent.


theorem HasDerivAt.comp_hasFDerivWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type w} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {𝕜' : Type u_1} [inst_3 : NontriviallyNormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜']
      {h₂ : 𝕜' → 𝕜'} {h₂' : 𝕜'} {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} {s : Set E} (x : E),
      HasDerivAt h₂ h₂' (f x) → HasFDerivWithinAt f f' s x → HasFDerivWithinAt (h₂ ∘ f) (h₂' • f') s x :=
  by sorry

This theorem states that if a function `h₂` has a derivative `h₂'` at the point `f(x)`, and another function `f` has a Fréchet derivative `f'` within a set `s` at the point `x`, then the composition of the functions `h₂ ∘ f` also has a Fréchet derivative `h₂' • f'` within the set `s` at the same point `x`. Here, `𝕜` and `𝕜'` are types representing non-trivially normed fields, and `E` is a type representing an additive commutative group that is also a normed space over `𝕜`. The operator `•` denotes scalar multiplication, and `∘` denotes function composition.

If functions `f : E → E` and `h₂ : 𝕜 → 𝕜'` have derivatives `f' : E → E` and `h₂' : 𝕜 → 𝕜'` respectively at points `x : E` and `y : 𝕜` with `y = f(x)`, then the composition `h₂ ∘ f` has a Fréchet derivative `h₂' • f'` at point `x`.


theorem Equiv.swap_apply_of_ne_of_ne :
    ∀ {α : Sort u_1} [inst : DecidableEq α] {a b x : α}, x ≠ a → x ≠ b → (Equiv.swap a b) x = x := by sorry

The theorem `Equiv.swap_apply_of_ne_of_ne` states that for any type `α` that has decidable equality (expressed by `DecidableEq α`), and for any three elements `a`, `b`, and `x` of that type, if `x` is not equal to `a` and `x` is not equal to `b`, then applying the swap operation `Equiv.swap a b` to `x` leaves `x` unchanged. In other words, the function `Equiv.swap a b` acts as the identity on elements distinct from `a` and `b`. This swap operation, `Equiv.swap a b`, is a permutation that swaps the positions of `a` and `b` and leaves all other elements as they are.

For any type `α` with decidable equality and distinct elements `a`, `b`, and `x` of `α`, `Equiv.swap a b x = x`.


TensorProduct.ext

/-- This used to be an `@[ext]` lemma, but it fails very slowly when the `ext` tactic tries to apply
it in some cases, notably when one wants to show equality of two linear maps. The `@[ext]`
attribute is now added locally where it is needed. Using this as the `@[ext]` lemma instead of
`TensorProduct.ext'` allows `ext` to apply lemmas specific to `M →ₗ _` and `N →ₗ _`.

See note [partially-applied ext lemmas].  -/
theorem TensorProduct.ext :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
      [inst_6 : Module R P] {g h : TensorProduct R M N →ₗ[R] P},
      LinearMap.compr₂ (TensorProduct.mk R M N) g = LinearMap.compr₂ (TensorProduct.mk R M N) h → g = h :=
  by sorry

The theorem `TensorProduct.ext` states that for any commutative semiring `R`, and any modules `M`, `N`, `P` over `R`, if two linear maps `g` and `h` from the tensor product of `M` and `N` over `R` to `P` are such that the composition of each map with the canonical bilinear map from `M` and `N` to their tensor product is the same, then the two linear maps `g` and `h` are equal. In more compact terms, if `LinearMap.compr₂ (TensorProduct.mk R M N) g = LinearMap.compr₂ (TensorProduct.mk R M N) h`, then `g = h`. This theorem provides a criterion for equality of linear maps in terms of their compositions with a specific bilinear map.

If `g` and `h` are linear maps from the tensor product of modules `M` and `N` over a commutative semiring `R` to module `P`, and `LinearMap.compr₂ (TensorProduct.mk R M N) g = LinearMap.compr₂ (TensorProduct.mk R M N) h`, then `g = h`.


theorem Fin.le_last : ∀ {n : ℕ} (i : Fin (n + 1)), i ≤ Fin.last n := by sorry

The theorem `Fin.le_last` states that for any natural number `n` and any element `i` of the finite ordered set `Fin (n + 1)`, `i` is less than or equal to the greatest value of `Fin (n + 1)`, denoted as `Fin.last n`. In other words, all elements of the finite set `Fin (n + 1)` are less than or equal to the maximum element of that set.

For any natural number `n` and element `i` of `Fin (n + 1)`, `i ≤ Fin.last n`.


/-- See also `finite_or_infinite`, `fintypeOrInfinite`.  -/
theorem Set.finite_or_infinite : ∀ {α : Type u} (s : Set α), Set.Finite s ∨ Set.Infinite s := by sorry

The theorem `Set.finite_or_infinite` states that for any set `s` of an arbitrary type `α`, the set `s` is either finite or infinite. In other words, given any set `s`, there exists a logical disjunction - `s` is a finite set (there exists a natural number `n` and an equivalence between the set `s` and `Fin n`), or `s` is an infinite set (it is not finite). This theorem provides a comprehensive partition of all sets into two mutually exclusive categories: finite and infinite sets.

Every set can be classified as either finite or infinite.


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

This theorem states that for any type `α` that has a partial order structure, given any two elements `a` and `b` of type `α`, `a` is less than or equal to `b` if and only if `a` is equal to `b` or `a` is strictly less than `b`. It essentially defines the 'less than or equal to' relation in terms of equality and strict less than relation.

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


Finset.Subset.trans

theorem Finset.Subset.trans : ∀ {α : Type u_1} {s₁ s₂ s₃ : Finset α}, s₁ ⊆ s₂ → s₂ ⊆ s₃ → s₁ ⊆ s₃ := by sorry

This theorem, `Finset.Subset.trans`, states that for any three finite sets (`Finset`) `s₁`, `s₂`, and `s₃` of any type `α`, if `s₁` is a subset of `s₂` and `s₂` is a subset of `s₃`, then `s₁` is also a subset of `s₃`. This is a formal statement of the transitivity property for subset relations among finite sets.

If `s₁ ⊆ s₂` and `s₂ ⊆ s₃`, then `s₁ ⊆ s₃` (`s₁` is a subset of `s₃` if `s₁` is a subset of `s₂` and `s₂` is a subset of `s₃`).


theorem IsAbsoluteValue.abv_nonneg :
    ∀ {S : Type u_5} [inst : OrderedSemiring S] {R : Type u_6} [inst_1 : Semiring R] (abv : R → S)
      [inst_2 : IsAbsoluteValue abv] (x : R), 0 ≤ abv x :=
  by sorry

The theorem `IsAbsoluteValue.abv_nonneg` states that for any ordered semiring `S`, semiring `R`, and any function `abv` from `R` to `S` that is an absolute value, the absolute value of any element `x` from `R` is always nonnegative. In other words, the absolute value of a number, under these mathematical conditions, can never be less than zero.

For any ordered semiring (S, ≤) and semiring (R, +, *) with an absolute value function abv : R -> S, ∀ x : R, abv x ≥ 0.


theorem Set.mulIndicator_of_not_mem :
    ∀ {α : Type u_1} {M : Type u_4} [inst : One M] {s : Set α} {a : α},
      a ∉ s → ∀ (f : α → M), Set.mulIndicator s f a = 1 :=
  by sorry

The theorem `Set.mulIndicator_of_not_mem` states that for any types `α` and `M`, where `M` has the structure of a monoid (given by the instance `One M`), any set `s` of type `α`, and any element `a` of type `α`, if `a` is not an element of the set `s`, then for any function `f` mapping elements of `α` to `M`, the multiplicative indicator function of the set `s` evaluated at `a` with respect to the function `f` is equal to the multiplicative identity in `M`, which is `1`. In other words, when an element does not belong to a particular set, the multiplicative indicator function for that set returns `1` irrespective of the function `f`.

For any monoid `M`, set `s` of type `α`, and element `a` not in `s`, the multiplicative indicator function `Set.mulIndicator s f` of `s` with respect to a function `f` mapping elements of `α` to `M` equals the multiplicative identity `1` in `M`.


theorem MeasureTheory.integral_nonneg :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ}, 0 ≤ f → 0 ≤ ∫ (a : α), f a ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_nonneg` states that for any measurable space `α`, any measure `μ` on that space, and any function `f` from `α` to the real numbers, if `f` is nonnegative (i.e., `f(a) ≥ 0` for all `a` in `α`), then the integral of `f` with respect to the measure `μ` is also nonnegative. In other words, if a function is nonnegative everywhere in a measurable space, then its integral over that space (under any measure) cannot be negative.

If `μ` is a measure on the measurable space `α` and `f: α → ℝ` is a nonnegative measurable function, then `∫f dμ ≥ 0`.


theorem vadd_eq_add : ∀ (α : Type u_10) [inst : Add α] {a a' : α}, a +ᵥ a' = a + a' := by sorry

This theorem, `vadd_eq_add`, states that for any type `α` that has an addition operation, the 'vector addition' of two elements `a` and `a'` of that type is equivalent to their standard addition. In other words, if you have two elements of a type that can be added together, the result of the 'vector addition' operation (represented by `+ᵥ`) is the same as the result of the standard addition operation (`+`).

For any type `α` with addition `+`, the vector addition of two elements `a` and `a'` is equivalent to their standard addition: `a +ᵥ a' = a + a'`.


Filter.NeBot.ne

theorem Filter.NeBot.ne : ∀ {α : Type u} {f : Filter α}, Filter.NeBot f → f ≠ ⊥ := by sorry

This theorem states that for any type `α` and any filter `f` of type `α`, if `f` is not a "bottom" filter (as denoted by `Filter.NeBot f`), then `f` is not equal to `⊥`. In other words, if `f` is not a trivial (or empty) filter, then `f` is not the least element in the order of filters, which is represented by `⊥` in Lean.

If `f` is a non-bottom filter on type `α`, then `f ≠ ⊥`.


theorem Filter.eventually_of_mem :
    ∀ {α : Type u} {f : Filter α} {P : α → Prop} {U : Set α}, U ∈ f → (∀ x ∈ U, P x) → ∀ᶠ (x : α) in f, P x := by sorry

This theorem, `Filter.eventually_of_mem`, states that for any type `α`, any filter `f` on `α`, any proposition `P` depending on an element of `α`, and any set `U` of elements of `α`: if `U` belongs to the filter `f` and the proposition `P` holds for all elements `x` in `U`, then `P` will eventually hold for all elements `x` in the filter `f`. This concept of "eventually" comes from the idea of filters which is a mathematical construction used in analysis and topology to generalize notions of limit and neighborhood.

If a set belongs to a filter and its elements satisfy a proposition, then every element in the filter eventually satisfies the proposition.


theorem CategoryTheory.Limits.prod.map_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
      [inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
      (f : W ⟶ Y) (g : X ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f g) CategoryTheory.Limits.prod.fst =
        CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst f :=
  by sorry

The theorem `CategoryTheory.Limits.prod.map_fst` states that, for all categories `C` and objects `W`, `X`, `Y`, `Z` in the category, given that there are binary products `W ⨯ X` and `Y ⨯ Z` in the category and morphisms `f : W ⟶ Y` and `g : X ⟶ Z`, the composition of the product map `CategoryTheory.Limits.prod.map f g` with the projection to the first component of the product `CategoryTheory.Limits.prod.fst` is equal to the composition of `CategoryTheory.Limits.prod.fst` and `f`. In other words, the map resulting from first applying the product map and then projecting onto the first component is the same as the map resulting from first projecting onto the first component and then applying `f`. This theorem is a part of the properties of categorical limits, specifically binary products, in Category Theory.

For all categories, objects, and morphisms, the composition of the product map with the first projection is equal to the first projection followed by the morphism.


theorem iInf_subtype' :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : CompleteLattice α] {p : ι → Prop} {f : (i : ι) → p i → α},
      ⨅ i, ⨅ (h : p i), f i h = ⨅ x, f ↑x ⋯ :=
  by sorry

This theorem states that for any complete lattice `α` and a predicate `p` on type `ι`, the infimum over `ι` of function `f` satisfying the predicate `p` is equal to the infimum of `f` over the subtype induced by the predicate `p`. In other words, the theorem ensures that the calculation of the infimum does not change when the domain of the function is restricted to a subtype defined by a certain predicate.

For any complete lattice `α` and a predicate `p` on type `ι`, the infimum of `f` over `ι` equals the infimum of `f` restricted to the subtype of `ι` where `p` holds.


theorem CategoryTheory.ShortComplex.hom_ext :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (f g : S₁ ⟶ S₂), f.τ₁ = g.τ₁ → f.τ₂ = g.τ₂ → f.τ₃ = g.τ₃ → f = g :=
  by sorry

This theorem states in the context of category theory that for any category `C` with zero morphisms, and any two short complexes `S₁` and `S₂` within that category, if two morphisms `f` and `g` from `S₁` to `S₂` have the same τ₁, τ₂, and τ₃ components, then `f` and `g` are indeed the same morphism.

In the category with zero morphisms `C`, if two complex morphisms `f` and `g` from complex `S₁` to complex `S₂` have equal componentwise truncations `τ₁`, `τ₂`, and `τ₃`, then `f` equals `g`.


theorem MeasureTheory.aestronglyMeasurable_const :
    ∀ {α : Type u_5} {β : Type u_6} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
      {b : β}, MeasureTheory.AEStronglyMeasurable (fun x => b) μ :=
  by sorry

The theorem `MeasureTheory.aestronglyMeasurable_const` states that for any types `α` and `β`, where `α` is equipped with a measurable space structure, `β` is equipped with a topological space structure, and a measure `μ` on `α`, for any constant function `b` from `α` to `β`, the function `(fun x => b)` is `AEStronglyMeasurable` with respect to the measure `μ`. This means that the constant function is almost everywhere equal to the limit of a sequence of simple functions.

For any measurable space `(α, Σ)`, topological space `(β, τ)`, measure `μ` on `(α, Σ)`, and constant function `b : α → β`, the function `(fun x => b)` is `AEStronglyMeasurable` with respect to `μ`.


theorem Ordinal.opow_pos : ∀ {a : Ordinal.{u_1}} (b : Ordinal.{u_1}), 0 < a → 0 < a ^ b := by sorry

The theorem `Ordinal.opow_pos` states that for any two ordinals `a` and `b`, if `a` is greater than 0, then `a` raised to the power of `b` is also greater than 0. In mathematical terms, this theorem is stating that for any two ordinal numbers `a` and `b`, if `a > 0` then `a^b > 0`. This is essentially a property of ordinal exponentiation, guaranteeing that a positive base results in a positive result when raised to any power.

For any ordinal numbers `a` and `b` with `a > 0`, `a^b > 0`.


theorem lie_add :
    ∀ {L : Type v} {M : Type w} [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L)
      (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆ :=
  by sorry

This theorem, `lie_add`, states that for any Lie ring `L` and any additive commutative group `M`, where `M` is also a module over the Lie ring `L`, the Lie bracket of an element `x` in `L` with the sum of two elements `m` and `n` in `M` is equal to the sum of the Lie bracket of `x` with `m` and the Lie bracket of `x` with `n`. In terms of mathematical notation, this is stating that for all `x`, `m`, and `n`, `[x, m + n] = [x, m] + [x, n]`, where `[.,.]` denotes the Lie bracket.

For any Lie ring `L` and additive commutative group `M` being an `L`-module, the Lie bracket of an element `x` in `L` with the sum of two elements `m` and `n` in `M` equals the sum of the Lie brackets of `x` with `m` and `n`, i.e., `[x, m + n] = [x, m] + [x, n]`.


theorem Equiv.swap_apply_right : ∀ {α : Sort u_1} [inst : DecidableEq α] (a b : α), (Equiv.swap a b) b = a := by sorry

The theorem `Equiv.swap_apply_right` states that for any type `α` that has decidable equality, given any two elements `a` and `b` of type `α`, applying the "swap" permutation (which is defined such that it swaps `a` and `b` and leaves other values unchanged) to `b` results in `a`. In other words, if we swap `a` and `b` and then look at the position of `b`, we will find `a` there.

For any type `α` with decidable equality and any `a, b : α`, swapping `a` and `b` yields `b` becoming equal to `a`.


IsPreconnected.image

/-- The image of a preconnected set is preconnected as well.  -/
theorem IsPreconnected.image :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α},
      IsPreconnected s → ∀ (f : α → β), ContinuousOn f s → IsPreconnected (f '' s) :=
  by sorry

The theorem `IsPreconnected.image` states that for any two types `α` and `β`, equipped with their respective topological spaces, and for any set `s` of type `α`, if `s` is preconnected and there is a function `f` from `α` to `β` that is continuous on `s`, then the image of `s` under `f` is also preconnected. In simpler terms, this theorem asserts that the continuous image of a preconnected set remains preconnected.

If `s` is a preconnected subset of a topological space `(α, τα)`, and `f : α → β` is a continuous function, then the image `f''(s)` is also a preconnected subset of `(β, τβ)`.


theorem Nat.div_le_self : ∀ (n k : ℕ), n / k ≤ n := by sorry

This theorem states that for any two natural numbers `n` and `k`, the result of integer division of `n` by `k` is always less than or equal to `n`. This is always true regardless of the values of `n` and `k` because integer division rounds down, so `n / k` is always going to be less than `n` unless `k` is 1.

For all natural numbers n and k, ⌊n / k⌋ ≤ n. (Here, ⌊x⌋ denotes the floor function, which returns the largest integer less than or equal to x.)


/-- **Alias** of `Int.natCast_natAbs`. -/
theorem Int.coe_natAbs : ∀ (n : ℤ), ↑(Int.natAbs n) = |n| := by sorry

This theorem, referred to as an alias of `Int.natCast_natAbs`, states that for any integer `n`, the natural number obtained by applying the `Int.natAbs` function on `n` is equal to the absolute value of `n`. Here, `↑(Int.natAbs n)` represents the natural number cast as an integer. Essentially, it affirms that the absolute value operation on an integer and the `Int.natAbs` function (which returns the absolute value of an integer as a natural number) are equivalent when the natural number is cast back into an integer.

For any integer `n`, `Int.natAbs n = abs n` holds, where `abs` denotes the absolute value and `Int.natAbs` returns the absolute value as a natural number and then is cast back to an integer.


Nat.le.intro

theorem Nat.le.intro : ∀ {n m k : ℕ}, n + k = m → n ≤ m := by sorry

This theorem, `Nat.le.intro`, states that for all natural numbers `n`, `m`, and `k`, if `n + k` equals `m`, then `n` is less than or equal to `m`. It provides a method to introduce an inequality based on the properties of natural numbers, essentially stating that if you can add some natural number to `n` to reach `m`, then `n` must be less than or equal to `m`.

If `n + k = m` for natural numbers `n`, `m`, and `k`, then `n ≤ m`.


theorem neg_mul_eq_neg_mul : ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b := by
  sorry

This theorem, named `neg_mul_eq_neg_mul`, states that for any type `α` that has a multiplication operation (denoted by `Mul α`) and a distributive negation operation (denoted by `HasDistribNeg α`), the negation of the product of two elements `a` and `b` (i.e., `-(a * b)`) is equal to the product of the negation of `a` and `b` (`-a * b`). This is a generalization of the property from number theory where the negation of a product is equivalent to multiplying one of the factors by negative one.

For any type `α` with multiplication `Mul α` and distributive negation `HasDistribNeg α`, `-(a * b)` equals `-a * b` for all `a, b : α`.


theorem Rat.num_den : ∀ {a : ℚ}, Rat.divInt a.num ↑a.den = a := by sorry

This theorem, `Rat.num_den`, states that for any rational number `a`, the quotient of its numerator (`a.num`) divided by its denominator (`a.den`) when the denominator is treated as an integer (`↑a.den`), is equal to the original rational number `a`. In other words, if you form a new rational number by dividing the numerator by the denominator of a given rational number, you get the original rational number back. This is a fundamental property of rational numbers that is made precise in the context of Lean 4.

For any rational number `a`, `a.num / ↑a.den = a`.


theorem not_isMax : ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : NoMaxOrder α] (a : α), ¬IsMax a := by sorry

The theorem `not_isMax` asserts that for any type `α` which has a preorder structure and also satisfies the `NoMaxOrder` condition (i.e., there is no maximal element in the set), any element `a` of type `α` cannot be a maximal element. In other words, in a set with a preorder structure without a maximum element, there always exists some other element that is strictly greater than any given element.

In a preordered type without a maximum element, no element is maximal.


theorem orderOf_dvd_of_pow_eq_one : ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, x ^ n = 1 → orderOf x ∣ n := by
  sorry

The theorem `orderOf_dvd_of_pow_eq_one` states that for any type `G` that is a monoid and any element `x` of `G`, if `x` raised to the power `n` equals 1 then the order of `x` divides `n`. Here, the order of `x` is the smallest positive integer `n` for which `x` to the power `n` equals 1, or 0 if no such integer exists (which indicates that `x` is of infinite order). In mathematical notation, if $x^n = 1$, then $orderOf\ x | n$.

For any monoid `G` and its element `x`, if `x^n` equals 1 then the order of `x` divides `n`.


theorem Mathlib.Order.BoundedOrder._auxLemma.7 :
    ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (⊤ ≤ a) = (a = ⊤) := by sorry

This theorem, `Mathlib.Order.BoundedOrder._auxLemma.7`, states that for any type `α` with a partial order and an order top (greatest element), and for any element `a` of this type, the condition of the greatest element being less than or equal to `a` is equivalent to `a` being the greatest element. In terms of mathematical notation, `⊤ ≤ a` is equivalent to `a = ⊤`.

The greatest element `⊤` of a partially ordered type `α` is equal to any element `a` if and only if `⊤` is less than or equal to `a`.


theorem Int.one_mul : ∀ (a : ℤ), 1 * a = a := by sorry

This theorem states that for any integer 'a', the product of 1 and 'a' is equal to 'a'. In other words, it confirms the multiplicative identity property in the set of integers, which says that any number multiplied by 1 remains unchanged.

For all integers a, 1 * a = a. (This statement asserts the multiplicative identity property in the integers.)


theorem subset_convexHull :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
      (s : Set E), s ⊆ (convexHull 𝕜) s :=
  by sorry

This theorem states that for any given set `s` of type `E` within a module over an ordered semiring `𝕜`, the set `s` is a subset of its convex hull. In other words, all elements of `s` are also elements of the convex hull of `s`. In mathematical terms, if `𝕜` is an ordered semiring, `E` is an additive commutative monoid that forms a module over `𝕜`, and `s` is a set of elements from `E`, then `s ⊆ convexHull 𝕜 s`.

For any set `s` of elements from an additive commutative monoid `E` within a module over an ordered semiring `𝕜`, `s` is a subset of its convex hull.


theorem CategoryTheory.Limits.Fork.IsLimit.lift_ι :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
      {s t : CategoryTheory.Limits.Fork f g} (hs : CategoryTheory.Limits.IsLimit s),
      CategoryTheory.CategoryStruct.comp (hs.lift t) (CategoryTheory.Limits.Fork.ι s) =
        CategoryTheory.Limits.Fork.ι t :=
  by sorry

The theorem `CategoryTheory.Limits.Fork.IsLimit.lift_ι` states that for any category `C` with objects `X` and `Y`, and morphisms `f` and `g` between `X` and `Y`, given any two forks `s` and `t` on `f` and `g`, if `s` is a limit, then the composition of the lift of `t` with respect to `s` and the projection (`ι`) of `s` is equal to the projection of `t`. In simpler terms, if we have a limit structure on a fork, we can lift any other fork to it in a way that preserves the fork structure.

If $s$ and $t$ are forks on morphisms $f$ and $g$ in a category $C$ with limit $s$, then the projection of $t$ is equal to the composition of the lift of $t$ with respect to $s$ and the projection of $s$.


theorem add_lt_add_of_le_of_lt :
    ∀ {α : Type u_1} [inst : Add α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a ≤ b → c < d → a + c < b + d :=
  by sorry

This theorem, named `add_lt_add_of_le_of_lt`, states that for all types `α` equipped with an additive operation, a preorder (an ordering relation that is reflexive and transitive), and two covariant classes (that ensure compatibility between the additive operation and the ordering relations), given four elements `a`, `b`, `c`, and `d` of type `α`, if `a` is less than or equal to `b` and `c` is strictly less than `d`, then the sum of `a` and `c` is strictly less than the sum of `b` and `d`. In other words, if `a ≤ b` and `c < d`, then `a + c < b + d`.

For all types `α` with additive operation, preorder, and covariant classes: if `a ≤ b` and `c < d` in `α`, then `a + c < b + d`.


theorem iSup_apply :
    ∀ {α : Type u_9} {β : α → Type u_10} {ι : Sort u_11} [inst : (i : α) → SupSet (β i)] {f : ι → (a : α) → β a}
      {a : α}, iSup (fun i => f i) a = ⨆ i, f i a :=
  by sorry

This theorem, `iSup_apply`, states that for all types `α`, `β`, and `ι`, where `β` is dependent on `α`, along with an instance of the `SupSet` class for each `β i` where `i` is a member of `α`, and a function `f` from `ι` to `β a`, for any given `a` in `α`, the supremum, `iSup`, of `f i` evaluated at `a` is equal to the indexed supremum (denoted as ⨆ i) of `f i a`. In simpler terms, it states that the supremum of the function `f` at a particular value `a` is equivalent to the supremum of the values of `f` at `a` over all possible indices `i`.

For any type `α`, dependent type `β`, indexed family `SupSet` instances, and function `f` from `ι` to `β` indexed over `α`, the supremum of `f i` at `a` equals the indexed supremum of `f i a`.


theorem lt_add_of_le_of_pos :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] {a b c : α},
      b ≤ c → 0 < a → b < c + a :=
  by sorry

The theorem `lt_add_of_le_of_pos` states that for any type `α` that has an addition operation and a zero element (`AddZeroClass`), a preorder relation (`Preorder`), and obeys the property that adding an element to both sides of a relation preserves the order (`CovariantClass`), if `b` is less than or equal to `c` and `a` is greater than zero, then `b` is less than the sum of `c` and `a`. This theorem essentially formalizes the idea that adding a positive number to a value makes the result greater, under certain conditions.

If `α` is an additive preorder type with zero `0` and `a > 0`, then for all `b ≤ c`, we have `b < c + a`.


theorem Real.cos_neg : ∀ (x : ℝ), Real.cos (-x) = Real.cos x := by sorry

The theorem `Real.cos_neg` states that the cosine function has reflectional symmetry over the y-axis. Specifically, it asserts that for every real number `x`, the value of cosine at negative `x` (`Real.cos (-x)`) is equal to the value of cosine at `x` (`Real.cos x`). In mathematical terms, this is the property $\cos(-x) = \cos(x)$ for all real numbers `x`.

The cosine function is reflectionally symmetric over the y-axis, that is, cos(-\x) = cos(\x) for all real numbers \x.


theorem ENNReal.toReal_le_toReal : ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal ≤ b.toReal ↔ a ≤ b) := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b` that are not infinity (`⊤`), the inequality `a.toReal ≤ b.toReal` holds if and only if `a ≤ b`. In other words, when `a` and `b` are finite, comparing them as extended nonnegative real numbers or as standard real numbers gives the same result. This is a property that connects the orderings of the extended nonnegative reals and the standard reals.

For any finite extended nonnegative real numbers `a` and `b`, the equality `a.toReal = b.toReal` if and only if `a = b`. (The implication also holds with `≤` instead of `=` for the order relation.)


theorem CategoryTheory.Limits.biprod.lift_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {W X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f : W ⟶ X) (g : W ⟶ Y),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift f g) CategoryTheory.Limits.biprod.fst = f :=
  by sorry

This theorem states that for any category `C` with zero morphisms, and any objects `W`, `X`, `Y` in `C` where `X` and `Y` form a binary biproduct, the composition of the lift morphism from `W` to the biproduct `X ⊞ Y` with the projection onto the first summand `X` of the biproduct is equal to the original morphism `f : W ⟶ X`. In essence, the theorem is a statement about morphism composition in categories involving binary biproducts.

For any category with zero morphisms and any objects forming a binary biproduct, the lift morphism from one object to the biproduct and the projection onto the first summand compose to give the original morphism.


theorem Finset.sup_singleton :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {f : β → α} {b : β},
      Finset.sup {b} f = f b :=
  by sorry

The theorem `Finset.sup_singleton` states that for any types `α` and `β`, given a semilattice structure and a least element for `α` (the type `α` endowed with a semilattice structure and a least element is known as a bounded semilattice), a function `f` from `β` to `α`, and an element `b` of `β`, the supremum of the singleton set `{b}` under the function `f` is equal to the function `f` applied to `b`. In plain language, when a set has only one element, the supremum (greatest value) of the set under a function is just the value of the function at that single element.

For any semilattice `α` with least element, function `f` from `β` to `α`, and `b` in `β`, the supremum of the singleton set `{b}` under `f` equals `f(b)`.


theorem Real.Angle.tan_coe : ∀ (x : ℝ), Real.Angle.tan ↑x = Real.tan x := by sorry

This theorem states that for every real number `x`, the tangent of the angle corresponding to `x` (when `x` is interpreted as a real angle) is equal to the real tangent of `x`. In mathematical terms, for all `x` in real numbers, `tan(↑x)` (where `↑x` stands for the angle corresponding to `x`) equals `tan(x)`.

For all real numbers x, the tangent of the angle with radian measure x is equal to the real value of the tangent function of x.


theorem Set.finite_univ : ∀ {α : Type u} [inst : Finite α], Set.Finite Set.univ := by sorry

The theorem `Set.finite_univ` states that for any type `α`, if `α` is finite, then the universal set of `α` is also finite. Here, the universal set of a type `α` refers to the set containing all elements of `α`, and a set is considered finite if there exists a natural number `n` such that there is an equivalence between the set and `Fin n`, the set of natural numbers less than `n`. This theorem essentially bridges the concept of finiteness between the realms of type theory and set theory.

If `α` is a finite type, then the universal set of `α` is equivalent to `Fin (|α|)`, where `|α|` denotes the cardinality of `α`.


theorem MeasureTheory.measure_union_le :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} (s₁ s₂ : Set α),
      ↑↑μ (s₁ ∪ s₂) ≤ ↑↑μ s₁ + ↑↑μ s₂ :=
  by sorry

The theorem `MeasureTheory.measure_union_le` states that for any type `α` equipped with a `MeasurableSpace` structure and for any measure `μ` on `α`, the measure `μ` of the union of two sets `s₁` and `s₂` is always less than or equal to the sum of the measures of `s₁` and `s₂`. In other words, the measure of the union of two sets is at most the sum of their individual measures.

For any measurable spaces `(α, Σ, μ)` and sets `s₁, s₂ ∈ Σ`, we have `μ(s₁ ∪ s₂) ≤ μ(s₁) + μ(s₂)`.


theorem CategoryTheory.Iso.eq_inv_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
      g = CategoryTheory.CategoryStruct.comp α.inv f ↔ CategoryTheory.CategoryStruct.comp α.hom g = f :=
  by sorry

This theorem from category theory, `CategoryTheory.Iso.eq_inv_comp`, states that for any category `C` with objects `X`, `Y` and `Z`, and an isomorphism `α` from `X` to `Y`, the morphism `g` from `Y` to `Z` is equal to the composition of the inverse of `α` and `f` if and only if the composition of `α` and `g` is equal to `f`. In other words, the theorem describes a property of the composition of morphisms in a category involving an isomorphism.

For any category C, an isomorphism α from X to Y in C makes morphisms f : X → Z and g : Y → Z equal if and only if g = f ∘ α^(-1).


theorem norm_div : ∀ {α : Type u_1} [inst : NormedDivisionRing α] (a b : α), ‖a / b‖ = ‖a‖ / ‖b‖ := by sorry

This theorem states that for any normed division ring `α` and any elements `a` and `b` of `α`, the norm of the quotient `a / b` is equal to the quotient of the norms `‖a‖ / ‖b‖`. Here, the norm of an element in a normed division ring is a function that assigns a non-negative real number to each element such that it satisfies certain properties.

In a normed division ring, the norm of the quotient of two elements is equal to the quotient of their respective norms.


/-- In a pseudometric space, the extended distance is always finite -/
theorem edist_ne_top : ∀ {α : Type u} [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. The pseudometric space is defined over any type `α`. Given any two points `x` and `y` in this space, the theorem guarantees that the extended distance `edist x y` can never be infinite (`⊤`). In mathematical terms, this would be saying that for all points `x` and `y` in a given pseudometric space, the extended distance between `x` and `y` is not equal to infinity.

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


theorem Rat.cast_zero : ∀ {α : Type u_3} [inst : DivisionRing α], ↑0 = 0 := by sorry

This theorem states that for any type `α` which is a `DivisionRing`, the rational number zero (denoted as `↑0`) is equivalent to the zero of type `α` (denoted as `0`). In simple terms, it says that casting the rational number zero to any division ring type yields the zero element of that type.

For any division ring type `α`, the rational number zero `↑0` maps to the zero element `0` of type `α`.


theorem Set.Ioi_subset_Ici_self : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Ioi a ⊆ Set.Ici a := by sorry

The theorem `Set.Ioi_subset_Ici_self` states that for any type `α` which is a preorder, and any element `a` of type `α`, the set of all elements which are strictly greater than `a` (`Set.Ioi a`) is a subset of the set of all elements which are greater than or equal to `a` (`Set.Ici a`). In other words, if an element is in the left-open right-infinite interval `(a, +∞)`, it is also in the left-closed right-infinite interval `[a, +∞)`.

For any preorder type `α` and its element `a`, `Set.Ioi a` (strictly greater elements) is a subset of `Set.Ici a` (greater than or equal elements).


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

This theorem states that for any two cardinal numbers `a` and `b` in a certain type universe `u`, the lifting of `a` and `b` to a potentially larger universe `v` preserves the order relation. In other words, `a` is less than `b` in the original universe if and only if the lift of `a` is less than the lift of `b` in the larger universe. Here, 'less than' refers to cardinality, meaning that there is no bijection between the two sets, but there is an injective (one-to-one) function from the set with smaller cardinality to the set with larger cardinality.

For any cardinal numbers `a` and `b` in universe `u`, if `a` is smaller than `b` in cardinality, then their liftings to universe `v` also satisfy `lift a < lift b`.


theorem vadd_vadd :
    ∀ {M : Type u_1} {α : Type u_6} [inst : AddMonoid M] [inst_1 : AddAction M α] (a₁ a₂ : M) (b : α),
      a₁ +ᵥ (a₂ +ᵥ b) = a₁ + a₂ +ᵥ b :=
  by sorry

This theorem states that for any underlying type `M` that forms an additive monoid, and any type `α` on which `M` acts additively, the vector addition operation respects the associativity of the monoid's addition. Specifically, for any elements `a₁`, `a₂` of `M` and `b` of `α`, the equation `a₁ +ᵥ (a₂ +ᵥ b) = a₁ + a₂ +ᵥ b` holds. Here, `+ᵥ` denotes the vector addition operation, and `+` denotes the addition operation in the monoid `M`.
The `AddAction M α` structure indicates that `M` acts on `α` in a way that respects the addition operation in `M`.

For any additive monoid `M` and any additive action `AddAction M α`, the vector addition `+ᵥ` of elements in `M` on a type `α` is associative with respect to the monoid addition `+` of `M`, i.e., `(a₁ + a₂) +ᵥ b = a₁ +ᵥ (a₂ + b)` for all `a₁`, `a₂` in `M` and `b` in `α`.


theorem measurable_swap :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β}, Measurable Prod.swap := by sorry

The `measurable_swap` theorem states that for any types `α` and `β` and for any measurable spaces `m` over `α` and `mβ` over `β`, the function `Prod.swap` is measurable. The function `Prod.swap` takes a pair `(a, b)` and returns a pair `(b, a)`, essentially swapping the elements of the pair. The `Measurable` property ensures that the preimage of a measurable set under the `Prod.swap` function is also measurable.

The `Prod.swap` function on measurable spaces is measurable.


theorem Fin.val_lt_of_le : ∀ {n b : ℕ} (i : Fin b), b ≤ n → ↑i < n := by sorry

This theorem states that for any two natural numbers `n` and `b`, and any `i` which is a finite subtype of `b`, if `b` is less than or equal to `n`, then the casting of `i` to a natural number is strictly less than `n`. In other words, it asserts that if a number is within the bounds of a smaller natural number, it must be strictly less than a larger one it is compared to.

If `i` is a finite subtype of natural number `b` and `b` is less than or equal to natural number `n`, then the natural number cast of `i` is strictly less than `n`.


Embedding.continuous

theorem Embedding.continuous :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Embedding f → Continuous f :=
  by sorry

This theorem states that for any two types `X` and `Y`, given a function `f` from `X` to `Y`, and assuming that both `X` and `Y` have topological space structures, if `f` is an embedding (i.e., an injective (one-to-one) function that preserves the topology), then `f` is also continuous. In terms of topology, a function is continuous if the preimage of every open set in the codomain is an open set in the domain.

If `X` and `Y` are topological spaces and `f : X → Y` is an injective function that preserves open sets, then `f` is continuous.


MeasureTheory.Integrable.add

theorem MeasureTheory.Integrable.add :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      {f g : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → MeasureTheory.Integrable (f + g) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.add` states that for any two functions `f` and `g` from a set `α` to a normed additively commutative group `β`, with `α` being a measurable space and `μ` being a measure on `α`, if `f` and `g` are both integrable with respect to measure `μ`, then their sum `f + g` is also integrable with respect to the same measure. This means that the sum of two integrable functions is again an integrable function.

If `f` and `g` are integrable functions from a measurable space `(α, μ)` to a normed additively commutative group `β`, then their sum `f + g` is also integrable on `(α, μ)`.


theorem Finset.smul_sum :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid β] [inst_1 : DistribSMul α β] {r : α}
      {f : γ → β} {s : Finset γ}, (r • Finset.sum s fun x => f x) = Finset.sum s fun x => r • f x :=
  by sorry

The theorem `Finset.smul_sum` states that for all types `α`, `β`, `γ`, under the condition that `β` is an additive commutative monoid and `α` and `β` together form a distributive scalar multiplication system, for any scalar `r` of type `α`, any function `f` from `γ` to `β`, and any finite set `s` of elements of type `γ`, the scalar multiplication of `r` and the sum of `f(x)` for each `x` in `s` is equal to the sum of `r • f(x)` for each `x` in `s`. In other words, it asserts that scalar multiplication distributes over the summation operation in a finite set, a property analogous to the distributive law in algebra: $r \cdot \sum_{x \in S} f(x) = \sum_{x \in S} r \cdot f(x)$, where $S$ is a finite set, $r$ is a scalar, and $f(x)$ is a function mapping elements of the set to the monoid.

For any scalar `r`, additive commutative monoid `β`, distributive scalar multiplication system `α` and `β`, and finite set `s` of elements `γ`, the scalar multiplication of `r` and the sum of `f(x)` for each `x` in `s` equals the sum of `r • f(x)` for each `x` in `s`.


theorem Complex.norm_eq_abs : ∀ (z : ℂ), ‖z‖ = Complex.abs z := by sorry

The theorem `Complex.norm_eq_abs` states that for any complex number `z`, the norm of `z` is equal to the absolute value of `z`. In mathematical terms, this theorem can be written as `‖z‖ = |z|` for all `z` in the set of complex numbers ℂ. This theorem establishes a direct relationship between the norm (a measure of the "length" or "size" of `z`) and the absolute value (which provides the magnitude of `z`) for complex numbers.

The theorem `Complex.norm_eq_abs` asserts that the norm and absolute value of a complex number are equal.


theorem Int.natAbs_ofNat : ∀ (n : ℕ), Int.natAbs ↑n = n := by sorry

The theorem `Int.natAbs_ofNat` states that for every natural number `n`, the absolute value of the integer representation of `n` is `n` itself. In other words, when a natural number is considered as an integer and its absolute value is taken, it remains the same. This is because natural numbers are non-negative and so their absolute value doesn't change. In mathematical notation, the theorem is saying that for all natural numbers `n`, |n| = n.

The theorem `Int.natAbs_ofNat` asserts that for all natural numbers `n`, the absolute value of their integer representation equals `n` itself.


Nat.ModEq.trans

theorem Nat.ModEq.trans : ∀ {n a b c : ℕ}, a ≡ b [MOD n] → b ≡ c [MOD n] → a ≡ c [MOD n] := by sorry

This theorem, `Nat.ModEq.trans`, demonstrates the transitivity of congruence modulo `n` for natural numbers. In other words, if `a` is congruent to `b` modulo `n`, and `b` is congruent to `c` modulo `n`, then `a` is also congruent to `c` modulo `n`. This transitivity property is a fundamental aspect of modular arithmetic.

If `a` is congruent to `b` modulo `n` and `b` is congruent to `c` modulo `n`, then `a` is congruent to `c` modulo `n`. (Modular arithmetic)


theorem HasDerivAt.comp_hasDerivWithinAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {s : Set 𝕜} {𝕜' : Type u_1}
      [inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'} {h' h₂' : 𝕜'},
      HasDerivAt h₂ h₂' (h x) → HasDerivWithinAt h h' s x → HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x :=
  by sorry

The theorem `HasDerivAt.comp_hasDerivWithinAt` states that given two functions `h` and `h₂` and their respective derivatives `h'` and `h₂'` at a point `x`, within a subset `s`, where the field `𝕜` is a non-trivially normed field, and `𝕜'` is another non-trivially normed field under a normed algebra over `𝕜`. If the function `h₂` has a derivative at `h(x)`, and the function `h` has a derivative within the subset `s` at point `x`, then the composition of `h₂` and `h` also has a derivative within the subset `s` at point `x`, and the derivative is the product of `h₂'` and `h'`. This theorem essentially states the chain rule for derivatives within a subset.

Given functions `h: 𝕜 → 𝕜'`, `h₂: 𝕜' → 𝕜''`, `h', h₂'` their respective derivatives, if `h` is differentiable at `x`, `h₂` is differentiable at `h(x)`, and `𝕜`, `𝕜'`, `𝕜''` are non-trivially normed fields under normed algebra over `𝕜`, then `h₂ ∘ h` is differentiable at `x` with derivative `h₂'(h(x)) * h'(x)`.


theorem Finset.mem_Iic :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, x ∈ Finset.Iic a ↔ x ≤ a := by
  sorry

This theorem states that for any given type `α` which has a preorder and a locally finite order bot, and any elements `a` and `x` of this type, `x` is a member of the finite set `Finset.Iic a` if and only if `x` is less than or equal to `a`. In other words, it formalizes the intuition that `Finset.Iic a` contains exactly those elements `x` which satisfy `x ≤ a`.

For any type `α` with a preorder and locally finite order bottom element, `x` belongs to the interval `Finset.Iic a` if and only if `x ≤ a`.


Set.Bounded.mono

theorem Set.Bounded.mono :
    ∀ {α : Type u_1} {r : α → α → Prop} {s t : Set α}, s ⊆ t → Set.Bounded r t → Set.Bounded r s := by sorry

The theorem `Set.Bounded.mono` states that for any type `α`, any relation `r` on `α`, and any sets `s` and `t` of type `α`, if `s` is a subset of `t` and `t` is a bounded set under the relation `r`, then `s` is also a bounded set under the relation `r`. In other words, the boundedness property of a set is preserved under taking subsets.

If `s` is a subset of the bounded set `t` under relation `r`, then `s` is also a bounded set under relation `r`.


theorem MeasurableSpace.measurableSet_generateFrom :
    ∀ {α : Type u_1} {s : Set (Set α)} {t : Set α}, t ∈ s → MeasurableSet t := by sorry

This theorem states that, for any type `α`, if we have a set `s` where each element is itself a set of `α`, and a set `t` of `α`, then if `t` is an element of `s`, `t` is a measurable set. In other words, any set that is a member of a collection of sets is measurable. This is a fundamental concept of measure theory, where a measurable set is one that we are capable of assigning a "measure" or size to in a coherent manner.

If `s` is a set of sets where each element is a set of type `α`, then any element `t` in `s` is a measurable set of type `α`.


theorem add_div' : ∀ {α : Type u_1} [inst : DivisionSemiring α] (a b c : α), c ≠ 0 → b + a / c = (b * c + a) / c := by
  sorry

This theorem states that for any type `α` that forms a division semiring, and for any three elements `a`, `b`, and `c` of type `α`, as long as `c` is not zero, the sum of `b` and `a` divided by `c` is equal to the result of `b` times `c` plus `a`, all divided by `c`. In mathematical terms, it is asserting that for all `a`, `b`, `c` in a division semiring `α`, given `c ≠ 0`, it holds that `b + a / c = (b * c + a) / c`.

For any division semiring `α` and elements `a, b, c` in `α` with `c neq 0`, `b + a / c = (b * c + a) / c`.


UpperSet.upper

theorem UpperSet.upper : ∀ {α : Type u_1} [inst : LE α] (s : UpperSet α), IsUpperSet ↑s := by sorry

This theorem states that for every type `α` with an order relation (denoted by `≤`), any upper set `s` is indeed an upper set. In terms of order theory, this means that if `s` is a subset of `α` such that every element in `s` is less than or equal to any element from `α`, then `s` is considered an upper set. An upper set is defined as a set where if an element `a` is in the set and `a` is less than or equal to another element `b`, then `b` is also in the set.

For any type `α` with an order relation `≤`, every subset `s` such that `x ∈ s` implies `x ≤ y` for all `y ∈ α`, is an upper set.


Set.InjOn.mono

theorem Set.InjOn.mono :
    ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f : α → β}, s₁ ⊆ s₂ → Set.InjOn f s₂ → Set.InjOn f s₁ := by sorry

The theorem `Set.InjOn.mono` states that for all types `α` and `β`, and for all sets `s₁` and `s₂` of type `α` and any function `f` from type `α` to `β`, if `s₁` is a subset of `s₂` and `f` is injective on `s₂`, then `f` is also injective on `s₁`. In other words, if we have a function that does not map two different elements to the same element in the larger set, it will also have this property in any subset of that larger set.

If `s₁ ⊆ s₂` and `f : α → β` is injective on `s₂`, then `f` is injective on `s₁`.


theorem Mathlib.Order.MinMax._auxLemma.4 :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b ≤ c) = (a ≤ c ∧ b ≤ c) := by sorry

This theorem, `Mathlib.Order.MinMax._auxLemma.4`, states that for any type `α` that has a linear order, and any three elements `a`, `b`, and `c` of type `α`, the maximum of `a` and `b` is less than or equal to `c` if and only if both `a` and `b` are less than or equal to `c`. This means that for `c` to be greater than or equal to the maximum of `a` and `b`, it must be greater than or equal to both `a` and `b` individually.

For any type with a linear order, the maximum of two elements is less than or equal to a third element if and only if the first two elements are less than or equal to the third.


theorem Cardinal.toNat_lift : ∀ (c : Cardinal.{v}), Cardinal.toNat (Cardinal.lift.{u, v} c) = Cardinal.toNat c := by
  sorry

The theorem `Cardinal.toNat_lift` states that for any cardinal number `c` (from the universe `v`), the process of converting that cardinal to a natural number remains unchanged, whether the cardinal is first lifted to a higher universe (from `v` to `max v u`) or not. In other words, lifting the universe of the cardinal does not affect its conversion to a natural number. This theorem guarantees the compatibility of the cardinal number universe lifting operation with the function that maps cardinals to natural numbers.

For any cardinal number `c`, the function `Cardinal.toNat` from cardinal numbers to natural numbers is invariant under universe lifting, i.e., `Cardinal.toNat c = Cardinal.toNat (lift c)`.


theorem ne_of_eq_of_ne : ∀ {α : Sort u_1} {a b c : α}, a = b → b ≠ c → a ≠ c := by sorry

This theorem, `ne_of_eq_of_ne`, states that for any type `α`, and any three elements `a`, `b`, and `c` of type `α`, if `a` is equal to `b` and `b` is not equal to `c`, then `a` is also not equal to `c`. In other words, transitivity of equality and inequality is preserved.


theorem Units.mul_inv_cancel_right : ∀ {α : Type u} [inst : Monoid α] (a : α) (b : αˣ), a * ↑b * ↑b⁻¹ = a := by sorry

This theorem states that for any type `α` that is a monoid, and for any elements `a` of type `α` and `b` of type `αˣ` (which means `b` is a unit or invertible element in the monoid), the product of `a` and `b` followed by multiplication by the inverse of `b` is equal to `a`. In mathematical terms, this theorem is stating the property `a * b * b⁻¹ = a` for monoids.

For any monoid `α` and invertible element `b` of `α`, the product of any element `a` in `α` with `b` and the inverse of `b` is equal to `a`. In Lean notation, `(a : α) : a * b * b⁻¹ = a`.


Set.BijOn.mapsTo

theorem Set.BijOn.mapsTo :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.MapsTo f s t := by sorry

The theorem `Set.BijOn.mapsTo` states that for any types `α` and `β`, any sets `s` of `α` and `t` of `β`, and any function `f` from `α` to `β`, if `f` is a bijective function from `s` to `t` (meaning that `f` is injective on `s` and the image of `s` under `f` is exactly `t`), then `f` maps every element of `s` to some element in `t`. In other words, the image of the set `s` under the function `f` is contained in the set `t`.

If `f` is a bijection from set `s` to set `t`, then the image of `s` under `f` is exactly `t`.


AlgEquiv.commutes

theorem AlgEquiv.commutes :
    ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁]
      [inst_2 : Semiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (r : R),
      e ((algebraMap R A₁) r) = (algebraMap R A₂) r :=
  by sorry

The theorem `AlgEquiv.commutes` asserts that for all commutative semirings `R`, semirings `A₁` and `A₂`, and algebra structures on `R` with `A₁` and `A₂`, an algebra isomorphism `e` from `A₁` to `A₂` over `R` commutes with the algebra maps from `R` to `A₁` and `A₂`. In other words, for any element `r` of `R`, applying `e` after the algebra map from `R` to `A₁` is the same as applying the algebra map from `R` to `A₂` directly. This property is also known as "the compatibility of algebra isomorphisms with scalar multiplication".

For any commutative semirings R, algebra structures on R with semirings A₁ and A₂, and an algebra isomorphism e from A₁ to A₂, e commutes with the algebra maps from R to A₁ and A₂, i.e., for all r in R, e (r *\_A₁ x) = r *\_A₂ (e x), where *\_A₁ and *\_A₂ denote multiplication in the respective algebra structures.


theorem Mathlib.Order.Filter.Basic._auxLemma.36 :
    ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) := by sorry

The theorem `Mathlib.Order.Filter.Basic._auxLemma.36` states that for any type `α`, any set `s` of type `α`, and any filter `f` of type `α`, the filter `f` is less than or equal to the principal filter of `s` if and only if `s` is a member of the filter `f`. In other words, the filter `f` contains all supersets of `s` if and only if `s` is one of the sets in the filter `f`. This provides a condition for a filter to be a superset of another filter in terms of element membership.

A filter `f` of a type `α` contains a set `s` if and only if `s` is a subset of the principal filter of `s` and `s` is an element of `f`.


theorem Filter.Germ.inductionOn₃ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} (f : Filter.Germ l β)
      (g : Filter.Germ l γ) (h : Filter.Germ l δ) {p : Filter.Germ l β → Filter.Germ l γ → Filter.Germ l δ → Prop},
      (∀ (f : α → β) (g : α → γ) (h : α → δ), p ↑f ↑g ↑h) → p f g h :=
  by sorry

The theorem `Filter.Germ.inductionOn₃` states that for every filter `l` on a type `α`, and for `Filter.Germ`s `f`, `g`, and `h` of types `β`, `γ`, and `δ` respectively, if a property `p` holds for every triple of functions `(f : α → β)`, `(g : α → γ)`, `(h : α → δ)`, then the property `p` also holds for the corresponding `Filter.Germ`s `f`, `g`, and `h`. This theorem provides a method for proving certain properties about germ of functions at a filter by reducing the problem to proving the property for all functions.

The theorem `Filter.Germ.inductionOn₃` asserts that if a property `p` holds for all triples of functions `f : α → β`, `g : α → γ`, `h : α → δ`, then it holds for their corresponding `Filter.Germ`s.


theorem abs_sub_comm : ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a b : α), |a - b| = |b - a| := by
  sorry

This theorem states that for any type `α` that satisfies the properties of a lattice and an additive group, the absolute difference between any two elements `a` and `b` of `α` is the same regardless of the order in which `a` and `b` are subtracted. In other words, the absolute value of `a` subtracted from `b` is the same as the absolute value of `b` subtracted from `a`. This corresponds to the mathematical principle that the absolute value of the difference between two elements is unaffected by their order.

For any lattice and additive group type `α`, the absolute difference between two elements `a` and `b` is commutative, that is, |a - b| = |b - a|.


theorem mul_le_mul_iff_right :
    ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α) {b c : α},
      b * a ≤ c * a ↔ b ≤ c :=
  by sorry

The theorem `mul_le_mul_iff_right` states that for any type `α` that supports multiplication (`Mul α`) and a less-than-or-equal-to relation (`LE α`), and satisfies both the `CovariantClass` and `ContravariantClass` conditions for multiplication and the less-than-or-equal-to relation, for every element `a` of type `α`, and for all `b` and `c` of type `α`, the inequality `b * a ≤ c * a` holds if and only if `b ≤ c`.

In mathematical terms, this says that for a given `a`, multiplication by `a` from the right preserves the order of `b` and `c`. That is, if `b` is less than or equal to `c`, then `b * a` is also less than or equal to `c * a`, and vice versa. This property is crucial for defining ordered rings and fields.

For any type `α` with multiplication and a bilaterally ordered structure, the inequality `b ≤ c` is equivalent to `b * a ≤ c * a` for all `a, b, c ∈ α`.


theorem Ideal.Quotient.mk_surjective :
    ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, Function.Surjective ⇑(Ideal.Quotient.mk I) := by sorry

This theorem states that for any given type `R`, which is a commutative ring, and any left ideal `I` of `R`, the ring homomorphism from `R` to the quotient ring `R/I` is surjective. In other words, for every element in the quotient ring `R/I`, there exists an element in `R` such that when the ring homomorphism is applied to this element in `R`, we get the element in `R/I`.

For any commutative ring `R` and its left ideal `I`, the ring homomorphism from `R` to the quotient ring `R/I` is surjective.


Pairwise.mono

theorem Pairwise.mono : ∀ {α : Type u_1} {r p : α → α → Prop}, Pairwise r → (∀ ⦃i j : α⦄, r i j → p i j) → Pairwise p :=
  by sorry

The theorem `Pairwise.mono` states that for any type `α` and any two relations `r` and `p` on `α`, if the relation `r` holds pairwise and for all `i` and `j` in `α`, if `r i j` implies `p i j`, then the relation `p` also holds pairwise. In other words, if we have a pairwise relation `r` and every instance of `r` implies an instance of another relation `p`, then `p` is also pairwise.

If a relation `r` on a type `α` is pairwise and implies another relation `p` on `α` pairwise, then `p` is pairwise.


theorem induced_compose :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {tγ : TopologicalSpace γ} {f : α → β} {g : β → γ},
      TopologicalSpace.induced f (TopologicalSpace.induced g tγ) = TopologicalSpace.induced (g ∘ f) tγ :=
  by sorry

This theorem states that for any three types `α`, `β`, and `γ`, and a topological space `tγ` on `γ`, and any functions `f : α → β` and `g : β → γ`, the topology induced on `α` by `f` followed by the topology induced by `g` is the same as the topology induced directly by the composition of `g` and `f`. In other words, the process of inducing topologies through composition of functions is associative.

For any types `α`, `β`, and `γ`, and topological spaces `tβ` on `β` and `tγ` on `γ`, the topology induced on `α` by the composition `g ∘ f` is equal to the topology induced by first inducing the topology on `β` by `f` and then inducing the topology on `α` by `g`, i.e., `induced_topology tγ (g ∘ f) = induced_topology (induced_topology tβ f) g`.


theorem isClosed_compl_iff : ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed sᶜ ↔ IsOpen s := by sorry

This theorem states that for any type `X` equipped with a topology (represented by the `TopologicalSpace X` instance) and any set `s` of elements of type `X`, the set `s` is closed if and only if its complement `sᶜ` is open. This is a basic property of topological spaces, expressing a deep connection between the notions of open and closed sets. Here, `IsClosed sᶜ` refers to the closedness of the complement of `s`, and `IsOpen s` refers to `s` being an open set in the topological space.

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


theorem BoundedContinuousFunction.norm_coe_le_norm :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
      (f : BoundedContinuousFunction α β) (x : α), ‖f x‖ ≤ ‖f‖ :=
  by sorry

This theorem states that for any topological space `α` and any seminormed add commutative group `β`, for any bounded continuous function `f` from `α` to `β` and any element `x` in `α`, the norm of the function evaluated at `x` is less than or equal to the norm of the function `f`. In mathematical notation, this is equivalent to saying that for all `f` and `x`, `‖f(x)‖ ≤ ‖f‖`. This theorem is a key property of bounded continuous functions in functional analysis.

The norm of a bounded continuous function's evaluation at a point is less than or equal to the function's norm.


theorem MeasureTheory.nonempty_of_measure_ne_zero :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α}, ↑↑μ s ≠ 0 → Set.Nonempty s :=
  by sorry

The theorem `MeasureTheory.nonempty_of_measure_ne_zero` states that for any type `α` that has a `MeasurableSpace` instance and for any measure `μ` on `α` and any set `s` of `α`, if the measure of `s` under `μ` is not zero, then the set `s` is nonempty. In simpler terms, if a set has a non-zero measure, it must contain at least one element.

If a measurable set in a measurable space has a non-zero measure, then it is nonempty.


theorem Filter.map_id : ∀ {α : Type u} {f : Filter α}, Filter.map id f = f := by sorry

This theorem, `Filter.map_id`, states that for any type `α` and any filter `f` of type `α`, the map of `f` with the identity function (`id`) is equal to `f` itself. In other words, applying the identity function to each element of the filter does not change the filter. This reflects the mathematical concept that mapping a set or collection through the identity function always results in the same set or collection.

For any filter `f` on type `α`, `map f id = f`.


theorem Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.1 :
    ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSet ∅ = True := by sorry

The theorem `Mathlib.MeasureTheory.MeasurableSpace.Defs._auxLemma.1` states that for all types `α` that have an associated `MeasurableSpace` structure, the empty set `∅` is a measurable set. In other words, in the context of measure theory, the empty set is always considered measurable regardless of the space we are working in.

The empty set is measurable in any measurable space.


CategoryTheory.Monad.Algebra.Hom.ext'

theorem CategoryTheory.Monad.Algebra.Hom.ext' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C}
      (X Y : CategoryTheory.Monad.Algebra T) (f g : X ⟶ Y), f.f = g.f → f = g :=
  by sorry

This theorem states that in the category theory, for a given category `C` and a monad `T` on `C`, if we have two morphisms `f` and `g` from a monad algebra `X` to another monad algebra `Y`, and if the underlying functions of `f` and `g` (denoted by `f.f` and `g.f`) are identical, then the morphisms `f` and `g` themselves are identical. This is a statement about the uniqueness of morphisms in the category of monad algebras.

In the category of monad algebras, if two morphisms have identical underlying functions, then they are equal.


theorem Sym2.eq_swap : ∀ {α : Type u_1} {a b : α}, s(a, b) = s(b, a) := by sorry

This theorem, `Sym2.eq_swap`, states that for any type `α` and any two elements `a` and `b` of that type, the function `s` applied to `a` and `b` is equal to the function `s` applied to `b` and `a`. This essentially encapsulates the property of commutativity for the function `s` on any pair of elements of a given type.

For any type `α` and any elements `a` and `b` of type `α`, the function application `s a b` is equal to `s b a`.


theorem eq_zero_of_zero_dvd : ∀ {α : Type u_1} [inst : SemigroupWithZero α] {a : α}, 0 ∣ a → a = 0 := by sorry

This theorem states that for any type `α` that forms a `SemigroupWithZero` (which is a type of structure that combines the properties of a semigroup and the existence of a "zero" element), if zero divides some element `a` of this type `α`, then `a` must be equal to zero. In mathematical terms, this theorem refers to the property in ring theory that if zero divides any element in a ring, that element must be zero.

If `α` is a type with a `SemigroupWithZero` structure, and there exists an element `a` and another element `z` of type `α` such that `a * x = z` for all `x` in `α`, then `a` is equal to the additive identity (zero) of `α`.


theorem map_list_prod :
    ∀ {M : Type u_5} {N : Type u_6} [inst : Monoid M] [inst_1 : Monoid N] {F : Type u_11} [inst_2 : FunLike F M N]
      [inst_3 : MonoidHomClass F M N] (f : F) (l : List M), f (List.prod l) = List.prod (List.map (⇑f) l) :=
  by sorry

The theorem `map_list_prod` states that for any types `M` and `N` that have monoid structures, any type `F` which is a functor from `M` to `N` and also a monoid homomorphism, and any function `f` of type `F` and any list `l` of type `List M`, the result of applying function `f` to the product of the list `l` is equal to the product of the list obtained by mapping `f` over `l`. In other words, the mapping of a function over the product of a list of monoids is the same as the product of the list obtained by mapping the function over each element of the original list. This theorem essentially asserts the compatibility of the function mapping and product operation in the context of monoids.

For any monoid functor F from type M to type N that preserves monoid multiplication, and any list l of monoid elements M, the map of the product of l under F is equal to the product of the images of each element in l under F.


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

This theorem, `Filter.eventually_congr`, states that for any type `α`, any `Filter α` called `f`, and any two propositions `p` and `q` about `α`, if it is eventually the case in `f` that `p x` is equivalent to `q x` for all `x` of type `α`, then it is true that `p x` is eventually the case in `f` if and only if `q x` is eventually the case in `f`. In simpler terms, if two conditions `p` and `q` are eventually equivalent in a certain context (the filter `f`), then an event described by `p` happens eventually in this context if and only if an event described by `q` does.

If two propositions `p` and `q` are eventually equivalent in a filter `f` over type `α`, then `p` and `q` have equivalent eventually subsets in `f`.


theorem Polynomial.monic_mul_leadingCoeff_inv :
    ∀ {K : Type u_1} [inst : DivisionRing K] {p : Polynomial K},
      p ≠ 0 → Polynomial.Monic (p * Polynomial.C (Polynomial.leadingCoeff p)⁻¹) :=
  by sorry

The theorem `Polynomial.monic_mul_leadingCoeff_inv` states that for every nonzero polynomial `p` over a division ring `K`, the polynomial obtained by multiplying `p` by the inverse of its leading coefficient (which is a constant polynomial), is monic. In other words, if you "normalize" a polynomial by its leading coefficient, the resulting polynomial has leading coefficient 1, which is the definition of being monic.

For any nonzero polynomial $p$ over a division ring $K$, the polynomial $p \cdot (\text{lc}(p))^{-1}$ is monic, where $\text{lc}(p)$ is the leading coefficient of $p$.


theorem interior_mono : ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], s ⊆ t → interior s ⊆ interior t := by
  sorry

This theorem, named `interior_mono`, states that for any type `X` with a topology (that is, `X` is a topological space), and for any two sets `s` and `t` of elements of type `X`, if `s` is a subset of `t`, then the interior of `s` is also a subset of the interior of `t`. The interior of a set is defined as the largest open subset of the given set, in the context of the topology on `X`. So, this theorem establishes a monotonicity property for the operation of taking interiors of sets in a topological space.

If `X` is a topological space and `s` is a subset of `t`, then the interior of `s` is contained in the interior of `t`.


theorem Matrix.cons_val' :
    ∀ {α : Type u} {m : ℕ} {n' : Type uₙ} (v : n' → α) (B : Fin m → n' → α) (i : Fin (Nat.succ m)) (j : n'),
      Matrix.vecCons v B i j = Matrix.vecCons (v j) (fun i => B i j) i :=
  by sorry

The theorem `Matrix.cons_val'` states that for any type `α`, natural number `m`, type `n'`, a function `v` mapping from `n'` to `α`, a function `B` mapping from `Fin m` to `n'` to `α`, and elements `i` of `Fin (Nat.succ m)` and `j` of `n'`, the operation of prepending the vector `v` to the matrix `B` and then selecting the `(i, j)`-th entry is the same as prepending the `j`-th entry of `v` to the `j`-th column of `B` and then selecting the `i`-th entry. In other words, constructing a matrix by appending a row and fetching a value from it is the same as appending an element to each column and fetching a value.

For any type `α`, natural numbers `m` and `n`, functions `v : Fin n -> α` and `B : Fin m -> Fin n -> α`, elements `i : Fin (Nat.succ m)` and `j : Fin n`, the `(i, j)`-th entry of the matrix `[B : matrix α m n | v]` is equal to the `j`-th entry of the `j`-th column of the matrix `B` appended with the row `[v]`.


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

The `Finset.sum_attach` theorem asserts that for any finite set `s` of type `α` and any function `f` from `α` to `β` (where `β` is an additive commutative monoid), the sum of `f x` over all elements `x` in the attached form of `s` (i.e., `Finset.attach s`, which is a set of elements of the subtype `{x // x ∈ s}`) is equal to the sum of `f x` over all elements `x` in `s` itself. This theorem essentially states that attaching a finite set does not change the sum of the function applied to the elements of the set.

For any finite set `s` of type `α` and any additive commutative monoid `β`, the sum of a function `f` from `α` to `β` over the attached form of `s` is equal to the sum over `s` itself.


/-- A submonoid `S` includes `closure s` if and only if it includes `s`.  -/
theorem Submonoid.closure_le :
    ∀ {M : Type u_1} [inst : MulOneClass M] {s : Set M} {S : Submonoid M}, Submonoid.closure s ≤ S ↔ s ⊆ ↑S := by sorry

The theorem `Submonoid.closure_le` states that for any type `M` equipped with a `MulOneClass` structure (that is, a multiplication operation and a multiplicative identity), any set `s` of elements of type `M`, and any submonoid `S` of `M`, the submonoid generated by `s` (denoted as `Submonoid.closure s`) is a subset of `S` if and only if the set `s` itself is a subset of the underlying set of `S` (denoted as `↑S`). In other words, a submonoid `S` contains the submonoid generated by a set `s` if and only if it contains all the elements of `s`.

A submonoid contains the submonoid generated by a set if and only if the set is a subset of the submonoid.


theorem inf_eq_iInf : ∀ {α : Type u_1} [inst : CompleteLattice α] (x y : α), x ⊓ y = ⨅ b, bif b then x else y := by
  sorry

This theorem states that for any complete lattice `α` and any two elements `x` and `y` from `α`, the infimum of `x` and `y` (denoted as `x ⊓ y`) is equal to the infimum (denoted as `⨅ b`) over all boolean values `b` such that if `b` is true, then the value is `x`, else the value is `y`. That is, the smallest element that's less than or equal to both `x` and `y` is the same as the smallest element when comparing `x` and `y` as options determined by boolean value `b`.

For any complete lattice `α` and elements `x, y ∈ α`, the infimum `x ⊓ y` equals the greatest lower bound over all boolean values `b` such that `x = b ⟶ x` and `y = ¬b ⟶ y`. (Here, `⟶` denotes material implication and `¬` denotes boolean negation.)


theorem Int.ediv_zero : ∀ (a : ℤ), a / 0 = 0 := by sorry

This theorem states that for any integer `a`, the integer division of `a` by zero is equal to zero. In the context of Lean 4, the `/` operator represents integer division. Note that while in many contexts, division by zero is undefined, in Lean 4, it is defined to be zero for all integers.

For all integers `a`, the result of the integer division of `a` by zero is equal to zero.


BoundedContinuousFunction.continuous

theorem BoundedContinuousFunction.continuous :
    ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
      (f : BoundedContinuousFunction α β), Continuous ⇑f :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` is equipped with a topology and `β` is equipped with a pseudo metric space structure, any bounded continuous function `f` from `α` to `β` is itself continuous. In mathematical terms, if $f$ is a bounded continuous function between a topological space and a pseudometric space, then $f$ is a continuous function.

A bounded continuous function between a topological space and a pseudometric space is continuous.


theorem Mathlib.Algebra.GroupWithZero.Units.Lemmas._auxLemma.1 :
    ∀ {M₀ : Type u_2} {G₀ : Type u_3} {F : Type u_6} [inst : MonoidWithZero M₀] [inst_1 : GroupWithZero G₀]
      [inst_2 : Nontrivial M₀] [inst_3 : FunLike F G₀ M₀] [inst_4 : MonoidWithZeroHomClass F G₀ M₀] (f : F) {a : G₀},
      (f a = 0) = (a = 0) :=
  by sorry

This theorem states that for any types `M₀`, `G₀`, and `F`, given the conditions that `M₀` is a monoid with zero, `G₀` is a group with zero, `M₀` is nontrivial, `F` is a function-like structure from `G₀` to `M₀` obeying the rules of a monoid with zero homomorphism, and for any function `f` of type `F` and any element `a` of type `G₀`, the proposition that `f(a)` equals zero is equivalent to the proposition that `a` equals zero. Basically, it ensures that applying the function `f` to the zero element of `G₀` yields the zero element of `M₀`.

If `F` is a monoid homomorphism from the group `G₀` with nontrivial identity to the monoid `M₀`, then `F(0) = 0`, where `0` denotes the zero elements in `G₀` and `M₀`.


/-- **Alias** of the reverse direction of `Finset.card_union_eq_card_add_card`. -/
theorem Finset.card_union_of_disjoint :
    ∀ {α : Type u_1} {s t : Finset α} [inst : DecidableEq α], Disjoint s t → (s ∪ t).card = s.card + t.card := by sorry

This theorem, `Finset.card_union_of_disjoint`, states that for any given type `α` with decidable equality, any two disjoint finite sets `s` and `t` (where disjointness is defined in terms of the bottom element of a lattice), the cardinality or size of their union equals the sum of their individual cardinalities. This is essentially a formalization of the principle from set theory that the size of the union of two disjoint sets is the sum of their sizes.

For any type `α` with decidable equality, the cardinality of the union of two disjoint finite sets `s` and `t` equals the sum of their individual cardinalities.


Function.Injective.subsingleton

/-- If the codomain of an injective function is a subsingleton, then the domain
is a subsingleton as well.  -/
theorem Function.Injective.subsingleton :
    ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Injective f → ∀ [inst : Subsingleton β], Subsingleton α := by
  sorry

The theorem states that if we have an injective function (a function where different inputs always produce different outputs) from one set to another, and if the set that is the function's output (the codomain) is a subsingleton (a set with at most one element), then the set that is the function's input (the domain) must also be a subsingleton. In other words, if a function cannot produce the same output from two different inputs, and there is at most one possible output, then there can be at most one possible input.

If a function from a set to a subsingleton set is injective, then the set is a subsingleton.


TopologicalSpace.Opens.isOpen

theorem TopologicalSpace.Opens.isOpen :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] (U : TopologicalSpace.Opens α), IsOpen ↑U := by sorry

This theorem states that for any type `α` equipped with a topological space structure and any open set `U` in this topological space, `U` is indeed an open set in the ambient topological space on `α`. The theorem essentially confirms the fact that the elements of the structure `TopologicalSpace.Opens α`, which are supposed to represent open sets, are truly "open" according to the mathematics definition of openness in topology.

For any topological space `(α, top)`, every element of `top.opens α` is an open set in `α`.


theorem pos_of_gt : ∀ {M : Type u_1} [inst : CanonicallyOrderedAddCommMonoid M] {n m : M}, n < m → 0 < m := by sorry

This theorem states that for any type `M` that forms a canonically ordered additive commutative monoid, if `n` and `m` are elements of `M` such that `n` is less than `m`, then `m` is greater than 0. In other words, in such a monoid, any element that is greater than another element is necessarily greater than zero.

In a canonically ordered, additive commutative monoid `M`, if `n` is less than `m` in `M`, then `m` is positive (or non-zero).


theorem Mathlib.Algebra.Order.Monoid.Canonical.Defs._auxLemma.9 :
    ∀ {α : Type u} [inst : CanonicallyOrderedAddCommMonoid α] {a b : α}, (a + b = 0) = (a = 0 ∧ b = 0) := by sorry

This theorem states that for any given type `α`, which forms a canonically ordered additive commutative monoid, and for any two elements `a` and `b` of this type, the sum of `a` and `b` is equal to zero if and only if both `a` and `b` are zero. In other words, in the context of a canonically ordered additive commutative monoid, the only way two elements can add to zero is if both elements are zero.

In a canonically ordered additive commutative monoid, for all elements `a` and `b`, if `a + b = 0` then both `a` and `b` are zero.


theorem List.indexOf_lt_length :
    ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α}, List.indexOf a l < List.length l ↔ a ∈ l := by sorry

This theorem, `List.indexOf_lt_length`, states that for any type `α` with decidable equality, any element `a` of type `α`, and any list `l` of elements of type `α`, the index of the first occurrence of `a` in `l` is less than the length of `l` if and only if `a` is an element of `l`. In other words, if `a` is in the list `l`, then its index should be a valid index within the list, and conversely, if the index of `a` is a valid index within the list, then `a` must be in the list.

For any type `α` with decidable equality, list `l` of length `n` over `α`, and element `a` of `α`, if `a` is in list `l`, then its index in `l` is less than `n`, and conversely.