theorem Matrix.kroneckerMap_diagonal_diagonal :
    ∀ {α : Type u_2} {β : Type u_4} {γ : Type u_6} {m : Type u_9} {n : Type u_10} [inst : Zero α] [inst_1 : Zero β]
      [inst_2 : Zero γ] [inst_3 : DecidableEq m] [inst_4 : DecidableEq n] (f : α → β → γ),
      (∀ (b : β), f 0 b = 0) →
        (∀ (a : α), f a 0 = 0) →
          ∀ (a : m → α) (b : n → β),
            Matrix.kroneckerMap f (Matrix.diagonal a) (Matrix.diagonal b) =
              Matrix.diagonal fun mn => f (a mn.1) (b mn.2) :=
  by sorry

This theorem states that for any types `α`, `β`, `γ`, `m`, and `n`, where `α`, `β`, and `γ` have a zero and `m` and `n` have decidable equality, and a function `f` from `α` and `β` to `γ` such that `f` of `0` and any `β` equals `0` and `f` of any `α` and `0` equals `0`, for any functions `a` from `m` to `α` and `b` from `n` to `β`, the Kronecker product (i.e., the operation that combines two matrices into a larger matrix) of the diagonal matrix defined by `a` and the diagonal matrix defined by `b` using the function `f` is equal to the diagonal matrix defined by the function from `m` and `n` to `f` of `a` of `m` and `b` of `n`. This essentially demonstrates a relationship between the Kronecker product and diagonal matrices.

For types `α`, `β`, `γ`, `m`, and `n` with zeroes and decidable equality, and a function `f` from `α × β` to `γ` satisfying `f(0, _) = f(_, 0) = 0`, the Kronecker product of diagonal matrices defined by functions `m → α` `a` and `n → β` `b` using `f` equals the diagonal matrix defined by the function `m × n → γ` `x mapsto f(a(x), b(y))`.


theorem Commute.isNilpotent_add :
    ∀ {R : Type u_1} {x y : R} [inst : Semiring R], Commute x y → IsNilpotent x → IsNilpotent y → IsNilpotent (x + y) :=
  by sorry

The theorem `Commute.isNilpotent_add` states that for any type `R` that behaves as a semiring, given two elements `x` and `y` of this type, if `x` and `y` commute (meaning `x * y = y * x`), and if both `x` and `y` are nilpotent (meaning there exists a natural number `n` such that `x^n = 0` and `y^n = 0` respectively), then their sum `x + y` is also nilpotent.

If `R` is a semiring, `x` and `y` are commuting nilpotent elements of `R`, then `x + y` is nilpotent.


theorem MeasureTheory.Lp.lipschitzWith_pos_part : LipschitzWith 1 fun x => max x 0 := by sorry

This theorem states that the function `max x 0`, which yields the maximum of `x` and `0`, is Lipschitz continuous with a Lipschitz constant of `1`. More formally, for any two inputs `x` and `y`, the distance in the pseudo metric space between `max x 0` and `max y 0` is less than or equal to `1` times the distance between `x` and `y`.

The function `max x 0` is Lipschitz continuous with Lipschitz constant 1 in the pseudo metric space. That is, |max x 0 - max y 0| ≤ |x - y| for all x and y.


FreeAddGroup.Red.exact

theorem FreeAddGroup.Red.exact :
    ∀ {α : Type u} {L₁ L₂ : List (α × Bool)},
      FreeAddGroup.mk L₁ = FreeAddGroup.mk L₂ ↔ Relation.Join FreeAddGroup.Red L₁ L₂ :=
  by sorry

This theorem, `FreeAddGroup.Red.exact`, states that for any type `α` and any two lists `L₁` and `L₂` of pairs of elements from `α` and a Boolean, the canonical mapping of `L₁` to the free additive group on `α` is equal to the canonical mapping of `L₂` to the same free additive group if and only if `L₁` and `L₂` are related by the join of the reflexive-transitive closure of the reduction step relation in the free additive group. In other words, two lists are mapped to the same element in the free additive group if they can both be reduced to the same list through a sequence of reduction steps.

The canonical mappings of two lists of pairs to the free additive group on a type `α` are equal if and only if the lists are related by the reduction step relation's reflexive-transitive closure.


theorem IsCompact.sInf_mem :
    ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : ClosedIicTopology α] {s : Set α}, IsCompact s → Set.Nonempty s → sInf s ∈ s :=
  by sorry

This theorem, `IsCompact.sInf_mem`, states that for any type `α` that has a conditionally complete linear order and a topological structure with the topology being the closed interval from negative infinity to a given number (closed on the right), given a set `s` of this type `α`, if `s` is compact (in the topological sense) and nonempty, then the infimum (greatest lower bound) of the set `s` is an element of the set `s`. In layman's terms, for certain types of ordered sets with suitable topology, if the set is compact and not empty, the smallest element in the set is indeed part of the set.

If `α` is a type with a conditionally complete linear order and a topology as described, and `s` is a compact, nonempty subset of `α`, then the infimum of `s` belongs to `s`.


theorem conj_inv : ∀ {α : Type u} [inst : Group α] {a b : α}, (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹ := by sorry

This theorem states that for any group `α` and any elements `a` and `b` of `α`, the inverse of the element obtained by multiplying `b`, `a`, and the inverse of `b` in sequence is equal to the sequence obtained by multiplying `b`, the inverse of `a`, and the inverse of `b`. In other words, if you take the product of `b`, `a` and `b⁻¹` and then take the inverse of this product, you get the same result as if you had multiplied `b`, `a⁻¹`, and `b⁻¹` in sequence. This is often referred to as the "conjugate inverse" property in group theory.

For any group `α` and elements `a`, `b` in `α`, `b⁻¹ a⁻¹ b = a (b a⁻¹)`.


theorem OreLocalization.numeratorHom_apply :
    ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {r : R},
      OreLocalization.numeratorHom r = r /ₒ 1 :=
  by sorry

The theorem `OreLocalization.numeratorHom_apply` states that for any type `R` that forms a monoid, any submonoid `S` of `R` that serves as an Ore localization set, and any element `r` from `R`, the application of the Ore localization numerator homomorphism on `r` results in the fraction `r /ₒ 1`. This expresses the action of the Ore localization numerator homomorphism as creating fractions where the denominator is `1`.

For any monoid `R`, submonoid `S` serving as an Ore localization set, and `r` in `R`, the Ore localization numerator homomorphism applied to `r` equals `r /ₒ 1`.


theorem Pi.uniformSpace_eq :
    ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)],
      Pi.uniformSpace α = ⨅ i, UniformSpace.comap (fun a => a i) (U i) :=
  by sorry

The theorem `Pi.uniformSpace_eq` states that, for any index type `ι` and any family `α` of types indexed over `ι` where each type in the family is equipped with a uniform space `U`, the uniform space of the product type (denoted as `Pi.uniformSpace α`) is equal to the infimum of the collection of uniform spaces obtained by applying the `comap` function to the projection functions `(fun a => a i)` and the corresponding uniform space `U i` for each index `i`. Here, `UniformSpace.comap` describes the operation of pulling back a uniform space along a function, and `⨅ i` represents the infimum (or greatest lower bound) over all indices `i`.

The uniform space of a product type of uniform spaces indexed over a type, equipped with the projections as functions, is equal to the infimum of the uniform spaces pulled back via these projections.


theorem Polynomial.support_monomial' :
    ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (a : R), Polynomial.support ((Polynomial.monomial n) a) ⊆ {n} := by sorry

The theorem `Polynomial.support_monomial'` states that for any semiring `R`, any natural number `n`, and any element `a` of `R`, the support of the monomial `a * X^n` (where `X` is an indeterminate) is a subset of the singleton set containing `n`. The support of a polynomial is the set of all powers `n` such that `X^n` has a non-zero coefficient. In simpler terms, this theorem says that the only power of `X` that may have a non-zero coefficient in the monomial `a * X^n` is `n`.

For any semiring R, natural number n, and element a in R, the support of the monomial a * X^n contains only the power n.


theorem PMF.mem_support_iff : ∀ {α : Type u_1} (p : PMF α) (a : α), a ∈ PMF.support p ↔ p a ≠ 0 := by sorry

The theorem `PMF.mem_support_iff` states that for any type `α` and any probability mass function `p : PMF α`, an element `a : α` belongs to the support of `p` if and only if the value of `p` at `a` is not equal to zero. In other words, the support of a probability mass function is exactly the set of points where the function is nonzero.

The support of a probability mass function `p : PMF α` equals the set of elements `a : α` such that `p a ≠ 0`.


theorem Mathlib.Data.Matroid.IndepAxioms._auxLemma.15 :
    ∀ {α : Type u_1} {M : IndepMatroid α} {I : Set α}, (IndepMatroid.matroid M).Indep I = M.Indep I := by sorry

The theorem `Mathlib.Data.Matroid.IndepAxioms._auxLemma.15` states that for any type `α`, any independent matroid `M` of type `α`, and any set `I` of elements of type `α`, the independence property of the matroid derived from `M` by the `IndepMatroid.matroid` function applied to `I` is equal to the independence property of `M` applied to `I`. In simpler terms, it says that the independence property is preserved when we convert an independent matroid to a matroid using the `IndepMatroid.matroid` function.

For any type `α`, any independent matroid `M` over `α`, and any set `I` of elements from `α`, the matroid `IndepMatroid.matroid M I` is independent if and only if `I` is independent in `M`.


theorem ENNReal.mul_rpow_of_ne_top : ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ ⊤ → ∀ (z : ℝ), (x * y) ^ z = x ^ z * y ^ z := by
  sorry

The theorem `ENNReal.mul_rpow_of_ne_top` states that for any two numbers `x` and `y` from the set of extended nonnegative real numbers (usually denoted as [0, ∞] and is relevant as the codomain of a measure), where neither `x` nor `y` are equal to ∞, and for any real number `z`, the power of the product of `x` and `y` raised to the `z` is equal to the product of `x` raised to `z` and `y` raised to `z`. This is a version of the power of a product property from elementary algebra, but specified for the set of extended nonnegative real numbers and excluding the case where `x` or `y` are ∞.

For any extended nonnegative real numbers `x` and `y` not equal to ∞, and for any real number `z`, `x^z * y^z = (x * y)^z`.


/-- Construct a `RingHomInvPair` from both directions of a ring equiv.

This is not an instance, as for equivalences that are involutions, a better instance
would be `RingHomInvPair e e`. Indeed, this declaration is not currently used in mathlib.

See note [reducible non-instances].
 -/
theorem RingHomInvPair.of_ringEquiv :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] (e : R₁ ≃+* R₂),
      RingHomInvPair ↑e ↑(RingEquiv.symm e) :=
  by sorry

The theorem `RingHomInvPair.of_ringEquiv` states that for any two types `R₁` and `R₂`, which are semirings, and given a ring isomorphism `e` from `R₁` to `R₂`, we can construct a `RingHomInvPair` from the ring isomorphism `e` and its inverse. Here, a `RingHomInvPair` is a pair of ring homomorphisms that are inverses of each other. This theorem is not an instance, meaning it does not provide a canonical way to construct a `RingHomInvPair` in all contexts. This is because, for ring isomorphisms that are also involutions (self-inverses), a better instance would be a pair consisting of the isomorphism and itself.

Given a ring isomorphism between semirings with a inverse, there exists a pair of ring homomorphisms that are inverses of each other.


theorem vectorAll_iff_forall :
    ∀ {α : Type u_1} {n : ℕ} (f : Vector3 α n → Prop), VectorAll n f ↔ ∀ (v : Vector3 α n), f v := by sorry

This theorem states that for any type `α`, natural number `n`, and a property `f` that takes a vector of length `n` with elements of type `α`, the property `VectorAll n f` is equivalent to saying that for all vectors `v` of length `n` with elements of type `α`, the property `f` holds for `v`. In other words, it's proving that the "curried" version of the universal quantifier (represented by `VectorAll`) over vectors is equivalent to the standard universal quantifier over vectors.

For any type `α`, natural number `n`, and property `f` on vectors of length `n` with elements of type `α`, `VectorAll n f` is equivalent to `∀v: Vector α n, f v`.


theorem injective_toPullbackDiag : ∀ {X : Type u_1} {Y : Sort u_2} (f : X → Y), Function.Injective (toPullbackDiag f) :=
  by sorry

This theorem states that for all types `X` and `Y`, and for any function `f` from `X` to `Y`, the function `toPullbackDiag f` is injective. This means that if `toPullbackDiag f` maps two elements from `X` to the same element in the pullback of `f` with itself, then those two elements must be identical. In other words, `toPullbackDiag f` never maps different elements to the same value, when `f` is a function from `X` to `Y`. Here, `toPullbackDiag f` is the diagonal map from `X` to the pullback of `f` with itself, which associates to each element `x` of `X` the pair `(x, x)` in the pullback, satisfying some property.

For any function `f` from type `X` to type `Y`, the diagonal map `toPullbackDiag f` from `X` to the pullback of `f` with itself is an injection.


theorem iSup_eq_iSup_subseq_of_monotone :
    ∀ {ι₁ : Type u_3} {ι₂ : Type u_4} {α : Type u_5} [inst : Preorder ι₂] [inst_1 : CompleteLattice α] {l : Filter ι₁}
      [inst_2 : Filter.NeBot l] {f : ι₂ → α} {φ : ι₁ → ι₂},
      Monotone f → Filter.Tendsto φ l Filter.atTop → ⨆ i, f i = ⨆ i, f (φ i) :=
  by sorry

This theorem states that for any types `ι₁`, `ι₂`, `α` and a function `f` from `ι₂` to `α` where `ι₂` has a preorder structure and `α` has a complete lattice structure, and a function `φ` from `ι₁` to `ι₂`, if `f` is a monotone function and `φ` tends to infinity with respect to some filter `l` on `ι₁` that is not `⊥` (the smallest filter or the empty set), then the supremum (`⨆`) of the values of `f` over all `ι₂` is equal to the supremum of the values of `f` composed with `φ` over all `ι₁`.

In simpler terms, if `f` is a function that preserves order, and `φ` is a function that generates a sequence that goes to infinity, then the largest value that `f` can take (when it is defined for all `ι₂`) is the same as the largest value that `f` can take when it is applied to the sequence generated by `φ`.

If `f: ι₂ → α` is a monotone function, `φ: ι₁ → ι₂` is a function, `ι₂` is a preordered type with a complete lattice structure, `ι₁` is non-empty and has a filter `l` not equal to the bottom element, then `⨆ (f ∘ φ) (i₁ : ι₁) = ⨆ f (i₂ : ι₂)`.


theorem Sylow.exists_comap_eq_of_ker_isPGroup :
    ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {H : Type u_2} [inst_1 : Group H] (P : Sylow p H) {f : H →* G},
      IsPGroup p ↥(MonoidHom.ker f) → ∃ Q, Subgroup.comap f ↑Q = ↑P :=
  by sorry

The theorem `Sylow.exists_comap_eq_of_ker_isPGroup` states that for any prime number `p`, groups `G` and `H`, a Sylow `p`-subgroup `P` of `H`, and a group homomorphism `f` from `H` to `G`, if the kernel of `f` forms a `p`-group, then there exists a subgroup `Q` of `H` such that the preimage of `Q` under `f` is exactly `P`. In other words, we can find a subgroup `Q` in `H` where all elements map to the Sylow `p`-subgroup `P` in `G` under the homomorphism `f` provided the kernel of `f` is a `p`-group.

Given a prime number `p`, groups `G` and `H`, a Sylow `p`-subgroup `P` of `H`, and a group homomorphism `f` from `H` to `G` with kernel being a `p`-group, there exists a subgroup `Q` of `H` such that `f(Q) = P`.


theorem Int.natCast_add : ∀ (a b : ℕ), ↑(a + b) = ↑a + ↑b := by sorry

This theorem states that for any two natural numbers `a` and `b`, the casting of their sum to an integer is equal to the sum of these two numbers individually cast to integers. In other words, casting to an integer preserves the operation of addition from natural numbers. This is symbolically expressed as `(a + b) = a + b` for two natural numbers `a` and `b`, where the operations and equality are interpreted in the domain of integers.

The theorem asserts that the casting of natural numbers `a` and `b` to integers and their subsequent addition is equal to the individual casting and addition of `a` and `b` as integers. Symbolically, `(to_int a + to_int b) = to_int (a + b)`.


theorem Finsupp.mem_splitSupport_iff_nonzero :
    ∀ {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_13} [inst : Zero M] (l : (i : ι) × αs i →₀ M) (i : ι),
      i ∈ Finsupp.splitSupport l ↔ Finsupp.split l i ≠ 0 :=
  by sorry

The theorem `Finsupp.mem_splitSupport_iff_nonzero` states that for any type `ι`, a type `M` with a zero element, a type function `αs` from `ι`, a finitely supported function `l` from the sigma type `(i : ι) × αs i` to `M`, and an index `i` of type `ι`, `i` is in the split support of `l` if and only if the `i`th component of `l` is non-zero. Essentially, this theorem is providing a condition for membership in the split support set in terms of the non-zeroness of the corresponding component of the function `l`.

For any type `ι`, type function `αs` from `ι`, finitely supported function `l` from `(i : ι) × αs i` to a type `M` with a zero element, and `i` in `ι`, `i` is in the split support of `l` if and only if `l i` is non-zero.


theorem OrderIso.isLUB_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set α} {x : β},
      IsLUB (⇑f '' s) x ↔ IsLUB s ((OrderIso.symm f) x) :=
  by sorry

This theorem states that for any given preorder types `α` and `β`, and a order isomorphism `f` from `α` to `β`, a particular element `x` from `β` is a least upper bound of the image set of `s` under `f` if and only if the inverse image of `x` under `f` (denoted as `(OrderIso.symm f) x`) is a least upper bound of the original set `s` in `α`. In other words, the least upper bound property is preserved under the order isomorphism and its inverse.

For any preorders types `α` and `β`, and an order isomorphism `f` from `α` to `β`, the element `x` in `β` is the least upper bound of `f(s)` if and only if `(OrderIso.symm f) x` is the least upper bound of `s` in `α`.


/-- Two equivalent partial equivs have the same source.  -/
theorem PartialEquiv.EqOnSource.source_eq :
    ∀ {α : Type u_1} {β : Type u_2} {e e' : PartialEquiv α β}, e ≈ e' → e.source = e'.source := by sorry

This theorem states that if two partial equivalences, e and e', of types α and β are equivalent, then their sources are the same. In simple terms, for any two partial equivalences between two types, if they are equivalent, their starting points are identical. The sources of the partial equivalences, in this case, represent the subset of the first type from which the function is defined.

If two partial equivalences `e : α ≃ β` and `e' : α' ≃ β'` are equivalent in Lean 4, then `α = α'`.


RelEmbedding.acc

theorem RelEmbedding.acc :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) (a : α), Acc s (f a) → Acc r a :=
  by sorry

This theorem states that for any two types `α` and `β`, and any two binary relations `r` on `α` and `s` on `β`, if there exists a relation-preserving embedding `f` from `r` to `s` (represented as `r ↪r s`), then for any element `a` of type `α`, if `Acc s (f a)` is true (which means that every chain in `s` starting from `f a` is finite), then `Acc r a` is also true (which means every chain in `r` starting from `a` is also finite). The theorem thus establishes a condition under which the accessibility property can be transferred from a relation to its image under a relation-preserving embedding.

If there exists a relation-preserving embedding from binary relation `r` on type `α` to binary relation `s` on type `β`, and every chain in `s` starting from the image of an element `a` in `α` is finite, then every chain in `r` starting from `a` is also finite.


theorem Mathlib.Topology.Basic._auxLemma.5 : ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ = True := by sorry

This theorem states that for any type `X`, endowed with a `TopologicalSpace` structure, the empty set is always a closed set. In other words, in the context of a given topological space, the empty set is always considered closed regardless of the specific type of `X` or the specifics of the topology.

In any topological space, the empty set is a closed set.


theorem WithBot.some_eq_coe : ∀ {α : Type u_1} (a : α), some a = ↑a := by sorry

This theorem, `WithBot.some_eq_coe`, states that for any type `α` and for any instance `a` of that type, wrapping `a` with `some` operator is equivalent to coercing `a` to its `WithBot` form. In simpler terms, this theorem asserts an equivalence between the option-wrapped form and the subtype-wrapped form of any given instance of a type.

For any type `α` and instance `a` of it, `some (someDem cry a) = coe (withBot a)`, where `someDem` is the default `some` constructor and `withBot` is the `WithBot` subtype constructor.


theorem WithTop.iSup_coe_eq_top :
    ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {f : ι → α},
      ⨆ x, ↑(f x) = ⊤ ↔ ¬BddAbove (Set.range f) :=
  by sorry

The theorem `WithTop.iSup_coe_eq_top` states that for any types `α` and `ι`, given a conditionally complete linear order with a bottom for `α` and a function `f` from `ι` to `α`, the supremum of the co-domain of `f` is equal to the top element if and only if the range of `f` is not bounded above. In other words, the supremum of the image of `f` over all `ι` being infinity implies that there is no upper bound for the set of all possible values of `f`.

For any conditionally complete linear order with a bottom, a function from an index type to the order's type, and an unbounded range, the supremum of the function's image equals the top element.


theorem Finset.prod_disjiUnion :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} {f : α → β} [inst : CommMonoid β] (s : Finset ι) (t : ι → Finset α)
      (h : Set.PairwiseDisjoint (↑s) t),
      (Finset.prod (Finset.disjiUnion s t h) fun x => f x) = Finset.prod s fun i => Finset.prod (t i) fun x => f x :=
  by sorry

The theorem `Finset.prod_disjiUnion` states that for any type `ι`, `α`, `β`, and a function `f` from `α` to `β` with a commutative monoid structure on `β`, given a finite set `s` of elements of type `ι`, a function `t` from `ι` to finite sets of `α` such that the images of any two distinct elements under `t` are disjoint sets, the product over the disjoint union of the sets `t i` for `i` in `s` (using the function `f`) is equal to the product over `s` of the product over `t i` (using the function `f`). In mathematical notation, this can be represented as
\[
\prod_{x \in \bigcup_{i\in s}t i} f(x) = \prod_{i\in s} \left(\prod_{x \in t i} f(x)\right)
\]
where the union in the left-hand side is a disjoint union. The theorem essentially says that when dealing with a product over a disjoint union of sets, you can distribute the product over the union.

For any commutative monoid `β`, given a function `f` from a type `α` to `β`, and a finite set `s` of elements of type `ι` with disjoint images under a function `t` from `ι` to finite sets of `α`, the product of `f` over the disjoint union of `t i` equals the product of the products of `f` over each `t i` in `s`.


theorem AffineSubspace.wSameSide_comm :
    ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : StrictOrderedCommRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] {s : AffineSubspace R P} {x y : P},
      AffineSubspace.WSameSide s x y ↔ AffineSubspace.WSameSide s y x :=
  by sorry

The theorem `AffineSubspace.wSameSide_comm` states that for any given strict ordered commutative ring `R`, an additive commutative group `V`, a module `R` of `V`, an additive torsor `V` of `P`, an affine subspace `s` of `P`, and two points `x` and `y` in `P`, the property of `x` and `y` being weakly on the same side of `s` is commutative. In other words, `x` and `y` are weakly on the same side of `s` if and only if `y` and `x` are weakly on the same side of `s`. Here, being weakly on the same side means that there exists two points in the subspace such that the vectors from these points to `x` and `y` respectively are in the same direction or opposite directions.

For any strict ordered commutative ring R, additive commutative group V, R-module V, additive torsor V over a point P, affine subspace s of P, and points x and y in P, x and y are weakly on the same side of s if and only if y and x are weakly on the same side of s.


theorem GaloisConnection.l_unique :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : PartialOrder β] {l : α → β} {u : β → α},
      GaloisConnection l u →
        ∀ {l' : α → β} {u' : β → α}, GaloisConnection l' u' → (∀ (b : β), u b = u' b) → ∀ {a : α}, l a = l' a :=
  by sorry

The theorem `GaloisConnection.l_unique` states that for any two pairs of functions `(l, u)` and `(l', u')` from a Preorder `α` to a PartialOrder `β` and vice versa, if both pairs form a Galois connection (i.e., for each `l a ≤ b` if and only if `a ≤ u b`, and the same holds with `l'` and `u'`), and the second functions of both pairs `u` and `u'` are equal for all `b` in `β`, then the first functions `l` and `l'` of these pairs are also equal for all `a` in `α`. In other words, given two Galois connections with the same right-adjoint, their left-adjoints are equal.

If two Galois connection pairs between a preorder and a partial order have equal right-adjoint functions, then their left-adjoint functions are equal.


theorem Matrix.fromBlocks_submatrix_sum_swap_sum_swap :
    ∀ {l : Type u_14} {m : Type u_15} {n : Type u_16} {o : Type u_17} {α : Type u_18} (A : Matrix n l α)
      (B : Matrix n m α) (C : Matrix o l α) (D : Matrix o m α),
      Matrix.submatrix (Matrix.fromBlocks A B C D) Sum.swap Sum.swap = Matrix.fromBlocks D C B A :=
  by sorry

The theorem `Matrix.fromBlocks_submatrix_sum_swap_sum_swap` states that for all types `l`, `m`, `n`, `o`, and `α`, and for any matrices `A` of size `n x l`, `B` of size `n x m`, `C` of size `o x l` and `D` of size `o x m` with entries in `α`, the submatrix of the matrix formed by flattening the block matrices `A`, `B`, `C`, and `D` with the factors of the sum type swapped is itself a matrix formed by flattening the block matrices `D`, `C`, `B`, and `A`. In essence, this theorem states that swapping the factors of the sum type and then creating a block matrix is equivalent to creating a block matrix first and then swapping the factors.

For any matrices A of size n x l, B of size n x m, C of size o x l, and D of size o x m with entries in α, the flattened matrices formed by swapping the factors of the sum types (A ⊕ B ⊕ C ⊕ D) and (D ⊕ C ⊕ B ⊕ A) are equal.


theorem Multiset.zero_inter : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α), 0 ∩ s = 0 := by sorry

This theorem states that for any type `α` with decidable equality and for any multiset `s` of type `α`, the intersection of the empty multiset (notated as `0`) and `s` is always the empty multiset. Essentially, it's stating that when you intersect any collection with an empty collection, the result is always an empty collection.

For any type `α` with decidable equality, the intersection of an empty multiset `s` of type `α` with any multiset `s'` is the empty multiset.


theorem Fin.init_snoc :
    ∀ {n : ℕ} {α : Fin (n + 1) → Type u} (x : α (Fin.last n)) (p : (i : Fin n) → α (Fin.castSucc i)),
      Fin.init (Fin.snoc p x) = p :=
  by sorry

The theorem `Fin.init_snoc` states that for any natural number `n` and any function `α` that maps each element of the type `Fin (n + 1)` to a type `u`, for any element `x` of type `α` at the greatest value of `Fin (n+1)`, and any function `p` that maps each element of `Fin n` to `α (Fin.castSucc i)`, the initial `n` entries (obtained by the function `Fin.init`) of the `n+1`-tuple formed by appending `x` at the end of the `n`-tuple (obtained by the function `Fin.snoc`) are equal to the `n` entries of the original `n`-tuple. In other words, adding an element at the end of an `n`-tuple does not change the first `n` elements.

For any natural number `n` and function `α : Fin (n + 1) → Type_, the initial `n` entries of `α` restricted to `Fin n` are equal to the first `n` entries of the `n+1`-tuple obtained by appending an element `x` of type `α (Fin.max)` to an `n`-tuple `p : ∀ i : Fin n, α (Fin.castSucc i)`.


theorem Multiset.dvd_sum :
    ∀ {α : Type u_1} [inst : NonUnitalSemiring α] {s : Multiset α} {a : α}, (∀ x ∈ s, a ∣ x) → a ∣ Multiset.sum s := by
  sorry

This theorem states that for any type `α` equipped with the structure of a non-unital semiring, and for any multiset `s` of elements of `α` and any element `a` of `α`, if `a` divides every element in `s`, then `a` also divides the sum of all elements in `s`. In other words, if each item in a multiset is divisible by a particular number, then the sum of the multiset is also divisible by that number.

If `α` is a semiring and `a` divides every element in a multiset `s` over `α`, then `a` divides the sum of `s`.


theorem AffineMap.lineMap_eq_lineMap_iff :
    ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
      [inst_3 : AddTorsor V1 P1] [inst_4 : NoZeroSMulDivisors k V1] {p₀ p₁ : P1} {c₁ c₂ : k},
      (AffineMap.lineMap p₀ p₁) c₁ = (AffineMap.lineMap p₀ p₁) c₂ ↔ p₀ = p₁ ∨ c₁ = c₂ :=
  by sorry

The theorem `AffineMap.lineMap_eq_lineMap_iff` states that for any ring `k`, any additive commutative group `V1`, any module of `k` over `V1`, any additive torsor `V1` over `P1`, and any non-zero scalar multiplication divisor of `k` over `V1`, if `p₀` and `p₁` are two points in `P1` and `c₁` and `c₂` are two scalars in `k`, then the affine map from `k` to `P1` that sends `0` to `p₀` and `1` to `p₁`, evaluated at `c₁`, equals the same affine map evaluated at `c₂` if and only if either `p₀` equals `p₁` or `c₁` equals `c₂`.

For any ring `k`, additive commutative group `V1`, module `M` over `k` as an `AddMonoidWithCarrier` over `V1`, additive torsor `V1` over a group `P1`, and non-zero scalar multiplication divisor `r` over `V1`, the affine maps from `k` to `P1` that send `0` to `p0` and `1` to `p1`, are equal if and only if `p0 = p1` or `c1 = c2`, where `c1` and `c2` are scalars in `k`.


theorem Real.strictMonoOn_arcsin : StrictMonoOn Real.arcsin (Set.Icc (-1) 1) := by sorry

The theorem `Real.strictMonoOn_arcsin` states that the inverse sine function, `arcsin`, is strictly monotonic on the interval from -1 to 1, inclusive. In other words, if `a` and `b` are any two different real numbers in the closed interval from -1 to 1 (i.e., `-1 ≤ a, b ≤ 1`), and `a < b`, then the `arcsin` of `a` is less than the `arcsin` of `b` (i.e., `arcsin(a) < arcsin(b)`).

The inverse sine function is strictly increasing on the interval [-1, 1].


theorem MeasureTheory.martingale_iff :
    ∀ {Ω : 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 : PartialOrder E],
      MeasureTheory.Martingale f ℱ μ ↔ MeasureTheory.Supermartingale f ℱ μ ∧ MeasureTheory.Submartingale f ℱ μ :=
  by sorry

This theorem, `MeasureTheory.martingale_iff`, defines the condition under which a stochastic process is a martingale. For any types `Ω`, `E`, and `ι`, with `Ω` being a measurable space and `μ` its measure, `E` being a normed add commutative group also being a complete normed space over the reals, and `ι` being a preordered type representing time, and given a stochastic process `f` (a function from time `ι` to a function from `Ω` to `E`) and a filtration `ℱ` (a sequence of sigma-algebras representing the information available at each time), the process `f` is a martingale if and only if it is both a supermartingale and a submartingale.

A stochastic process is a martingale if and only if it is both a supermartingale and a submartingale.


theorem partialSups_iff_forall :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] {f : ℕ → α} (p : α → Prop),
      (∀ {a b : α}, p (a ⊔ b) ↔ p a ∧ p b) → ∀ {n : ℕ}, p ((partialSups f) n) ↔ ∀ k ≤ n, p (f k) :=
  by sorry

The theorem `partialSups_iff_forall` states that for any type `α` that forms a semilattice with a supremum operation, for any function `f` from natural numbers to `α`, and for any property `p` about elements of `α`, if the property `p` distributes over the supremum operation (meaning that `p` holds for the supremum of `a` and `b` if and only if `p` holds for both `a` and `b`), then the property `p` holds for the `n`-th element of the sequence of partial supremums of `f` if and only if `p` holds for all elements `f k` where `k` is a natural number less than or equal to `n`.

For any semilattice `α` with supremum operation, function `f` from natural numbers to `α`, and property `p` distributive over suprema, `p` holds for the `n`-th partial supremum of `f` if and only if `p` holds for all `f k` for `k` up to `n`.


theorem Valuation.isEquiv_of_val_le_one :
    ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} {Γ'₀ : Type u_5}
      [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [inst_2 : LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀)
      (v' : Valuation K Γ'₀), (∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1) → Valuation.IsEquiv v v' :=
  by sorry

This theorem, `Valuation.isEquiv_of_val_le_one`, states that for any division ring `K` and two types `Γ₀` and `Γ'₀`, which are both linearly ordered commutative groups with zero, if for any element `x` of `K` the valuation `v` of `x` is less than or equal to 1 if and only if the valuation `v'` of `x` is also less than or equal to 1, then the valuations `v` and `v'` are equivalent. In other words, if two valuations agree on whether or not their values are less than or equal to 1 for all elements of the division ring, these two valuations are considered equivalent.

If for all `x` in a division ring `K`, the valuations `v` and `v'` satisfy `v x <= 1 <-> v' x <= 1`, then `v` and `v'` are equivalent.


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

This theorem states that for any two types `X` and `Y`, if `Y` is a T1 space (meaning that for any two distinct points in `Y`, they each have a neighborhood that does not contain the other point), and if there exists a function `f` from `X` to `Y` that is an embedding (a function that preserves the topological structure), then `X` is also a T1 space. The topological structures of `X` and `Y` are given by the instances `inst` and `inst_1` respectively.

If `X` is a topological space, `Y` is a T1 space, and `f : X → Y` is an embedding, then `X` is a T1 space.


/-- A greatest element of a set is the supremum of this set.  -/
theorem IsGreatest.csSup_eq :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {s : Set α} {a : α}, IsGreatest s a → sSup s = a := by
  sorry

The theorem `IsGreatest.csSup_eq` states that for any type `α` which is a conditionally complete lattice, and for any set `s` of type `α` and an element `a` of type `α`, if `a` is the greatest element of the set `s`, then the supremum (`sSup`) of the set `s` is equal to `a`. This means that in a conditionally complete lattice, the greatest element of a set is always equal to the supremum of the set.

In a conditionally complete lattice, the greatest element of a set is equal to its supremum.


theorem spectrum.zero_mem_iff :
    ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
      0 ∈ spectrum R a ↔ ¬IsUnit a :=
  by sorry

The theorem `spectrum.zero_mem_iff` states that for any commutative semiring `R` and any `R`-algebra `A`, zero is in the spectrum of an element `a` of `A` if and only if `a` is not a unit (i.e., it does not have a two-sided inverse) in the algebra `A`. In mathematical terms, 0 belongs to the set of `r` in `R` such that `r•1 - a` is not a unit in the algebra `A`, if and only if `a` itself is not a unit.

The theorem `spectrum.zero_mem_iff` asserts that an element `a` of an `R`-algebra `A` over a commutative semiring `R` is not a unit if and only if zero is in the spectrum of `a` in `A`.


theorem MeasureTheory.Measure.InnerRegularWRT.of_imp :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop},
      (∀ (s : Set α), q s → p s) → MeasureTheory.Measure.InnerRegularWRT μ p q :=
  by sorry

The theorem `MeasureTheory.Measure.InnerRegularWRT.of_imp` states that for any type `α`, measurable space `m` of `α`, measure `μ` of `α`, and predicates `p` and `q` on the sets of `α`, if it holds that for every set `s`, `q s` implies `p s`, then the measure `μ` is inner regular with respect to `p` and `q`. In other words, for any set `U` that satisfies `q`, and any real number `r` less than the measure of `U`, there exists a subset `K` of `U` that satisfies `p` and its measure is greater than `r`.

Given a measurable space `(α, m)`, measure `μ`, and predicates `p` and `q` on `α` such that `q ⊆ p` and `μ(U) < ∞` for all `U` with `q U`, for any `r < μ(U)`, there exists a `K ⊆ U` with `p K` and `μ(K) > r`.


theorem star_bit0 :
    ∀ {R : Type u} [inst : AddMonoid R] [inst_1 : StarAddMonoid R] (r : R), star (bit0 r) = bit0 (star r) := by sorry

This theorem, named `star_bit0`, states that for all objects `r` of some type `R`, where `R` is equipped with an addition operation forming an additive monoid, and also equipped with a `star` operation forming a star-additive monoid, the `star` of the bit doubling operation applied to `r` is equal to the bit doubling operation applied to the `star` of `r`. In other words, in the context of these algebraic structures, the `star` operation and the bit doubling operation commute with each other.

For all additive monoid `R` with a star operation making it a star-additive monoid, the star of the bit doubling operation applied to an element `r` equals the bit doubling operation applied to the star of `r`: `(*(2 & r) = 2 & *(r))`.


theorem subset_antisymm_iff :
    ∀ {α : Type u} [inst : HasSubset α] {a b : α} [inst_1 : IsRefl α fun x x_1 => x ⊆ x_1]
      [inst_2 : IsAntisymm α fun x x_1 => x ⊆ x_1], a = b ↔ a ⊆ b ∧ b ⊆ a :=
  by sorry

This theorem states that for any type 'α' that has a subset operation, given any two elements 'a' and 'b' from this type, if the subset operation is reflexive and antisymmetric, then 'a' is equal to 'b' if and only if 'a' is a subset of 'b' and 'b' is a subset of 'a'. In other words, two elements of a reflexive and antisymmetric subset relation are identical if and only if they are subsets of each other.

For any reflexive and antisymmetric subset relation on a type, elements are equal if and only if they are subsets of each other.


IsPiSystem.singleton

theorem IsPiSystem.singleton : ∀ {α : Type u_1} (S : Set α), IsPiSystem {S} := by sorry

The theorem `IsPiSystem.singleton` states that for any set `S` of any type `α`, the singleton set containing only `S` is a π-system. In other words, any singleton set containing a set `S` is closed under binary intersection, meaning that if two subsets of `S` have a nonempty intersection, then their intersection is also a subset of `S`.

For any set `S` of type `α`, the singleton set `{S}` is a π-system, i.e., any two subsets of `S` have nonempty intersection implies their intersection is a subset of `S`.


theorem LinearMap.toMatrix'_comp :
    ∀ {R : Type u_1} [inst : CommSemiring R] {l : Type u_3} {m : Type u_4} {n : Type u_5} [inst_1 : DecidableEq n]
      [inst_2 : Fintype n] [inst_3 : Fintype l] [inst_4 : DecidableEq l] (f : (n → R) →ₗ[R] m → R)
      (g : (l → R) →ₗ[R] n → R), LinearMap.toMatrix' (f ∘ₗ g) = LinearMap.toMatrix' f * LinearMap.toMatrix' g :=
  by sorry

This theorem states that for any commutative semiring `R` and types `l`, `m`, `n` with `n` and `l` being finite and having decidable equality, the composition of two linear maps `f : (n → R) →ₗ[R] m → R` and `g : (l → R) →ₗ[R] n → R` can be expressed in terms of the matrix representation of the individual maps. Specifically, the matrix representation of the composition of `f` and `g` is equal to the product of the matrix representation of `f` and the matrix representation of `g`. This result is a reflection of the associativity property in linear algebra, where the composition of two linear transformations corresponds to the product of their matrix representations.

Given commutative semirings `R`, finite types `l`, `m`, `n` with decidable equality, the matrix representation of the composition of linear maps `f : (n → R) →ₗ[R] m` and `g : (l → R) →ₗ[R] n` equals the product of the matrix representations of `f` and `g`.


theorem Set.iUnionLift.proof_1 :
    ∀ {α : Type u_2} {ι : Sort u_1} (S : ι → Set α), ∀ T ⊆ Set.iUnion S, ∀ (x : ↑T), ∃ i, ↑x ∈ S i := by sorry

The theorem `Set.iUnionLift.proof_1` states that for any type `α`, any sort `ι`, and any family of sets `S` indexed by `ι`, if a set `T` is a subset of the indexed union of the family `S`, then for every element `x` in `T`, there exists an index `i` such that `x` is in the set `S i`. In other words, every element of a subset of an indexed union of sets comes from at least one of the sets in the union.

If `T` is a subset of the indexed union of a family `S` of sets indexed by `ι`, then for every `x` in `T`, there exists an index `i` such that `x` is in `S i`.


theorem MeasureTheory.SimpleFunc.restrict_of_not_measurable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Zero β] {f : MeasureTheory.SimpleFunc α β}
      {s : Set α}, ¬MeasurableSet s → MeasureTheory.SimpleFunc.restrict f s = 0 :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.restrict_of_not_measurable` states that for any given types `α` and `β`, with `α` having a `MeasurableSpace` instance and `β` having a `Zero` instance, given a simple function `f` from `α` to `β` and a set `s` of type `α`, if the set `s` is not measurable, then the restriction of the simple function `f` to the set `s` is equivalent to the zero function. In other words, if you restrict a simple function to a non-measurable set, you will get a function that is identically zero.

If `α` is a measurable space, `β` has a zero, `f` is a simple function from `α` to `β`, and `s` is a non-measurable subset of `α`, then `f[s]` (the restriction of `f` to `s`) is equal to the zero function.


theorem Mathlib.Algebra.Pointwise.Stabilizer._auxLemma.9 :
    ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = ∀ (x : B), x ∈ p ↔ x ∈ q := by sorry

This theorem, titled `_auxLemma.9` under the `Mathlib.Algebra.Pointwise.Stabilizer` namespace, states that for any two objects `p` and `q` of a type `A`, in a context where `A` behaves like a set of elements of another type `B`, the equality of `p` and `q` is equivalent to the condition that for every element `x` of type `B`, `x` is in `p` if and only if `x` is in `q`. Simply put, two objects are equal if and only if they contain exactly the same elements.

For any objects $p$ and $q$ of a type $A$ behaving like a set in $B$, $p = q$ if and only if for all $x$ in $B$, $x$ is in $p$ if and only if $x$ is in $q$.


theorem Ordinal.principal_add_isLimit :
    ∀ {o : Ordinal.{u_1}}, 1 < o → Ordinal.Principal (fun x x_1 => x + x_1) o → Ordinal.IsLimit o := by sorry

The theorem `Ordinal.principal_add_isLimit` states that for any ordinal `o`, if `o` is greater than 1 and is a principal ordinal with respect to the operation of addition (meaning all ordinals less than `o`, when added together, result in an ordinal still less than `o`), then `o` is a limit ordinal. A limit ordinal, here, is defined as an ordinal which is not zero and is not the successor of any other ordinal.

If an ordinal greater than 1 is principal with respect to addition, then it is a limit ordinal.


theorem sign_one :
    ∀ {α : Type u_1} [inst : OrderedSemiring α] [inst_1 : DecidableRel fun x x_1 => x < x_1] [inst_2 : Nontrivial α],
      SignType.sign 1 = 1 :=
  by sorry

The theorem `sign_one` states that for any ordered semiring `α` in which a less than relation is decidable, and which is non-trivial (i.e., not all elements are equal), the sign of the number 1 is 1. This function `SignType.sign` gives the sign of an element: it returns 1 if the element is positive, -1 if it's negative, and 0 if it's neither (i.e., it's zero). According to this theorem, the sign of the number 1 in such a semiring is always 1.

In any decidably ordered non-trivial semiring, the sign of 1 is 1.


theorem CategoryTheory.shiftFunctorAdd'_zero_add :
    ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
      [inst_2 : CategoryTheory.HasShift C A] (a : A),
      CategoryTheory.shiftFunctorAdd' C 0 a a ⋯ =
        (CategoryTheory.Functor.leftUnitor (CategoryTheory.shiftFunctor C a)).symm ≪≫
          CategoryTheory.isoWhiskerRight (CategoryTheory.shiftFunctorZero C A).symm (CategoryTheory.shiftFunctor C a) :=
  by sorry

The theorem `CategoryTheory.shiftFunctorAdd'_zero_add` states that for any category `C` with an associated shift and an additive monoid `A` with an element `a`, the composition of shifting by `0` and `a` (in the category `C`) is equivalent to the composition of the symmetric of the left unitor of the shift functor applied to `a` and the symmetric of the zero shift functor whiskered to the right of the shift functor applied to `a`. This essentially says that shifting by 0 and `a` is the same as shifting by `a` alone, reflecting the additive identity property of the monoid in the category-theoretic context.

For any category with shift functor and additive monoid, shifting by 0 and an element a is equivalent to shifting by a alone.


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

This theorem states that for all types `V` and `V'` with corresponding simple graphs `G` and `G'`, and a graph homomorphism `f` from `G` to `G'`, if `f` is injective then a walk `p` starting and ending at a vertex `u` in `G` is a cycle if and only if the corresponding walk `SimpleGraph.Walk.map f p` in `G'` is a cycle. In other words, the property of being a cycle is preserved under the action of an injective map from one graph to another.

If `f` is an injective graph homomorphism from simple graph `G` to simple graph `G'`, then a walk in `G` starting and ending at vertex `u` forms a cycle if and only if the image walk in `G'` formed by applying `f` to each vertex and edge of the walk also forms a cycle.


StrictMonoOn.mono

theorem StrictMonoOn.mono :
    ∀ {α : Type u_1} {β : Type u_2} {s s₂ : Set α} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β],
      StrictMonoOn f s → s₂ ⊆ s → StrictMonoOn f s₂ :=
  by sorry

This theorem states that if a function `f` is strictly monotone on a set `s` and if another set `s₂` is a subset of `s`, then the function `f` is also strictly monotone on `s₂`. Here, strict monotonicity means that for all pairs of distinct elements `a` and `b` belonging to the set such that `a < b`, we have `f(a) < f(b)`. The theorem therefore asserts the preservation of strict monotonicity under taking subsets.

If `f` is a strictly monotone function on set `s`, then `f` is also strictly monotone on any subset `s₂` of `s`.


theorem Nat.commute_cast : ∀ {α : Type u_1} [inst : NonAssocSemiring α] (x : α) (n : ℕ), Commute x ↑n := by sorry

This theorem, `Nat.commute_cast`, states that for any type `α` that is a nonassociative semiring, and for any element `x` of this type and any natural number `n`, the multiplication of `x` and the cast of `n` to type `α` commutes. In other words, `x * ↑n = ↑n * x`.

For any nonassociative semiring type `α` and its element `x` and any natural number `n`, the multiplication of `x` with the cast of `n` to `α` is commutative: `x * ↑n = ↑n * x`.


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

The theorem `HomogeneousLocalization.mul_val` states that for any given types ι, R, and A, where ι is an additive commutative monoid and R and A are commutative rings, and A is an algebra over R, given a function 𝒜 from ι to submodules of A over R forming a graded algebra, and a submonoid x of A, and any two elements y1 and y2 of the homogeneous localization of 𝒜 at x, the value of the product of y1 and y2 in the homogeneous localization is equal to the product of the values of y1 and y2. In other words, this is a statement of multiplicativity in the context of homogeneous localization, indicated by the equality `HomogeneousLocalization.val (y1 * y2) = HomogeneousLocalization.val y1 * HomogeneousLocalization.val y2`.

In the context of commutative rings R, commutative monoid ι, and an algebra A over R, given a graded submodule algebra 𝒜 from ι to submodules of A, and a submonoid x of A, the product of two elements in the homogeneous localization of 𝒜 at x is equal to the product of their localized values.


theorem div_lt_iff_of_neg :
    ∀ {α : Type u_2} [inst : LinearOrderedField α] {a b c : α}, c < 0 → (b / c < a ↔ a * c < b) := by sorry

This theorem states that for any type `α` that is a linearly ordered field, and for any three elements `a`, `b`, and `c` of this type, if `c` is less than zero, then `b` divided by `c` is less than `a` if and only if `a` multiplied by `c` is less than `b`. This is a statement about the properties of division and multiplication in ordered fields where one of the elements is negative.

For any linearly ordered field `α` and elements `a, b, c` of `α` with `c < 0`, we have `b/c < a` if and only if `ac < b`.


theorem Nat.ModEq.add_right_cancel' : ∀ {n a b : ℕ} (c : ℕ), a + c ≡ b + c [MOD n] → a ≡ b [MOD n] := by sorry

The theorem `Nat.ModEq.add_right_cancel'` states that for any natural numbers `n`, `a`, `b`, and `c`, if `a + c` is congruent to `b + c` modulo `n`, then `a` is congruent to `b` modulo `n`. In other words, if two numbers, when added to the same number, give the same remainder when divided by a particular number, then those two original numbers also give the same remainder when divided by that particular number. This is a property of modulo arithmetic.

If `a` is congruent to `b` modulo `n` and `c` is any natural number, then `a + c` is congruent to `b + c` modulo `n` implies `a` is congruent to `b` modulo `n`.


theorem CauSeq.const_neg :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] (x : β), CauSeq.const abv (-x) = -CauSeq.const abv x :=
  by sorry

The theorem `CauSeq.const_neg` states that for any types `α` and `β`, where `α` is a linearly ordered field and `β` is a ring, and for any absolute value function `abv` from `β` to `α`, the constant Cauchy sequence of the negation of a value `x` (from the ring `β`) is equal to the negation of the constant Cauchy sequence of `x`. In mathematical terms, it's saying that in this setting, negating `x` before or after forming the constant Cauchy sequence doesn't make a difference—the two resulting sequences are the same.

For any linearly ordered field `α`, ring `β`, and absolute value function `abv` from `β` to `α`, the constant Cauchy sequences of `x` and `-x` are equal for all `x` in `β`.


theorem Finsupp.mapDomain_comp :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M} {f : α → β}
      {g : β → γ}, Finsupp.mapDomain (g ∘ f) v = Finsupp.mapDomain g (Finsupp.mapDomain f v) :=
  by sorry

This theorem states that for any types `α`, `β`, `γ`, and `M` with `M` being an additive commutative monoid, and any finitely supported function `v` from `α` to `M`, and any functions `f` from `α` to `β` and `g` from `β` to `γ`, the composition of the `f` and `g` functions after mapping the domain of `v` is equal to the result of first mapping the domain of `v` with `f`, and then mapping the domain of the result with `g`. In simple terms, it's stating that the "mapDomain" operation in the context of finitely supported functions is compatible with function composition - a property commonly known as functoriality in mathematics.

For any additive commutative monoids M, types α, β, γ, finitely supported functions v from α to M, and functions f : α -> β and g : β -> γ, the map of the composition g . f of the domains of v is equal to the map of f followed by g of the domain of v. In other words, (g . f) ^^ v = g ^^ (f ^^ v).


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

The theorem `HasFDerivWithinAt.congr_mono` states that for any types `𝕜`, `E`, and `F` where `𝕜` is a nontrivially normed field, `E` is a normed addition commutative group and a normed space over `𝕜`, and `F` is a normed addition commutative group and a normed space over `𝕜`, given two functions `f` and `f₁` from `E` to `F`, a continuous linear map `f'` from `E` to `F`, a point `x` in `E`, and two sets `s` and `t` of `E`, if `f` has a derivative within `s` at `x` equal to `f'`, function `f₁` equals function `f` on set `t`, `f₁` at `x` is equal to `f` at `x`, and set `t` is a subset of set `s`, then `f₁` also has a derivative within `t` at `x` equal to `f'`.

If `f` has a derivative within `s` at `x` equal to `f'`, `f₁` equals `f` on `t`, `f₁(x) = f(x)`, and `t` is a subset of `s`, then `f₁` has a derivative within `t` at `x` equal to `f'`.


theorem Int.add_lt_add_of_lt_of_le : ∀ {a b c d : ℤ}, a < b → c ≤ d → a + c < b + d := by sorry

This theorem states that for all integers `a`, `b`, `c`, and `d`, if `a` is less than `b` and `c` is less than or equal to `d`, then the sum of `a` and `c` is less than the sum of `b` and `d`. This theorem is a fundamental result in order theory and is applicable to integers in this context.

For all integers `a`, `b`, `c`, and `d`, if `a < b` and `c <= d`, then `a + c < b + d`.


theorem CategoryTheory.ShortComplex.LeftHomologyData.homologyπ_comp_homologyIso_hom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      (S : CategoryTheory.ShortComplex C) (h : CategoryTheory.ShortComplex.LeftHomologyData S)
      [inst_2 : CategoryTheory.ShortComplex.HasHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyπ S)
          (CategoryTheory.ShortComplex.LeftHomologyData.homologyIso h).hom =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso h).hom h.π :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.LeftHomologyData.homologyπ_comp_homologyIso_hom`, states that for any type `C` that forms a category with zero morphisms, and any short complex `S` in this category, as well as any left homology data `h` for this short complex, if `S` has homology, then the composition of the homology morphism of `S` and the homomorphism part of the homology isomorphism of `h` is equal to the composition of the homomorphism part of the cycles isomorphism of `h` and left homology morphism of `h`.

In terms of category theory, this theorem asserts an equality of two composed morphisms in certain conditions, which is a fundamental type of statement in the theory of categories and their morphisms.

For any short complex `S` in a category with zero morphisms, and given left homology data `h` for `S` when it has homology, the composition of homology morphism of `S` and homomorphism part of homology isomorphism `h` equals the composition of homomorphism part of cycles isomorphism and left homology morphism of `h`.


theorem IsAntichain.to_dual :
    ∀ {α : Type u_1} {s : Set α} [inst : LE α],
      IsAntichain (fun x x_1 => x ≤ x_1) s → IsAntichain (fun x x_1 => x ≤ x_1) s :=
  by sorry

The theorem `IsAntichain.to_dual` states that for any type `α` and any set `s` of elements of this type, where the elements of `α` have a less than or equal to (`≤`) relation, if `s` is an antichain with respect to the `≤` relation, then `s` is also an antichain with respect to the dual of the `≤` relation. In other words, if no two distinct elements in `s` are related by `≤`, then no two distinct elements in `s` are related by the opposite relation as well.

If `s` is an antichain of a partially ordered type `α` with respect to the relation `≤`, then `s` is also an antichain with respect to the dual relation `>=`.


theorem Set.mapsTo_iInter_iInter :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {s : ι → Set α} {t : ι → Set β} {f : α → β},
      (∀ (i : ι), Set.MapsTo f (s i) (t i)) → Set.MapsTo f (⋂ i, s i) (⋂ i, t i) :=
  by sorry

The theorem `Set.mapsTo_iInter_iInter` states that for any types `α`, `β` and a sort `ι`, given a family of sets `{s i}` in `α` and `{t i}` in `β` indexed by `ι`, and a function `f` mapping from `α` to `β`, if for all `i` in `ι` the function `f` maps every element in `s i` into `t i` (represented by `Set.MapsTo f (s i) (t i)`), then `f` also maps every element in the intersection of all `s i` into the intersection of all `t i` (represented by `Set.MapsTo f (⋂ i, s i) (⋂ i, t i)`). In other words, if a function maps every element of each set in a family of sets to a corresponding set in another family of sets, it does the same for the intersections of those families of sets.

If for each index `i` in `ι`, a function `f` maps every element of `s i` to `t i`, then `f` maps every element of the intersection of all `s i` to the intersection of all `t i`.


WithSeminorms.congr

/-- Two families of seminorms `p` and `q` on the same space generate the same topology
if each `p i` is bounded by some `C • Finset.sup s q` and vice-versa.

We formulate these boundedness assumptions as `Seminorm.IsBounded q p LinearMap.id` (and
vice-versa) to reuse the API. Furthermore, we don't actually state it as an equality of topologies
but as a way to deduce `WithSeminorms q` from `WithSeminorms p`, since this should be more
useful in practice.  -/
theorem WithSeminorms.congr :
    ∀ {𝕜 : Type u_1} {E : Type u_5} {ι : Type u_8} {ι' : Type u_9} [inst : Nonempty ι] [inst_1 : Nonempty ι']
      [inst_2 : NormedField 𝕜] [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {p : SeminormFamily 𝕜 E ι}
      {q : SeminormFamily 𝕜 E ι'} [t : TopologicalSpace E],
      WithSeminorms p → Seminorm.IsBounded p q LinearMap.id → Seminorm.IsBounded q p LinearMap.id → WithSeminorms q :=
  by sorry

In the realm of seminorms, the theorem `WithSeminorms.congr` states the following: Given two families of seminorms `p` and `q` on the same space, if each seminorm `p i` is bounded by some linear combination of a finite subset of `q`, and vice versa, then the topologies generated by `p` and `q` are equivalent. In this context, the boundedness of a seminorm is formulated as `Seminorm.IsBounded q p LinearMap.id` and its inverse. Rather than stating this as an equality of topologies, it is expressed in a more practical form: if the topology can be described with the seminorms `p`, and the boundedness conditions are satisfied, then the topology can also be described with the seminorms `q`.

If two families of seminorms on the same vector space have each seminorm in one family bounded by a linear combination of a finite subset of seminorms in the other family, and vice versa, then the topologies generated by both families are equal.


theorem OmegaCompletePartialOrder.Continuous.of_bundled' :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
      (f : α →o β), OmegaCompletePartialOrder.Continuous f → OmegaCompletePartialOrder.Continuous' ⇑f :=
  by sorry

This theorem states that for any two types `α` and `β` endowed with the structures of omega complete partial orders, if a function `f` from `α` to `β` is a continuous function (as a bundled function in the sense of order theory), then it is also continuous in the sense of being both monotone and omega continuous. In other words, if a function preserves the order and is continuous in the order-theoretic sense, then it also has the property that it preserves the order and is continuous in the context of omega complete partial orders.

If `α` and `β` are omega complete partial orders and `f` is a bundled continuous function from `α` to `β`, then `f` is both monotone and omega continuous.


LT.lt.gt

theorem LT.lt.gt : ∀ {α : Type u} [inst : LT α] {x y : α}, x < y → y > x := by sorry

This theorem, referred to as `LT.lt.gt`, asserts that for all instances of a type `α` that has a less-than (`LT`) operator, if `x` and `y` are elements of this type, and if `x` is less than `y`, then `y` is greater than `x`. Essentially, this theorem states that the "less than" and "greater than" relationships are inverse of each other in the context of an ordered type.

For all types `α` with a less-than (`LT`) operator and all `x` and `y` of type `α`, if `x` is less than `y` (`x < y`), then `y` is greater than `x` (`y > x`).


theorem MeasureTheory.sigmaFiniteTrim_mono :
    ∀ {α : Type u_1} {m m₂ m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) (hm₂ : m₂ ≤ m)
      [inst : MeasureTheory.SigmaFinite (μ.trim ⋯)], MeasureTheory.SigmaFinite (μ.trim hm) :=
  by sorry

This theorem states that for any type `α` and given three measurable spaces `m`, `m₂`, and `m0` on `α`, and a measure `μ` on `α`, if `m` is less than or equal to `m0` and `m₂` is less than or equal to `m`, then if the measure `μ` trimmed by the measurable space `m` (and additional parameters) is sigma-finite, it implies that the measure `μ` trimmed by the measurable space `m` alone is also sigma-finite. In other words, the sigma-finiteness of a trimmed measure is preserved under monotone functions of measurable spaces.

If `μ` is a sigma-finite measure on a measurable space `α`, `m` and `m₂` are measurable spaces on `α` with `m ≤ m₀` and `m ≤ m₂`, then the trimmed measure `μℙm` is sigma-finite, where `μℙm` is the measure `μ` restricted to the measurable sets in `m`.


theorem Mathlib.Data.Pi.Interval._auxLemma.1 :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {δ : α → Type u_3} {t : (a : α) → Finset (δ a)}
      {f : (a : α) → δ a}, (f ∈ Fintype.piFinset t) = ∀ (a : α), f a ∈ t a :=
  by sorry

The theorem `Mathlib.Data.Pi.Interval._auxLemma.1` states that for any type `α` with decidable equality and finite number of instances, and for any function `δ` from `α` to another type, given a function `t` that maps each instance of type `α` to a finite set of instances of the type determined by `δ`, and a function `f` that maps each instance of `α` to an instance of the type determined by `δ`, the condition `f` being an element of the set of functions from `α` to the types determined by `δ` that are constrained by `t` is equivalent to the condition that for every instance of `α`, the value of `f` at that instance is an element of the set determined by `t` at that instance.

For a decidably equal and finite type α, function δ : α -> Type, functions t : α -> Set (δ α), and f : α -> δ α, the condition that for all x : α, f(x) ∈ t(x) is equivalent to f ∈ {g : α -> δ α | ∀ x, g(x) ∈ t(x)} (the set of functions from α to the types determined by δ that are constrained by t).


theorem Dioph.mul_dioph :
    ∀ {α : Type} {f g : (α → ℕ) → ℕ}, Dioph.DiophFn f → Dioph.DiophFn g → Dioph.DiophFn fun v => f v * g v := by sorry

The theorem `Dioph.mul_dioph` states that for any type `α` and any two functions `f` and `g` from `(α → ℕ) → ℕ`, if both `f` and `g` are Diophantine functions (i.e., their graphs are Diophantine sets), then the function that maps each function `v` to the product of `f v` and `g v` is also a Diophantine function. In other words, the product of two Diophantine functions is also a Diophantine function.

The product of two Diophantine functions is a Diophantine function.


theorem Mathlib.Data.Pi.Interval._auxLemma.3 :
    ∀ {ι : Type u} {α : ι → Type v} [inst : (i : ι) → LE (α i)] {x y : (i : ι) → α i}, (x ≤ y) = ∀ (i : ι), x i ≤ y i :=
  by sorry

This is a theorem about functions and ordering in the mathematical library (Mathlib) of Lean 4. The theorem, denoted as `Mathlib.Data.Pi.Interval._auxLemma.3`, states that for any type `ι` and a function `α : ι → Type v` (which maps elements of `ι` to some type `v`), given an ordering (≤) on the range of `α`, and two functions `x` and `y` of type `(i : ι) → α i`, `x` is less than or equal to `y` if and only if `x i` is less than or equal to `y i` for each `i` in `ι`.

For any type `ι` and function `α : ι → Type v` with an ordering on its range, `x` and `y` being functions of type `(i : ι) → α i`, the equality `x ≤ y` holds if and only if `x i ≤ y i` for all `i` in `ι`.


theorem Filter.lift'_bot :
    ∀ {α : Type u_1} {β : Type u_2} {h : Set α → Set β}, Monotone h → Filter.lift' ⊥ h = Filter.principal (h ∅) := by
  sorry

The theorem `Filter.lift'_bot` states that for all types `α` and `β`, and for any function `h` mapping sets of `α` to sets of `β`, if `h` is a monotone function, then lifting the bottom filter via `h` (essentially applying `h` to each set in the bottom filter) is equivalent to the principal filter of `h` applied to the empty set. In other words, if you consider the smallest possible filter (the empty set), and you map it using a monotone function, you end up with the filter that contains all sets that are supersets of the image of the empty set under `h`. This theorem connects the concepts of monotone functions, the bottom filter, and principal filters in the context of order theory and filter theory.

For any monotone function `h` between sets, lifting the bottom filter of `α` through `h` equals the principal filter of `h` on the empty set of `α`.


theorem dist_midpoint_left :
    ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
      [inst_2 : NormedAddTorsor V P] {𝕜 : Type u_6} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V]
      [inst_5 : Invertible 2] (p₁ p₂ : P), dist (midpoint 𝕜 p₁ p₂) p₁ = ‖2‖⁻¹ * dist p₁ p₂ :=
  by sorry

The theorem `dist_midpoint_left` states that for all types `V`, `P`, and `𝕜` where `V` is a semi-normed add commutative group, `P` is a pseudo metric space, `V` is a normed add torsor over `P`, `𝕜` is a normed field, and `V` is a normed space over `𝕜`, and for all points `p₁` and `p₂` of type `P`, the distance between the midpoint of `p₁` and `p₂` and `p₁` is equal to the inverse of the norm of `2` multiplied by the distance between `p₁` and `p₂`. In mathematical notation, if $m$ is the midpoint of points $p₁$ and $p₂$, this can be written as $dist(m, p₁) = \frac{1}{\|2\|} * dist(p₁, p₂)$.

The midpoint of two points in a normed add torsor over a pseudo metric space, where the underlying vector space is a normed space over a normed field, satisfies the property that the distance from the midpoint to one of the original points is equal to half the distance between the two original points, divided by the norm of 2.


/-- The `0` power series is the unique power series with infinite order. -/
theorem PowerSeries.order_eq_top :
    ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, PowerSeries.order φ = ⊤ ↔ φ = 0 := by sorry

This theorem states that for any type `R` equipped with a semiring structure, and for any formal power series `φ` over `R`, the order of `φ` is infinite if and only if `φ` equals to the zero power series. In other words, the zero power series is uniquely characterized by having an infinite order.

For any semiring `R` and formal power series `φ` over `R`, `φ` has infinite order if and only if `φ` is the zero power series.


theorem Profinite.NobelingProof.πs'.proof_1 :
    ∀ {I : Type u_1} [inst : LinearOrder I] [inst_1 : IsWellOrder I fun x x_1 => x < x_1] {o₁ o₂ : Ordinal.{u_1}},
      o₁ ≤ o₂ → ∀ (x : I), Profinite.NobelingProof.ord I x < o₁ → Profinite.NobelingProof.ord I x < o₂ :=
  by sorry

The theorem `Profinite.NobelingProof.πs'.proof_1` states that for any type `I` equipped with a linear order and a well-order, and for any two ordinals `o₁` and `o₂` in the same type, if `o₁` is less than or equal to `o₂`, then for any element `x` of type `I`, if the ordinal of `x` is less than `o₁`, it will also be less than `o₂`. In other words, this theorem guarantees the preservation of order among ordinals under certain conditions.

For any type equipped with a linear order and a well-order, if one ordinal is less than or equal to another, then the ordinal of any element is preserved and is less than or equal to the larger ordinal.


theorem usize_size_eq : USize.size = 4294967296 ∨ USize.size = 18446744073709551616 := by sorry

This theorem states that the size of the unsigned size (USize) in Lean is either 4294967296 or 18446744073709551616. This is equivalent to saying that the size of USize is either 32 bits or 64 bits, depending on the system architecture.

The size of Lean's unsigned integer type USize is either 32 or 64 bits, equivalent to having a range of 2^32 or 2^64 possible values.


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

This theorem, named as `Mathlib.Order.Filter.Basic._auxLemma.14`, states that for any type `α`, any filter `f` on `α`, and any set `s` of elements of type `α`, the proposition that `s` belongs to `f` is equivalent to the proposition that `s` belongs to the collection of sets in `f`. In other words, a set is a member of a given filter if and only if it is a member of the collection of sets that constitute that filter.

For any filter `f` on type `α` and any set `s` of elements of type `α`, `s` belongs to filter `f` if and only if there exists a set `t` in `f` such that `s` is a subset of `t`.


theorem Mathlib.Order.Filter.Basic._auxLemma.15 :
    ∀ {α : Type u} {s : Set α} {f : Filter (Filter α)}, (s ∈ Filter.join f) = ({t | s ∈ t} ∈ f) := by sorry

The theorem `Mathlib.Order.Filter.Basic._auxLemma.15` states that for any type `α`, any set `s` of type `α`, and any filter `f` on the type `Filter α` (that is, a filter of filters), the set `s` is an element of the filter obtained by joining `f` if and only if the set of all filters `t` such that `s` is an element of `t` is an element of `f`. This is essentially the defining property of the join operation on filters of filters.

A set belongs to the join of filters if and only if it is an element of every filter in the joining family.


theorem bernoulli'_def :
    ∀ (n : ℕ),
      bernoulli' n = 1 - Finset.sum (Finset.range n) fun k => ↑(Nat.choose n k) / (↑n - ↑k + 1) * bernoulli' k :=
  by sorry

The theorem `bernoulli'_def` states that for all natural numbers `n`, the `n`-th Bernoulli number `B_n`, as represented by the function `bernoulli' n`, is equal to `1` minus the sum over all natural numbers `k` less than `n` (represented by `Finset.range n`) of the binomial coefficient `n choose k` (represented by `Nat.choose n k`) divided by `(n - k + 1)` times the `k`-th Bernoulli number `B_k`. This sum is represented in Lean by `Finset.sum (Finset.range n) fun k => ↑(Nat.choose n k) / (↑n - ↑k + 1) * bernoulli' k`, and corresponds to the mathematical formula `1 - \sum_{k < n} \binom{n}{k}\frac{B_k}{n+1-k}`.

The `n`-th Bernoulli number `B_n` is equal to `1` minus the sum over all `0 < k < n` of the binomial coefficient `n choose k` divided by `(n - k + 1)` times the `k`-th Bernoulli number `B_k`.


theorem AddMonoidHom.functions_ext :
    ∀ {I : Type u_1} [inst : DecidableEq I] {Z : I → Type u_2} [inst_1 : (i : I) → AddCommMonoid (Z i)]
      [inst_2 : Finite I] (G : Type u_3) [inst_3 : AddCommMonoid G] (g h : ((i : I) → Z i) →+ G),
      (∀ (i : I) (x : Z i), g (Pi.single i x) = h (Pi.single i x)) → g = h :=
  by sorry

This theorem, `AddMonoidHom.functions_ext`, asserts that for a finite index set `I` with decidable equality and a type `Z` indexed by `I` such that each `Z i` forms an additive commutative monoid, given another type `G` that also forms an additive commutative monoid, if we have two additive monoid homomorphisms `g` and `h` from the function space `(i : I) → Z i` to `G`, then these two homomorphisms are equal if and only if they map each individual function `Pi.single i x` (a function supported at `i` with value `x` there, and `0` elsewhere) to the same value in `G` for all `i` in `I` and `x` in `Z i`.

Given a finite indexed set I with decidable equality, types Z indexed by I forming additive commutative monoids, and type G also forming an additive commutative monoid, two additive monoid homomorphisms from the function space (i : I) -> Z i to G are equal if and only if they map each Pi.single i x to the same value in G for all i in I and x in Z i.


theorem Mathlib.Order.Filter.Basic._auxLemma.94 :
    ∀ {α : Type u} {f : Filter α} [inst : Filter.NeBot f] {p : Prop}, (∃ᶠ (x : α) in f, p) = p := by sorry

This theorem states that for any type `α`, any filter `f` on `α` that is not bottom (i.e., does not contain all subsets of `α`), and any proposition `p`, the statement "There exists an element `x` in the filter `f` for which `p` holds" is equivalent to `p`. In other words, the property `p` holds eventually in the filter `f` if and only if `p` is true.

For any filter `f` on a type `α` that is not bottom and any proposition `p` on `α`, the filter `f` contains an element `x` satisfying `p` if and only if `p` is true for all elements of `α`.


theorem Mathlib.Order.Filter.Basic._auxLemma.97 :
    ∀ {α : Type u} {f : Filter α} {p q : α → Prop},
      (∃ᶠ (x : α) in f, p x ∨ q x) = ((∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in f, q x) :=
  by sorry

This theorem states that for any type `α`, any filter `f` of `α`, and any two predicate functions `p` and `q` on `α`, the eventuality that `p` or `q` holds for some element in `f` is equivalent to the eventuality that `p` holds for some element in `f` or `q` holds for some element in `f`. The notation `∃ᶠ (x : α) in f, p x` is used to represent the eventuality (in the filter `f`) that the predicate `p` is true for some `α`.

For any filter `f` on type `α` and any predicate functions `p` and `q` on `α`, the eventualities `∃ᶠ (x : α) in f, p x` and `∃ᶠ (x : α) in f, p x ∨ q x` are equivalent.


theorem Ordinal.lsub_empty : ∀ {ι : Type u_4} [h : IsEmpty ι] (f : ι → Ordinal.{max u_5 u_4}), Ordinal.lsub f = 0 := by
  sorry

The theorem `Ordinal.lsub_empty` states that for any type `ι` that is empty (i.e., it has no elements), and any function `f` from `ι` to the ordinals (of type `Ordinal.{max u_5 u_4}`), the least strict upper bound of the family of ordinals defined by `f` (denoted as `Ordinal.lsub f`) is zero. In other words, if you have an empty set of ordinals, the smallest ordinal that is strictly greater than all ordinals in the set is zero.

If `ι` is empty, then the least upper bound of the ordinal family `f : ι → Ordinal` is zero.


/-- An ordinal lifted to the same universe equals itself.  -/
theorem Ordinal.lift_id : ∀ (a : Ordinal.{u}), Ordinal.lift.{u, u} a = a := by sorry

The theorem `Ordinal.lift_id` states that for any ordinal `a` in a given universe `u`, lifting `a` to the same universe `u` (i.e., applying the universe lift operation `Ordinal.lift` with both source and target universes being `u`) results in `a` itself. In other words, the operation of lifting an ordinal to its own universe is an identity operation. This is a structural property of ordinals in the context of set theory in Lean 4.

For any ordinal `a` in universe `u`, `Ordinal.lift a u a` holds, or equivalently, applying the `Ordinal.lift` operation with source and target universes equal to `u` results in the identity on ordinals.


theorem Mathlib.Order.Filter.Basic._auxLemma.65 : ∀ {a b : Prop}, (a → b) = (¬a ∨ b) := by sorry

This theorem, named `Mathlib.Order.Filter.Basic._auxLemma.65`, states that for any two propositions `a` and `b`, the implication from `a` to `b` is equivalent to the disjunction of the negation of `a` or `b`. In other words, the statement "if `a` then `b`" is logically equivalent to the statement "either `a` is not true, or `b` is true".

The implication `a → b` is logically equivalent to the disjunction `¬a ∨ b`.


theorem TypeVec.appendFun_comp_splitFun :
    ∀ {n : ℕ} {α : TypeVec.{u_1} n} {γ : TypeVec.{u_2} n} {β : Type u_1} {δ : Type u_2} {ε : TypeVec.{u_3} (n + 1)}
      (f₀ : TypeVec.Arrow (TypeVec.drop ε) α) (f₁ : TypeVec.Arrow α γ) (g₀ : TypeVec.last ε → β) (g₁ : β → δ),
      TypeVec.comp (f₁ ::: g₁) (TypeVec.splitFun f₀ g₀) = TypeVec.splitFun (TypeVec.comp f₁ f₀) (g₁ ∘ g₀) :=
  by sorry

The theorem `TypeVec.appendFun_comp_splitFun` states that for any natural number `n`, given type vectors `α` and `γ` of length `n`, types `β` and `δ`, and a type vector `ε` of length `n + 1`, if we have type vector arrows `f₀` and `f₁` from the "dropped" version of `ε` to `α` and from `α` to `γ` respectively, as well as functions `g₀` and `g₁` from the "last" type of `ε` to `β` and from `β` to `δ` respectively, then composing the arrow `f₁` with the function `g₁` and then applying it to the result of splitting the functions `f₀` and `g₀` yields the same result as splitting the composition of `f₁` and `f₀` with the composition of `g₁` and `g₀`. In mathematical terms, this asserts the commutativity of certain operations involving type vectors, function composition, and arrow composition in Lean 4.

For any natural number `n` and type vectors `α` and `γ` of length `n`, types `β` and `δ`, and type vector arrows `f₀ : ε(0) -> α` and `f₁ : α -> γ`, and functions `g₀ : ε(n) -> β` and `g₁ : β -> δ`, we have `(g₁ ∘ f₁) ∘ (splitFun ε f₀ g₀) = splitFun ε (f₁ ∘ f₀) (g₁ ∘ g₀)`.


theorem Stream'.WSeq.exists_of_liftRel_left :
    ∀ {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β},
      Stream'.WSeq.LiftRel R s t → ∀ {a : α}, a ∈ s → ∃ b ∈ t, R a b :=
  by sorry

The theorem `Stream'.WSeq.exists_of_liftRel_left` states that for every type `α` and `β`, and every relation `R` between `α` and `β`, if `s` and `t` are weak sequences of type `α` and `β` respectively such that `s` and `t` are related by the `LiftRel R` relation, then for any element `a` of `s`, there exists an element `b` in `t` such that `a` and `b` are related by the relation `R`.

For every type `α`, `β`, and relation `R` between `α` and `β`, if `s` and `t` are weak sequences of type `α` and `β` respectively with `LiftRel R`(s, t), then for each `a` in `s`, there exists `b` in `t` such that `R(a, b)`.


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

The theorem `Ordinal.lift_lt` states that for any two ordinals `a` and `b` in a universe `v`, the ordinal `a` is less than the ordinal `b` if and only if the lift of the ordinal `a` to a larger universe `max v u` is less than the lift of the ordinal `b` to the same larger universe. This theorem establishes the preservation of order relationships under the universe lift operation for ordinals.

For any ordinals `a` and `b` in a universe `v`, `a < b` if and only if the lifted ordinals `Ordinal.lift a max v` and `Ordinal.lift b max v` satisfy `Ordinal.lift a max v < Ordinal.lift b max v` in the larger universe `max v`.


theorem SeparatedNhds.of_isCompact_isCompact :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {s t : Set X},
      IsCompact s → IsCompact t → Disjoint s t → SeparatedNhds s t :=
  by sorry

This theorem states that in a topological space `X` that is also a T2 space (also known as a Hausdorff space), for any two compact sets `s` and `t` that are disjoint, it is guaranteed that there exist two open sets `U` and `V` such that `s` is a subset of `U`, `t` is a subset of `V`, and `U` and `V` are disjoint. This theorem therefore expresses a property of compact sets in a Hausdorff space, saying that they can be separated by two disjoint open sets.

In a T2 (Hausdorff) topological space, any two disjoint compact sets can be separated by two disjoint open sets.


theorem Set.range_eq_empty_iff : ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, Set.range f = ∅ ↔ IsEmpty ι := by sorry

The theorem `Set.range_eq_empty_iff` states that for any type `α` and sort `ι`, and a function `f` from `ι` to `α`, the range of the function `f` is equal to the empty set if and only if the sort `ι` is empty. In other words, a function has an empty range if there are no elements in its domain.

For any function f from a non-empty sort ι to type α, the range of f is empty if and only if ι is empty.


theorem Mathlib.Order.Filter.Basic._auxLemma.43 :
    ∀ {α : Type u} {f g : Filter α} {s : Set α}, (s ∈ f ⊓ g) = ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ := by sorry

The theorem `Mathlib.Order.Filter.Basic._auxLemma.43` states that for any type `α`, any two filters `f` and `g` on `α`, and any set `s` of `α`, the set `s` is in the intersection of the filters `f` and `g` if and only if there exists some set `t₁` in filter `f` and some set `t₂` in filter `g` such that `s` is the intersection of `t₁` and `t₂`.

For filters ${f, g}$ on type ${α}$, and ${s \subseteq α}$, ${s} \in {f} \cap {g}$ if and only if there exist ${{t₁} \in {f}}$ and ${{t₂} \in {g}}$ such that ${s = t₁ ∩ t₂}$.


theorem Mathlib.Order.Filter.Basic._auxLemma.41 :
    ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) := by sorry

This theorem states that for any type `α` that forms a semilattice with an infimum operation and has a smallest element, and for any two elements `a` and `b` of this type, `a` and `b` are disjoint (in the sense that any element `x` that is less than or equal to both `a` and `b` is also less than or equal to the smallest element of the type) if and only if the infimum of `a` and `b` is the smallest element of the type. The theorem therefore provides a characterization of disjointness in terms of the infimum operation and the smallest element of the type.

For any semilattice with a smallest element `α`, elements `a` and `b` are disjoint if and only if their infimum is the smallest element of `α`.


theorem Mathlib.Order.Filter.Basic._auxLemma.47 :
    ∀ {α : Sort u_1} {p : α → Prop} {q : { a // p a } → Prop},
      (∃ x, q x) = ∃ a, ∃ (b : p a), q { val := a, property := b } :=
  by sorry

This theorem states that for any type `α`, any property `p` of `α`, and any property `q` of `a` such that `a` satisfies `p`, stating that there exists an `x` that satisfies `q` is equivalent to stating that there exists an `a` and a proof `b` that `a` satisfies `p` such that `q` holds for `a` with the given proof `b`. In other words, it defines how existential quantification interacts with the subtype construction in Lean.

For any type `α`, property `p` of `α`, and property `q` of `a` satisfying `p`, the existence of an `x` with `q` is equivalent to the existence of `a` with `p` and a proof `b` such that `a` has property `p` and `q` holds for `a` with proof `b`.


theorem Mathlib.Order.Filter.Basic._auxLemma.49 :
    ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b := by sorry

This theorem states that for any type `α`, any proposition `p` about `α`, and any proposition `b`, the statement "if there exists an `x` of type `α` that satisfies `p`, then `b` must be true" is equivalent to the statement "for all `x` of type `α`, if `x` satisfies `p`, then `b` must be true". Essentially, it captures the logical equivalence between an existential quantifier in the antecedent of an implication and a universal quantifier in the hypothesis of the implication.

For any type `α`, proposition `p` about `α`, and proposition `b`, the existential quantifier "∃x : α. p(x)" is logically equivalent to the universal quantifier "∀x : α. p(x) → b".


theorem Filter.EventuallyConst.comp₂ :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {l : Filter α} {f : α → β} {g : α → γ},
      Filter.EventuallyConst f l →
        ∀ (op : β → γ → δ), Filter.EventuallyConst g l → Filter.EventuallyConst (fun x => op (f x) (g x)) l :=
  by sorry

The theorem `Filter.EventuallyConst.comp₂` states that for any types `α`, `β`, `γ`, and `δ`, and any filter `l` on `α`, if a function `f` from `α` to `β` is eventually constant along `l`, and a function `g` from `α` to `γ` is also eventually constant along `l`, then for any binary operation `op` from `β` and `γ` to `δ`, the function which maps `x` in `α` to `op (f x) (g x)` in `δ` is also eventually constant along `l`. In other words, the composite function of two functions that are eventually constant along a filter is also eventually constant along that filter.

If functions `f` and `g` are eventually constant along filter `l` on type `α`, then their composition `x ↦ op (f x) (g x)` is also eventually constant along filter `l`, where `op` is a binary operation from `β` and `γ` to `δ`.


ProbabilityTheory.kernel.iIndep.indep

theorem ProbabilityTheory.kernel.iIndep.indep :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {m : ι → MeasurableSpace Ω}
      {_mΩ : MeasurableSpace Ω} {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.iIndep m κ μ → ∀ {i j : ι}, i ≠ j → ProbabilityTheory.kernel.Indep (m i) (m j) κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.iIndep.indep` states that for any types `α`, `Ω`, and `ι`, and for any measure space over `α`, any function `m` from `ι` to a measure space over `Ω`, any measure space over `Ω`, any kernel `κ` from a probability theory over types `α` and `Ω`, and any measure `μ` over `α`, if the family of measurable space structures is independent with respect to the kernel `κ` and the measure `μ`, then for any distinct `i` and `j` in `ι`, the measurable spaces `m i` and `m j` are also independent with respect to the kernel `κ` and the measure `μ`.

If a family of measurable spaces is independent with respect to a kernel and a measure, then any pair of distinct measurable spaces in the family are also independent with respect to that kernel and measure.


theorem LinearEquiv.toSpanNonzeroSingleton_homothety :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E]
      [inst_2 : Module 𝕜 E] [inst_3 : BoundedSMul 𝕜 E] (x : E) (h : x ≠ 0) (c : 𝕜),
      ‖(LinearEquiv.toSpanNonzeroSingleton 𝕜 E x h) c‖ = ‖x‖ * ‖c‖ :=
  by sorry

This theorem states that for any type 𝕜, normed division ring over 𝕜, seminormed additive commutative group E, a module 𝕜 E, a bounded scalar multiplication of 𝕜 and E, and any non-zero element x of E, and any element c of 𝕜, the norm of the element obtained by applying the linear equivalence `toSpanNonzeroSingleton` with arguments 𝕜, E, x, h (where h is the condition that x ≠ 0) to the element c, is equal to the product of the norm of x and the norm of c. This theorem can be understood as stating the property that the norm of the projection of an element c in the span of a non-zero element x is proportional to the norm of x and the norm of c.

For any normed division ring 𝕜, seminormed additive commutative group E, module 𝕜 E, and bounded scalar multiplication, the norm of the product of a non-zero element x in E and any scalar c in 𝕜, as defined by `toSpanNonzeroSingleton`, equals the product of the norms of x and c.


theorem Memℓp.const_smul :
    ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] {𝕜 : Type u_3}
      [inst_1 : NormedRing 𝕜] [inst_2 : (i : α) → Module 𝕜 (E i)] [inst_3 : ∀ (i : α), BoundedSMul 𝕜 (E i)]
      {f : (i : α) → E i}, Memℓp f p → ∀ (c : 𝕜), Memℓp (c • f) p :=
  by sorry

The theorem `Memℓp.const_smul` states that for any given type `α`, a function `f` from `α` to a type `E` (where `E` is a normed additive commutative group), an extended nonnegative real number `p`, a normed ring `𝕜`, a module structure over `𝕜` and `E`, and a bounded scalar multiplication operation, if `f` has the property `Memℓp` for the value `p`, then for any constant `c` in `𝕜`, the function resulting from scalar multiplication of `f` by `c` also has the property `Memℓp` for the same `p`.

The `Memℓp` property can have three different meanings depending on the value of `p`. If `p` is 0, `Memℓp` means that `f` is finitely supported. If `p` is ∞, `Memℓp` means that the set of the norms of `f` has an upper bound. If `p` is any other number between 0 and ∞, `Memℓp` means that the series formed by raising the norms of `f` to the power `p` is summable.

If `f` is a function from type `α` to a normed additive commutative group `E` with the `Memℓp` property for some extended nonnegative real number `p`, then the scalar multiplication of `f` by any constant `c` in the normed ring `𝕜` also possesses the `Memℓp` property for the same `p`.


theorem Mathlib.Order.Filter.Basic._auxLemma.21 : ∀ {α : Type u} {f : Filter α}, Filter.NeBot f = (f ≠ ⊥) := by sorry

This theorem states that for any given type `α` and any filter `f` of this type, the property that `f` is not a trivial (or "bottom") filter is equivalent to the assertion that `f` is not equal to the bottom filter. In other words, a filter `f` on `α` is non-trivial if and only if `f` is not equal to the trivial filter.

A filter `f` on type `α` is non-trivial if and only if it is not equal to the bottom filter.


theorem Mathlib.Order.Filter.Basic._auxLemma.25 : ∀ {α : Type u} {s : Set α}, (s ∈ ⊥) = True := by sorry

This theorem states that for any type `α` and any set `s` of elements of type `α`, it is always true that `s` is an element of the bottom filter, denoted by `⊥`. A filter is a mathematical concept that generalizes the notion of a subsequence in sequences and the notion of an "open neighborhood" in topology. The bottom filter, `⊥`, is the smallest filter that contains all subsets of the type `α`.

For any type `α` and set `s` of elements from `α`, `s` is an element of the bottom filter `⊥`.


theorem continuousAt_const_cpow : ∀ {a b : ℂ}, a ≠ 0 → ContinuousAt (fun x => a ^ x) b := by sorry

The theorem `continuousAt_const_cpow` states that for any two complex numbers `a` and `b`, given that `a` is not equal to zero, the function that takes `x` to `a ^ x` (i.e., raises `a` to the power `x`) is continuous at `b`. In mathematical terms, this means that as `x` approaches `b`, `a ^ x` tends to `a ^ b`.

For complex numbers `a ≠ 0` and `b`, the function `x ↦ a ^ x` is continuous at `b`.


theorem Filter.mem_inf_of_left : ∀ {α : Type u} {f g : Filter α} {s : Set α}, s ∈ f → s ∈ f ⊓ g := by sorry

The theorem `Filter.mem_inf_of_left` states that for any type `α`, any filters `f` and `g` of type `α`, and any set `s` of type `α`, if `s` is in `f`, then `s` is in the infimum (intersection) of `f` and `g`. This expresses the intuitive idea that if a set is contained in a filter, then it is also contained in the intersection of that filter with any other filter.

If `s` is in filter `f` and `g` is another filter on type `α`, then `s` is in the intersection `f ∩ g`.


/-- To prove something for an arbitrary measurable function into `ℝ≥0∞`, it suffices to show
that the property holds for (multiples of) characteristic functions and is closed under addition
and supremum of increasing sequences of functions.

It is possible to make the hypotheses in the induction steps a bit stronger, and such conditions
can be added once we need them (for example in `h_add` it is only necessary to consider the sum of
a simple function with a multiple of a characteristic function and that the intersection
of their images is a subset of `{0}`.  -/
theorem Measurable.ennreal_induction :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {P : (α → ENNReal) → Prop},
      (∀ (c : ENNReal) ⦃s : Set α⦄, MeasurableSet s → P (Set.indicator s fun x => c)) →
        (∀ ⦃f g : α → ENNReal⦄,
            Disjoint (Function.support f) (Function.support g) → Measurable f → Measurable g → P f → P g → P (f + g)) →
          (∀ ⦃f : ℕ → α → ENNReal⦄,
              (∀ (n : ℕ), Measurable (f n)) → Monotone f → (∀ (n : ℕ), P (f n)) → P fun x => ⨆ n, f n x) →
            ∀ ⦃f : α → ENNReal⦄, Measurable f → P f :=
  by sorry

This theorem, `Measurable.ennreal_induction`, is a form of structural induction for measurable functions into the extended nonnegative real numbers (ℝ≥0∞).

The theorem states that to prove a property, `P`, holds for an arbitrary measurable function, `f`, it is sufficient to show three things:
1. `P` holds for characteristic functions (functions that take the value 1 on a given set and 0 otherwise) multiplied by a constant `c`.
2. `P` is preserved under the addition of two measurable functions `f` and `g` whose supports (the sets where the functions are non-zero) are disjoint, given that `P` holds for `f` and `g`.
3. `P` is preserved under the supremum (least upper bound) of a monotone increasing sequence of measurable functions, given that `P` holds for every function in the sequence.

If these conditions are met, then `P` holds for any measurable function `f` into ℝ≥0∞.

Given a property `P` and a measurable function `f` from a measurable space to the extended nonnegative real numbers, if `P` holds for characteristic functions scaled by constants, is preserved under the addition of measurable functions with disjoint supports, and is preserved under the supremum of monotone increasing sequences of measurable functions, then `P` holds for `f`.


IsMin.isSuccLimit

theorem IsMin.isSuccLimit : ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsMin a → Order.IsSuccLimit a := by sorry

The theorem `IsMin.isSuccLimit` states that for any type `α` with a preorder structure, if an element `a` of `α` is a minimal element (i.e., there is no other element in `α` that is strictly smaller than `a`), then `a` is also a successor limit. In other words, no element `b` in `α` is strictly less than `a` and also covers `a`. Hence, `a` cannot be the successor of anything smaller.

If an element is minimal in a preordered type, then it has no strictly smaller covering elements.


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

This theorem states that for any type `E` which is a normed addition-commutative group and also a normed space over the real numbers, and for any real numbers `a` and `b`, and any measure `μ` on the real numbers, and any function `f` from the real numbers to `E`, the norm of the interval integral of `f` from `a` to `b` with respect to `μ` is equal to the norm of the interval integral of `f` over the half-open interval from `a` to `b` with respect to `μ`. This means that the way we choose the end points of the interval (inclusive or exclusive) does not impact the norm of the integral.

For any normed additive commutative group and normed space `E` over the real numbers, any measure `μ` on the real numbers, any function `f` from the real numbers to `E`, and real numbers `a` and `b`, the norms of the interval integrals of `f` from `a` to `b` and from `a` to `b` (half-open) with respect to `μ` are equal.


/-- A semiring is local if it is nontrivial and the set of nonunits is closed under the addition.  -/
theorem LocalRing.of_nonunits_add :
    ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : Nontrivial R],
      (∀ (a b : R), a ∈ nonunits R → b ∈ nonunits R → a + b ∈ nonunits R) → LocalRing R :=
  by sorry

The theorem `LocalRing.of_nonunits_add` states that for any type `R` that is a commutative semiring and nontrivial, if for all elements `a` and `b` in `R`, `a` and `b` being non-invertible implies that the sum of `a` and `b` is also non-invertible, then `R` is a local ring. In mathematical terms, a semiring is considered local if it has at least two distinct elements (nontrivial) and the set of its non-invertible elements (nonunits) is closed under addition.

If a commutative semiring R with at least two elements is such that the sum of any two non-invertible elements is non-invertible, then R is a local ring.


theorem List.head!_mem_self : ∀ {α : Type u} [inst : Inhabited α] {l : List α}, l ≠ [] → List.head! l ∈ l := by sorry

The theorem `List.head!_mem_self` states that for all types `α` that are inhabited, and for any list `l` of type `α`, if `l` is not an empty list, then the head of the list (obtained by `List.head! l`) is an element of `l`. This means we can always retrieve the first element from a non-empty list and that element will certainly be a part of the list.

For all inhabited types `α` and non-empty lists `l` of `α`, the head element of `l` is an element of `l`.


theorem CategoryTheory.Limits.kernelSubobject_arrow_comp_assoc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f]
      {Z : C} (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.arrow (CategoryTheory.Limits.kernelSubobject f))
          (CategoryTheory.CategoryStruct.comp f h) =
        CategoryTheory.CategoryStruct.comp 0 h :=
  by sorry

This theorem states that in a category `C` with zero morphisms, given morphisms `f : X ⟶ Y` and `h : Y ⟶ Z` where `f` has a kernel, the composition of the arrow from the kernel subobject of `f` to `f`, followed by the composition of `f` and `h`, is equal to the composition of the zero morphism and `h`. This is a statement about the behavior of kernel subobjects in a category.

In a category with zero morphisms, given a morphism `f` with kernel `k` and another morphism `h`, the composition of `k` with `f` and `h` is equal to the composition of the zero morphism and `h`.