theorem Finsupp.support_indicator_subset :
    ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) (f : (i : ι) → i ∈ s → α),
      ↑(Finsupp.indicator s f).support ⊆ ↑s :=
  by sorry

The theorem `Finsupp.support_indicator_subset` states that for any finset `s` and function `f` from elements of `s` to a type `α` (with zero element), the support of the `Finsupp.indicator` of `s` and `f` (which is a function from `ι` to `α` that is zero outside of `s`) is a subset of `s`. In other words, all the non-zero elements in the function created by `Finsupp.indicator` are in the original finset `s`.

The support of the indicator function of a finset and a function from its elements to a type is contained in the finset.


theorem RatFunc.denom_zero : ∀ {K : Type u} [inst : Field K], RatFunc.denom 0 = 1 := by sorry

This theorem, `RatFunc.denom_zero`, states that for any type `K`, which is a field, the denominator of the zero rational function (`RatFunc 0`) is equal to `1`. In other words, in any field, the denominator of the rational function representing zero is normalized to be the monic polynomial `1`.

In any field, the denominator of the zero rational function is equal to 1.


theorem
  DomMulAct.instSMulDomMulActSubtypeAEEqFunToTopologicalSpaceToUniformSpaceToPseudoMetricSpaceToSeminormedAddCommGroupMemAddSubgroupInstAddGroupToAddGroupToNormedAddGroupToTopologicalAddGroupInstMembershipInstSetLikeAddSubgroupLp.proof_2 :
    ∀ {M : Type u_2} {α : Type u_1} [inst : MeasurableSpace M] [inst_1 : MeasurableSpace α]
      {μ : MeasureTheory.Measure α} [inst_2 : SMul M α] [inst_3 : MeasureTheory.SMulInvariantMeasure M α μ]
      [inst : MeasurableSMul M α] (c : Mᵈᵐᵃ), MeasureTheory.MeasurePreserving (fun x => DomMulAct.mk.symm c • x) μ μ :=
  by sorry

This theorem states that for any given types `M` and `α`, where `M` is a measurable space, `α` is also a measurable space and a `M`-module, and `μ` is a measure on `α` that is invariant under the action of `M`, then for any element `c` from the opposite ring of `M`, the mapping that sends every element `x` in `α` to the result of the scaled multiplication of `x` by the `c`'s equivalent element in `M`, is measure-preserving with respect to measure `μ`. This means that the measure of any set before and after the mapping remains the same.

For any measure `μ` on a measurable space `(α, Σ)` that is invariant under the action of a measurable `M`-module `M`, the scaling map that sends each `x ∈ α` to `cx` has measure-preserving property, i.e., `μ(A) = μ(c⁰(A))` for all `A ∈ Σ`.


theorem elementalStarAlgebra.self_mem :
    ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
      [inst_3 : Semiring A] [inst_4 : StarRing A] [inst_5 : TopologicalSemiring A] [inst_6 : ContinuousStar A]
      [inst_7 : Algebra R A] [inst_8 : StarModule R A] (x : A), x ∈ elementalStarAlgebra R x :=
  by sorry

This theorem states that for any given type `R` and another type `A`, under several conditions - `R` is a commutative semiring and a star ring, `A` is a topological space, a semiring, a star ring, a topological semiring, a continuous star, an algebra over `R`, and a star module over `R` - any element `x` from `A` is contained in the elemental star algebra of `R` and `x`.

For any commutative semiring and star ring `R`, and any topological space, semiring, star ring, topological semiring, continuous star, algebra, and star module `A` over `R`, every element `x` in `A` is contained in the elemental star algebra of `R` and `x`.


theorem AddAction.stabilizer_coe_finset :
    ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : DecidableEq α]
      (s : Finset α), AddAction.stabilizer G ↑s = AddAction.stabilizer G s :=
  by sorry

This theorem states that for any given additive group `G`, any type `α`, and a finite set `s` of elements of type `α`, if `G` acts on `α` and `α` has decidable equality, then the stabilizer of the set `s` under this action is the same as the stabilizer of the coerced set `↑s`. In other words, the set of elements in `G` that leave `s` unchanged under the additive action is the same whether we consider `s` as a finite set or as a coerced set.

For any additive group `G`, type `α` with decidable equality, and finite set `s` of `α`, if `G` acts on `α` and the stabilizer of `s` is defined, then the stabilizer of `s` equals the stabilizer of the coerced set `↑s`.


theorem Nat.add_succ_sub_one : ∀ (m n : ℕ), m + Nat.succ n - 1 = m + n := by sorry

This theorem states that for all natural numbers `m` and `n`, the result of adding `n` incremented by one to `m` and then subtracting one is the same as just adding `n` to `m`. In mathematical notation, it asserts that for each pair of natural numbers `m` and `n`, the equation `m + (n + 1) - 1 = m + n` holds true.

For all natural numbers `m` and `n`, `m + (n + 1) - 1` equals `m + n`.


theorem Submodule.iInf_coe :
    ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
      (p : ι → Submodule R M), ↑(⨅ i, p i) = ⋂ i, ↑(p i) :=
  by sorry

This theorem, `Submodule.iInf_coe`, states that for any indexed collection of submodules `p` of a module `M` over a semiring `R`, the set theoretic intersection of the underlying sets of all these submodules (`⋂ i, ↑(p i)`) is the same as the underlying set of the infimum of all these submodules (`↑(⨅ i, p i)`). In other words, taking the intersection of the submodules in the set context is equivalent to taking the infimum in the submodule context.

For any indexed collection of submodules `p` of a module `M` over a semiring `R`, the set-theoretic intersection of their underlying sets equals the underlying set of the infimum of these submodules.


theorem addOrderOf_eq_zero_iff : ∀ {G : Type u_1} [inst : AddMonoid G] {x : G}, addOrderOf x = 0 ↔ ¬IsOfFinAddOrder x :=
  by sorry

The theorem `addOrderOf_eq_zero_iff` states that for any type `G` that is an additive monoid and any element `x` of type `G`, the additive order of `x` is zero if and only if `x` is not of finite additive order. In mathematical terms, if there does not exist a nonnegative integer `n` such that `n * x = 0`, then the additive order of `x` is defined to be zero. Conversely, if the additive order of `x` is zero, this indicates that `x` does not have a finite additive order.

The additive order of an element in an additive monoid is zero if and only if the element has no finite additive order.


theorem MonotoneOn.convex_ge :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : OrderedSemiring 𝕜] [inst_1 : LinearOrderedAddCommMonoid E]
      [inst_2 : OrderedAddCommMonoid β] [inst_3 : Module 𝕜 E] [inst_4 : OrderedSMul 𝕜 E] {s : Set E} {f : E → β},
      MonotoneOn f s → Convex 𝕜 s → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ r ≤ f x} :=
  by sorry

The theorem `MonotoneOn.convex_ge` states that for any ordered semiring `𝕜`, linearly ordered additive commutative monoid `E`, and ordered additive commutative monoid `β`, with `E` being a module over `𝕜` and `𝕜` being able to scalar-multiply `E`, given a set `s` of type `E` and a function `f` mapping from `E` to `β`, if the function `f` is monotone on the set `s` and the set `s` itself is convex, then for any value `r` of type `β`, the set of all `x` from `s` such that `r` is less than or equal to `f(x)` is also convex. In simpler terms, this theorem is saying that the 'above-graph' of a monotone function over a convex set is also convex.

If `f` is a monotone function over a convex set `s` in an ordered additive commutative monoid `E`, then the level set `{x : s | r ≤ f x}` is convex for any `r` in the ordered semiring `𝕜`.


theorem ENNReal.continuousOn_sub : ContinuousOn (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)} := by sorry

This theorem states that the function defined as the subtraction of the pair of elements `(p.1 - p.2)` is continuous on a set of pairs `p`, excluding the pair `(⊤, ⊤)`. Here, the continuity is defined in the topological sense, meaning that the function satisfies the condition of being continuous at every point within this subset. In other words, for all pairs `p` except `(⊤, ⊤)`, the difference between the two elements of the pair changes continuously as you move around in this set.

The function subtracting the first component from the second component of a pair is continuous on the set of pairs excluding `(⊤, ⊤)`.


theorem AntitoneOn.mapsTo_Icc :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β] {a b : α},
      AntitoneOn f (Set.Icc a b) → Set.MapsTo f (Set.Icc a b) (Set.Icc (f b) (f a)) :=
  by sorry

The theorem `AntitoneOn.mapsTo_Icc` states that for all types `α` and `β`, a function `f` from `α` to `β`, and any elements `a` and `b` of type `α`, if that function `f` is antitone on the interval `Set.Icc a b` (i.e., for all `a, b` in this interval, `a ≤ b` implies `f b ≤ f a`), then the function `f` maps the interval `Set.Icc a b` to the interval `Set.Icc (f b) (f a)`. In other words, all the values `f x` for `x` in the interval from `a` to `b` fall within the interval from `f b` to `f a`. This theorem is about the behavior of an antitone function on a closed interval in a preordered set.

If a function between two preordered types is antitone on an interval, then it maps that interval to a reversed interval.


theorem Finsupp.mem_span_image_iff_total :
    ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
      {v : α → M} {s : Set α} {x : M},
      x ∈ Submodule.span R (v '' s) ↔ ∃ l ∈ Finsupp.supported R R s, (Finsupp.total α M R v) l = x :=
  by sorry

The theorem `Finsupp.mem_span_image_iff_total` states that for any semiring `R`, an additively commutative monoid `M` that is also an `R`-module, a function `v` from an arbitrary type `α` to `M`, a set `s` of type `α`, and an element `x` of `M`, `x` belongs to the submodule spanned by the image of `s` under `v` in `R` if and only if there exists a function `l` in the submodule of all `p : α →₀ R` such that the support of `p` is a subset of `s` (denoted by `Finsupp.supported R R s`), such that the total of `l` with respect to `v` equals `x`. In other words, `x` is in the span of `s` mapped through `v` if and only if `x` can be expressed as a linear combination of elements in `s`, with the coefficients being the elements in the support of some `l`.

For an additively commutative monoid M being an R-module, an R-valued function v from type α, set s of α, and an element x of M, x lies in the submodule spanned by s through v if and only if there exists a function p from s to R, such that the support of p is contained in s and the total of p applied to v equals x.


/-- A topological space is σ-compact iff `univ` is σ-compact.  -/
theorem isSigmaCompact_univ_iff :
    ∀ {X : Type u_1} [inst : TopologicalSpace X], IsSigmaCompact Set.univ ↔ SigmaCompactSpace X := by sorry

This theorem states that a topological space is σ-compact if and only if the universal set is σ-compact. In other words, for any topological space 'X', 'X' is said to be σ-compact (meaning it can be represented as a union of countably many compact sets) if and only if the set of all elements of 'X' is also σ-compact.

A topological space is σ-compact if and only if its underlying set is σ-compact with respect to the same topology.


/-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later.  -/
theorem SetTheory.PGame.lf_def :
    ∀ {x y : SetTheory.PGame},
      SetTheory.PGame.LF x y ↔
        (∃ i,
            (∀ (i' : SetTheory.PGame.LeftMoves x),
                SetTheory.PGame.LF (SetTheory.PGame.moveLeft x i') (SetTheory.PGame.moveLeft y i)) ∧
              ∀ (j : SetTheory.PGame.RightMoves (SetTheory.PGame.moveLeft y i)),
                SetTheory.PGame.LF x (SetTheory.PGame.moveRight (SetTheory.PGame.moveLeft y i) j)) ∨
          ∃ j,
            (∀ (i : SetTheory.PGame.LeftMoves (SetTheory.PGame.moveRight x j)),
                SetTheory.PGame.LF (SetTheory.PGame.moveLeft (SetTheory.PGame.moveRight x j) i) y) ∧
              ∀ (j' : SetTheory.PGame.RightMoves y),
                SetTheory.PGame.LF (SetTheory.PGame.moveRight x j) (SetTheory.PGame.moveRight y j') :=
  by sorry

This theorem defines the "less or fuzzy" (⧏) relation between two pre-games, `x` and `y`. According to this definition, `x` is less or fuzzy to `y` if and only if one of two conditions is met: first, there exists a move for Left in `y` such that for all moves for Left in `x`, the game state after Left's move in `x` is less or fuzzy to the game state after Left's move in `y`, and for all moves for Right in the game state after Left's move in `y`, `x` is less or fuzzy to the game resulting after Right's move; or secondly, there exists a move for Right in `x` such that for all moves for Left in the game state after Right's move in `x`, the game state after Left's move is less or fuzzy to `y`, and for all moves for Right in `y`, the game state after Right's move in `x` is less or fuzzy to the game state after Right's move in `y`.

For pre-games x and y, x is less or fuzzy to y if and only if there exists a move for Left in y such that the sub-game starting from the resulting state in y is less or fuzzy to the sub-game starting from the corresponding move in x, and the reverse holds for a move for Right.


theorem CategoryTheory.Limits.le_kernelSubobject :
    ∀ {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]
      (A : CategoryTheory.Subobject X),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.arrow A) f = 0 →
        A ≤ CategoryTheory.Limits.kernelSubobject f :=
  by sorry

In the context of category theory, this theorem states that for any category `C` with zero morphisms, given a morphism `f` from object `X` to `Y` that has a kernel, and a subobject `A` of `X`, if the composition of the arrow of `A` and `f` is a zero morphism, then `A` is less than or equal to the kernel subobject of `f`. Here, "less than or equal to" is meant in the sense of the ordering of subobjects.

If `C` is a category with zero morphisms, given a morphism `f` from object `X` to `Y` with kernel `k`, and a subobject `A` of `X` such that `A ∘ f = 0`, then `A ≤ k`.


IsCyclotomicExtension.integral

/-- A finite cyclotomic extension of an integral noetherian domain is integral  -/
theorem IsCyclotomicExtension.integral :
    ∀ (S : Set ℕ+) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
      [inst_3 : IsDomain B] [inst_4 : IsNoetherianRing A] [inst_5 : Finite ↑S] [inst_6 : IsCyclotomicExtension S A B],
      Algebra.IsIntegral A B :=
  by sorry

This theorem states that for any set `S` of positive natural numbers, and any types `A` and `B` with `A` being a commutative ring, `B` being a commutative ring as well as a domain, and `B` being an algebra over `A`, if `A` is a Noetherian ring, `S` is finite, and `B` is a cyclotomic extension of `A` defined by `S`, then every element of the extension `B` is integral over the base ring `A`. This means that for every element in `B`, there exists a monic polynomial with coefficients in `A` such that the element is a root of the polynomial.

If `A` is a Noetherian commutative ring, `B` is a finite cyclotomic extension of `A` as a commutative algebra and domain over `A`, then every element of `B` is integral over `A`.


/-- Calculate the integral of `g ∘ f : α →ₛ F`, where `f` is an integrable function from `α` to `E`
and `g` is a function from `E` to `F`. We require `g 0 = 0` so that `g ∘ f` is integrable.  -/
theorem MeasureTheory.SimpleFunc.map_integral :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      (f : MeasureTheory.SimpleFunc α E) (g : E → F),
      MeasureTheory.Integrable (↑f) μ →
        g 0 = 0 →
          MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.map g f) =
            Finset.sum (MeasureTheory.SimpleFunc.range f) fun x => (↑↑μ (↑f ⁻¹' {x})).toReal • g x :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.map_integral` states that for any measure space `α`, and any normed additive commutative groups `E` and `F` (which are also normed spaces over `ℝ`), given a measurable space `m`, a measure `μ` on that space, a simple function `f` mapping from `α` to `E`, and a function `g` mapping from `E` to `F`, if `f` is integrable with respect to `μ` and `g` at `0` is `0`, then the integral of the function `g ∘ f` (which maps from `α` to `F`) is equal to the sum, over the range of `f`, of the product of real-valued measure of the preimage of each value in the range under `f`, and the value of `g` at that point. This sum is calculated using the `Finset.sum` function in Lean, which sums up the values of a given function over a finite set.

For any measurable function `f: α -> E` from a measure space `(α, μ)` to a normed additive commutative group `E` over `ℝ`, and any function `g: E -> F` mapping from `E` to another normed space `F` over `ℝ` with `g(0) = 0`, the integral of `g ∘ f` over `α` with respect to `μ` equals the sum, over the range of `f`, of the product of the measure of `f^(-1)(x)` and `g(x)`.


theorem Mathlib.Algebra.Lie.Submodule._auxLemma.52 :
    ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
      [inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (N = N') = (↑N = ↑N') :=
  by sorry

This theorem, part of the Mathlib library in the section on algebra and Lie submodules, states that for any commutative ring `R`, any Lie ring `L`, and any additive commutative group `M` that is also a module over `R`, and any two Lie submodules `N` and `N'` of `M`, the equality `N = N'` is equivalent to the equality `↑N = ↑N'`. In other words, two Lie submodules are considered equal if and only if they are equal as sets.
Here `↑N` is the coercion of `N` to a set, so the theorem is about the equality of Lie submodules as set-theoretic subsets of `M`.

For any commutative ring `R`, Lie ring `L`, and additive commutative group `M` that is an `R`-module, two Lie submodules `N` and `N'` of `M` are equal if and only if their set-theoretic representations `↑N` and `↑N'` are equal.


theorem upperBounds_lowerClosure :
    ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, upperBounds ↑(lowerClosure s) = upperBounds s := by sorry

The theorem `upperBounds_lowerClosure` states that for any set `s` of elements of a given type `α` in a preordered set, the set of upper bounds of the least lower set containing `s` (i.e., the lower closure of `s`) is equal to the set of upper bounds of `s` itself. In other words, all elements that are greater than or equal to every element of `s` are also greater than or equal to every element in the least lower set containing `s`, and vice versa.

The theorem `upperBounds_lowerClosure` asserts that the set of upper bounds of a set in a preordered set equals the set of upper bounds of its lower closure.


theorem SetTheory.PGame.add_comm_le : ∀ {x y : SetTheory.PGame}, x + y ≤ y + x := by sorry

This theorem states that, for all elements `x` and `y` of the type `SetTheory.PGame` (which represents games in set theory), the sum `x + y` is less than or equal to the sum `y + x`. In mathematical terms, this means that addition of these games is commutative with respect to the 'less than or equal to' relation. This essentially says that swapping the order of summands doesn't increase the value of the sum.

For all `x` and `y` in `SetTheory.PGame`, `x + y` is less than or equal to `y + x`. (Or, equivalently, addition of games in `SetTheory.PGame` is commutative with respect to the 'less than or equal to' relation.)


theorem CategoryTheory.ShortComplex.leftHomologyMap'_neg :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂),
      CategoryTheory.ShortComplex.leftHomologyMap' (-φ) h₁ h₂ = -CategoryTheory.ShortComplex.leftHomologyMap' φ h₁ h₂ :=
  by sorry

This theorem states that, in the context of category theory, given two objects `S₁` and `S₂` in a short complex `C` of a preadditive category, and a morphism `φ` between them, if we negate this morphism to obtain `-φ`, then the left homology map of `-φ` is just the negation of the left homology map of `φ`. In other words, the left homology map of a negated morphism is the negation of the original left homology map. This property holds for any left homology data `h₁` for `S₁` and `h₂` for `S₂`.

Given a short complex in a preadditive category and morphism `φ` between objects `S₁` and `S₂`, the negation of the left homology map of `φ` is equal to the negation of the left homology map of `-φ`.


theorem wbtw_swap_right_iff :
    ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : OrderedRing R] [inst_1 : AddCommGroup V]
      [inst_2 : Module R V] [inst_3 : AddTorsor V P] [inst_4 : NoZeroSMulDivisors R V] (x : P) {y z : P},
      Wbtw R x y z ∧ Wbtw R x z y ↔ y = z :=
  by sorry

The theorem `wbtw_swap_right_iff` states that for any ordered ring `R`, and given an additive commutative group `V`, a module `R V`, and an additive torsor `V P` where `P` is a type, and assuming `R V` has no zero scalar multipliers or divisors, for any points `x`, `y`, `z` of type `P`, the point `y` is weakly between `x` and `z` and the point `z` is weakly between `x` and `y` if and only if `y` is equal to `z`. In other words, it asserts that in the given algebraic structures, `y` and `z` can only both be weakly between `x` and each other if they are actually the same point.

In an additive commutative group `V` over an ordered ring `R` with no zero scalar multipliers or divisors, two points `y` and `z` of type `P` are weakly between each other if and only if they are equal.


theorem Ordinal.opow_le_opow_iff_right : ∀ {a b c : Ordinal.{u_1}}, 1 < a → (a ^ b ≤ a ^ c ↔ b ≤ c) := by sorry

This theorem states that for any three ordinals `a`, `b`, and `c` in a type `u_1`, assuming `a` is greater than 1, the ordinal exponentiation `a` raised to the power `b` is less than or equal to `a` raised to the power `c` if and only if `b` is less than or equal to `c`. This essentially states the property of increasing monotonicity of the exponentiation function for ordinals greater than 1.

For ordinals `a` > 1, `a^b` <= `a^c` if and only if `b` <= `c`.


theorem Cardinal.toENatAux_gc : GaloisConnection Cardinal.ofENat Cardinal.toENatAux := by sorry

The theorem `Cardinal.toENatAux_gc` states that there is a Galois connection between the function `Cardinal.ofENat` and `Cardinal.toENatAux`. In other words, for any cardinal number `a` and extended natural number `b`, `Cardinal.ofENat a` is less than or equal to `b` if and only if `a` is less than or equal to `Cardinal.toENatAux b`. The functions `Cardinal.ofENat` and `Cardinal.toENatAux` represent a coercion from extended natural numbers to cardinal numbers and the other way around, respectively.

The functions `Cardinal.ofENat` and `Cardinal.toENatAux` form a Galois connection, meaning `Cardinal.ofENat a <= b` if and only if `a <= Cardinal.toENatAux b` for all cardinal numbers `a` and extended natural numbers `b`.


theorem Finset.card_inv :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : InvolutiveInv α] (s : Finset α), s⁻¹.card = s.card := by sorry

The theorem `Finset.card_inv` states that for any given type `α` which has decidable equality and an involution operation (meaning applying the operation twice will return the original value), the cardinality (i.e., the number of elements) of the inverse `s⁻¹` of a finite set `s` of type `α` is equal to the cardinality of `s` itself. This means that applying the inverse operation to all elements of the set doesn't change the number of distinct elements in the set.

For any finite set `s` of type `α` with decidable equality and an involution operation, the cardinality of `s` is equal to the cardinality of its inverse.


theorem MeasureTheory.aecover_Ioo_of_Icc :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a b : ι → α} {A B : α},
      Filter.Tendsto a l (nhds A) →
        Filter.Tendsto b l (nhds B) → MeasureTheory.AECover (μ.restrict (Set.Ioo A B)) l fun i => Set.Icc (a i) (b i) :=
  by sorry

The theorem `MeasureTheory.aecover_Ioo_of_Icc` states that for any measurable space `α`, index type `ι`, measure `μ`, filter `l`, order-relevant and topology-relevant instances, and functions `a` and `b` mapping from `ι` to `α`, if `a` and `b` both tend towards some values `A` and `B` (respectively) with respect to the neighborhood filter, then we can almost everywhere cover the open interval `(A, B)` (with respect to the measure restricted to `(A, B)`) using closed intervals `[a(i), b(i)]` as `i` ranges over the index set under the filter `l`. This theorem characterizes a key property of measure theory in handling the transition from open to closed intervals.

Given a measurable space, if functions mapping from an index set to the space tend towards two values, then there exists a sequence of closed intervals almost covering the open interval between those values with respect to the measure restricted to that interval.


theorem MeasureTheory.aecover_Ioo_of_Ico :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a b : ι → α} {A B : α},
      Filter.Tendsto a l (nhds A) →
        Filter.Tendsto b l (nhds B) → MeasureTheory.AECover (μ.restrict (Set.Ioo A B)) l fun i => Set.Ico (a i) (b i) :=
  by sorry

This theorem states that for every type `α` and `ι`, given a measurable space `α` and a measure `μ` on this space, a filter `l` on `ι`, a linear order on `α`, a topological space structure on `α`, order closed topology on `α`, open set measurability on `α`, function `a` and `b` from `ι` to `α`, and constants `A` and `B` of `α`, if `a` and `b` tend to `A` and `B` respectively with respect to the filter `l` and the neighborhood filter at `A` and `B`, then there exists an almost everywhere cover of the measure space restricted to the open interval `(A, B)`, i.e., excluding `A` and `B`, by the increasing countable union of the closed-open intervals `[a(i), b(i))` for each `i` in `ι`, where `i` is drawn from the filter `l`.

Given a measurable space with a measure, a filter, a linear order, topology, and open set measurability, if functions `a` and `b` tend to `A` and `B` respectively with respect to the filter and neighborhood filters at `A` and `B`, there exists an almost everywhere cover of the open interval `(A, B)` by the increasing countable union of closed-open intervals `[a(i), b(i))` from the filter.


theorem Set.smul_subset_smul_right :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s₁ s₂ : Set α} {t : Set β}, s₁ ⊆ s₂ → s₁ • t ⊆ s₂ • t := by sorry

The theorem `Set.smul_subset_smul_right` states that for any types `α` and `β` with a scalar multiplication operation (denoted `SMul α β`), given two sets `s₁` and `s₂` of type `α` and a set `t` of type `β`, if `s₁` is a subset of `s₂` (denoted `s₁ ⊆ s₂`), then the scalar multiplication of `s₁` and `t` is a subset of the scalar multiplication of `s₂` and `t` (denoted `s₁ • t ⊆ s₂ • t`). In other words, we are showing that scalar multiplication preserves the subset relation on the right.

For sets `s₁ ⊆ s₂` of types `α` with a scalar multiplication operation `SMul α β`, `s₁ • t ⊆ s₂ • t` holds for any set `t` of type `β`.


theorem BoxIntegral.Prepartition.IsPartition.biUnion :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π : BoxIntegral.Prepartition I}
      {πi : (J : BoxIntegral.Box ι) → BoxIntegral.Prepartition J},
      BoxIntegral.Prepartition.IsPartition π →
        (∀ J ∈ π, BoxIntegral.Prepartition.IsPartition (πi J)) →
          BoxIntegral.Prepartition.IsPartition (BoxIntegral.Prepartition.biUnion π πi) :=
  by sorry

The theorem `BoxIntegral.Prepartition.IsPartition.biUnion` states that for any given type `ι`, box `I` of type `BoxIntegral.Box ι`, prepartition `π` of `I`, and function `πi` which, for every box `J`, gives a prepartition of `J`, if `π` is a partition of `I` and for all `J` in `π`, the prepartition `πi J` is a partition of `J`, then the biUnion of `π` and `πi` is a partition of `I`.

In other words, this theorem assures that a biUnion of partitions, where each element of the primary partition is itself a partition of a subbox, is also a partition of the original box `I`.

Given a type `ι`, a box `I` of type `BoxIntegral.Box ι`, a prepartition `π` of `I` that is a partition and for each subbox `J` in `π`, the prepartition `πi J` is a partition of `J`, then the biUnion of `π` and `πi` is a partition of `I`.


theorem Mathlib.Data.Polynomial.Degree.Definitions._auxLemma.16 :
    ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic Polynomial.X = True := by sorry

This theorem states that, for any type `R` that forms a semiring, the polynomial variable (or indeterminate), denoted as `Polynomial.X`, is a monic polynomial. This means that the leading coefficient of `Polynomial.X` is 1.

For any semiring type `R`, the polynomial indeterminate `Polynomial.X` over `R` is a monic polynomial (i.e., its leading coefficient is 1).


theorem MeasureTheory.OuterMeasure.mkMetric'.pre_le :
    ∀ {X : Type u_2} [inst : EMetricSpace X] {m : Set X → ENNReal} {r : ENNReal} {s : Set X},
      EMetric.diam s ≤ r → ↑(MeasureTheory.OuterMeasure.mkMetric'.pre m r) s ≤ m s :=
  by sorry

This theorem states that for any type `X` which is an e-Metric space, for any function `m` mapping sets of `X` to extended nonnegative real numbers (`ENNReal`), for any extended nonnegative real number `r` and for any set `s` of `X`, if the `e-Metric` diameter of the set `s` is less than or equal to `r`, then the outer measure (created by `MeasureTheory.OuterMeasure.mkMetric'.pre m r`) of the set `s` is less than or equal to `m(s)`. In other words, for sets with a diameter at most `r`, the outer measure created by `MeasureTheory.OuterMeasure.mkMetric'.pre m r` is an upper bound for the function `m` on these sets.

For any e-Metric space `X`, any function `m` mapping sets of `X` to extended nonnegative real numbers, and any set `s` in `X` with e-Metric diameter less than or equal to `r`, we have `MeasureTheory.OuterMeasure.mkMetric'.pre m r s <= m s`.


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

The theorem `Sym2.inductionOn` states that for any type `α`, a property `f` on the symmetric square of `α` (i.e., unordered pairs of elements from `α`), and an instance `i` of the symmetric square of `α`, if the property `f` holds for any pair of elements `(x, y)` from `α` (considered as an instance of the symmetric square `s(x, y)`), then the property `f` also holds for the instance `i`. This theorem provides the basis for induction on instances of the symmetric square of a type.

If a binary property holds for all unordered pairs of elements in a type, then it holds for any symmetric square instance.


theorem selfZPow_of_nonneg :
    ∀ {R : Type u_1} [inst : CommRing R] (x : R) (B : Type u_2) [inst_1 : CommRing B] [inst_2 : Algebra R B]
      [inst_3 : IsLocalization.Away x B] {n : ℤ}, 0 ≤ n → selfZPow x B n = (algebraMap R B) x ^ Int.natAbs n :=
  by sorry

The theorem `selfZPow_of_nonneg` states that, given a commutative ring `R`, an element `x` in `R`, a commutative ring `B`, and an algebra structure from `R` to `B`, if `B` is isomorphic to the localization of `R` at the submonoid generated by `x`, then for any integer `n` that is nonnegative, the result of applying the `selfZPow` function to `x` and `n` is equivalent to mapping `x` into `B` using the algebra structure and then raising it to the power of the absolute value of `n`. In simpler terms, it relates the power operations in the original ring and the localized ring when the exponent is a nonnegative integer.

If `R` is a commutative ring, `x` is an element of `R`, `B` is isomorphic to the localization of `R` at the submonoid generated by `x`, and `n` is a nonnegative integer, then `x ^ n` in `B` is equivalent to applying the algebra homomorphism from `R` to `B` to `x` and then raising the result to the power of `n`.


/-- The function `exp (b * x) / x ^ s` tends to `+∞` at `+∞`, for any real `s` and `b > 0`.  -/
theorem tendsto_exp_mul_div_rpow_atTop :
    ∀ (s b : ℝ), 0 < b → Filter.Tendsto (fun x => Real.exp (b * x) / x ^ s) Filter.atTop Filter.atTop := by sorry

The theorem `tendsto_exp_mul_div_rpow_atTop` states that for any real numbers `s` and `b` where `b > 0`, the function `(exp (b * x) / x^s)` tends to positive infinity as `x` tends to positive infinity. In mathematical notation, this can be expressed as: for all real numbers `s` and `b > 0`, the limit as `x` approaches positive infinity of `(exp(b*x) / x^s)` is positive infinity.

For any real numbers `s` and `b > 0`, the limit as `x -> +∞` of `(exp(b*x) / x^s)` is +∞.


theorem openSegment_subset_segment :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E] (x y : E),
      openSegment 𝕜 x y ⊆ segment 𝕜 x y :=
  by sorry

The theorem `openSegment_subset_segment` states that, for any type `𝕜`, which is an ordered semiring, and for any `E`, which is a type with operations of addition and scalar multiplication, the open segment between two elements `x` and `y` of `E` is a subset of the segment between `x` and `y`. This means every element from the open segment (which includes points represented as a convex combination of `x` and `y` with coefficients strictly between 0 and 1) is also included in the segment (which includes end points `x` and `y`).

For any ordered semiring 𝕜 and type E equipped with addition and scalar multiplication, the open segment between any two elements of E (as convex combinations with coefficients in (0,1)) is contained in the closed segment between those elements.


theorem Mathlib.CategoryTheory.Limits.Shapes.Pullbacks._auxLemma.2 :
    ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h :=
  by sorry

This theorem is stating an aspect of associativity for category theory. Specifically, for any objects `W`, `X`, `Y`, and `Z` in a category, and for any morphisms `f: W ⟶ X`, `g: X ⟶ Y`, and `h: Y ⟶ Z`, the composition `(f ≫ (g ≫ h))` is equal to the composition `((f ≫ g) ≫ h)`. This is akin to saying that the order in which the morphisms are composed does not matter, as long as the order of the morphisms themselves is preserved.

For any objects `W`, `X`, `Y`, and `Z` in a category, and morphisms `f: W ⟶ X`, `g: X ⟶ Y`, and `h: Y ⟶ Z`, the compositions `f ≫ (g ≫ h)` and `((f ≫ g) ≫ h)` are equal.


theorem Set.prod_iUnion :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {s : Set α} {t : ι → Set β}, s ×ˢ ⋃ i, t i = ⋃ i, s ×ˢ t i := by
  sorry

This theorem, `Set.prod_iUnion`, states that for any type `α`, another type `β`, an index type `ι`, a set `s` of type `α` and a function `t` that maps from index `ι` to sets of type `β`, the Cartesian product of `s` and the union over `t i` for all `i` in `ι` is equal to the union over the Cartesian product of `s` and each `t i`. In simpler terms, we are distributing the Cartesian product over the union, similar to the distribution law in algebra.

For any set `s` of type `α` and a family `(t\_i : β → Set) i in ι`, the Cartesian product `s × ⋃i in ι (t\_i)` is equal to `⋃i in ι (s × t\_i)`.


theorem Ordinal.zero_nadd : ∀ (a : Ordinal.{u}), Ordinal.nadd 0 a = a := by sorry

The theorem `Ordinal.zero_nadd` states that for any ordinal `a` from the type of well orders, the natural addition (also known as the Hessenberg sum) of 0 and `a` is equal to `a`. This is akin to the identity property in arithmetic where adding zero to any number does not change its value.


theorem min_eq_left_iff : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, min a b = a ↔ a ≤ b := by sorry

This theorem states that for any given type `α` that has a linear order, the minimum of two elements `a` and `b` of this type will be `a` if and only if `a` is less than or equal to `b`. In other words, it provides a condition under which the minimum of two elements in a linearly ordered set is the first of those elements.

For any linearly ordered type `α`, the minimum element is equal to the least element with respect to the order relation. In other words, `a` is the minimum of `a` and `b` if and only if `a ≤ b` holds in the order relation.


theorem Filter.exists_seq_monotone_tendsto_atTop_atTop :
    ∀ (α : Type u_6) [inst : SemilatticeSup α] [inst_1 : Nonempty α]
      [inst_2 : Filter.IsCountablyGenerated Filter.atTop],
      ∃ xs, Monotone xs ∧ Filter.Tendsto xs Filter.atTop Filter.atTop :=
  by sorry

This theorem states that for every type `α` which is a semilattice with a supremum operation, is nonempty, and has a filter `atTop` which is countably generated, there exists a sequence `xs` which is monotone (meaning that if an element `a` is less than or equal to `b`, then `xs a` is less than or equal to `xs b`) and tends to infinity along with the `atTop` filter. In other words, for every neighborhood of infinity in the `atTop` filter, the pre-image of that neighborhood under the `xs` sequence is also a neighborhood of infinity.

For every nonempty semilattice `α` with a countably generated filter `atTop` and a supremum operation, there exists a monotone sequence `xs` such that for every neighborhood of infinity in `atTop`, `xs⁻¹(U)` is also a neighborhood of infinity.


theorem exists_le_le :
    ∀ {α : Type u} [inst : LE α] [inst_1 : IsDirected α fun x x_1 => x ≥ x_1] (a b : α), ∃ c ≤ a, c ≤ b := by sorry

This theorem, `exists_le_le`, states that for any type `α` that has a less than or equal to (`LE`) operation and for which there is always a 'direction' (expressed by the `IsDirected` property) such that `x` is greater than or equal to `x_1` (i.e., for any two elements, one of them is greater than or equal to the other), if we take any two elements `a` and `b` of this type, there exists another element `c` which is less than or equal to both `a` and `b`.

For any type `α` with a directed `LE` relation, given any `a` and `b` in `α`, there exists an element `c` such that `c LE a` and `c LE b`.


theorem Finset.compl_filter :
    ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (p : α → Prop) [inst_2 : DecidablePred p]
      [inst_3 : (x : α) → Decidable ¬p x], (Finset.filter p Finset.univ)ᶜ = Finset.filter (fun x => ¬p x) Finset.univ :=
  by sorry

This theorem, `Finset.compl_filter`, states that for any type `α` which has a finite number of elements (`Fintype α`) and a decidable equality (`DecidableEq α`), and a predicate `p` on `α` that is decidable (`DecidablePred p`), the complement (`ᶜ`) of the set of all elements in the universal set (`Finset.univ`) that satisfy `p` (i.e., `(Finset.filter p Finset.univ)ᶜ`) is equal to the set of all elements in the universal set that do not satisfy `p` (i.e., `Finset.filter (λ x => ¬p x) Finset.univ`). Here, the complement of a set refers to all elements that are not in the set, and the universality of a set refers to the set containing all possible elements of a given type.

For any `Fintype α` with decidable equality and a decidable predicate `p` on `α`, `Finset.filter (λ x => ¬p x) Finset.univ` equals the complement of `Finset.filter p Finset.univ` in the finite power set.


/-- Summing an indicator function over a possibly larger `Finset` is the same as summing
the original function over the original finset. -/
theorem Finset.sum_indicator_subset :
    ∀ {ι : Type u_1} {β : Type u_4} [inst : AddCommMonoid β] (f : ι → β) {s t : Finset ι},
      s ⊆ t → (Finset.sum t fun i => Set.indicator (↑s) f i) = Finset.sum s fun i => f i :=
  by sorry

This theorem states that if we have a function `f` from a type `ι` to a type `β`, where `β` forms an additive commutative monoid, along with two finite sets (`Finsets`) `s` and `t` of elements of type `ι` such that `s` is a subset of `t`, then the sum of the indicator function of set `s` applied to each element of `t` (where the indicator function returns `f i` if `i` belongs to `s`, and `0` otherwise) is equal to the sum of `f i` for each element `i` in `s`. In other words, if we sum the function values over a potentially larger set but ignore the elements not in our original set using the indicator function, we get the same result as just summing the function over the original set.

If `f` is a function from a type `ι` to an additive commutative monoid `β`, and `s` is a subset of `t` in `Finsets` of type `ι`, then the sum of the indicator function of `s` applied to `t` equals the sum of `f` applied to `s`.


theorem PrimeSpectrum.isIrreducible_zeroLocus_iff_of_radical :
    ∀ {R : Type u} [inst : CommSemiring R] (I : Ideal R),
      Ideal.IsRadical I → (IsIrreducible (PrimeSpectrum.zeroLocus ↑I) ↔ Ideal.IsPrime I) :=
  by sorry

This theorem states that for any set `R` of commutative semiring structure, and any ideal `I` in `R`, if `I` is a radical ideal, then the set of all prime ideal points where `I` becomes zero, denoted as `PrimeSpectrum.zeroLocus ↑I`, is irreducible if and only if `I` is a prime ideal. In other words, it establishes a correspondence between the irreducibility of the zero locus of a radical ideal in the prime spectrum and the primality of the ideal itself.

For any commutative semiring `R` and radical ideal `I` in `R`, the zero locus of `I` in the prime spectrum is irreducible if and only if `I` is a prime ideal.


theorem MeasureTheory.measure_biUnion :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set β} {f : β → Set α},
      Set.Countable s →
        Set.PairwiseDisjoint s f → (∀ b ∈ s, MeasurableSet (f b)) → ↑↑μ (⋃ b ∈ s, f b) = ∑' (p : ↑s), ↑↑μ (f ↑p) :=
  by sorry

The theorem `MeasureTheory.measure_biUnion` states that for any type `α` and `β`, a measurable space `α`, a measure `μ` on `α`, a countable set `s` of type `β`, and a function `f` mapping from `β` to a set of `α`, if the images of any two distinct elements of `s` under `f` are disjoint, and each set `f b` for `b` in `s` is a measurable set, then the measure of the union of these sets is equal to the sum of their individual measures. In mathematical terms, if the sets `{f(b) : b ∈ s}` are pairwise disjoint and measurable, then `μ (⋃ b ∈ s, f b) = ∑' (p : s), μ (f p)`.

Given a measurable space `(α, μ)`, a countable set `s` of elements `β`, and a function `f : β → α` such that the images `{f(b) : b ∈ s}` are pairwise disjoint measurable sets, then `μ (⋃ b ∈ s, f(b)) = ∑' (b : s), μ (f(b))`.


theorem Topology.IsLowerSet.topology_eq :
    ∀ (α : Type u_1) [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Topology.IsLowerSet α],
      inst_1 = Topology.lowerSet α :=
  by sorry

This theorem states that for any type `α` with a preorder structure, and equipped with a topological space and lower set topology, the topological space is equivalent to the lower set topology. In other words, if a topology on a preordered type is defined in such a way that its open sets are lower sets, then this topology is exactly the same as the lower set topology on that type.

For any preordered type `α` with a topology making open sets equivalent to lower sets, the topology is identical to the lower set topology.


/-- If the Lebesgue integral of a function is bounded by some constant on all sets with finite
measure in a sub-σ-algebra and the measure is σ-finite on that sub-σ-algebra, then the integral
over the whole space is bounded by that same constant.  -/
theorem MeasureTheory.lintegral_le_of_forall_fin_meas_le' :
    ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0)
      [inst : MeasureTheory.SigmaFinite (μ.trim hm)] (C : ENNReal) {f : α → ENNReal},
      AEMeasurable f μ →
        (∀ (s : Set α), MeasurableSet s → ↑↑μ s ≠ ⊤ → ∫⁻ (x : α) in s, f x ∂μ ≤ C) → ∫⁻ (x : α), f x ∂μ ≤ C :=
  by sorry

The theorem `MeasureTheory.lintegral_le_of_forall_fin_meas_le'` states that given a measure space `α` with two measurable spaces `m` and `m0` such that `m` is a sub-σ-algebra of `m0`, and a measure `μ` which is σ-finite on the sub-σ-algebra `m`, if for a function `f` from `α` to the extended nonnegative real numbers which is almost everywhere measurable with respect to `μ`, the Lebesgue integral of `f` over any set `s` with finite measure (i.e., `μ s` is not infinity) and which is a measurable set is less than or equal to some constant `C`, then the Lebesgue integral of `f` over the entire space `α` is also less than or equal to `C`. In other words, if the integral of a function is bounded by a constant on all sets with finite measure in a sub-σ-algebra, then the integral over the whole space is also bounded by that same constant.

If `μ` is a σ-finite measure on the sub-σ-algebra `m` of a measure space `α`, `f` is an almost everywhere measurable function from `α` to the extended nonnegative real numbers, and for every measurable set `s` in `m` with finite measure `μ(s)`, the Lebesgue integral of `f` over `s` is bounded by a constant `C`, then the Lebesgue integral of `f` over the entire space `α` is also bounded by `C`.


theorem Ordinal.bsup_le_blsub :
    ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}), Ordinal.bsup o f ≤ Ordinal.blsub o f := by
  sorry

This theorem, `Ordinal.bsup_le_blsub`, states that for any ordinal `o` and any function `f` that maps each ordinal less than `o` to another ordinal, the supremum (`bsup`) of the family of all such ordinals generated by `f` is less than or equal to the least strict upper bound (`blsub`) of the same family. In other words, the highest ordinal that can be reached by `f` for all ordinals less than `o` is always less than or equal to the smallest ordinal that is strictly greater than all ordinals in the same family.

For any ordinal `o` and function `f` mapping ordinals below `o`, the supremum of the image of `f` is less than or equal to the least strict upper bound of the domain of `f`.


theorem SemiconjBy.inv_right₀ :
    ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a x y : G₀}, SemiconjBy a x y → SemiconjBy a x⁻¹ y⁻¹ := by sorry

This theorem states that for any type `G₀` that forms a group with zero, and for any elements `a`, `x`, and `y` of that group, if `x` is semiconjugate to `y` by `a` (which means that multiplying `a` with `x` equals multiplying `y` with `a`), then the inverse of `x` is semiconjugate to the inverse of `y` by `a`. In mathematical terms, if $a \cdot x = y \cdot a$, then it implies that $a \cdot x^{-1} = y^{-1} \cdot a$.

If `a`, `x`, and `y` are elements of a group with identity, and `a` semiconjugates `x` and `y` (i.e., `a * x = y * a`), then `a` semiconjugates their inverses (i.e., `a * x⁻¹ = y⁻¹ * a`).


/-- An inductive-like property for the objects of a connected category.
If the set `p` is nonempty, and `p` is closed under morphisms of `J`,
then `p` contains all of `J`.

The converse is given in `IsConnected.of_induct`.
 -/
theorem CategoryTheory.induct_on_objects :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [inst_1 : CategoryTheory.IsPreconnected J] (p : Set J)
      {j₀ : J}, j₀ ∈ p → (∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)) → ∀ (j : J), j ∈ p :=
  by sorry

This theorem describes an inductive-like property for objects in a connected category. It states that, for any given category `J`, which is pre-connected, and any given set `p` of objects in `J`, if `p` is nonempty (i.e. it contains an object `j₀`) and `p` is closed under the morphisms of `J` (meaning that if `j₁` is an element in `p` and there is a morphism from `j₁` to `j₂`, then `j₂` is also in `p`), then all objects in `J` belong to `p`. Essentially, this theorem states that if a set contains one object and is invariant under morphisms, it must contain all objects of the pre-connected category. The converse scenario is detailed in `IsConnected.of_induct`.

In a pre-connected category `J`, any nonempty set `p` of objects that is closed under morphisms contains all objects in `J`.


theorem Matrix.zpow_add_one :
    ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
      {A : Matrix n' n' R}, IsUnit (Matrix.det A) → ∀ (n : ℤ), A ^ (n + 1) = A ^ n * A :=
  by sorry

The theorem `Matrix.zpow_add_one` states that for any type `n'` with decidable equality and finite cardinality, and any type `R` forming a commutative ring, given a square matrix `A` with elements of type `R` and indices of type `n'`, if the determinant of `A` is a unit (i.e., has a multiplicative inverse), then for any integer `n`, the `(n + 1)`-th power of `A` is equal to the `n`-th power of `A` multiplied by `A`. This in essence provides a recursive definition for calculating the powers of a matrix, assuming the determinant is a unit.

For any square matrix `A` over a commutative ring `R` with determinant unit `det(A)`, the `(n + 1)`-th power of `A` equals the `n`-th power of `A` multiplied by `A`.


theorem ApproximatesLinearOn.mono_set :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {f' : E →L[𝕜] F} {s t : Set E} {c : NNReal},
      s ⊆ t → ApproximatesLinearOn f f' t c → ApproximatesLinearOn f f' s c :=
  by sorry

The theorem `ApproximatesLinearOn.mono_set` states that for any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` of `E` and `F`, given the function `f : E → F`, the continuous linear map `f' : E →L[𝕜] F`, and two sets `s` and `t` of type `E`, along with the non-negative real number `c`, if set `s` is a subset of set `t` and function `f` approximates a linear function on set `t` with an error of at most `c`, then `f` also approximates a linear function on set `s` with the same error margin `c`. This theorem is a demonstration of the principle of restriction, asserting that if a property holds on a larger set, it also holds on any of its subsets.

Given a nontrivially normed field `𝕜`, normed additive commutative groups `E` and `F`, and normed spaces over `𝕜` of `E` and `F`, if `f : E → F` is a continuous linear map, `s ⊆ t ∈ E`, and `f` approximates a linear function on `t` with error `c`, then `f` approximates a linear function on `s` with the same error `c`.


theorem openSegment_symm :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : SMul 𝕜 E] (x y : E),
      openSegment 𝕜 x y = openSegment 𝕜 y x :=
  by sorry

The theorem `openSegment_symm` states that for any ordered semiring `𝕜` and any two elements `x` and `y` of an additive commutative monoid `E` endowed with a scalar multiplication `SMul` by `𝕜`, the open segment between `x` and `y` is the same as the open segment between `y` and `x`. In other words, the order of `x` and `y` does not matter when determining the open segment, symbolically represented as `openSegment 𝕜 x y = openSegment 𝕜 y x`. An open segment here refers to the set of all points that can be obtained as a convex combination of `x` and `y`, where the coefficients are strictly positive and sum to 1.

For any ordered semiring 𝕜 and additive commutative monoid E with scalar multiplication SMul, the open segment between elements x and y in E with respect to 𝕜 is equal to the open segment between y and x.


theorem Matrix.updateColumn_transpose :
    ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {b : n → α} [inst : DecidableEq m],
      Matrix.updateColumn (Matrix.transpose M) i b = Matrix.transpose (Matrix.updateRow M i b) :=
  by sorry

The theorem `Matrix.updateColumn_transpose` states that for any type `m` and `n` indicating the rows and columns of a matrix respectively, and any type `α` representing the content of the matrix, given a matrix `M` of type `Matrix m n α`, an index `i` of type `m` and a function `b` mapping from type `n` to type `α`, if equality of type `m` is decidable, then updating the `i`th column of the transpose of `M` with the values in `b` is equivalent to transposing the result of updating the `i`th row of `M` with the values in `b`. In other words, transposing a matrix after updating one of its columns has the same effect as first updating the corresponding row of the original matrix and then transposing it.

For any matrix `M` of type `m x n α`, index `i`, and function `b`, if `m` has decidable equality, then updating the `i`th column of the transpose of `M` with `b` is equivalent to transposing the matrix obtained by updating the `i`th row of `M` with `b`.


theorem ContinuousMap.norm_lt_iff :
    ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
      [inst_2 : NormedAddCommGroup E] (f : C(α, E)) {M : ℝ}, 0 < M → (‖f‖ < M ↔ ∀ (x : α), ‖f x‖ < M) :=
  by sorry

This theorem states that for any topological space `α`, which is also a compact space, and any normed additive commutative group `E`, if we have a continuous map `f` from `α` to `E` and a real number `M` that is greater than zero, then the norm of `f` is less than `M` if and only if the norm of `f` applied to any element `x` in `α` is less than `M`. In simpler terms, the overall norm of a continuous function is less than a positive value if and only if the norm of the function's output is less than that value for every input in the domain.

For any compact topological space α and continuous function f from α to a normed additive commutative group E, the function norm ||f|| is less than M if and only if ||f(x)|| < M for all x in α.


theorem Real.exp_monotone : Monotone Real.exp := by sorry

The theorem `Real.exp_monotone` states that the real exponential function, denoted by `Real.exp`, is monotone. In other words, given two real numbers where the first is less than or equal to the second, the exponential of the first number will also be less than or equal to the exponential of the second number.

For all real numbers x and y with x ≤ y, it holds that Real.exp x ≤ Real.exp y.


/-- The integral of `f (R • x)` with respect to an additive Haar measure is a multiple of the
integral of `f`. The formula we give works even when `f` is not integrable or `R = 0`
thanks to the convention that a non-integrable function has integral zero.  -/
theorem MeasureTheory.Measure.integral_comp_smul :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
      [inst_3 : BorelSpace E] [inst_4 : FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E)
      [inst_5 : MeasureTheory.Measure.IsAddHaarMeasure μ] {F : Type u_2} [inst_6 : NormedAddCommGroup F]
      [inst_7 : NormedSpace ℝ F] (f : E → F) (R : ℝ),
      ∫ (x : E), f (R • x) ∂μ = |(R ^ FiniteDimensional.finrank ℝ E)⁻¹| • ∫ (x : E), f x ∂μ :=
  by sorry

This theorem states that for any normed add-commutative group `E`, equipped with a normed space structure over the real numbers ℝ, a measurable space structure, a Borel space structure, and a finite-dimensional real vector space structure, and given an additive Haar measure `μ` on `E`, if we take any normed add-commutative group `F`, equipped with a normed space structure over ℝ, and a function `f` from `E` to `F`, then the integral of the function `f` after scalar multiplication by a real number `R` (written as `f (R • x)`) with respect to the measure `μ` is equal to a scaled version of the integral of `f` with respect to `μ`. The scaling factor is the absolute value of the reciprocal of the real number `R` raised to the power of the rank of the vector space `E` (using `FiniteDimensional.finrank`). This theorem holds even when `f` is not integrable or when `R` equals zero due to the convention that a non-integrable function has an integral of zero.

For any normed add-commutative groups `E` and `F` with finite-dimensional normed space structures over the real numbers, and additive Haar measure `μ` on `E`, the integral of `f: E → F` with respect to `μ` after scalar multiplication by `R ∈ ℝ` is equal to the scaled version of the integral of `f` with a factor of `|R|^{-rank(E)}`, where `rank(E)` is the rank of `E`.


/-- If `K / E / F` is an extension tower such that `E / F` is separable,
`x : K` is separable over `E`, then it's also separable over `F`.  -/
theorem Polynomial.Separable.comap_minpoly_of_isSeparable :
    ∀ (F : Type u) {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type w}
      [inst_3 : Field K] [inst_4 : Algebra F K] [inst_5 : Algebra E K] [inst_6 : IsScalarTower F E K]
      [inst_7 : IsSeparable F E] {x : K}, Polynomial.Separable (minpoly E x) → Polynomial.Separable (minpoly F x) :=
  by sorry

The theorem `Polynomial.Separable.comap_minpoly_of_isSeparable` states that if we have an extension tower `K / E / F` such that the extension `E / F` is separable, and if a value `x` from `K` is separable over `E`, then it will also be separable over `F`. Here, separability of a polynomial is defined as the polynomial being coprime with its derivative. The `minpoly E x` and `minpoly F x` represent the minimal polynomials of `x` over `E` and `F` respectively. So, if the minimal polynomial of `x` over `E` is separable, then the minimal polynomial of `x` over `F` is also separable.

If `x` is separable over `E` in a separable extension tower `K / E / F`, then the minimal polynomial of `x` over `F` is coprime with its derivative, i.e., separable.


theorem EReal.exists_between_coe_real : ∀ {x z : EReal}, x < z → ∃ y, x < ↑y ∧ ↑y < z := by sorry

The theorem `EReal.exists_between_coe_real` states that for any two extended real numbers `x` and `z` (represented as `EReal`), if `x` is less than `z`, then there exists a regular real number `y` (represented as `↑y` after being coerced from real numbers to `EReal`), such that `x` is less than `y` and `y` is less than `z`. This means that between any two distinct extended real numbers, we can always find a regular real number.

For any two extended real numbers `x` and `z` with `x < z`, there exists a regular real number `y` such that `x < y < z`.


theorem List.foldlM_append :
    ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] [inst_1 : LawfulMonad m]
      (f : β → α → m β) (b : β) (l l' : List α),
      List.foldlM f b (l ++ l') = do
        let init ← List.foldlM f b l
        List.foldlM f init l' :=
  by sorry

The theorem `List.foldlM_append` states that for any monad `m`, any types `β` and `α`, any lawful monad instance of `m`, a function `f` from `β` to `α` to `m β`, a value `b` of type `β`, and lists `l` and `l'` of type `List α`, the result of folding `f` over the concatenation of `l` and `l'` starting with `b` is equivalent to folding `f` over `l` starting with `b` to get an intermediate result, and then folding `f` over `l'` starting with this intermediate result. In other words, it demonstrates the associative property of the monadic fold operation on lists.

For any monad `m`, any types `β` and `α`, and lawful monad instance of `m`, the result of `List.foldlM f b (l ++ l')` is equal to `List.foldlM (λ x acc. f x acc) b l` then `List.foldlM f acc l'`.


theorem eq_of_nhds_neBot :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] {x y : X},
      Filter.NeBot (nhds x ⊓ nhds y) → x = y :=
  by sorry

This theorem states that for any type `X` equipped with a topology (i.e., `X` is a topological space) and satisfying the Hausdorff condition (also known as a `T2Space`), given any two elements `x` and `y` from `X`, if the intersection of the neighborhood filters of `x` and `y` is not the bottom filter (i.e., it is not empty), then `x` must be equal to `y`. This theorem captures a key property of Hausdorff spaces: distinct points have disjoint neighborhoods.

In a Hausdorff topological space, distinct points have disjoint neighborhoods, i.e., if `x` and `y` are distinct points and their neighborhood filters intersect non-emptily, then `x = y`.


theorem LocalizedModule.mk_cancel_common_right :
    ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {M : Type v} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] (s s' : ↥S) (m : M), LocalizedModule.mk (s' • m) (s * s') = LocalizedModule.mk m s :=
  by sorry

The theorem `LocalizedModule.mk_cancel_common_right` states that for any commutative semiring `R`, any submonoid `S` of `R`, any additively commutative monoid `M` that is also a `R`-module, and any elements `s` and `s'` from `S` and `m` from `M`, the localization of `s'` scaled by `m` at the product `s * s'` is equal to the localization of `m` at `s`. In other words, the process of localizing `m` at `s` in a localized module `S` of `M` is not affected by scaling the module element `m` by an element `s'` from `S` and simultaneously multiplying the localizing element `s` by the same `s'`.

For any commutative semiring R, submonoid S, additively commutative R-module M, and elements s, s' from S and m from M, the localization of m at s in the localized module S of M is equal to the localization of m scaled by s' at s * s'.


AccPt.mono

/-- If `x` is an accumulation point of `F` and `F ≤ G`, then
`x` is an accumulation point of `D`.  -/
theorem AccPt.mono :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {F G : Filter X}, AccPt x F → F ≤ G → AccPt x G := by sorry

This theorem states that if `x` is an accumulation point of a filter `F` in a topological space `X`, and `F` is a subset of another filter `G` (in the sense that `F ≤ G`), then `x` is also an accumulation point of `G`. An accumulation point of a filter, roughly speaking, is a point in the topological space where the filter "accumulates". In other words, any open set containing the point will intersect with the set of filter elements.

If `F ≤ G` are filters in a topological space `X` and `x` is an accumulation point of `F`, then `x` is an accumulation point of `G`.


theorem ProbabilityTheory.kernel.IndepSets.union :
    ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.IndepSets s₁ s' κ μ →
        ProbabilityTheory.kernel.IndepSets s₂ s' κ μ → ProbabilityTheory.kernel.IndepSets (s₁ ∪ s₂) s' κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.IndepSets.union` in probability theory states that given measurable spaces `α` and `Ω` with `α` being the type of the random variables and `Ω` the sample space, two collections of sets `s₁` and `s₂`, and a third collection of sets `s'`. If `s₁` and `s'` are independent with respect to a kernel `κ` and a measure `μ`, and if `s₂` and `s'` are also independent with respect to the same kernel and measure, then the union of `s₁` and `s₂` is independent with `s'` with respect to the same kernel and measure. In mathematical terms, independence here means that for all `t₁` in `s₁` (or `s₂`) and `t₂` in `s'`, almost everywhere in `a` with respect to measure `μ`, the kernel of `a` applied to the intersection of `t₁` and `t₂` equals the product of the kernel of `a` applied to `t₁` and `t₂` separately.

If measurable collections of sets `s₁` and `s₂` are independent of a collection `s'` with respect to a kernel `κ` and measure `μ`, then the union of `s₁` and `s₂` is independent of `s'` with respect to `κ` and `μ`, meaning their intersections almost everywhere have kernels equal to the product of their individual kernels.


theorem ENNReal.inv_rpow : ∀ (x : ENNReal) (y : ℝ), x⁻¹ ^ y = (x ^ y)⁻¹ := by sorry

This theorem states that for all extended nonnegative real numbers `x` and any real number `y`, the inverse of `x` raised to the power `y` is equal to the inverse of `x` raised to the power `y`. Symbolically, this can be represented as $(x^{-1})^y = (x^y)^{-1}$. This property is commonly used in the manipulation of exponents and is part of the general rules of exponents in mathematics.

For all extended nonnegative real numbers x and real number y, $(x^{-1})^y = (x^y)^{-1}$.


theorem LinearMap.tunnelAux_injective :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] {N : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M × N →ₗ[R] M),
      Function.Injective ⇑f →
        ∀ (Kφ : (K : Submodule R M) × ↥K ≃ₗ[R] M), Function.Injective ⇑(LinearMap.tunnelAux f Kφ) :=
  by sorry

The theorem `LinearMap.tunnelAux_injective` states that for any ring `R` and its modules `M` and `N`, given a linear map `f` from the cartesian product of `M` and `N` to `M`, if `f` is injective, then for any isomorphism `Kφ` between a pair consisting of a submodule `K` of `M` and an element of `K`, and `M`, the function obtained by applying `LinearMap.tunnelAux` to `f` and `Kφ` is also injective.

If `f` is an injective linear map from `M × N` to `M`, for any submodule `K` of `M` and isomorphism `Kφ` between `K` and an element of `M`, the linear map obtained by applying `LinearMap.tunnelAux` to `f` and `Kφ` is also injective.


theorem IsPrimitiveRoot.coe_units_iff :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : Mˣ}, IsPrimitiveRoot (↑ζ) k ↔ IsPrimitiveRoot ζ k := by sorry

This theorem states that for any type `M` which forms a commutative monoid, for any natural number `k`, and for any unit `ζ` in `M`, `ζ` is a primitive root of `k` if and only if the coercion of `ζ` is also a primitive root of `k`. Here, a primitive root of `k` is an element which, when repeatedly multiplied by itself `k` times, yields 1, but does not yield 1 when multiplied by itself fewer than `k` times.

For any commutative monoid type `M` and unit `ζ` in `M`, `ζ` is a primitive root of a natural number `k` if and only if the coercion of `ζ` is a primitive root of `k`.


theorem MonoidAlgebra.mul_single_apply_aux :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Mul G] (f : MonoidAlgebra k G) {r : k} {x y z : G},
      (∀ (a : G), a * x = z ↔ a = y) → (f * MonoidAlgebra.single x r) z = f y * r :=
  by sorry

The theorem `MonoidAlgebra.mul_single_apply_aux` states that for any semiring `k`, any multiplicative group `G`, a monoid algebra `f` over `k` and `G`, and any elements `r` in `k`, `x`, `y`, and `z` in `G` such that for any element `a` in `G`, the equality `a * x = z` holds if and only if `a = y`, then the product of `f` and the monoid algebra generated by `x` and `r` evaluated at `z` equals the product of `f` evaluated at `y` and `r`.

Given a semiring `k`, a multiplicative group `G`, a monoid algebra `f` over `k` and `G`, and `x`, `y` in `G` such that `x * a = z` if and only if `a = y`, then `f * (algBase x r) = f y * r`.


theorem MeasureTheory.memℒp_top_const :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
      (c : E), MeasureTheory.Memℒp (fun x => c) ⊤ μ :=
  by sorry

This theorem states that for any type `α`, any type `E` that forms a normed additive commutative group, any measurable space `m0` over `α`, any measure `μ` of `α`, and any constant `c` of type `E`, the function `f` that maps every element of `α` to `c` satisfies the `Memℒp` property at infinity with respect to `μ`. In mathematical terms, this means that the function `f` is almost everywhere strongly measurable and its essential supremum is finite.

For any measurable space `(α, m0)`, any normed additive commutative group `E` with measure `μ`, and any constant `c` in `E`, the function mapping every `x` in `α` to `c` is a strongly measurable function of `α` with finite essential supremum with respect to `μ`.


theorem MeasureTheory.aecover_Ioo_of_Ioc :
    ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
      [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [inst_3 : OrderClosedTopology α]
      [inst_4 : OpensMeasurableSpace α] {a b : ι → α} {A B : α},
      Filter.Tendsto a l (nhds A) →
        Filter.Tendsto b l (nhds B) → MeasureTheory.AECover (μ.restrict (Set.Ioo A B)) l fun i => Set.Ioc (a i) (b i) :=
  by sorry

This theorem, `MeasureTheory.aecover_Ioo_of_Ioc`, states that for any types `α` and `ι`, a measurable space structure on `α`, a measure `μ` on `α`, a filter `l` on `ι`, a linear order, a topological space, an order closed topology and an open measurable space on `α`, given two function `a` and `b` mapping from `ι` to `α` and two real numbers `A` and `B`. If the function `a` tends to `A` with respect to filter `l` and the neighborhood filter at `A` and the function `b` tends to `B` with respect to filter `l` and the neighborhood filter at `B`, then the sequence of intervals `(a i, b i]` forms an almost everywhere convergent (aecover) sequence with respect to the measure restricted to the open interval `(A, B)` and the filter `l`. The term "almost everywhere" means that the set of `ι`'s where the property does not hold is of measure zero.

Given measurable spaces `(α, μ)`, filters `l` on index set `ι`, linear order `<`, topological space `(α, τ)`, open measurable space `(α, μℙ)`, functions `a, b: ι → α`, real numbers `A, B`, and if `a` converges to `A` and `b` converges to `B` with respect to filters `l` and their neighborhood filters, then the sequence `(a i, b i]` is almost everywhere convergent to `A` with respect to measure `μ` restricted to the open interval `(A, B)` on set `α`.


BoxIntegral.Prepartition.isPartitionTop

theorem BoxIntegral.Prepartition.isPartitionTop :
    ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), BoxIntegral.Prepartition.IsPartition ⊤ := by sorry

The theorem `BoxIntegral.Prepartition.isPartitionTop` states that for any type `ι` and any box `I` of type `BoxIntegral.Box ι`, the top element `⊤` of the prepartitions of `I` is a partition. This implies that the entirety of the box `I` is covered by the boxes of the top element prepartition.

The top element of the prepartitions of a box integral over type `ι` is a partition, covering the entire box.


theorem Sum.not_inl_lt_inr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a : α} {b : β}, ¬Sum.inl b < Sum.inr a := by sorry

This theorem states that, for any types `α` and `β` equipped with a less than (`<`) relation, and any elements `a` of type `α` and `b` of type `β`, it is not the case that `b` labelled as an element of `β` in a sum type is less than `a` labelled as an element of `α` in the same sum type. In other words, if you have two elements from different types and you put them into a sum type, you cannot say that the one from the second type is less than the one from the first type. The theorem holds for any types that have a less than relation defined.

For any types `α` and `β` with a defined `<` relation and any `a : α` and `b : β`, `a < b` is not provable.


theorem Lagrange.eval_interpolate_at_node :
    ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {i : ι} {v : ι → F}
      (r : ι → F), Set.InjOn v ↑s → i ∈ s → Polynomial.eval (v i) ((Lagrange.interpolate s v) r) = r i :=
  by sorry

The theorem `Lagrange.eval_interpolate_at_node` states that for any field `F`, index type `ι` with decidable equality, a finite set `s` of indices, an index `i`, a nodal map `v` from `ι` to `F`, and a value function `r` from `ι` to `F`, if `v` is injective on the set `s` and `i` is an element of `s`, then the value of the polynomial obtained by the Lagrange interpolation of `s`, `v`, and `r` evaluated at `v i` is equal to `r i`. In essence, this theorem ensures that the Lagrange interpolation polynomial accurately reproduces the given value `r i` at each node `v i` in the set.

For any injective nodal map `v` from an index type `ι` to a field `F`, finite set `s ⊆ ι`, index `i ∈ s`, and value function `r : ι → F`, the Lagrange interpolation polynomial of `s`, `v`, and `r` evaluates to `r i` at `v i`.


TendstoUniformlyOn.mono

theorem TendstoUniformlyOn.mono :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
      {p : Filter ι} {s' : Set α}, TendstoUniformlyOn F f p s → s' ⊆ s → TendstoUniformlyOn F f p s' :=
  by sorry

The theorem `TendstoUniformlyOn.mono` states that for any types `α`, `β`, and `ι`, with `β` being a uniform space, given a sequence of functions `F` from `ι` to `α → β`, a limiting function `f` from `α` to `β`, a filter `p` on `ι`, and two sets `s` and `s'` of `α`, if the sequence `F` converges uniformly on set `s` to the function `f` with respect to the filter `p`, and if `s'` is a subset of `s`, then the sequence `F` also converges uniformly on the subset `s'` to the function `f` with respect to the same filter `p`. In other words, the uniform convergence of a sequence of functions on a set implies its uniform convergence on any subset of that set.

If a sequence of functions converges uniformly on a set and a subset of that set, then the uniform convergence holds on the subset as well.


theorem AddSubgroup.relindex_eq_zero_of_le_left :
    ∀ {G : Type u_1} [inst : AddGroup G] {H K L : AddSubgroup G},
      H ≤ K → AddSubgroup.relindex K L = 0 → AddSubgroup.relindex H L = 0 :=
  by sorry

This theorem states that for any additive group `G` and any three of its subgroups `H`, `K`, and `L`, if `H` is a subgroup of (or equal to) `K` and the relative index (as a natural number) of `K` and `L` is zero, then the relative index of `H` and `L` is also zero. The relative index of two subgroups here is defined as the index of the subgroup formed by their intersection, and it returns 0 if this relative index is infinite.

If subgroups H, K, and L of an additive group G have H a subgroup of (or equal to) K and the index of K in L is finite and equal to one, then the index of H in L is also finite and equal to one.


/-- The cardinality of the multiset `nthRoots ↑n (1 : R)` is `n`
if there is a primitive root of unity in `R`.  -/
theorem IsPrimitiveRoot.card_nthRoots_one :
    ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R} {n : ℕ},
      IsPrimitiveRoot ζ n → Multiset.card (Polynomial.nthRoots n 1) = n :=
  by sorry

The theorem `IsPrimitiveRoot.card_nthRoots_one` states that for any commutative ring `R` that is also an integral domain, if `ζ` is a primitive nth root of unity in `R` (meaning ζ^n = 1 and ζ^k ≠ 1 for any positive integer `k` less than `n`), then the cardinality (or size) of the multiset of all nth roots of 1 in `R` is exactly `n`. In other words, if there is a primitive nth root of unity in `R`, there are exactly `n` distinct solutions to the equation x^n = 1 in `R`.

For any commutative integral domain R, the number of distinct n-th roots of 1 in R is exactly n if and only if there exists a primitive n-th root of unity in R.


theorem IsIdempotentElem.one_sub :
    ∀ {R : Type u_6} [inst : NonAssocRing R] {p : R}, IsIdempotentElem p → IsIdempotentElem (1 - p) := by sorry

The theorem `IsIdempotentElem.one_sub` states that for any type `R` that forms a non-associative ring, and for any element `p` of `R`, if `p` is an idempotent element (meaning `p * p = p`), then the element `1 - p` is also idempotent. In mathematical terms, it states that if `p` is such that `p^2 = p`, then `(1 - p)^2 = 1 - p`.

If `p` is an idempotent element in a non-associative ring `R`, then `1 - p` is also an idempotent element in `R` (i.e., `(1 - p)^2 = 1 - p`).


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

The theorem `CategoryTheory.Limits.biprod.inr_map` states that for any category `C` that has zero morphisms, given four objects `W`, `X`, `Y`, `Z` in `C`, such that `C` has binary biproducts of `W` and `X`, and `Y` and `Z`, and two morphisms `f : W ⟶ Y` and `g : X ⟶ Z`, the composition of the inclusion into the second summand of a binary biproduct (`CategoryTheory.Limits.biprod.inr`) followed by the mapping of the binary biproduct via `f` and `g` is equal to the composition of `g` followed by the inclusion into the second summand of a binary biproduct. In other words, this theorem is about the commutativity of a certain diagram involving binary biproducts in a category.

For any category with zero morphisms `C` having binary biproducts, the inclusion into the second summand of a binary biproduct of objects `W`, `X` followed by morphisms `f : W ⟶ Y` and `g : X ⟶ Z`, is equal to the morphism `g` followed by the inclusion into the second summand of the binary biproduct of objects `X`, `Z`.


theorem CategoryTheory.Limits.Types.Limit.π_mk :
    ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
      [inst_1 : CategoryTheory.Limits.HasLimit F] (x : (j : J) → F.obj j)
      (h : ∀ (j j' : J) (f : j ⟶ j'), F.map f (x j) = x j') (j : J),
      CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.Types.Limit.mk F x h) = x j :=
  by sorry

This theorem, `CategoryTheory.Limits.Types.Limit.π_mk`, states that for any category `J` with objects of type `v` and morphisms of type `w`, and any functor `F` from `J` to the category of types, if `F` has a limit, then for any function `x` assigning to each object `j` of `J` an element of `F.obj j`, and for any proof `h` that `x` respects the morphisms of `J` (i.e., for all objects `j` and `j'` of `J` and any morphism `f` from `j` to `j'`, `F.map f` applied to `x j` equals `x j'`), if you take the limit of `F` and apply the projection to `j` to the limit object associated with `F`, `x`, and `h`, you get back `x j`. In other words, the projection function from the limit object of the functor to the value of the functor at a given point is equal to the function value at that point when the function is cohesive with the functor.

Given a limit-preserving function `x` from objects of a category `J` to the values of a functor `F` from `J`, the projection of the limit object of `F` to `x j` equals `x j`, for any object `j` in `J`.


/-- If the identity arrow is in a sieve, the sieve is maximal.  -/
theorem CategoryTheory.Sieve.id_mem_iff_eq_top :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X},
      S.arrows (CategoryTheory.CategoryStruct.id X) ↔ S = ⊤ :=
  by sorry

This theorem states that for any category `C`, any object `X` in `C`, and any sieve `S` on `X`, if the identity arrow (or morphism) on `X` is in the sieve `S`, then `S` must be the top or maximal sieve on `X`. In other words, if a sieve includes the identity morphism on an object, it is the largest possible sieve on that object.

In any category, if a sieve on an object contains the identity morphism, then it is the maximal (or top) sieve on that object.


theorem Filter.le_cofinite_iff_eventually_ne :
    ∀ {α : Type u_2} {l : Filter α}, l ≤ Filter.cofinite ↔ ∀ (x : α), ∀ᶠ (y : α) in l, y ≠ x := by sorry

This theorem states that for any type `α` and any filter `l` of that type, `l` is less than or equal to the cofinite filter if and only if for each element `x` of type `α`, it is eventually the case in the filter `l` that `y` is not equal to `x`. In other words, any element `x` in the filter `l` will eventually be followed by some other element `y` that is not equal to `x`.

For any type `α` and filter `l` of `α`, `l` is equal to the cofinite filter if and only if for all `x` in `α`, there exists an `y` not equal to `x` such that `y` is in `l` and is eventually greater than `x` in `l`.


theorem tsub_right_comm :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst : OrderedSub α]
      {a b c : α}, a - b - c = a - c - b :=
  by sorry

This theorem, `tsub_right_comm`, states that for any type `α` that has a partial order, is an additive commutative semigroup, has a subtraction operation, and respects the order under subtraction, and for any three elements `a`, `b`, and `c` of this type, the difference `a - b - c` is equal to `a - c - b`. In other words, the subtraction operation on the right side of `a` in this type is commutative.

For any type with a partial order, additive commutative semigroup structure, and subtraction operation respecting the order, the subtraction operation is right-commutative. That is, for all `a, b, c`, `a - b - c = a - c - b`.


theorem zero_pow_eq : ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (n : ℕ), 0 ^ n = if n = 0 then 1 else 0 := by sorry

This theorem states that for any natural number `n` and a type `M₀` that is a monoid with zero, the power of 0 raised to `n` (`0 ^ n`) equates to 1 if `n` equals zero (`n = 0`), else it equates to zero. Essentially, it's defining the outcome of zero raised to any natural number, following the mathematical convention that zero to the power of zero is defined as one, and zero to the power of any other natural number is zero.

For any monoid with zero `M₀` and natural number `n`, `0 ^ n = 1` if `n = 0`, otherwise `0 ^ n = 0`.


theorem Mathlib.Data.Polynomial.Div._auxLemma.11 :
    ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R},
      (Polynomial.X - Polynomial.C a ∣ p) = Polynomial.IsRoot p a :=
  by sorry

This theorem states that for any commutative ring `R` and any element `a` of `R`, a polynomial `p` over `R` is divisible by the polynomial `X - C a` (where `X` is the polynomial variable and `C a` is the constant polynomial `a`) if and only if `a` is a root of `p`. In mathematical terms, this says that the polynomial `p` has `a` as a root if and only if `p` can be written as `(X - a)q` for some polynomial `q` in `R`.

A polynomial `p` over a commutative ring `R` has a root `a` in `R` if and only if `p` is divisible by `X - a` in `R[X]`.


theorem Multiset.inj_on_of_nodup_map :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Multiset α},
      Multiset.Nodup (Multiset.map f s) → ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y :=
  by sorry

This theorem states that for any multiset `s` of type `α`, function `f` mapping from `α` to `β`, and any elements `x` and `y` in `s`, if there are no duplicates in the multiset obtained by applying `f` to each element of `s`, then if `f x` equals `f y`, `x` must equal `y`. In other words, under the condition of no duplicates in the mapped multiset, the function `f` is injective (one-to-one) on the elements of the original multiset `s`.

If `s` is a multiset, `f` is a function from `s.elem type` to `β`, and the multiset `{f x | x ∈ s}` has no duplicates, then `f x = f y` implies `x = y`.


theorem Real.cosh_sq' : ∀ (x : ℝ), Real.cosh x ^ 2 = 1 + Real.sinh x ^ 2 := by sorry

This theorem states that for every real number `x`, the square of the hyperbolic cosine of `x` is equal to 1 plus the square of the hyperbolic sine of `x`. In mathematical notation, this is represented as: ∀x ∈ ℝ, cosh²(x) = 1 + sinh²(x). This is analogous to the well-known trigonometric identity involving the sine and cosine functions, but in the context of hyperbolic functions.

For all real numbers x, the square of the hyperbolic cosine of x equals the sum of the squares of the hyperbolic sine and one: cosh²(x) = 1 + sinh²(x).


theorem Complex.exp_ofReal_im : ∀ (x : ℝ), (Complex.exp ↑x).im = 0 := by sorry

This theorem states that for every real number `x`, the imaginary part of the exponential function of `x` interpreted as a complex number, denoted by `(Complex.exp ↑x).im`, is always equal to zero. In other words, the imaginary part of the complex exponential of a real number is always zero. This is equivalent to saying that the complex exponential of any real number lies on the real line in the complex plane.

The imaginary part of the complex exponential function of a real number is equal to zero.


theorem summable_geometric_of_norm_lt_one :
    ∀ {K : Type u_4} [inst : NormedField K] {ξ : K}, ‖ξ‖ < 1 → Summable fun n => ξ ^ n := by sorry

The theorem `summable_geometric_of_norm_lt_one` states that for any normed field `K` and any element `ξ` of `K`, if the norm of `ξ` is strictly less than 1, then the infinite geometric series `ξ^n` is summable. Here, summability refers to the existence of a finite sum to which the infinite series converges. In the context of this theorem, the infinite series is the sequence of terms `ξ^n` as `n` ranges over all nonnegative integers.

For any normed field K and any element ξ in K with norm strictly less than 1, the geometric series Σ(ξ^n. LEAN: ∑ i, xi < power i 1) converges.


/-- If `f` is a Lipschitz continuous map, then `dimH (f '' s) ≤ dimH s`.  -/
theorem LipschitzWith.dimH_image_le :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : EMetricSpace X] [inst_1 : EMetricSpace Y] {K : NNReal} {f : X → Y},
      LipschitzWith K f → ∀ (s : Set X), dimH (f '' s) ≤ dimH s :=
  by sorry

The theorem `LipschitzWith.dimH_image_le` states that if `f` is a Lipschitz continuous function, then the Hausdorff dimension of the image of a set `s` under `f` is less than or equal to the Hausdorff dimension of the set `s` itself. Here, the Hausdorff dimension of a set in a metric space is denoted by `dimH`. The set `s` is a collection of elements of some type `X`, and `f` is a function mapping from `X` to another type `Y`. Both `X` and `Y` are types in an extended metric space.

If `f` is Lipschitz continuous, then `dimH(f(s)) ≤ dimH(s)` for any set `s` in a metric space.


theorem AlgebraicGeometry.StructureSheaf.localizationToStalk_stalkSpecializes :
    ∀ {R : Type u_1} [inst : CommRing R] {x y : PrimeSpectrum R} (h : x ⤳ y),
      CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.StructureSheaf.localizationToStalk R y)
          (TopCat.Presheaf.stalkSpecializes (TopCat.Sheaf.presheaf (AlgebraicGeometry.Spec.structureSheaf R)) h) =
        CategoryTheory.CategoryStruct.comp (CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h))
          (AlgebraicGeometry.StructureSheaf.localizationToStalk R x) :=
  by sorry

The theorem `AlgebraicGeometry.StructureSheaf.localizationToStalk_stalkSpecializes` states that for a commutative ring `R` and two points `x` and `y` in the spectrum of `R` such that `x` specializes to `y`, the composition of the canonical ring homomorphism from the localization of `R` at `y` to the stalk of the structure sheaf at `y` and the natural transformation from the stalk at `y` to the stalk at `x` is equal to the composition of the ring homomorphism from the localization at `y` to the localization at `x` and the canonical ring homomorphism from the localization of `R` at `x` to the stalk of the structure sheaf at `x`. In essence, this is saying that the diagram involving the localization-to-stalk maps and the specialization-induced localizations is commutative in the category of commutative rings.

Given a commutative ring R and points x and y in its spectrum with x specializing to y, the diagram commutes in the category of commutative rings, where the maps are given by the localization-to-stalk homomorphisms and specialization-induced localizations.


theorem eq_tsub_iff_add_eq_of_le :
    ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [inst_2 : ExistsAddOfLE α]
      [inst_3 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [inst_4 : Sub α] [inst_5 : OrderedSub α]
      {a b c : α} [inst_6 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      c ≤ b → (a = b - c ↔ a + c = b) :=
  by sorry

This theorem is about certain properties of an ordered and additive set. For any given type `α`, that forms an additive commutative semigroup, a partial order, and for which addition operation is monotonic and subtraction operation is defined and respects order, if an instance `c` is less than or equal to an instance `b`, then `a` is equal to the difference `b - c` if and only if `a + c` is equal to `b`. In terms of arithmetic, it states that in a setting where all the relevant operations and orderings are defined and behave properly, subtracting a value from another and adding that value back gives you the original number.

For any additive commutative semigroup `α` with monotonic addition and defined subtraction respecting order, if `c ≤ b` then `a = b - c` if and only if `a + c = b`.


theorem Mathlib.RingTheory.Ideal.Operations._auxLemma.15 :
    ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y : M},
      (x ∈ Submodule.span R {y}) = ∃ a, a • y = x :=
  by sorry

The theorem `Mathlib.RingTheory.Ideal.Operations._auxLemma.15` states that for any types `R` and `M`, where `R` is a semiring, `M` is an additive commutative monoid, and `M` is also a module over `R`, for any elements `x` and `y` of `M`, `x` is in the span of the set containing just `y` if and only if there exists a scalar `a` in `R` such that `a` times `y` equals `x`. In other words, `x` is in the span of `{y}` iff `x` is a scalar multiple of `y`.

For any semiring `R`, additive commutative monoid `M`, and `M` being an `R`-module, an element `x` of `M` lies in the span of `{y}` if and only if there exists `a` in `R` such that `x = a * y`.


theorem MvPolynomial.isHomogeneous_X :
    ∀ {σ : Type u_1} (R : Type u_3) [inst : CommSemiring R] (i : σ), MvPolynomial.IsHomogeneous (MvPolynomial.X i) 1 :=
  by sorry

This theorem states that for any type `σ` and any ring `R` that is a commutative semiring, for any `i` of type `σ`, the polynomial `MvPolynomial.X i` is homogeneous of degree 1. In other words, all the monomials in the polynomial `MvPolynomial.X i` have degree 1. In the context of multivariate polynomials, `MvPolynomial.X i` refers to the degree `1` monomial $X_i$, and a multivariate polynomial is considered homogeneous of a certain degree if all monomials that compose it have that same degree.

For any commutative semiring R and type σ, the polynomial Map (MvPolynomial.X) i is a homogeneous polynomial of degree 1, where MvPolynomial.X i is the degree 1 monomial with respect to the variable i in multivariate polynomials.


theorem Derivation.eqOn_adjoin :
    ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
      [inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
      {D1 D2 : Derivation R A M} {s : Set A}, Set.EqOn (⇑D1) (⇑D2) s → Set.EqOn ⇑D1 ⇑D2 ↑(Algebra.adjoin R s) :=
  by sorry

This theorem states that for any commutative semiring `R`, commutative semiring `A`, add-commutative monoid `M`, and any sets `D1` and `D2` of derivations from `R` to `A` to `M`, and any set `s` of `A`, if `D1` and `D2` are equal on `s` (i.e., for all elements `x` in `s`, applying `D1` and `D2` to `x` gives the same result), then `D1` and `D2` are also equal on `Algebra.adjoin R s` (i.e., the minimal subalgebra that includes `s`). In other words, if two derivations agree on a set, they also agree on the smallest subalgebra containing that set.

For any commutative semirings `R` and `A`, add-commutative monoid `M`, sets `D1` and `D2` of derivations from `R` to `A` to `M`, and set `s` of `A`, if `D1` and `D2` agree on `s`, then they agree on the algebra generated by `s`.


theorem Sum.range_eq :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ⊕ β → γ),
      Set.range f = Set.range (f ∘ Sum.inl) ∪ Set.range (f ∘ Sum.inr) :=
  by sorry

This theorem, `Sum.range_eq`, states that for all types `α`, `β`, and `γ` and a function `f` that maps each element of the sum type `α ⊕ β` to `γ`, the range of `f` is equal to the union of the ranges of `f` composed with `Sum.inl` and `f` composed with `Sum.inr`. In other words, all elements of `γ` that `f` can possibly output, regardless of whether the input is from `α` or `β`, are either in the range of `f` when applied to elements of `α` or in the range of `f` when applied to elements of `β`.

For any types `α`, `β`, and `γ`, and a function `f : α ⊕ β → γ`, the range of `f` is equal to the union of the ranges of `f ∘ Sum.inl` and `f ∘ Sum.inr`.


theorem ContinuousMultilinearMap.toMultilinearMap_add :
    ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
      [inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
      [inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
      [inst_7 : ContinuousAdd M₂] (f g : ContinuousMultilinearMap R M₁ M₂),
      (f + g).toMultilinearMap = f.toMultilinearMap + g.toMultilinearMap :=
  by sorry

This theorem states that for any semiring `R`, any type `ι`, any type functions `M₁` from `ι` to some type `w₁`, any type `M₂`, under the conditions that for any `i` in `ι`, `M₁ i` forms an additive commutative monoid, `M₂` is also an additive commutative monoid, `M₁ i` and `M₂` are both `R`-modules, `M₁ i` and `M₂` both have a topological space structure, `M₂` supports continuous addition, and given two continuous multilinear maps `f` and `g` from `R` in the `M₁` space to the `M₂` space, the sum of `f` and `g` as a multilinear map equals the sum of `f` and `g` as multilinear maps separately. In other words, the process of converting a continuous multilinear map to a multilinear map commutes with the operation of addition.

Given any semiring `R`, type `ι`, type functions `M₁ : ι → AddCommMonoid (R-Module topological_space)`, `M₂ : AddCommMonoid (R-Module topological_space)`, and continuous multilinear maps `f, g : R → M₁ i → M₂`, the sum of `f` and `g` as multilinear maps equals their pointwise sum.


theorem Set.mulIndicator_one :
    ∀ {α : Type u_1} (M : Type u_4) [inst : One M] (s : Set α), (Set.mulIndicator s fun x => 1) = fun x => 1 := by sorry

The theorem `Set.mulIndicator_one` states that for any type `α`, for any Monoid `M` with an identity element `1`, and for any set `s` of type `α`, the multiplication indicator of the set `s` with the constant function that always returns `1` is equal to the constant function that always returns `1`. In other words, regardless of whether an element is in set `s` or not, the multiplication indicator will always output `1`.

For any set `s` and monoid `M` with identity `1`, the multiplication indicator of `s` with the constant function mapping to `1` equals the constant function mapping to `1`. In Lean, this is expressed as `Set.mulIndicator s (λ _ => 1) = λ _ => 1`.


theorem MeasureTheory.average_zero_measure :
    ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      (f : α → E), ⨍ (x : α), f x ∂0 = 0 :=
  by sorry

This theorem states that for any function `f` mapping from a measurable space `α` to a normed add commutative group `E` that's a normed space over the real numbers ℝ, the integral (denoted by `⨍`) of `f` with respect to the zero measure (denoted by `∂0`) is always zero. In other words, if you integrate a function over a space with zero measure, the result is zero. This is consistent with the intuitive sense that areas or volumes of "empty" sets are zero.

For any measurable function `f` from a measurable space `α` to a normed add commutative group `E` over ℝ, the integral `⨍f d∂0` is equal to the zero element of `E`.


/-- If `R → A → B` is an algebra tower,
then if the entire tower is an integral extension so is `A → B`.  -/
theorem IsIntegral.tower_top :
    ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [inst_6 : IsScalarTower R A B] {x : B},
      IsIntegral R x → IsIntegral A x :=
  by sorry

The theorem `IsIntegral.tower_top` states that, in the context of an algebra tower from `R` to `A` to `B` where `R` is a commutative ring, `A` is a commutative ring, and `B` is a ring, if the element `x` of `B` is integral over `R` (meaning that `x` is a root of some monic polynomial with coefficients in `R`), then `x` is also integral over `A`. This corresponds to the property that if the entire algebra tower is an integral extension, then the sub-extension from `A` to `B` is also integral.

If `x` is integral over a commutative ring `R`, then `x` is also integral over any commutative subring `A` contained in the ring `R` where `x` is an element.


theorem Set.Finite.encard_eq_coe_toFinset_card :
    ∀ {α : Type u_1} {s : Set α} (h : Set.Finite s), Set.encard s = ↑(Set.Finite.toFinset h).card := by sorry

This theorem states that for any finite set `s` of a certain type `α`, the cardinality of `s` (when represented as a term in `ℕ∞` using `Set.encard`) is equal to the cardinality of the `Finset` representation of `s` (obtained using `Set.Finite.toFinset`). Here, `card` is used to find the cardinality of the `Finset`, and the `↑` operator is used to coerce this natural number to a term in `ℕ∞`. In other words, the theorem ensures that the notion of the size of a finite set is consistent whether we consider the set as a mathematical set or as a finite set in Lean.

For any finite set `s` of type `α`, the cardinality of `s` as represented in `ℕ∞` by `Set.encard` equals the cardinality of the `Finset` representation of `s` obtained using `Set.Finite.toFinset`.