theorem CategoryTheory.ShortComplex.homologyMap_comp :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂] [inst_4 : CategoryTheory.ShortComplex.HasHomology S₃]
      (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
      CategoryTheory.ShortComplex.homologyMap (CategoryTheory.CategoryStruct.comp φ₁ φ₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ₁)
          (CategoryTheory.ShortComplex.homologyMap φ₂) :=
  by sorry

The `CategoryTheory.ShortComplex.homologyMap_comp` theorem states that for any category `C` with zero morphisms and any three 'short complexes' `S₁`, `S₂`, and `S₃` in that category, the homology map of the composite of two morphisms `φ₁` and `φ₂` (where `φ₁` maps `S₁` to `S₂` and `φ₂` maps `S₂` to `S₃`) is equal to the composite of the homology maps of `φ₁` and `φ₂`. In mathematical terms, this theorem asserts the functoriality of the homology map in the category of short complexes, that is, the homology map commutes with the composition of morphisms.

The homology map between complexes commutes with composition of morphisms.


theorem Matrix.IsHermitian.eigenvectorMatrix_mul_inv :
    ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
      (hA : Matrix.IsHermitian A),
      Matrix.IsHermitian.eigenvectorMatrix hA * Matrix.IsHermitian.eigenvectorMatrixInv hA = 1 :=
  by sorry

This theorem states that if you have a Hermitian matrix `A` over a ring `𝕜`, where `𝕜` has a structure of a ring with conjugation (i.e., it is an instance of `RCLike`), and the indices `n` of the matrix form a finite type (i.e., there are finitely many indices), with a decidable equality, then the product of `A`'s eigenvector matrix and the inverse of this eigenvector matrix is equal to the identity matrix.

In simpler terms, for a Hermitian matrix (which is a matrix that is equal to its own conjugate transpose, and includes as a special case symmetric matrices over the real numbers), there exists a matrix of eigenvectors such that when it is multiplied by its inverse, the result is the identity matrix. This is an important property in linear algebra as it shows that Hermitian matrices can be diagonalized using a basis of their eigenvectors.

For a finite-sized Hermitian matrix `A` over a ring `𝕜` with a decidable equality and conjugation structure, the product of its eigenvector matrix and the inverse of its eigenvector matrix equals the identity matrix.


theorem Multiset.map_injective :
    ∀ {α : Type u_1} {β : Type v} {f : α → β}, Function.Injective f → Function.Injective (Multiset.map f) := by sorry

The theorem `Multiset.map_injective` states that for any types `α` and `β`, and any function `f` from `α` to `β`, if `f` is injective (i.e., it never maps different elements of `α` to the same element of `β`), then the function `Multiset.map f`, which applies `f` to each element of a multiset, is also injective. In other words, if `f` never produces the same output from different inputs, then neither does `Multiset.map f` when applied to multisets.

If `f: α → β` is an injective function, then `Multiset.map f` preserves the injectivity property on multisets of type `α`.


theorem Nat.div_eq_zero_iff : ∀ {a b : ℕ}, 0 < b → (a / b = 0 ↔ a < b) := by sorry

This theorem states that for any two natural numbers `a` and `b`, if `b` is greater than 0, then the quotient of `a` divided by `b` equals 0 if and only if `a` is less than `b`. That is, in the context of natural numbers, a number `a` divided by another number `b` (where `b` is non-zero) yields a result of zero precisely when `a` is smaller than `b`.

For natural numbers `a` and `b` with `b > 0`, `a / b = 0` if and only if `a < b`.


theorem LocallyFinite.comp_injective :
    ∀ {ι : Type u_1} {ι' : Type u_2} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X} {g : ι' → ι},
      LocallyFinite f → Function.Injective g → LocallyFinite (f ∘ g) :=
  by sorry

The theorem `LocallyFinite.comp_injective` states that for any types `ι`, `ι'`, and `X`, where `X` is a topological space, if we have a locally finite family of sets `f : ι → Set X` and an injective function `g : ι' → ι`, then the composition of `f` and `g` (i.e., `f ∘ g`) is also a locally finite family of sets. In other words, under these conditions, if we apply `g` to change the indexing of the sets in the family `f`, the resulting family of sets remains locally finite. This is a statement about the preservation of the property of local finiteness under injective re-indexing.

If `f : ι → Sets X` is a locally finite family of sets and `g : ι' → ι` is an injective function, then `f ∘ g` is also a locally finite family of sets.


theorem hasFTaylorSeriesUpToOn_univ_iff :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {n : ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
      HasFTaylorSeriesUpToOn n f p Set.univ ↔ HasFTaylorSeriesUpTo n f p :=
  by sorry

The theorem `hasFTaylorSeriesUpToOn_univ_iff` states that for any nontrivially normed field `𝕜`, any normed addition-commutative group `E` and `F` that are also normed spaces over `𝕜`, any function `f` mapping from `E` to `F`, any infinite natural number `n`, and any formal multilinear series `p` from `E` to `F`, the function `f` has a Taylor series up to `n` with respect to the series `p` on the universal set of `E` if and only if `f` has a Taylor series up to `n` with respect to the series `p`.

In mathematical terms, if we let `𝕜` represent our field, `E` and `F` represent our normed vector spaces, `f` represent our function from `E` to `F`, `n` represent the degree of our series, and `p` represent our formal multilinear series, the theorem states that `f` has a Taylor series of degree `n` represented by `p` on the entire space `E` if and only if `f` has a Taylor series of degree `n` represented by `p`.

For any nontrivially normed field `𝕜`, normed addition-commutative groups `E` and `F` over `𝕜`, function `f` from `E` to `F`, infinite natural number `n`, and formal multilinear series `p` from `E` to `F`, `f` has a Taylor series up to degree `n` with respect to `p` on the universal set of `E` if and only if `f` has a Taylor series up to degree `n` with respect to `p`.


theorem Sigma.vadd_mk :
    ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} [inst : (i : ι) → VAdd M (α i)] (a : M) (i : ι) (b : α i),
      a +ᵥ { fst := i, snd := b } = { fst := i, snd := a +ᵥ b } :=
  by sorry

This theorem, `Sigma.vadd_mk`, states that for all types `ι`, `M`, and `α`, where `α` is a function from `ι` to some Type `u_4`, and for each `i : ι` there is a vector addition operation `VAdd M (α i)`, the addition operation on a sigma type (a dependent pair) can be decomposed. Specifically, for any `a : M`, `i : ι`, and `b : α i`, adding `a` to the sigma type with first element `i` and second element `b` results in a new sigma type with the same first element `i` and second element being `a` added to `b`.

For all types `ι`, `M`, and functions `α : ι → u_4`, and for all `i : ι` and `a : M` and `b : (α i)`, the sigma type `Σ i, α i => a + b` is equal to the sigma type `Σ i, α i => a + π i` where `π : Σ i, α i => α i` is the projection function.


theorem Ideal.IsPrime.radical_le_iff :
    ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, Ideal.IsPrime J → (Ideal.radical I ≤ J ↔ I ≤ J) := by sorry

This theorem states that for any given commutative semiring `R` and any two ideals `I` and `J` of `R`, if `J` is a prime ideal, then the radical of `I` is contained in `J` if and only if `I` is contained in `J`. Here, the term "contained in" is used to express the mathematical concept of "subset or equal to". The radical of an ideal `I`, denoted as `Ideal.radical I`, is the set of elements `r` in `R` such that `r` to the power of `n` is in `I` for some `n`. An ideal `J` is said to be prime if the product of any two elements of `R` is in `J` then at least one of the elements must be in `J`.

For any commutative semiring R and ideals I and J, I is contained in J if and only if the radical of I is contained in J, given that J is a prime ideal.


theorem Real.log_lt_log_iff : ∀ {x y : ℝ}, 0 < x → 0 < y → (Real.log x < Real.log y ↔ x < y) := by sorry

This theorem states that, for any two real numbers `x` and `y` that are positive, the logarithm of `x` is less than the logarithm of `y` if and only if `x` is less than `y`. In other words, the logarithm function preserves the order of positive real numbers.

For all positive real numbers x and y, x < y if and only if log (x) < log (y).


MeasureTheory.Martingale.submartingale

theorem MeasureTheory.Martingale.submartingale :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0} [inst_4 : Preorder E],
      MeasureTheory.Martingale f ℱ μ → MeasureTheory.Submartingale f ℱ μ :=
  by sorry

This theorem states that, given a particular set of conditions, if a function `f` is a martingale with respect to a filtration `ℱ` and a measure `μ`, then `f` is also a submartingale with the same `ℱ` and `μ`. The conditions include: the function `f` mapping from a type `ι` to a space of type `E` that is a normed add commutative group, a normed space over the real numbers, and a complete space; `ℱ` being a filtration over a measurable space of type `Ω` that `f` maps to; and `E` and `ι` both having a preorder. In the context of probability theory, a martingale is a sequence of random variables where the expected value of the next variable, given all past variables, is equal to the present variable. A submartingale is a sequence of random variables where the expected value of the next variable, given all past variables, is greater than or equal to the present variable.

If `f` is a martingale with respect to filtration `ℱ` and measure `μ` on a measurable space `Ω`, and `f` maps to a normed add commutative group `E` over the real numbers that is complete, then `f` is a submartingale with the same filtration `ℱ` and measure `μ`.


theorem connectedComponentIn_subset :
    ∀ {α : Type u} [inst : TopologicalSpace α] (F : Set α) (x : α), connectedComponentIn F x ⊆ F := by sorry

This theorem states that for any type `α` and any topological space `α`, for any set `F` of type `α` and any point `x` of type `α`, the connected component of `x` in `F` is always a subset of `F`. In other words, any element of the connected component of `x` in `F` is also an element of `F`. Here, `connectedComponentIn F x` refers to the set of all points in `F` that are in the same connected component as `x` in the topology of `F`. If `x` is not an element of `F`, the connected component of `x` in `F` is defined to be the empty set, which is trivially a subset of `F`.

For any topological space `α`, type `α`, set `F ⊆ α`, and point `x ∈ α`, the connected component of `x` in `F`, `connectedComponentIn F x`, is a subset of `F`.


/-- See also `Finset.product_biUnion`.  -/
theorem Finset.sup_product_left :
    ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (s : Finset β)
      (t : Finset γ) (f : β × γ → α), Finset.sup (s ×ˢ t) f = Finset.sup s fun i => Finset.sup t fun i' => f (i, i') :=
  by sorry

The theorem `Finset.sup_product_left` states that for any types `α`, `β`, and `γ`, with `α` being orderable with a least element and also being a semilattice with respect to the supremum operation, and given two finite sets `s` of type `β` and `t` of type `γ`, along with a function `f` that maps pairs of elements from `β` and `γ` to `α`, the supremum of the function `f` over the Cartesian product of `s` and `t` is equal to the supremum of the function `f` over each element `i` of `s` and each element `i'` of `t`. In other words, it states that the supremum operation distributes over the Cartesian product of two finite sets.

For any orderable semilattice α with least element, and finite sets s:β and t:γ, the function sup (λ (i, j): s × t → α) = sup (i: s → α) ⊤ (sup (j: t → α) j) where ⊤ is the constant function mapping all elements to the least element of α.


/-- Equivalence classes partition the type.  -/
theorem Setoid.classes_eqv_classes : ∀ {α : Type u_1} {r : Setoid α} (a : α), ∃! b x, a ∈ b := by sorry

This theorem states that, for any type `α` and any equivalence relation `r` on `α`, if you take an element `a` of type `α`, there exists precisely one set `b` such that `a` belongs to `b`. In other words, equivalence classes uniquely partition the type, meaning every element belongs to exactly one equivalence class.

For any type `α` and equivalence relation `r` on `α`, the equivalence classes form a pairwise disjoint and exhaustive partition of `α`.


theorem Real.Angle.toReal_injective : Function.Injective Real.Angle.toReal := by sorry

The theorem `Real.Angle.toReal_injective` states that the function `Real.Angle.toReal`, which converts a `Real.Angle` to a real number in the interval `(-π, π)`, is injective. This means that if two angles are mapped to the same real number by this function, then those two angles were the same to start with. In other words, no two different angles will be mapped to the same real number by the `Real.Angle.toReal` function.

The function `Real.Angle.toReal` maps distinct `Real.Angle` values to distinct real numbers in the interval `(-π, π)`.


theorem Mathlib.Order.SuccPred.Basic._auxLemma.8 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α} [inst_2 : NoMaxOrder α],
      (a < Order.succ b) = (a ≤ b) :=
  by sorry

This theorem states that for any type `α` endowed with a preorder and a successor order (where the successor of an element is defined as the least element greater than the given element or the element itself if it is maximal), and a pair of elements `a` and `b` of type `α` in a context where no maximal order is defined, the proposition that `a` is less than the successor of `b` is equivalent to the proposition that `a` is less than or equal to `b`.

In a preordered type `α` with a successor order and no maximal element, for all `a` and `b` in `α`, `a` is less than the successor of `b` if and only if `a` is less than or equal to `b`.


theorem Mathlib.Order.SuccPred.Basic._auxLemma.9 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α} [inst_2 : NoMaxOrder α],
      (Order.succ a ≤ b) = (a < b) :=
  by sorry

This theorem, `Mathlib.Order.SuccPred.Basic._auxLemma.9`, states that for any type `α` with a predefined preorder and successor order, and where maximum elements do not exist (`NoMaxOrder α`), for any two elements `a` and `b` of type `α`, the statement "`a` is strictly less than `b`" is equivalent to the statement "the successor of `a` is less than or equal to `b`".

For any type `α` without maximum elements and equipped with a preorder and successor order, `a` is strictly less than `b` if and only if `a <*: Succ a ≤ b`, where `<:*` denotes the preorder and `Succ` is the successor function.


theorem Num.cast_zero : ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : Add α], ↑0 = 0 := by sorry

This theorem, named `Num.cast_zero`, states that for any type `α` which has zero `0`, one `1`, and the operation of addition `+` defined, the numeric cast of `0` (from the built-in number type to `α`) is equal to the zero of `α`. In simpler words, casting `0` to any number type that has the concepts of zero, one, and addition will give you the zero in that number type.

For any type `α` with zero `0`, one `1`, and addition `+`, the numeric cast of `0` to `α` equals `0` in `α`.


theorem Int.zero_lt_one : 0 < 1 := by sorry

This theorem, `Int.zero_lt_one`, states that zero is less than one in the set of integers. In other words, it asserts the fundamental ordering of numbers on the number line where 0 is to the left of 1, hence less than 1. This is a basic and universally accepted principle in number theory.

The theorem `Int.zero_lt_one` asserts that 0 < 1 in the set of integers.


theorem Mathlib.Analysis.BoxIntegral.Partition.Basic._auxLemma.2 :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {s : Finset (BoxIntegral.Box ι)} {h₁ : ∀ J ∈ s, J ≤ I}
      {h₂ : Set.Pairwise (↑s) (Disjoint on BoxIntegral.Box.toSet)},
      (J ∈ { boxes := s, le_of_mem' := h₁, pairwiseDisjoint := h₂ }) = (J ∈ s) :=
  by sorry

This theorem states that for all types `ι`, given two boxes `I` and `J` of type `ι`, and a finite set `s` of such boxes, with the condition that every box `J` in `s` is less than or equal to `I` and all boxes in the set `s` are pairwise disjoint (i.e., the intersection of any two distinct boxes is the bottom element), then a box `J` is in the set `{ boxes := s, le_of_mem' := h₁, pairwiseDisjoint := h₂ }` if and only if `J` is in the set `s`. This essentially says the set `{ boxes := s, le_of_mem' := h₁, pairwiseDisjoint := h₂ }` is equivalent to the set `s` in terms of its membership.

Given a type `ι` and a finite set `s` of pairwise disjoint boxes `I` and `J` of type `ι` with `J ≤ I` for all `J` in `s`, the sets `{ boxes := s, le_of_mem' := h₁, pairwiseDisjoint := h₂ }` and `s` have equivalent membership.


theorem HasFTaylorSeriesUpToOn.of_le :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {m n : ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
      HasFTaylorSeriesUpToOn n f p s → m ≤ n → HasFTaylorSeriesUpToOn m f p s :=
  by sorry

This theorem, titled `HasFTaylorSeriesUpToOn.of_le`, states that for any nontrivially normed field `𝕜`, normed additive commutative group `E`, normed space over `𝕜` with base `E`, normed additive commutative group `F`, normed space over `𝕜` with base `F`, set `s` of elements of type `E`, function `f` from `E` to `F`, and formal multilinear series `p` in variables of type `E` with coefficients in `F`, if `f` has a Taylor series up to a certain order `n` in the set `s`, then `f` also has a Taylor series up to any order `m` that is less than or equal to `n` in the set `s`. This is essentially saying that if a function has a Taylor series expansion up to a high order, it also has a Taylor series expansion up to any lower order.

If a function has a Taylor series expansion up to order n in a set, it also has a Taylor series expansion up to any order less than or equal to n in that set.


theorem CategoryTheory.Limits.IsInitial.hasInitial :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C},
      CategoryTheory.Limits.IsInitial X → CategoryTheory.Limits.HasInitial C :=
  by sorry

The theorem `CategoryTheory.Limits.IsInitial.hasInitial` states that for any category `C` and any object `X` of `C`, if `X` is an initial object (meaning that the cocone it induces on the empty diagram is colimiting), then `C` has an initial object (meaning that it has a colimit over the empty diagram).

If an object `X` in a category `C` is initial, then `C` has an initial object.


Filter.EventuallyEq.preimage

theorem Filter.EventuallyEq.preimage :
    ∀ {α : Type u} {β : Type v} {l : Filter α} {f g : α → β}, f =ᶠ[l] g → ∀ (s : Set β), f ⁻¹' s =ᶠ[l] g ⁻¹' s := by
  sorry

The theorem `Filter.EventuallyEq.preimage` states that for any types `α` and `β`, any filter `l` on `α`, and any two functions `f` and `g` from `α` to `β`, if `f` and `g` are eventually equal at filter `l`, then for any set `s` of `β`, the preimages of `s` under `f` and `g` are also eventually equal at filter `l`. In plain terms, if two functions become identical beyond a certain point (as determined by the filter), then their preimages (the set of inputs that map to a particular set of outputs) will also become identical beyond that point.

If functions `f` and `g` are eventually equal at filter `l` on type `α`, then their preimages of any set `s` in `β` are eventually equal at filter `l`.


theorem Summable.mul_left :
    ∀ {ι : Type u_1} {α : Type u_4} [inst : NonUnitalNonAssocSemiring α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalSemiring α] {f : ι → α} (a : α), Summable f → Summable fun i => a * f i :=
  by sorry

The theorem `Summable.mul_left` states that for any type `ι`, a non-unital, non-associative semiring `α`, and a topological space `α` with a topological semiring structure, given a function `f : ι → α` and an element `a` in `α`, if the function `f` is summable, then the function defined as the product of `a` and `f` (i.e., `fun i => a * f i`) is also summable. In other words, multiplying a summable function by a scalar results in a summable function.

If `α` is a non-unital, non-associative semiring with a topological structure, `ι` is a type, `f : ι → α` is a summable function, and `a` is an element of `α`, then the function `g : ι → α` defined as `g i := a * f i` is also summable.


theorem Mathlib.Data.Multiset.Basic._auxLemma.2 : ∀ {α : Type u_1} (l : List α), (↑l = 0) = (l = []) := by sorry

This theorem states that for any list `l` of arbitrary type `α`, the list `l` is equivalent to an empty list if and only if the cardinality (or size) of `l` is zero. In other words, a list `l` in Lean 4 is empty if its size is zero.

For any list `l` in Lean 4, the list `l` is empty if and only if its cardinality is zero.


theorem Filter.eventually_smallSets :
    ∀ {α : Type u_1} {l : Filter α} {p : Set α → Prop},
      (∀ᶠ (s : Set α) in Filter.smallSets l, p s) ↔ ∃ s ∈ l, ∀ t ⊆ s, p t :=
  by sorry

The theorem `Filter.eventually_smallSets` states that, for any type `α`, any filter `l` on `α`, and any property `p` that sets of `α` might have, the statement "For almost all (in the sense of the filter `Filter.smallSets l`) sets `s` of `α`, the property `p` holds for `s`" is equivalent to the statement "There exists a set `s` in the filter `l` such that for all subsets `t` of `s`, the property `p` holds for `t`." Essentially, it provides a condition for a property to hold almost everywhere with respect to the `smallSets` filter of a given filter.

For any filter `l` on type `α` and property `p` on sets of `α`, the property "almost all sets in the filter `l` satisfy `p`" is equivalent to "there exists a set in `l` whose every subset satisfies `p`."


theorem Nat.nth_strictMono : ∀ {p : ℕ → Prop}, Set.Infinite (setOf p) → StrictMono (Nat.nth p) := by sorry

The theorem `Nat.nth_strictMono` states that for any predicate `p` on natural numbers, if the set of natural numbers satisfying `p` is infinite, then the function `Nat.nth p`, which returns the `n`-th natural number that satisfies `p`, is strictly monotone. This means that if `a < b`, then `Nat.nth p a < Nat.nth p b`. In essence, it says that as we increase `n`, the `n`-th natural number satisfying `p` also strictly increases, given an infinite set of natural numbers that satisfy `p`.

If a predicate `p` on natural numbers defines an infinite set, then the function `Nat.nth p` is strictly increasing.


theorem Filter.NeBot.comap_of_range_mem :
    ∀ {α : Type u} {β : Type v} {f : Filter β} {m : α → β},
      Filter.NeBot f → Set.range m ∈ f → Filter.NeBot (Filter.comap m f) :=
  by sorry

This theorem states that for any two types `α` and `β`, any filter `f` on `β`, and any function `m` from `α` to `β`, if the filter `f` is not the bottom filter and the range of function `m` is in the filter `f`, then the preimage filter (the filter obtained by applying the function `m` backwards to `f`) is also not the bottom filter. In other words, under these conditions, applying a function backwards to a filter does not result in the trivial (or bottom) filter.

If `f` is a non-bottom filter on type `β`, and the range of function `m` from type `α` to `β` is included in `f`, then the preimage filter of `f` under `m` is also a non-bottom filter.


theorem ContinuousWithinAt.congr_of_eventuallyEq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f f₁ : α → β} {s : Set α}
      {x : α}, ContinuousWithinAt f s x → f₁ =ᶠ[nhdsWithin x s] f → f₁ x = f x → ContinuousWithinAt f₁ s x :=
  by sorry

This theorem states that for any two functions `f` and `f₁` from a topological space `α` to another topological space `β`, a set `s` of elements from `α`, and a point `x` in `α`, if `f` is continuous at point `x` within the set `s`, and `f₁` equals `f` in a neighborhood within `s` around `x` (i.e., `f₁` and `f` are eventually equal in the neighborhood filter within `s` at `x`), and `f₁` at `x` equals `f` at `x`, then `f₁` is also continuous at point `x` within the set `s`. In other words, continuity of a function at a point within a set is preserved under an eventual equality in a neighborhood around that point.

If a function `f:` α -> β is continuous at a point `x` in a set `s` ⊆ α and `f₁:` α -> β equals `f` in a neighborhood of `x` in `s` and `f₁(x) = f(x)`, then `f₁` is continuous at `x` in `s`.


theorem MeasureTheory.Measure.AbsolutelyContinuous.smul :
    ∀ {α : Type u_1} {R : Type u_6} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [inst : Monoid R]
      [inst_1 : DistribMulAction R ENNReal] [inst_2 : IsScalarTower R ENNReal ENNReal],
      MeasureTheory.Measure.AbsolutelyContinuous μ ν →
        ∀ (c : R), MeasureTheory.Measure.AbsolutelyContinuous (c • μ) ν :=
  by sorry

The theorem states that for any type `α`, any type `R`, any measurable space `m0` on `α`, and any two measures `μ` and `ν` on `α`, if `R` is a monoid and there are actions of `R` on extended nonnegative real numbers (`ENNReal`) that satisfy the distributive law and scalar tower property, then if measure `μ` is absolutely continuous with respect to measure `ν`, it implies that for any element `c` of type `R`, the measure `c • μ` (which is the scalar multiplication of `c` and `μ`) is also absolutely continuous with respect to measure `ν`.

In simple terms, if a measure `μ` is dominated by another measure `ν` (meaning, if any set has measure zero under `ν`, it also has measure zero under `μ`), then any scaled version of `μ` (achieved by multiplying `μ` with any scalar `c`) is also dominated by the same measure `ν`.

If measure `μ` is absolutely continuous with respect to measure `ν` on measurable space `(α, m0)`, and `R` is a monoid with actions on `ENNReal` satisfying distributive law and scalar tower property, then for any `c` in `R`, the scaled measure `c • μ` is also absolutely continuous with respect to `ν`.


theorem Fin.rightInverse_cast : ∀ {n m : ℕ} (eq : n = m), Function.RightInverse (Fin.cast ⋯) (Fin.cast eq) := by sorry

The theorem `Fin.rightInverse_cast` states that for all natural numbers `n` and `m`, given an equality `eq` between `n` and `m`, the function `Fin.cast` with an unspecified equality is a right inverse to the function `Fin.cast eq`. In other words, if we apply `Fin.cast eq` and then apply `Fin.cast` with some equality, we get back to the original element. This is equivalent to saying that the composition of these two functions is the identity function.

For all natural numbers `n` and `m` and equality `eq` between them, `Fin.cast eq` and `Fin.cast` composition is equal to the identity function on `n`.


theorem NumberField.InfinitePlace.comap_surjective :
    ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K],
      Algebra.IsAlgebraic k K → Function.Surjective fun x => NumberField.InfinitePlace.comap x (algebraMap k K) :=
  by sorry

This theorem states that for any two types `k` and `K`, which are fields, where an algebra structure exists from `k` to `K` and `K` is an algebraic over `k`, the function that takes an infinite place of `K` and maps it to an infinite place of `k` is surjective. In other words, for every infinite place in `k`, there exists an infinite place in `K` such that when the infinite place of `K` is restricted along the algebraic embedding from `k` to `K`, we get the original infinite place of `k`.

For any field extension K of a field k with a given algebra structure, every infinite place of k has an infinite place in K mapping to it under restriction along the algebraic embedding.


theorem MvPolynomial.degrees_add :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq σ] (p q : MvPolynomial σ R),
      MvPolynomial.degrees (p + q) ≤ MvPolynomial.degrees p ⊔ MvPolynomial.degrees q :=
  by sorry

The theorem `MvPolynomial.degrees_add` states that, for any commutative semiring `R` and any type `σ` with decidable equality, and for any two multivariate polynomials `p` and `q` over `σ` with coefficients in `R`, the degrees of the polynomial formed by adding `p` and `q` is less than or equal to the join (supremum) of the degrees of `p` and `q`. In other words, adding two multivariate polynomials doesn't increase the degree beyond the maximum degree of the two original polynomials.

For any commutative semiring R and type σ with decidable equality, the degrees of the sum of two multivariate polynomials over σ with coefficients in R is less than or equal to the maximum of their degrees.


theorem Complex.arg_eq_pi_iff : ∀ {z : ℂ}, Complex.arg z = Real.pi ↔ z.re < 0 ∧ z.im = 0 := by sorry

This theorem, `Complex.arg_eq_pi_iff`, states that for any complex number `z`, the argument of `z` is equal to the mathematical constant `π` if and only if the real part of `z` is less than `0` and the imaginary part of `z` is exactly `0`. In other words, a complex number lies on the negative real axis (where the polar angle is `π`) if and only if its real component is negative and its imaginary component is zero.

The complex number `z` has argument equal to `π` if and only if the real part of `z` is less than 0 and the imaginary part is 0.


theorem IsPreconnected.subset_connectedComponentIn :
    ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α} {x : α} {F : Set α},
      IsPreconnected s → x ∈ s → s ⊆ F → s ⊆ connectedComponentIn F x :=
  by sorry

This theorem states that for any type `α` with a topological structure, given a preconnected subset `s` of `α`, a point `x` in `s`, and another set `F` in `α` that contains `s`, the set `s` is a subset of the connected component of `x` in `F`. Here, the connected component of `x` in `F` is defined as the connected component of `x` in the subtype `F` seen as a set in `α`, returning the empty set if `x` is not in `F`. The notion of a preconnected set is defined as a set where there is no non-trivial open partition. Therefore, this theorem asserts the relation between preconnected sets and connected components in a topological space.

For any topological space `α` with a preconnected subset `s` and a point `x` in `s`, the connected component of `x` in `α` contains `s`.


theorem Real.Angle.toReal_le_pi : ∀ (θ : Real.Angle), Real.Angle.toReal θ ≤ Real.pi := by sorry

This theorem states that for any angle `θ` of type `Real.Angle`, when this angle is converted to a real number using the function `Real.Angle.toReal`, the resulting real number is less than or equal to π (`Real.pi`). In other words, the real number equivalent of any angle is always within the range from -π to π.

For any angle `θ` of type `Real.Angle`, the value `Real.Angle.toReal θ` satisfies `-Real.pi ≤ Real.Angle.toReal θ ≤ Real.pi`.


theorem Set.subset_compl_comm : ∀ {α : Type u} {s t : Set α}, s ⊆ tᶜ ↔ t ⊆ sᶜ := by sorry

This theorem states that for any type `α` and any two sets `s` and `t` of the type `α`, `s` is a subset of the complement of `t` if and only if `t` is a subset of the complement of `s`. Here, the complement of a set `s` (denoted `sᶜ`) contains all elements of the type `α` that are not in `s`, and `s` is a subset of `t` (denoted `s ⊆ t`) if every element of `s` is also an element of `t`.

For any type `α` and sets `s` and `t` of type `α`, `s` is a subset of `sᶜ` if and only if `t` is a subset of `tᶜ`, where `sᶜ` denotes the complement of `s` and `tᶜ` denotes the complement of `t`.


theorem List.Ico.eq_nil_of_le : ∀ {n m : ℕ}, m ≤ n → List.Ico n m = [] := by sorry

The theorem `List.Ico.eq_nil_of_le` states that for all natural numbers `n` and `m`, if `m` is less than or equal to `n`, then the interval from `n` to `m`, represented as a list of natural numbers where `n` is included and `m` is excluded (`List.Ico n m`), is an empty list. Essentially, there are no natural numbers `x` such that `n ≤ x < m` if `m ≤ n`.

For all natural numbers n and m, the interval List.Ico n m is an empty list when m is less than or equal to n.


/-- The yoneda version of the sheaf condition is equivalent to the sheaf condition.

C2.1.4 of [Elephant].
 -/
theorem CategoryTheory.Presieve.isSheafFor_iff_yonedaSheafCondition :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X}
      {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)},
      CategoryTheory.Presieve.IsSheafFor P S.arrows ↔ CategoryTheory.Presieve.YonedaSheafCondition P S :=
  by sorry

This theorem states that the Yoneda version of the sheaf condition is equivalent to the sheaf condition for any category `C`, object `X` of `C`, sieve `S` on `X`, and presheaf `P`. In other words, for a given category, object, sieve, and presheaf, the presheaf satisfies the sheaf condition if and only if it satisfies the Yoneda sheaf condition. This is a formalization of Theorem C2.1.4 from the book "The Elephant".

In the context of category theory, the sheaf condition is a property that certain kinds of mathematical objects (such as presheaves) must satisfy. The Yoneda condition is a version of the sheaf condition that is often easier to work with.

For any category `C`, object `X` of `C`, sieve `S` on `X`, and presheaf `P`, the presheaf `P` satisfies the sheaf condition if and only if it satisfies the Yoneda sheaf condition.


theorem Finset.card_smul_finset :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] (a : α)
      (s : Finset β), (a • s).card = s.card :=
  by sorry

This theorem, `Finset.card_smul_finset`, states that for any type `α` that is a group, any type `β` that has a multiplication action by `α`, and any element `a` of `α`, the cardinality (size) of the set obtained by scaling a finite set `s` of `β` by `a` is the same as the cardinality of `s` itself. This assumes that equality for elements of `β` is decidable, which means we can always determine whether two elements of `β` are equal or not. The scaling of the set `s` is defined by the group action of `α` on `β`.

For any group `α`, any type `β` with a left action by `α`, and decidably equated `β`, the cardinality of the scaled finite set `{a * x | x ∈ s}` is equal to that of `s`, where `s` is a finite subset of `β` and `a` is an element of `α`.


theorem ULift.down_sup : ∀ {α : Type u} [inst : Sup α] (a b : ULift.{u_1, u} α), (a ⊔ b).down = a.down ⊔ b.down := by
  sorry

This theorem, `ULift.down_sup`, states that for any type `α` that has a supremum (or least upper bound), denoted as `Sup α`, and for any two `ULift` values `a` and `b` of the type `α`, the supremum of `a` and `b` when first lifted (using the `ULift` constructor) and then taken down (using the `.down` operation) is equal to the supremum of `a.down` and `b.down`. In other words, lifting does not change the order of the supremum operation.

For any type `α` with a supremum and for all `ULift a` and `ULift b` of type `α`, `Sup (ULift.lift a) (ULift.lift b) = Sup (a.down) (b.down)`.


theorem MeasureTheory.SimpleFunc.iSup_eapprox_apply :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (f : α → ENNReal),
      Measurable f → ∀ (a : α), ⨆ n, ↑(MeasureTheory.SimpleFunc.eapprox f n) a = f a :=
  by sorry

This theorem states that for any measurable space `α` and a measurable function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), for any element `a` in `α`, the supremum (or least upper bound) over all natural numbers `n` of the value of `a` under the `n`th approximation of `f` by simple functions is equal to the actual value of `f` at `a`. In other words, the sequence of simple function approximations converges pointwise to the original function `f` for every element in the domain.

For any measurable space `α`, measurable function `f` from `α` to the extended nonnegative real numbers, and any `α` element `a`, the pointwise limit of the sequence of simple function approximations of `f` equals the value of `f` at `a`.


theorem Set.subset_compl_iff_disjoint_right : ∀ {α : Type u} {s t : Set α}, s ⊆ tᶜ ↔ Disjoint s t := by sorry

The theorem `Set.subset_compl_iff_disjoint_right` states that for any type `α` and any sets `s` and `t` of type `α`, the set `s` is a subset of the complement of `t` if and only if the sets `s` and `t` are disjoint. In other words, no element in `s` also belongs to `t` if and only if all elements in `s` belong to the complement of `t`. The term "disjoint" here refers to the generalization of disjoint sets in a lattice context, meaning that the infimum (greatest lower bound) of the two sets is the bottom element of the lattice.

For sets \(s\) and \(t\) in type \(\alpha\), \(s \subseteq \neg t\) if and only if \(s \cap t = \bot\), where \(\neg\) denotes the complement and \(\bot\) the bottom element of the lattice.


theorem Order.pred_covBy_of_not_isMin :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a : α}, ¬IsMin a → Order.pred a ⋖ a := by sorry

The theorem `Order.pred_covBy_of_not_isMin` states that for every type `α` with a preorder and predecessor order, for any element `a` of `α` that is not a minimal element (i.e., there exists another element in `α` that is strictly less than `a`), the predecessor of `a` (which is the greatest element less than `a`) is strictly less than `a`. In terms of relations, this theorem says that if `a` is not the least element in its set, then its predecessor is strictly less than `a`.

If `α` is a type with a preorder and `a` is an element of `α` that is not minimal, then `pred a` (the predecessor of `a`) is strictly less than `a`.


/-- When a vector is in `Kᗮ`, with the inner product the
other way round.  -/
theorem Submodule.mem_orthogonal' :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (K : Submodule 𝕜 E) (v : E), v ∈ Kᗮ ↔ ∀ u ∈ K, ⟪v, u⟫_𝕜 = 0 :=
  by sorry

This theorem, `Submodule.mem_orthogonal'`, states that for any given types `𝕜` and `E` where `𝕜` behaves like a ring or a commutative ring and `E` is a normed addition commutative group with associated inner product space, a vector `v` is in the orthogonal complement `Kᗮ` of a submodule `K` if and only if the inner product between `v` and any vector `u` in `K` is zero. This means that `v` is orthogonal to every vector in `K`.

A vector `v` is in the orthogonal complement of a submodule `K` in a normed addition commutative group `E` with associated inner product space if and only if the inner product of `v` and every vector `u` in `K` is zero.


theorem ContinuousLinearMap.le_opNorm_of_le :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_6} [inst : SeminormedAddCommGroup E]
      [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
      [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
      (f : E →SL[σ₁₂] F) {c : ℝ} {x : E}, ‖x‖ ≤ c → ‖f x‖ ≤ ‖f‖ * c :=
  by sorry

The theorem `ContinuousLinearMap.le_opNorm_of_le` states that for any two seminormed additive commutative groups `E` and `F`, two nontrivially normed fields `𝕜` and `𝕜₂`, a normed space structure over `E` and `F` with respect to `𝕜` and `𝕜₂` respectively, a ring homomorphism `σ₁₂` from `𝕜` to `𝕜₂` which is an isometry, and a continuous linear map `f` from `E` to `F`, if the norm of an element `x` from `E` is less than or equal to a real number `c`, then the norm of `f(x)` is less than or equal to the operator norm of `f` multiplied by `c`. This theorem expresses a bounding property of continuous linear maps in the context of normed spaces.

For a continuous linear map between normed spaces, the norm of the image of any element is less than or equal to the operator norm times the norm of the element.


/-- We can more explicitly show that a category has an initial object by specifying the object,
and showing there is a unique morphism from it to any other object.  -/
theorem CategoryTheory.Limits.hasInitial_of_unique :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) [h : (Y : C) → Unique (X ⟶ Y)],
      CategoryTheory.Limits.HasInitial C :=
  by sorry

This theorem states that we can explicitly demonstrate that a category has an initial object by indicating a particular object, and showing that there exists a unique morphism from this object to any other object in the category. Specifically, for any category `C`, if there is an object `X` in `C` such that for every object `Y` in `C` there exists a unique morphism from `X` to `Y`, then `C` has an initial object. This object is unique up to unique isomorphism. This theorem is an important characteristic property of initial objects in category theory.

A category has an initial object if and only if there exists an object with a unique morphism to every other object.


theorem MeasureTheory.AECover.integrable_of_integral_norm_bounded :
    ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      {l : Filter ι} [inst_1 : NormedAddCommGroup E] [inst_2 : Filter.NeBot l] [inst_3 : Filter.IsCountablyGenerated l]
      {φ : ι → Set α},
      MeasureTheory.AECover μ l φ →
        ∀ {f : α → E} (I : ℝ),
          (∀ (i : ι), MeasureTheory.IntegrableOn f (φ i) μ) →
            (∀ᶠ (i : ι) in l, ∫ (x : α) in φ i, ‖f x‖ ∂μ ≤ I) → MeasureTheory.Integrable f μ :=
  by sorry

The theorem `MeasureTheory.AECover.integrable_of_integral_norm_bounded` states that, for a given measurable space `α`, a set `ι`, a normed additive commutative group `E`, a measure `μ` on `α`, a filter `l` on `ι` that is countably generated and not the bottom filter, and a function `φ` from `ι` to the set of `α`, if `φ` is an almost everywhere cover with respect to `μ` and `l`, then for any function `f` from `α` to `E` and any real number `I`, if `f` is integrable on each set `φ i` (for every `i` in `ι`), and if the integral of the norm of `f` over each set `φ i` is almost everywhere bounded by `I` (with respect to the filter `l`), then `f` is integrable with respect to the measure `μ`. In simpler terms, if a function is integrable on each set in a countable collection of sets that almost everywhere covers a space, and if the integral of the function's norm is bounded on these sets, then the function is integrable over the entire space.

If a function is integrable and has bounded integral norm on each set of a countably generated, non-bottom filter covering a measurable space, then the function is integrable over the entire space.


LinearEquiv.range

theorem LinearEquiv.range :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_12} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂}
      (e : M ≃ₛₗ[σ₁₂] M₂), LinearMap.range ↑e = ⊤ :=
  by sorry

The theorem `LinearEquiv.range` states that for any linear equivalence `e` between two modules `M` and `M₂` over semirings `R` and `R₂` respectively, the range of the corresponding linear map is the whole target module `M₂`. In other words, every element of `M₂` is reachable by applying the linear map to some element of `M`. This aligns with the intuition that a linear equivalence, being a bijective linear map, should "cover" the entire target module.

For any linear equivalence between modules, the image of the module under the corresponding linear map is the entire target module.


theorem ge_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [t : OrderTopology α] {a b : α},
      a < b → ∀ᶠ (x : α) in nhds a, x ≤ b :=
  by sorry

This theorem, `ge_mem_nhds`, states that for any topological space `α` supplied with a preorder and an order topology, and for any two elements `a` and `b` in `α` such that `a` is less than `b`, there exists a neighborhood of `a` in which all elements `x` are less than or equal to `b`. In less formal terms, it says that if `a` is less than `b`, there will always be a set of points close to `a` that are all less than or equal to `b`. Note that `∀ᶠ (x : α) in nhds a, x ≤ b` is a notation in Lean 4 to denote that the set `{x : α | x ≤ b}` is in the neighborhood filter of `a`.

For any topological space equipped with a preorder and order topology, if `a` is less than `b`, then there exists a neighborhood of `a` containing only elements less than or equal to `b`.


theorem Cardinal.lift_le_aleph0 :
    ∀ {c : Cardinal.{u}}, Cardinal.lift.{v, u} c ≤ Cardinal.aleph0 ↔ c ≤ Cardinal.aleph0 := by sorry

The theorem `Cardinal.lift_le_aleph0` asserts that for each cardinal number `c` in universe `u`, the universe-lifted version of `c` (from universe `v` to universe `u`) is less than or equal to the smallest infinite cardinal (`ℵ₀`) if and only if `c` itself is less than or equal to `ℵ₀`. In other words, the process of lifting a cardinal to a different universe preserves the property of being less than or equal to `ℵ₀`.

For all cardinal numbers `c` in a universe, `c ≤ ℵ₀` if and only if the lifted version of `c` in a higher universe is also less than or equal to `ℵ₀`.


Finite.Set.subset

theorem Finite.Set.subset : ∀ {α : Type u} (s : Set α) {t : Set α} [inst : Finite ↑s], t ⊆ s → Finite ↑t := by sorry

This theorem states that for any set `s` of type `α`, and another set `t` of the same type, if `s` is finite and `t` is a subset of `s`, then `t` is also finite. In other words, the theorem establishes that any subset of a finite set is also finite. This is a fundamental property in set theory.

If `s` is a finite set and `t` is a subset of `s`, then `t` is also finite.


theorem Ideal.bot_prime : ∀ {α : Type u} [inst : Semiring α] [inst_1 : IsDomain α], Ideal.IsPrime ⊥ := by sorry

This theorem states that, for any type `α` (assumed to be a semiring and a domain), the bottom ideal (`⊥`) is a prime ideal. In the context of ring theory in mathematics, a prime ideal of a ring is an ideal whose quotient ring is an integral domain. The bottom ideal, often denoted by `⊥`, is the smallest ideal in a ring, typically consisting of just the zero element.

For any semiring and domain type `α`, the bottom ideal `⊥` is a prime ideal.


theorem Filter.map_fst_prod :
    ∀ {α : Type u_1} {β : Type u_2} (f : Filter α) (g : Filter β) [inst : Filter.NeBot g],
      Filter.map Prod.fst (f ×ˢ g) = f :=
  by sorry

The theorem `Filter.map_fst_prod` states that for any two types `α` and `β`, and any two filters `f : Filter α` and `g : Filter β`, if `g` is a filter not equal to the bottom filter (i.e., a filter that does not contain all sets), then the forward map of the filter of the product `f ×ˢ g` under the function `Prod.fst`, which projects an element of the product to its first component, is equal to `f`. In other words, projecting the product filter `f ×ˢ g` to its first component results in the original filter `f`, given that the second component filter `g` is not a bottom filter. This theorem states a key property of filters in the context of product spaces and projection operations.

For any filters `f` on type `α` and `g` on type `β` with `g ≠ ⊥`, the forward image of `f ×ˢ g` under `Prod.fst` is equal to `f`.


Inducing.continuousNeg

theorem Inducing.continuousNeg :
    ∀ {G : Type u_1} {H : Type u_2} [inst : Neg G] [inst_1 : Neg H] [inst_2 : TopologicalSpace G]
      [inst_3 : TopologicalSpace H] [inst_4 : ContinuousNeg H] {f : G → H},
      Inducing f → (∀ (x : G), f (-x) = -f x) → ContinuousNeg G :=
  by sorry

The theorem `Inducing.continuousNeg` states that given two types `G` and `H` with negation operations, and equipped with topological structures, if the negation operation is continuous in `H` and there exists a function `f` from `G` to `H` which is an inducing function (it keeps the topological structure), and this function `f` also preserves the negation operation (i.e. `f` of `-x` equals `-f` of `x` for every `x` in `G`), then the negation operation is also continuous in `G`. This theorem is related to the continuity of the negation operation under certain conditions in the world of topological spaces.

If `f` is a continuous, negation-preserving inducing function from a topological space `(G, top_G)` to another topological space `(H, top_H)` with continuous negation operation, then the negation operation is continuous on `(G, top_G)`.


theorem Matrix.inv_def :
    ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
      A⁻¹ = Ring.inverse (Matrix.det A) • Matrix.adjugate A :=
  by sorry

This theorem, `Matrix.inv_def`, defines the inverse of a matrix. More precisely, it states that for any matrix `A` indexed by a finite type `n` with coefficients in a commutative ring `α`, the inverse of `A` is equal to the scalar product of the ring inverse of the determinant of `A` and the adjugate of `A`. In mathematical notation, this would be written as `A⁻¹ = (det(A))⁻¹ * adjugate(A)`. Here `•` denotes scalar multiplication, `Ring.inverse` the ring inverse (or reciprocal) function which sends `x` to `x⁻¹` if `x` is invertible and to `0` otherwise, and `Matrix.det` and `Matrix.adjugate` are the determinant and adjugate of the matrix respectively.

For a matrix `A` of size `n x n` over a commutative ring `α`, its inverse is equal to the product of the ring inverse of its determinant and its adjugate: `A⁻¹ = (det(A))⁻¹ * adjugate(A)`.


CategoryTheory.DifferentialObject.ext

theorem CategoryTheory.DifferentialObject.ext :
    ∀ {S : Type u_1} [inst : AddMonoidWithOne S] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
      [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
      {A B : CategoryTheory.DifferentialObject S C} {f g : A ⟶ B}, autoParam (f.f = g.f) _auto✝ → f = g :=
  by sorry

This theorem, named `CategoryTheory.DifferentialObject.ext`, states that for any type `S` equipped with an `AddMonoidWithOne` structure, and any category `C` that has zero morphisms and a shift structure with respect to `S`, if `A` and `B` are differential objects in `C` with respect to `S`, then any two morphisms `f` and `g` from `A` to `B` are equal if their underlying morphisms `f.f` and `g.f` are equal. The equality of `f.f` and `g.f` is provided as an automatically inferred parameter (`autoParam`) with a certain tactic (`_auto✝`).

If `S` is a type with an `AddMonoidWithOne` structure, and `C` is a category with zero morphisms and a shift structure with respect to `S`, then for any differential objects `A` and `B` in `C` with respect to `S`, any two morphisms `f` and `g` from `A` to `B` are equal if their underlying morphisms are equal.


theorem Set.singleton_eq_singleton_iff : ∀ {α : Type u} {x y : α}, {x} = {y} ↔ x = y := by sorry

This theorem states that for all types `α` and for any two elements `x` and `y` of that type, the set containing only `x` is equal to the set containing only `y` if and only if `x` is equal to `y`. In other words, two singleton sets (sets with only one element) are equal if and only if their elements are equal.

For any type `α` and elements `x, y` of type `α`, the singletons `{x}` and `{y}` are equal if and only if `x = y`.


theorem add_le_of_nonpos_left :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      b ≤ 0 → b + a ≤ a :=
  by sorry

This theorem, `add_le_of_nonpos_left`, is a statement about an ordered additive structure. Specifically, for any type `α` that has an additive zero, an addition operation, a less-than-or-equal-to relation, and satisfies the covariance property for addition and this relation (i.e., for all `x` and `y` in `α`, `x + y ≤ x` implies `y ≤ 0`), if `b` is a non-positive element of `α` (i.e., `b ≤ 0`), then adding `b` to any element `a` of `α` will result in a sum that is less than or equal to `a`.

For any additive structure `α` with covariance for addition and a non-positive element `b`, `a + b ≤ a` for all `a` in `α`.


theorem MeasureTheory.Measure.haar.addIndex_pos :
    ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalAddGroup G]
      (K : TopologicalSpace.PositiveCompacts G) {V : Set G},
      Set.Nonempty (interior V) → 0 < MeasureTheory.Measure.haar.addIndex (↑K) V :=
  by sorry

This theorem states that for any additive group `G` equipped with a topological space structure and a topological addition operation, given a non-empty positive compact set `K` and any set `V` whose interior is non-empty, the additive version of the Haar index of the sets `K` and `V` is strictly positive. The Haar index, in this context, is defined as the infimum of the size of finite coverings of `K` by translates of `V`.

For any additive group `G` with a topology and compact, non-empty set `K`, if the interior of set `V` is non-empty, then the Haar index of `K` and `V` is strictly positive.


theorem OrderIso.image_preimage :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set β), ⇑e '' (⇑e ⁻¹' s) = s := by
  sorry

The theorem `OrderIso.image_preimage` states that for any two ordered types `α` and `β`, given an order isomorphism `e` from `α` to `β` and a set `s` of type `β`, the image under `e` of the preimage under `e` of `s` is equal to `s` itself. In other words, if we first map elements of `β` back to `α` through the isomorphism `e` and then map them forward to `β` again, we end up with the original set `s`.

For any order isomorphism `e` between ordered types `α` and `β` and any set `s` of type `β`, `e''(e��мпи(s)) = s`.


theorem LipschitzOnWith.norm_sub_le :
    ∀ {E : Type u_6} {F : Type u_7} [inst : SeminormedAddGroup E] [inst_1 : SeminormedAddGroup F] {s : Set E}
      {f : E → F} {C : NNReal},
      LipschitzOnWith C f s → ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x - f y‖ ≤ ↑C * ‖x - y‖ :=
  by sorry

The theorem `LipschitzOnWith.norm_sub_le` states that for any types `E` and `F` that are seminormed add groups, any set `s` of type `E`, any function `f` from `E` to `F`, and any nonnegative real number `C`, if the function `f` is Lipschitz continuous with constant `C` on the set `s`, then for all `x` and `y` in `s`, the norm of the difference between `f(x)` and `f(y)` is less than or equal to `C` times the norm of the difference between `x` and `y`. In mathematical terms, we have $\|f(x) - f(y)\| \leq C \|x - y\|$ for all $x, y \in s$.

For any Lipschitz continuous function $f$ from a seminormed add group $E$ to another seminormed add group $F$, and any set $s$ in $E$, the norm of $f(x) - f(y)$ is less than or equal to the Lipschitz constant $C$ times the norm of $x - y$ for all $x, y \in s$.


theorem Bool.xor_false : ∀ (x : Bool), xor x false = x := by sorry

The theorem `Bool.xor_false` states that for any Boolean value `x`, the exclusive or (xor) of `x` and `false` is equal to `x`. In other words, when one of the inputs to the xor operation is `false`, the result is simply the other input. This is analogous to the mathematical statement: for all x in {true, false}, x XOR false equals x.

For all Boolean values x, x XOR false equals x.


/-- We shorten this from `measure_preimage_add_left`, since left invariant is the preferred option for
measures in this formalization. -/
theorem MeasureTheory.measure_preimage_add :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [inst_2 : MeasurableAdd G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsAddLeftInvariant μ] (g : G) (A : Set G),
      ↑↑μ ((fun h => g + h) ⁻¹' A) = ↑↑μ A :=
  by sorry

This theorem, `MeasureTheory.measure_preimage_add`, states that for any type `G` that has a measurable space structure, an addition group structure, and a measurable addition structure, and for any measure `μ` on `G` that is left-invariant under addition, and for any element `g` of `G` and any set `A` of `G`, the measure of the preimage of `A` under the function that adds `g` to every element, is equal to the measure of `A`.

In simple words, it states that if we have a measure that doesn't change when we shift everything by adding a fixed element, then the measure of a set is equal to the measure of the shifted set. In mathematical terms, it verifies the property $\mu(g + A) = \mu(A)$ where $\mu$ is a left-invariant measure on a group `G`, `g` is an element of `G`, and `A` is a subset of `G`.

A left-invariant measure on a group is unchanged when shifting the set by an element: $\mu(g + A) = \mu(A)$.


theorem Finset.biUnion_image_right :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β},
      (Finset.biUnion t fun b => Finset.image (fun a => f a b) s) = Finset.image₂ f s t :=
  by sorry

The theorem `Finset.biUnion_image_right` states that for any types `α`, `β`, and `γ` with `γ` having decidable equality, and given a binary function `f : α → β → γ` and two finite sets `s : Finset α` and `t : Finset β`, the biUnion of `t` with the function that applies `f` to each element of `s` and a fixed element of `t` (i.e. `(Finset.biUnion t fun b => Finset.image (fun a => f a b) s)`) is equivalent to the image of `f` over the Cartesian product of `s` and `t` (i.e. `Finset.image₂ f s t`). This means that the set of all values obtained by applying `f` to pairs `(a, b)` where `a` is from `s` and `b` is from `t` can be computed in either of these two ways.

For finite sets `s : Finset α` and `t : Finset β`, and a binary function `f : α → β → γ` with `γ` having decidable equality, the biUnion of `t` with the function `Finset.image (fun a => f a <$> t) s` is equal to the image of `f` over the Cartesian product `s × t` (`Finset.image₂ f s t`).


Order.Ideal.nonempty

theorem Order.Ideal.nonempty : ∀ {P : Type u_1} [inst : LE P] (s : Order.Ideal P), Set.Nonempty ↑s := by sorry

The theorem `Order.Ideal.nonempty` states that for any given Order Ideal `s` of a particular type `P` that has a less than or equal to (`LE`) order relation, the set of elements in `s` is nonempty. In other words, there exists at least one element `x` such that `x` belongs to the order ideal `s`.

For any Order Ideal `s` of type `P` with a `LE` order relation, `s` is nonempty.


/-- Composing two multiplications on the left by `y` then `x`
is equal to a multiplication on the left by `x * y`.
 -/
theorem comp_mul_left :
    ∀ {α : Type u_1} [inst : Semigroup α] (x y : α), ((fun x_1 => x * x_1) ∘ fun x => y * x) = fun x_1 => x * y * x_1 :=
  by sorry

This theorem states that for any type `α` that forms a semigroup (that is, it has an associative multiplication operation), given any two elements `x` and `y` from `α`, the function that first multiplies by `y` and then by `x` (i.e., composition of multiplying by `y` and then by `x`) is equivalent to the function that multiplies by `x * y`. In terms of mathematical notation, this reads as `(x * (y * _)) = (x * y * _)` for all `_` in `α`, where `_` is a placeholder for the argument to the function.

For any semigroup type `α` and elements `x, y` in `α`, the functions `x * (y * _)` and `(x * y) * _` are equal.


theorem isLUB_of_tendsto_atTop :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : OrderClosedTopology α]
      [inst_3 : Nonempty β] [inst_4 : SemilatticeSup β] {f : β → α} {a : α},
      Monotone f → Filter.Tendsto f Filter.atTop (nhds a) → IsLUB (Set.range f) a :=
  by sorry

The theorem `isLUB_of_tendsto_atTop` states that for any topological space `α` with a preorder and an order-closed topology, any nonempty semilattice `β`, a monotone function `f` from `β` to `α`, and an element `a` in `α`, if `f` tends to `a` as it approaches infinity (`Filter.Tendsto f Filter.atTop (nhds a)`), then `a` is a least upper bound (LUB) of the range of `f` (`IsLUB (Set.range f) a`).

In other words, if `f` is a monotone function whose limit at infinity is `a`, then `a` is the smallest value that is greater than or equal to all values in the range of `f`. This theorem is a combination of topology (concerning limits of functions) and order theory (concerning upper bounds).

If `α` is a topological space with a preorder and an order-closed topology, `β` is a nonempty semilattice, `f` is a monotone function from `β` to `α`, and `a` is the limit of `f` as it approaches infinity, then `a` is the least upper bound of the range of `f`.


theorem Nat.eq_zero_of_gcd_eq_zero_left : ∀ {m n : ℕ}, Nat.gcd m n = 0 → m = 0 := by sorry

The theorem `Nat.eq_zero_of_gcd_eq_zero_left` states that for any two natural numbers `m` and `n`, if the greatest common divisor (gcd) of `m` and `n` is zero, then `m` must be zero. In mathematical terms, this can be expressed as: for all natural numbers `m` and `n`, if `gcd(m, n) = 0`, then `m = 0`.

If the greatest common divisor of natural numbers `m` and `n` is zero, then `m` equals zero.


Equiv.invOn

theorem Equiv.invOn :
    ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) {s : Set α} {t : Set β}, Set.InvOn (⇑e) (⇑e.symm) t s := by sorry

This theorem states that for any two types, `α` and `β`, and any equivalence `e` between `α` and `β`, if `s` is a set of type `α` and `t` is a set of type `β`, then the function `e` (viewed as mapping from `α` to `β`), and its inverse `e.symm` (viewed as mapping from `β` to `α`) are inverses of each other with respect to the sets `s` and `t`. This means that the function `e` and its inverse `e.symm` are left and right inverses when restricted to these sets. In other words, applying `e` followed by `e.symm` (or vice versa) will leave any element of the sets `s` and `t` unchanged.

For any equivalence `e` between types `α` and `β`, and sets `s` of type `α` and `t` of type `β`, `e` and `e.symm` are mutual inverses when restricted to `s` and `t`, i.e., `e (x : s) ∈ t` if and only if `e.symm (y : t) = x`.


theorem summable_of_isBigO :
    ∀ {ι : Type u_1} {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : CompleteSpace E] {f : ι → E}
      {g : ι → ℝ}, Summable g → f =O[Filter.cofinite] g → Summable f :=
  by sorry

The theorem `summable_of_isBigO` asserts that for any types `ι` and `E` (where `E` is a seminormed additively commutative group and a complete space), and any functions `f: ι → E` and `g: ι → ℝ`, if `g` is summable and `f` is big O of `g` with respect to the cofinite filter (meaning that `f` is bounded above by some multiple of `g` outside of a finite set), then `f` is also summable. In other words, if a function `f` is dominated by a summable function `g` in the order of growth, then `f` is also summable.

If `f: ι → E` is a function that is big O of the summable function `g: ι → ℝ` with respect to the cofinite filter, then `f` is summable.


theorem Matroid.dual_base_iff :
    ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, autoParam (B ⊆ M.E) _auto✝ → (M﹡.Base B ↔ M.Base (M.E \ B)) := by
  sorry

This theorem, `Matroid.dual_base_iff`, states that for any type `α`, any matroid `M` over this type, and any set `B` of this type (with an automatic parameter ensuring that `B` is a subset of the set `E` of the matroid `M`), the set `B` is a base of the dual of the matroid `M` if and only if the complement of the set `B` with respect to `E` is a base of the matroid `M`. In mathematical terms, given a matroid `M` and a subset `B` of its ground set `E`, `B` is a base of the dual matroid if and only if the set difference `E \ B` is a base of the original matroid.

A set is a base of the dual matroid of a matroid if and only if its complement is a base of the original matroid.


theorem MeasureTheory.AEEqFun.induction_on₂ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
      [inst_1 : TopologicalSpace β] {α' : Type u_5} {β' : Type u_6} [inst_2 : MeasurableSpace α']
      [inst_3 : TopologicalSpace β'] {μ' : MeasureTheory.Measure α'} (f : α →ₘ[μ] β) (f' : α' →ₘ[μ'] β')
      {p : (α →ₘ[μ] β) → (α' →ₘ[μ'] β') → Prop},
      (∀ (f : α → β) (hf : MeasureTheory.AEStronglyMeasurable f μ) (f' : α' → β')
          (hf' : MeasureTheory.AEStronglyMeasurable f' μ'),
          p (MeasureTheory.AEEqFun.mk f hf) (MeasureTheory.AEEqFun.mk f' hf')) →
        p f f' :=
  by sorry

The theorem `MeasureTheory.AEEqFun.induction_on₂` states that for any two equivalence classes of almost everywhere strongly measurable functions `f` and `f'` (represented as `α →ₘ[μ] β` and `α' →ₘ[μ'] β'`), with respect to measures `μ` and `μ'`, and a property `p` that holds for the equivalence classes of all such functions, if the property `p` holds for the classes constructed from all almost everywhere strongly measurable functions `f` and `f'` (using the constructor `MeasureTheory.AEEqFun.mk`), then the property `p` must also hold for the equivalence classes `f` and `f'`. This can be seen as an induction principle for equivalence classes of almost everywhere strongly measurable functions.

If `p` is a property that holds for the equivalence classes of all almost everywhere strongly measurable functions `f : α →ₘ[μ] β` and `f' : α' →ₘ[μ'] β'`, and `p` holds for the classes constructed from all such functions using the constructor `MeasureTheory.AEEqFun.mk`, then `p` also holds for the equivalence classes `f` and `f'`.


/-- This lemma expresses the vanishing of
`(P q).f (n+1) ≫ X.δ k : X _[n+1] ⟶ X _[n]` when `k≠0` and `k≥n-q+2`  -/
theorem AlgebraicTopology.DoldKan.HigherFacesVanish.of_P :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {X : CategoryTheory.SimplicialObject C} (q n : ℕ),
      AlgebraicTopology.DoldKan.HigherFacesVanish q ((AlgebraicTopology.DoldKan.P q).f (n + 1)) :=
  by sorry

This theorem, named `AlgebraicTopology.DoldKan.HigherFacesVanish.of_P` in Lean 4, asserts that for a given simplicial object `X` in a category `C` that is preadditive, the composition of two morphisms `(P q).f (n+1)` and `X.δ k`, which maps from `X _[n+1]` to `X _[n]`, vanishes when `k` is not equal to `0` and `k` is greater than or equal to `n-q+2`. This theorem is related to the Dold-Kan correspondence in algebraic topology, which establishes an equivalence between the category of chain complexes and the category of simplicial abelian groups.

For a preadditive simplicial object `X` in a category `C`, the composition of the higher face morphism `X.δ` with the `q`-th face morphism `(P q).f` of its associated chain complex vanishes for `k > n - q + 1`.


theorem Int.ceil_mono : ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α], Monotone Int.ceil := by
  sorry

The theorem `Int.ceil_mono` asserts that for any type `α` that is a `LinearOrderedRing` and a `FloorRing`, the function `Int.ceil` is monotone. This means, given any two real numbers `a` and `b` such that `a ≤ b`, the smallest integer greater than or equal to `a` is less than or equal to the smallest integer greater than or equal to `b`. In other words, if `a` is less than or equal to `b`, then `⌈a⌉` is less than or equal to `⌈b⌉`.

For any type `α` that is a LinearOrderedRing and a FloorRing, the ceiling function `⌈.⌉ : ℝ → ℤ` is a monotone function, i.e., `a ≤ b` implies `⌈a⌉ ≤ ⌈b⌉`.


theorem Bornology.eventually_ne_cobounded :
    ∀ {α : Type u_2} [inst : Bornology α] (a : α), ∀ᶠ (x : α) in Bornology.cobounded α, x ≠ a := by sorry

The theorem `Bornology.eventually_ne_cobounded` states that for any type `α` equipped with a Bornology (a set of subsets known as "bounded sets"), and for any element `a` of this type, there is a filter (a generalization of a sequence) of elements of `α` that are not equal to `a`, and these elements are obtained from the cobounded sets of the Bornology (i.e., those sets in the Bornology that are not contained in any other set of the Bornology). This essentially says that given any point in a space with a Bornology, we can find a sequence of different points that are all part of large (in a sense defined by the Bornology) sets.

For any type `α` with a Bornology and any `a` in `α`, there exists a filter of cobounded sets containing elements not equal to `a`.


theorem Mathlib.Combinatorics.SimpleGraph.Metric._auxLemma.2 :
    ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
      (SimpleGraph.dist G u v = 0) = (u = v ∨ ¬SimpleGraph.Reachable G u v) :=
  by sorry

The theorem `Mathlib.Combinatorics.SimpleGraph.Metric._auxLemma.2` states that for any simple graph `G` of vertices `V` and any two vertices `u` and `v` from `V`, the distance between `u` and `v` in `G` is zero if and only if `u` and `v` are the same vertex or there is no walk in `G` that connects `u` and `v`. Here, the distance between two vertices is defined as the length of the shortest walk between them and two vertices are said to be reachable if there exists a walk between them.

The theorem asserts that in a simple graph, the distance between two vertices is zero if and only if they are the same vertex or there is no path connecting them.


theorem le_of_forall_lt' : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, (∀ (c : α), a < c → b < c) → b ≤ a := by
  sorry

This theorem, `le_of_forall_lt'`, states that for any type `α` that has a linear order, if for every element `c` of `α` the condition "if `a` is less than `c` then `b` is less than `c`" holds true, then `b` is less than or equal to `a`. This provides a way to establish an inequality relation between two elements in a linearly ordered set based on their relation to all other elements in the set. Essentially, if `b` is always less than any number that `a` is less than, then `b` must be less than or equal to `a`.

If every element less than `a` in a linearly ordered set is less than `b`, then `b` is less than or equal to `a`.


theorem Equiv.pointReflection_apply :
    ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [inst_1 : AddTorsor G P] (x y : P),
      (Equiv.pointReflection x) y = x -ᵥ y +ᵥ x :=
  by sorry

This theorem states that for any types G and P, given that G is an additive group and P is an additive torsor over G, the application of the point reflection operation at a point 'x' to another point 'y' results in the vector subtraction of 'y' from 'x' followed by vector addition to 'x'. In mathematical terms, `pointReflection(x)(y) = x - y + x`. The point reflection operation is established here as a function that reflects a point over another point in an additive group structure.

For any additive group G and additive torsor P over G, point reflection of y in x is equivalent to subtracting y from x and adding x, that is, `pointReflection(x)(y) = x - y + x`.


theorem real_inner_smul_left :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F) (r : ℝ),
      ⟪r • x, y⟫_ℝ = r * ⟪x, y⟫_ℝ :=
  by sorry

This theorem states that for any real number `r` and any two elements `x` and `y` from an inner product space over the real numbers (`ℝ`), the inner product of `r` scaled by `x` and `y` is equal to `r` multiplied by the inner product of `x` and `y`. In other words, scaling one of the vectors in the inner product by a real number is the same as scaling the result of the inner product by that number. This is a property of the distributivity of scalar multiplication over the inner product in real inner product spaces.

For any real number r and elements x, y of an inner product space over the real numbers, r <⟩x,y⟩ = ⟨x, y⟩ ⋅ r, where  <⟩denotes the inner product.


theorem Ordinal.div_one : ∀ (a : Ordinal.{u_4}), a / 1 = a := by sorry

This theorem states that for any ordinal number `a`, the quotient of `a` divided by one is `a` itself. In terms of ordinal arithmetic, this is equivalent to saying that division by one has no effect on an ordinal number.

For any ordinal number `a`, `a / 1 = a`.


CategoryTheory.GrothendieckTopology.ext

/-- An extensionality lemma in terms of the coercion to a pi-type.
We prove this explicitly rather than deriving it so that it is in terms of the coercion rather than
the projection `.sieves`.
 -/
theorem CategoryTheory.GrothendieckTopology.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J₁ J₂ : CategoryTheory.GrothendieckTopology C},
      J₁.sieves = J₂.sieves → J₁ = J₂ :=
  by sorry

This theorem is an extensionality lemma for Grothendieck topologies in category theory. It states that for any category "C" and two given Grothendieck topologies "J₁" and "J₂" on "C", if their "sieves" are equal, then these two topologies are identical. The "sieves" of a Grothendieck topology can be considered as a way to specify the 'coverage' of the topology, so the lemma essentially says that two Grothendieck topologies are the same if they cover the same 'area'. The proof is given in terms of the coercion to a pi-type instead of the projection `.sieves`.

If two Grothendieck topologies on a category have equal sieves, then they are identical.


theorem self_eq_add_right : ∀ {M : Type u} [inst : AddLeftCancelMonoid M] {a b : M}, a = a + b ↔ b = 0 := by sorry

This theorem states that for any Type `M` which forms an `AddLeftCancelMonoid`, for any two elements `a` and `b` of type `M`, `a` is equal to `a + b` if and only if `b` is equal to `0`. In other words, in a left-cancellable monoid, an element `a` only equals the sum of `a` and another element `b` when `b` is the additive identity (zero).

In a left-cancelable monoid, an element is equal to the sum of that element and another element if and only if the latter is the additive identity.


IsUpperSet.preimage

theorem IsUpperSet.preimage :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
      IsUpperSet s → ∀ {f : β → α}, Monotone f → IsUpperSet (f ⁻¹' s) :=
  by sorry

The theorem `IsUpperSet.preimage` states that for all types `α` and `β` with a preorder (a reflexive and transitive binary relation), given an upper set `s` (a set in which if an element is a member, then any element greater than it is also a member) in `α`, and a monotone function `f` from `β` to `α` (a function such that if `a ≤ b` then `f(a) ≤ f(b)`), the preimage of `s` under `f` (the set of all elements in `β` that `f` maps into `s`) is also an upper set. In other words, the monotone preimage of an upper set is also an upper set in the context of preordered sets.

If `s` is an upper set in a preordered type `α` and `f` is a monotone function from a preordered type `β` to `α`, then the preimage of `s` under `f` is an upper set in `β`.


theorem Nat.isUnit_iff : ∀ {n : ℕ}, IsUnit n ↔ n = 1 := by sorry

This theorem states that for any natural number `n`, `n` is a unit in the monoid of natural numbers under multiplication if and only if `n` is equal to 1. In other words, in the context of natural numbers, the only unit, i.e., the only number that has a multiplicative inverse, is 1.

The natural number `n` is a multiplicative unit in the monoid of natural numbers if and only if `n` equals 1.


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

This theorem, `inf_sdiff_assoc`, states that for any type `α` that is a Generalized Boolean Algebra, and any three elements `x`, `y`, `z` of this type, the "set difference" operation (`\`) behaves the same way whether it is applied to the intersection (`⊓`) of `x` and `y` first and then `z`, or to `x` and the set difference of `y` and `z`. In other words, it asserts that the set difference operation is associative with respect to the intersection operation.

For any type `α` being a Generalized Boolean Algebra and elements `x`, `y`, `z` of it, `(x ⊓ y) \ z` equals `x \ (y \ z)`.


theorem Multiset.cons_inter_of_pos :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (s : Multiset α) {t : Multiset α},
      a ∈ t → (a ::ₘ s) ∩ t = a ::ₘ s ∩ Multiset.erase t a :=
  by sorry

This theorem, `Multiset.cons_inter_of_pos`, states that for any type `α` with a decidable equality relation, any element `a` of this type, and any two multisets `s` and `t` of this type, if `a` is a member of multiset `t`, then the intersection of multiset `t` with the multiset formed by adding `a` to `s` (`a ::ₘ s`) is equal to the intersection of `s` with `t` after erasing `a` from `t`. In other words, when `a` is in `t`, adding `a` to `s` and then intersecting with `t` is the same as intersecting `s` with `t` after `a` has been removed from `t`.

If `α` has decidable equality, `a` is in multiset `t`, then intersecting `a ::ₘ s` with `t` equals intersecting `s` with the multiset obtained by removing `a` from `t`.


theorem Function.Semiconj₂.eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β},
      Function.Semiconj₂ f ga gb → ∀ (x y : α), f (ga x y) = gb (f x) (f y) :=
  by sorry

The theorem `Function.Semiconj₂.eq` states that for any types `α` and `β`, any function `f : α → β`, and any two binary operations `ga : α → α → α` and `gb : β → β → β`, if `f` semiconjugates `ga` to `gb` (meaning for all `x` and `y` in `α`, the function `f` applied on the operation `ga` on `x` and `y` equals the operation `gb` on `f x` and `f y`), then for any two elements `x` and `y` in `α`, the function `f` applied to the operation `ga` on `x` and `y` indeed equals the operation `gb` on `f x` and `f y`. This is the defining property of semiconjugates.

If a function `f` semiconjugs binary operations `ga` and `gb` on types `α` and `β` respectively, then `f (ga x y) = gb (f x) (f y)` for all `x, y` in `α`.


/-- If two additive homomorphisms from `α →₀ M` are equal on each `single a b`,
then they are equal.  -/
theorem Finsupp.addHom_ext :
    ∀ {α : Type u_1} {M : Type u_5} {N : Type u_7} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
      ⦃f g : (α →₀ M) →+ N⦄, (∀ (x : α) (y : M), (f fun₀ | x => y) = g fun₀ | x => y) → f = g :=
  by sorry

This theorem states that if two additive homomorphisms, from the function space `α →₀ M` to `N`, behave the same way on each function `single a b` (where `a` is an element from `α` and `b` is an element from `M`), then those two homomorphisms are equal. Here, `α →₀ M` denotes the function space of functions from `α` to `M` that are finitely supported, i.e., all but a finite number of their values are zero. And `single a b` represents a function in this space that takes the value `b` at `a` and zero elsewhere. "Additive homomorphisms" are functions that preserve the addition operation, and `AddZeroClass` is a typeclass for types having addition and zero operations.

If two additive homomorphisms from the finitely supported function space `α →₀ M` to `N` agree on all functions `single a b`, then they are equal.


theorem Nat.sInf_eq_zero : ∀ {s : Set ℕ}, sInf s = 0 ↔ 0 ∈ s ∨ s = ∅ := by sorry

The theorem `Nat.sInf_eq_zero` states that for any set `s` of natural numbers, the infimum of `s` is zero if and only if either zero is an element of `s` or `s` is an empty set. The 'infimum' of a set is the greatest number that is less than or equal to all numbers in the set. For natural numbers, this would be the smallest number in the set. So, this theorem is stating that the smallest number in a set of natural numbers is `0` if and only if `0` is in the set or the set has no elements.

The infimum of a set of natural numbers is zero if and only if the set contains the natural number zero or is empty.


theorem ball_mono :
    ∀ {β : Type ub} {V W : Set (β × β)}, V ⊆ W → ∀ (x : β), UniformSpace.ball x V ⊆ UniformSpace.ball x W := by sorry

This theorem, named `ball_mono`, states that for any type `β` and for any two sets `V` and `W` of pairs of elements of type `β`, if `V` is a subset of `W`, then for any element `x` of type `β`, the ball around `x` with respect to `V` (denoted as `UniformSpace.ball x V`) is a subset of the ball around `x` with respect to `W` (denoted as `UniformSpace.ball x W`). In other words, if a set of pairs `V` is contained within another set of pairs `W`, then the ball centered at any point `x` for `V` will be contained within the ball centered at the same point for `W`. This theorem establishes a key monotonicity property of balls in a uniform space.

For any type `β` and sets `V` and `W` of pairs of elements of type `β` with `V` being a subset of `W`, the ball around any element `x` of type `β` with respect to `V` (`UniformSpace.ball x V`) is included in the ball around `x` with respect to `W` (`UniformSpace.ball x W`).


/-- For prime `p` the only prime factor of `p^k` is `p` with multiplicity `k`  -/
theorem Nat.Prime.factorization_pow : ∀ {p k : ℕ}, Nat.Prime p → Nat.factorization (p ^ k) = fun₀ | p => k := by sorry

This theorem states that for a prime number `p` and a natural number `k`, the prime factorization of `p` raised to the power of `k` only includes `p` as the prime factor with `k` as its multiplicity. In other words, if you factorize `p^k`, where `p` is a prime number, you only get `p` and it appears `k` times. This aligns with the fundamental theorem of arithmetic which states that every natural number greater than 1 has a unique prime factorization, up to the order of the factors.

For a prime number p and a natural number k, the prime factorization of p^k consists only of p with multiplicity k.


theorem AlgebraicGeometry.Scheme.Pullback.p_comm :
    ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z)
      [inst : ∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.map i) f) g],
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) f =
        CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g) g :=
  by sorry

This theorem, `AlgebraicGeometry.Scheme.Pullback.p_comm`, states that for any three schemes `X`, `Y`, and `Z` in algebraic geometry, an open cover `𝒰` of `X`, and morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`, if for every index `i` in `𝒰.J` we have a pullback of the composite of the map `𝒰.map i` with `f` and `g`, then the composition of the first projection `AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g` with `f` equals the composition of the second projection `AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g` with `g`. In effect, this theorem asserts the commutativity of the pullback square in the context of schemes in algebraic geometry.

Given schemes X, Y, Z, an open cover 𝒰 of X, and morphisms f : X ⟶ Z and g : Y ⟶ Z, if the pullback squares commute for all i in 𝒰.J, then the diagram commutes: f ∘ AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g = g ∘ AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g.


theorem Mathlib.Data.Multiset.Basic._auxLemma.56 :
    ∀ {α : Type u_1} {β : Type v} {s : Multiset α} {f : α → β}, (Multiset.map f s = 0) = (s = 0) := by sorry

This theorem states that for any type `α` and `β`, any multiset `s` of type `α`, and any function `f` from `α` to `β`, the multiset resulting from mapping function `f` over the multiset `s` is empty if and only if the original multiset `s` is empty. In other words, an operation of mapping a function over a multiset will yield an empty multiset if and only if the original multiset was empty.

For any type `α`, any multiset `s` of type `α`, and any function `f` from `α` to any type `β`, if multiset `s` is empty then the multiset obtained by applying function `f` to every element in `s` is also empty.


theorem Multiset.eq_zero_of_forall_not_mem : ∀ {α : Type u_1} {s : Multiset α}, (∀ (x : α), x ∉ s) → s = 0 := by sorry

This theorem states that for any type `α` and any multiset `s` of type `α`, if it holds for every element `x` of type `α` that `x` is not a member of the multiset `s`, then the multiset `s` must be the empty multiset. In other words, if no elements of the given type are in the multiset, the multiset is empty.

If a multiset of type `α` contains no elements of type `α`, then it is the empty multiset.


theorem odd_one : ∀ {α : Type u_2} [inst : Semiring α], Odd 1 := by sorry

The theorem `odd_one` states that, for any type `α` that forms a semiring, the number 1 is odd. In more mathematical terms, this means that there exists a number `k` such that `1 = 2*k + 1`, which is the definition of an odd number in the given semiring.

In a semiring, the multiplicative identity is an odd element.


ContMDiff.contMDiffAt

theorem ContMDiff.contMDiffAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {x : M} {n : ℕ∞}, ContMDiff I I' n f → ContMDiffAt I I' n f x :=
  by sorry

This theorem, `ContMDiff.contMDiffAt`, states that for any nontrivially normed field 𝕜, normed add commutative groups E and E', normed spaces over 𝕜 E and E', topological spaces H, M, H', and M', models with corners I and I' over these spaces, a map `f` from M to M', a point `x` in M, and a natural number or infinity `n`, if the map `f` is continuously differentiable up to order `n` in the sense of the manifolds M and M', then `f` is also continuously differentiable at the point `x` up to the same order `n`. In other words, if a function is continuously differentiable everywhere in a manifold, it is also continuously differentiable at any specific point in the manifold.

If a function is continuously differentiable up to order n on a manifold, then it is continuously differentiable up to the same order at any point in the manifold.


theorem List.sublist_append_right : ∀ {α : Type u_1} (l₁ l₂ : List α), List.Sublist l₂ (l₁ ++ l₂) := by sorry

This theorem states that for any type `α` and any two lists `l₁` and `l₂` of that type, `l₂` is a sublist of the list formed by appending `l₁` and `l₂`. In other words, all elements of `l₂` will appear in the same order in the list `l₁ ++ l₂`, possibly interspersed with elements from `l₁`.

For any type `α` and lists `l₁`, `l₂` of type `list α`, `l₂` is a sublist of `l₁ ++ l₂`.


theorem Primrec.vector_get : ∀ {α : Type u_1} [inst : Primcodable α] {n : ℕ}, Primrec₂ Vector.get := by sorry

This theorem, `Primrec.vector_get`, asserts that for any type `α` that can be coded (as indicated by `[inst : Primcodable α]`) and any natural number `n`, the function `Vector.get` is a binary primitive recursive function. In simpler terms, fetching the nth element from a vector of length `n` whose elements are of type `α` is a process that can be broken down into primitive recursive steps. `Vector.get` is a function that takes a Vector of `α` elements and a `Fin n` (a finite ordinal number less than `n`) and returns the element at that specific position in the vector.

The function `Vector.get` on vectors of type `α` is a primitive recursive function.


theorem uniformEmbedding_subtype_val :
    ∀ {α : Type u} [inst : UniformSpace α] {p : α → Prop}, UniformEmbedding Subtype.val := by sorry

This theorem states that for any given type `α` equipped with a uniform space structure and a property `p` that `α` may satisfy, the function `Subtype.val` is a uniform embedding. `Subtype.val` is a function that takes a subtype (elements of type `α` satisfying property `p`) and returns the underlying element in `α`. In other words, this theorem asserts that the process of retrieving the underlying element from a subtype - under the conditions specified - preserves the uniformity structure.

Given a uniform space `(α, d)` and a subtype `s : α set` defined by a property `p`, the function `Subtype.val` is a uniform embedding from `(s, d)|._` to `(α, d)`.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxLemma.108 :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {y : N},
      (y ∈ AddMonoidHom.range f) = ∃ x, f x = y :=
  by sorry

The theorem `Mathlib.GroupTheory.Subgroup.Basic._auxLemma.108` states that for any additively-grouped types `G` and `N`, and a function `f` which is an additive monoid homomorphism from `G` to `N`, and any element `y` from `N`, `y` lies in the range of `f` if and only if there exists an element `x` from `G` such that `f x` equals `y`. In other words, an element `y` of `N` is in the image of the additive monoid homomorphism `f` if and only if `y` is the image of some element in `G` under the function `f`.

An additive monoid homomorphism maps elements of its domain to elements in its range, and the range contains a given element if and only if there exists a preimage in the domain.


theorem Int.neg_nonneg_of_nonpos : ∀ {a : ℤ}, a ≤ 0 → 0 ≤ -a := by sorry

This theorem states that for any integer `a`, if `a` is less than or equal to zero, then the negative of `a` is greater than or equal to zero. In other words, if `a` is non-positive (i.e., it's either negative or zero), then `-a` is non-negative (i.e., it's either positive or zero). This corresponds to the familiar mathematical fact that the negation of a non-positive number is a non-negative number.

For any integer `a`, if `a` is non-positive, then -`a` is non-negative.


theorem associated_one_iff_isUnit : ∀ {α : Type u_1} [inst : Monoid α] {a : α}, Associated a 1 ↔ IsUnit a := by sorry

This theorem states that for any type `α` that forms a `Monoid`, an element `a` of `α` is associated with 1 if and only if `a` is a unit. In mathematical terms, in the context of a given monoid, an element `a` is associated with the identity element (denoted by 1 here) if there exists a unit such that `a` multiplied by this unit equals to the identity. This is equivalent to saying that `a` is a unit itself, meaning there exists some unit such that when this unit is dereferenced, it equals to `a`.

In a monoid, an element is associated with the identity if and only if it is a unit.


/-- Reindexing both indices along the same equivalence preserves the determinant.

For the `simp` version of this lemma, see `det_submatrix_equiv_self`; this one is unsuitable because
`Matrix.reindex_apply` unfolds `reindex` first.
 -/
theorem Matrix.det_reindex_self :
    ∀ {m : Type u_1} {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : DecidableEq m]
      [inst_3 : Fintype m] {R : Type v} [inst_4 : CommRing R] (e : m ≃ n) (A : Matrix m m R),
      Matrix.det ((Matrix.reindex e e) A) = Matrix.det A :=
  by sorry

The theorem `Matrix.det_reindex_self` states that if you have a matrix `A` whose rows and columns are indexed by the same type `m`, and there's an equivalence `e` between `m` and another type `n`, then reindexing both rows and columns of `A` along this equivalence `e` will preserve the determinant of the matrix. That is, the determinant of the reindexed matrix is equal to the determinant of the original matrix `A`. This is true for any ring `R` and for any types `m` and `n` that have decidable equality and are finite. In other words, rearranging the rows and columns of a matrix in a consistent manner does not change the determinant of the matrix. The proof of this theorem is not shown here.

If `A` is a matrix over a ring `R` with finite, decidably equalized indices `m` and `n`, then the determinant of `A` is equal to the determinant of `A` reindexed along an equivalence between `m` and `n`.


theorem sdiff_sdiff_left :
    ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a \ b) \ c = a \ (b ⊔ c) := by sorry

This theorem states that for any GeneralizedCoheytingAlgebra `α`, and for any elements `a`, `b`, and `c` of `α`, the set difference of `a` and `b` subtracted by `c` is equal to the set difference of `a` and the join of `b` and `c`. In mathematical notation, this can be written as: $ (a \setminus b) \setminus c = a \setminus (b ∪ c) $.

For any Generalized Coalgebra `α`, the set difference `(a \setminus b) \setminus c` equals `a \setminus (b ∪ c)` for all elements `a`, `b`, and `c` of `α`.


theorem mem_chart_target :
    ∀ (H : Type u) {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
      (x : M), ↑(chartAt H x) x ∈ (chartAt H x).target :=
  by sorry

The theorem `mem_chart_target` states that for any given point `x` in a topological space `M` which is also a charted space `H`, the image of `x` under the chart at `x`, denoted by `chartAt H x`, is an element of the target set of the chart. In other words, the theorem guarantees that the chart at a given point `x` properly maps `x` into the target space of the chart.

For any point x in a charted space H of a topological space M, the image of x under the chart at x lies in the target set of the chart.


Nat.ModEq.refl

theorem Nat.ModEq.refl : ∀ {n : ℕ} (a : ℕ), a ≡ a [MOD n] := by sorry

This theorem, `Nat.ModEq.refl`, states that for any natural number `a` and any natural number `n`, `a` is congruent to itself modulo `n`. In other words, if you divide `a` and `a` by `n`, the remainders will be the same, which is a property of modulo operation. This is a general truth in number theory and is not dependent on the specific values of `a` or `n`.

For all natural numbers `a` and `n`, `a` is congruent to `a` modulo `n`. (Or, more mathematically: For all `a` and `n` in `ℕ`, `a` ≡ a (mod n)).


theorem iSup_union :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s t : Set β},
      ⨆ x ∈ s ∪ t, f x = (⨆ x ∈ s, f x) ⊔ ⨆ x ∈ t, f x :=
  by sorry

This theorem states that for any types `α` and `β`, with `α` being a complete lattice, and any function `f` of type `β → α`, and any sets `s` and `t` of type `Set β`, the supremum of `f(x)` where `x` is in the union of `s` and `t` is equal to the supremum of `f(x)` where `x` is in `s` joined with the supremum of `f(x)` where `x` is in `t`. In mathematical notation, this can be written as $\sup_{x \in (s \cup t)} f(x) = \sup_{x \in s} f(x) \cup \sup_{x \in t} f(x)$.

For any complete lattice `α`, function `f` from type `β` to `α`, and sets `s` and `t` of type `Set β`, the supremum of `f(x)` over `x` in `s ∪ t` equals the join (supremum) of the supremums of `f(x)` over `x` in `s` and `f(x)` over `x` in `t`. In Lean notation: `sup (f <$> (s ++ t)) = sup (f <$> s) ⊔ sup (f <$> t)`.


theorem PartialEquiv.symm_symm :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), PartialEquiv.symm (PartialEquiv.symm e) = e := by sorry

The theorem `PartialEquiv.symm_symm` states that for any partial equivalence `e` between two types `α` and `β`, applying the operation `PartialEquiv.symm` twice - that is, taking the "symmetry of the symmetry" - returns the original equivalence `e`. In other words, the double application of the symmetry operation on a partial equivalence is an identity operation.

For any partial equivalence relation $e$ between types $\alpha$ and $\beta$, we have $e \circ \text{symm}(e) = \text{id}_{\alpha}$ and $\text{symm}(e) \circ e = \text{id}_{\beta}$, where $\text{symm}$ is the symmetry operation on partial equivalences and $\text{id}$ denotes the identity relation.


/-- If `a` commutes with both `b` and `c`, then it commutes with their product.  -/
theorem Commute.mul_right :
    ∀ {S : Type u_2} [inst : Semigroup S] {a b c : S}, Commute a b → Commute a c → Commute a (b * c) := by sorry

The theorem `Commute.mul_right` states that: for any type `S` that forms a semigroup, if an element `a` of `S` commutes with two other elements `b` and `c` of `S` (i.e., `a * b = b * a` and `a * c = c * a`), then `a` also commutes with the product of `b` and `c` (i.e., `a * (b * c) = (b * c) * a`).

If `a` commutes with both `b` and `c` in a semigroup `S`, then `a` commutes with their product `b * c`.


theorem Set.sUnion_subset : ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, (∀ t' ∈ S, t' ⊆ t) → ⋃₀ S ⊆ t := by sorry

The theorem `Set.sUnion_subset` states that for any type `α`, and for any set `S` of sets of `α` and any set `t` of `α`, if every set `t'` in `S` is a subset of `t`, then the union over all sets in `S` is also a subset of `t`. This is a theorem that says, intuitively, if `t` contains all the elements of every set in `S`, then `t` contains all the elements in the "big" set that is formed by taking the union of all the sets in `S`.

If every set in a family `S` of subsets of type `α` is a subset of a set `t` of `α`, then the union of all sets in `S` is a subset of `t`.


theorem Mon_.Hom.ext :
    ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
      {M N : Mon_ C} (x y : Mon_.Hom M N), x.hom = y.hom → x = y :=
  by sorry

This theorem, `Mon_.Hom.ext`, states that for any category `C` (of a certain type `u₁`), given we have a monoidal structure over `C`, and two monoidal objects `M` and `N` in `C`, if we have two morphisms `x` and `y` from `M` to `N`, then if the underlying homomorphisms of these two morphisms are equal, the morphisms themselves must also be equal. Essentially, it states that for monoidal objects, the morphism between them is determined uniquely by its underlying homomorphism.

Given a monoidal category `C` and monoidal objects `M` and `N` in `C` with equal underlying homomorphisms from `M` to `N`, the morphisms from `M` to `N` are equal.


theorem Mathlib.Algebra.GroupWithZero.Basic._auxLemma.9 :
    ∀ {M₀ : Type u_2} [inst : CancelMonoidWithZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) := by sorry

This theorem from the Algebra.GroupWithZero.Basic module in the Mathlib library states that for any type `M₀` that is a Cancel Monoid With Zero, and for any three elements `a`, `b`, and `c` of this type, the statement "`a` multiplied by `b` equals `a` multiplied by `c`" is equivalent to the statement "either `b` equals `c` or `a` equals zero". In other words, if multiplication of `a` with two different elements yields the same result, then either those two elements are the same, or `a` is the zero of the monoid.

For any cancel monoid with zero `M₀`, for all `a` in `M₀` and `b, c` in `M₀`, `a * b = a * c` if and only if `b = c` or `a = 0`.