theorem dist_smul₀ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : NormedDivisionRing α] [inst_1 : SeminormedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : BoundedSMul α β] (s : α) (x y : β), dist (s • x) (s • y) = ‖s‖ * dist x y :=
  by sorry

This theorem, `dist_smul₀`, states that for any Normed Division Ring `α`, Seminormed Additive Commutative Group `β`, and given `β` is a module over `α` with bounded scalar multiplication, the distance between two vectors `x` and `y` in `β` when scaled by a scalar `s` from `α` is equal to the product of the norm of the scalar `s` and the original distance between `x` and `y`. In mathematical terms, for all `s`, `x`, and `y`, `dist (s • x) (s • y) = ‖s‖ * dist x y`.

For any Normed Division Ring `α`, Seminormed Additive Commutative Group `β` as an `α`-module with bounded scalar multiplication, the distance between scaled vectors `dist (s • x) (s • y)` equals the product of the norm of the scalar `‖s‖` and the original distance between `x` and `y` `(dist (s • x) (s • y) = ‖s‖ * dist x y)`.


theorem Finset.card_sigmaLift :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
      (f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : (i : ι) × α i) (b : (i : ι) × β i),
      (Finset.sigmaLift f a b).card = if h : a.fst = b.fst then (f (h ▸ a.snd) b.snd).card else 0 :=
  by sorry

The theorem `Finset.card_sigmaLift` states that for any types `ι`, `α`, `β`, `γ`, where `α`, `β`, `γ` are dependent on `ι`, and a function `f` that maps each element `i` of type `ι` with a pair of elements `α i` and `β i` to a finite set of `γ i`, and a pair of elements `a` and `b` formed by an element of `ι` and an element of `α i` and `β i` respectively, the cardinality of the finite set obtained by lifting the function `f` to the pair `a` and `b` is equal to the cardinality of the finite set obtained by applying `f` to the second elements of the pair `a` and `b` if the first elements of `a` and `b` are equal, otherwise it is 0.

For any function `f` mapping elements of type `ι` to finite sets of `γ` indexed by `α` and `β` dependent on `ι`, the cardinality of `f` applied to `(a, b)` where `a` and `b` have equal first components equals the cardinality of `f` applied to `b`, otherwise it is 0.


theorem Set.iInter_iInter_eq_or_left :
    ∀ {α : Type u_1} {β : Type u_2} {b : β} {p : β → Prop} {s : (x : β) → x = b ∨ p x → Set α},
      ⋂ x, ⋂ (h : x = b ∨ p x), s x h = s b ⋯ ∩ ⋂ x, ⋂ (h : p x), s x ⋯ :=
  by sorry

The theorem `Set.iInter_iInter_eq_or_left` states that for any types `α` and `β`, any element `b` of type `β`, any predicate `p` on `β`, and any function `s` mapping each `β` and a proof that it equals `b` or satisfies `p` to a set of `α`, the intersection over all `β` of the intersection over all proofs that the `β` equals `b` or satisfies `p` of `s` applied to the `β` and the proof, is equal to the intersection of `s` applied to `b` and the trivial proof that `b` equals `b` or `b` satisfies `p`, and the intersection over all `β` of the intersection over all proofs that the `β` satisfies `p` of `s` applied to the `β` and the proof. In simpler terms, this theorem essentially states a specific property of intersecting sets given a certain condition or predicate.

For any types `α` and `β`, any element `b` of type `β`, any predicate `p` on `β`, and any function `s`, the intersections of `s` over all proofs that each `β` equals `b` or satisfies `p`, are equal to the intersection of `s` applied to `b` with the trivial proof, and the intersection of `s` over all proofs that each `β` satisfies `p`.


/-- The rank of a finite product of free modules is the sum of the ranks.  -/
theorem rank_pi :
    ∀ {R : Type u} {η : Type u₁'} {φ : η → Type u_1} [inst : Ring R] [inst_1 : StrongRankCondition R]
      [inst_2 : (i : η) → AddCommGroup (φ i)] [inst_3 : (i : η) → Module R (φ i)]
      [inst_4 : ∀ (i : η), Module.Free R (φ i)] [inst_5 : Finite η],
      Module.rank R ((i : η) → φ i) = Cardinal.sum fun i => Module.rank R (φ i) :=
  by sorry

The theorem `rank_pi` states that for any ring `R` satisfying the strong rank condition, any family of additive commutative groups `φ i` indexed by `η` that are also `R`-modules, and any `η` which is finite, if every `φ i` is a free `R`-module, then the rank of the product module - denoted as a function from `η` to `φ` - is equal to the sum of the ranks of the individual `φ i` modules. In other words, the rank of a finite product of free modules is the sum of the ranks.

For any ring satisfying the strong rank condition, the rank of a finite product of free `R`-modules is the sum of the ranks of the individual modules.


theorem contDiff_norm_sq :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst : InnerProductSpace 𝕜 E]
      [inst : NormedSpace ℝ E] {n : ℕ∞}, ContDiff ℝ n fun x => ‖x‖ ^ 2 :=
  by sorry

The theorem `contDiff_norm_sq` states that for any type `𝕜`, any normed additive commutative group `E` over `𝕜`, any inner product space over `E` and `𝕜`, any normed space over `E` and real numbers, and any natural number `n` (which could also be infinite), the function that maps `x` to the square of its norm, `‖x‖ ^ 2`, is `n` times continuously differentiable over real numbers.

For any normed additive commutative group `E` over a field `𝕜`, any inner product space and normed space over `E` and `𝕜`, the function `x ↦ ‖x‖²` is `n`-times continuously differentiable on the real numbers.


theorem PowerSeries.coeff_one :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (PowerSeries.coeff R n) 1 = if n = 0 then 1 else 0 := by sorry

This theorem states that for any semiring `R` and any natural number `n`, the `n`th coefficient of the power series over `R` equals 1 if `n` equals 0 and otherwise it is 0. In other words, it specifies that the only non-zero coefficient in the power series is the one corresponding to `n` equals 0 and it is equal to 1, this power series represents the constant function with value 1.

For any semiring `R`, the power series of the constant function 1 over `R` has exactly one non-zero coefficient, which is 1 at `n = 0`.


theorem Mathlib.Computability.TuringMachine._auxLemma.5 : ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) := by sorry

This theorem states that for any three propositions `a`, `b`, and `c`, the statement "`a` and `b` imply `c`" is equivalent to the statement "`a` implies that `b` implies `c`". In other words, if `a` and `b` are both true, then `c` is true; this is the same as saying that if `a` is true, then if `b` is also true, `c` must be true. This illustrates one of the ways in which logical implications can be chained together.

The theorem asserts that `(a → b) → (a → c) ≡ a → (b → c)` in propositional logic.


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

The theorem `LinearMap.range_coe` states that for any semirings `R` and `R₂`, any additive commutative monoids `M` and `M₂`, any modules `M` over `R` and `M₂` over `R₂`, any ring homomorphism `τ₁₂` from `R` to `R₂`, any function `F` that is like a function from `M` to `M₂`, any semilinear map from `M` to `M₂` over `R` induced by `τ₁₂`, and assuming `τ₁₂` is surjective, the range of a linear map `f` of type `F` as a subtype (coerced to a set) is equal to the set of all outputs (range) of the function corresponding to `f`.

Given a semiring homomorphism τ₁₂, a semilinear map F induced by it between modules M over R and N₂ over R₂, and assuming τ₁₂ is surjective, the range of F as a subtype is equal to the image of M under F.


theorem Mathlib.Computability.TuringMachine._auxLemma.6 :
    ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b := by sorry

This theorem states that for any type `α` and any predicates `p` on `α` and `b`, the proposition that if there exists an `x` of type `α` such that `p x` is true then `b` is true, is equivalent to the proposition that for all `x` of type `α`, if `p x` is true then `b` is true. In LaTeX form it says: $(\exists x \, p(x)) \rightarrow b \equiv \forall x \, (p(x) \rightarrow b)$.

The theorem asserts that existence and universality quantifier logic equivalence holds for predicates `p` on type `α` and proposition `b`, i.e., `(∃x:α. p x) → b ↔ ∀x:α. p x → b`.


theorem CategoryTheory.Adjunction.left_triangle_components_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
      (adj : F ⊣ G) (X : C) {Z : D} (h : F.obj X ⟶ Z),
      CategoryTheory.CategoryStruct.comp (F.map (adj.unit.app X))
          (CategoryTheory.CategoryStruct.comp (adj.counit.app (F.obj X)) h) =
        h :=
  by sorry

This theorem is about the "left triangle identity" in category theory. It states that, given categories `C` and `D` with functors `F` from `C` to `D` and `G` from `D` to `C` forming an adjunction (that is, `F` is left adjoint to `G`), for any object `X` in `C` and morphism `h` from the image of `X` under `F` to some object `Z` in `D`, composing the morphism given by applying `F` to the unit of the adjunction at `X` with the composition of the counit of the adjunction at `F(X)` and `h`, is the same as `h` itself. In terms of the usual diagrammatic formulation of the triangle identities, this corresponds to the fact that one can go directly from `F(X)` to `Z`, or alternatively first go via `G(F(F(X)))` and then to `Z`, and the two routes give the same result.

Given functors `F: C -> D` and `G: D -> C` forming an adjunction, for any object `X` in `C` and morphism `h: F(X) -> Z` in `D`, the composition of `F(μX)` and `h`, and the composition of `h` with `γ(F(X))`, are equal in `D`, where `μX` is the unit of the adjunction at `X` and `γ(F(X))` is the counit of the adjunction at `F(X)`.


theorem isUnit_of_map_unit :
    ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) [inst_2 : IsLocalRingHom f]
      (a : R), IsUnit (f a) → IsUnit a :=
  by sorry

The theorem `isUnit_of_map_unit` states that for any two types `R` and `S`, which are semirings, and a function `f` which is a local ring homomorphism from `R` to `S`, if an element `a` of `R` maps to a unit in `S` under `f`, then `a` itself is a unit in `R`. In other words, the unitness of an element in the codomain of a local ring homomorphism implies the unitness of its preimage.

If `f` is a local ring homomorphism from semiring `R` to semiring `S`, and `a` in `R` maps to a unit in `S`, then `a` is a unit in `R`.


theorem AddUnits.continuous_iff :
    ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [inst_2 : TopologicalSpace X]
      {f : X → AddUnits M}, Continuous f ↔ Continuous (AddUnits.val ∘ f) ∧ Continuous fun x => ↑(-f x) :=
  by sorry

The theorem `AddUnits.continuous_iff` states that for any types `M` and `X` where `M` is both a topological space and an additive monoid, and `X` is a topological space, and given a function `f` from `X` to `AddUnits M` (where `AddUnits M` refers to the additive units in the additive monoid `M`), the function `f` is continuous if and only if both the composition of `AddUnits.val` and `f` is continuous, and the function that takes `x` in `X` to the additive inverse of `f(x)` is continuous. In simpler terms, it connects the continuity of a function into the additive units of a topological additive monoid with the continuity of two related functions.

A function from a topological space to the additive units of a topological additive monoid is continuous if and only if the composition of the valuation map and the function, and the function that maps each point to the additive inverse of the image of that point, are both continuous.


theorem ofAdd_zero : ∀ {α : Type u} [inst : Zero α], Multiplicative.ofAdd 0 = 1 := by sorry

The theorem `ofAdd_zero` states that for any type `α` equipped with a zero element, if we reinterpret the zero element of `α` as an element of `Multiplicative α` using the function `Multiplicative.ofAdd`, we get the multiplicative identity, which is `1`. This theorem essentially shows a correspondence between the additive identity (zero) in the original type `α` and the multiplicative identity (one) in the reinterpreted `Multiplicative α` type.

For any additive type `α` with zero element `0`, `Multiplicative.ofAdd 0 = 1` in `Multiplicative α`.


CommGroupCat.ext

theorem CommGroupCat.ext : ∀ {X Y : CommGroupCat} {f g : X ⟶ Y}, (∀ (x : ↑X), f x = g x) → f = g := by sorry

This theorem states that for any two commutative groups `X` and `Y` in the category of commutative groups (`CommGroupCat`), and any two morphisms `f` and `g` from `X` to `Y`, if the application of `f` and `g` to any element `x` of `X` gives the same result, then `f` and `g` must be the same morphism. In other words, two morphisms in the category of commutative groups are equal if they have the same action on all elements of the domain group.

In the category of commutative groups, two morphisms between groups are equal if and only if they map every element in the domain to the same image.


theorem IsUnit.unit_of_val_units : ∀ {M : Type u_1} [inst : Monoid M] {a : Mˣ} (h : IsUnit ↑a), IsUnit.unit h = a := by
  sorry

This theorem, `IsUnit.unit_of_val_units`, states that for any type `M` that has a `Monoid` structure and for any element `a` in the group of units `Mˣ` that is also a unit in the `Monoid` `M` (as specified by the predicate `IsUnit`), the unit of `a` in the `Monoid` (as obtained from the function `IsUnit.unit`) is equal to `a` itself. In other words, if `a` is a unit (i.e., it has a two-sided inverse) in the `Monoid` `M`, then the unit of `a` derived from `IsUnit.unit` is just `a`.

For any type `M` with a `Monoid` structure and any unit `a` in `Mˣ` that is also a unit in `M`, `IsUnit.unit a = a`.


theorem MvPowerSeries.coeff_mul_monomial :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (m n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R),
      (MvPowerSeries.coeff R m) (φ * (MvPowerSeries.monomial R n) a) =
        if n ≤ m then (MvPowerSeries.coeff R (m - n)) φ * a else 0 :=
  by sorry

This theorem states that for any types `σ` and `R`, and given a semiring instance on `R`, if we have two functions `m` and `n` from `σ` to natural numbers, a multivariate formal power series `φ` over `σ` and `R`, and a coefficient `a` from `R`, then the `m`th coefficient of the product of `φ` and the `n`th monomial with coefficient `a` is equal to the product of the `(m-n)`th coefficient of `φ` and `a` if `n` is less than or equal to `m`, and is zero otherwise. This theorem describes how the coefficients of the product of a multivariate formal power series and a monomial are distributed.

For any semiring `R`, type `σ`, and functions `m` and `n` from `σ` to natural numbers, if `φ` is a multivariate formal power series over `σ` and `R`, and `a` is a coefficient from `R`, then the coefficient of the `m`th monomial of `φ * (a * ∏ (x_i ^ n_i))` is `a * (coefficient_m φ)` if `n_i <= m_i` for all `i`, and is zero otherwise.


theorem CategoryTheory.MonoidalNatTrans.unit_assoc :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
      {D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
      {F G : CategoryTheory.LaxMonoidalFunctor C D} (self : CategoryTheory.MonoidalNatTrans F G) {Z : D}
      (h : G.obj (𝟙_ C) ⟶ Z),
      CategoryTheory.CategoryStruct.comp F.ε (CategoryTheory.CategoryStruct.comp (self.app (𝟙_ C)) h) =
        CategoryTheory.CategoryStruct.comp G.ε h :=
  by sorry

The theorem `CategoryTheory.MonoidalNatTrans.unit_assoc` states that for any two lax monoidal functors `F` and `G` from a monoidal category `C` to another monoidal category `D`, and a monoidal natural transformation `self` from `F` to `G`, if we have a morphism `h` from the monoidal unit object of `G` to any object `Z` of `D`, then the composition of the unit morphism of `F`, `self` applied to the unit object of `C`, and `h` is equal to the composition of the unit morphism of `G` and `h`. This is a property of natural transformations between lax monoidal functors in category theory.

For any lax monoidal functors F and G between monoidal categories C and D, and a monoidal natural transformation self from F to G, the composition of the unit morphism of F, self applied to the unit object of C, and any morphism h from the unit object of G to an object Z in D equals the composition of the unit morphism of G and h.


theorem ENNReal.measurable_of_measurable_nnreal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : ENNReal → α}, (Measurable fun p => f ↑p) → Measurable f := by sorry

This theorem states that for any measurable space `α` and any function `f` mapping from the extended nonnegative real numbers (`ENNReal`) to `α`, if the function `f` is measurable when applied to the embedding of nonnegative real numbers (denoted as `↑p`) into `ENNReal`, then `f` is measurable. Here, a function is called measurable if the preimage of every measurable set is also measurable. Essentially, this theorem allows us to conclude that a function is measurable in the extended nonnegative reals if it is measurable in the nonnegative reals.

If a function from the extended nonnegative real numbers to a measurable space is measurable when mapped from the nonnegative real numbers embedding, then it is measurable.


/-- Coercion from `C(X, Y)` with compact-open topology to `X → Y` with pointwise convergence
topology is a continuous map.

Porting note: merged `continuous_coe` with `continuous_coe'` removing unneeded assumptions.  -/
theorem ContinuousMap.continuous_coe :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      Continuous DFunLike.coe :=
  by sorry

This theorem states that for all types `X` and `Y`, given that `X` and `Y` are both topological spaces, the coercion from type `C(X, Y)` (where 'C' represents collections of continuous functions between `X` and `Y` with the compact-open topology) to type `X → Y` (representing functions from `X` to `Y` with the pointwise convergence topology) is a continuous map. This is essentially stating that the process of coercion preserves the topological structure, which is crucial in the study of topological spaces. The note also mentions that this theorem is a port of two previously separate theorems, `continuous_coe` and `continuous_coe'`, where some unnecessary assumptions have been removed.

The coercion from the type of continuous functions between topological spaces X and Y with compact-open topology to the type of functions from X to Y with pointwise convergence topology is a continuous map.


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

The theorem `BoxIntegral.Prepartition.iUnion_biUnion` states that for any type `ι`, given a box `I` of type `BoxIntegral.Box ι`, a prepartition `π` of `I`, and a function `πi` that returns a prepartition for each box `J` of type `BoxIntegral.Box ι`, the union of the boxes of the prepartition obtained by bisecting `π` using `πi` (`BoxIntegral.Prepartition.biUnion π πi`) is equal to the union of the unions of the boxes of the prepartitions returned by `πi` for each box `J` in `π`. In other words, bisecting the prepartition and then taking the union gives the same result as taking the union of the prepartitions for each box first and then taking the union.

For any type ι, given a box I of type BoxIntegral.Box ι, a prepartition π of I, and a function πi that returns a prepartition for each box J of type BoxIntegral.Box ι, the union of the boxes in BoxIntegral.Prepartition.biUnion π πi equals the union of the unions of the boxes in the prepartitions returned by πi for each J in π.


theorem MeasureTheory.levyProkhorovDist_comm :
    ∀ {Ω : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : PseudoEMetricSpace Ω] (μ ν : MeasureTheory.Measure Ω),
      MeasureTheory.levyProkhorovDist μ ν = MeasureTheory.levyProkhorovDist ν μ :=
  by sorry

The theorem `MeasureTheory.levyProkhorovDist_comm` states that for any measurable space `Ω` and any pseudo emetric space structure on `Ω`, for any two measures `μ` and `ν` on `Ω`, the Lévy-Prokhorov distance between `μ` and `ν` is the same as the Lévy-Prokhorov distance between `ν` and `μ`. In other words, the Lévy-Prokhorov distance is commutative with respect to the measures.
The Lévy-Prokhorov distance is defined as the infimum of all `r ≥ 0` such that for all measurable sets `B`, `μ B ≤ ν Bᵣ + r` and `ν B ≤ μ Bᵣ + r`, where `Bᵣ` denotes the `r`-enlargement of `B`.

The Lévy-Prokhorov distance between measures `μ` and `ν` on a measurable space `Ω` with a pseudo metric is equal to the Lévy-Prokhorov distance between `ν` and `μ`.


theorem Asymptotics.IsLittleO.inv_rev :
    ∀ {α : Type u_1} {𝕜 : Type u_15} {𝕜' : Type u_16} [inst : NormedDivisionRing 𝕜] [inst_1 : NormedDivisionRing 𝕜']
      {l : Filter α} {f : α → 𝕜} {g : α → 𝕜'},
      f =o[l] g → (∀ᶠ (x : α) in l, f x = 0 → g x = 0) → (fun x => (g x)⁻¹) =o[l] fun x => (f x)⁻¹ :=
  by sorry

This theorem, `Asymptotics.IsLittleO.inv_rev`, states that for any normed division rings `𝕜` and `𝕜'`, and any functions `f : α → 𝕜` and `g : α → 𝕜'` that are asymptotically equal almost everywhere on a filter `l` (i.e., `f =o[l] g`), if `f(x) = 0` implies that `g(x) = 0` almost everywhere on `l`, then the function `g` inverted (1/g(x)) is asymptotically equal to the function `f` inverted (1/f(x)) almost everywhere on `l`. In other words, if `f` and `g` are asymptotically equivalent and their zeros coincide almost everywhere, then their inverses are also asymptotically equivalent.

If functions `f : α → 𝕜` and `g : α → 𝕜'` are asymptotically equal almost everywhere on a filter `l` and `f(x) = 0` if and only if `g(x) = 0` almost everywhere on `l`, then `1/f` is asymptotically equal to `1/g` almost everywhere on `l`.


theorem List.exists_of_eraseP :
    ∀ {α : Type u_1} {p : α → Bool} {l : List α} {a : α},
      a ∈ l →
        p a = true → ∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b = true) ∧ p a = true ∧ l = l₁ ++ a :: l₂ ∧ List.eraseP p l = l₁ ++ l₂ :=
  by sorry

The theorem `List.exists_of_eraseP` states that for any type `α`, any predicate `p` from `α` to `Bool`, any list `l` of α, and any element `a` of α, if `a` is an element of `l` and `p(a)` equals true, then there exist elements `a`, `l₁`, and `l₂` such that for all `b` in `l₁`, `p(b)` is not true, `p(a)` is true, `l` is the concatenation of `l₁`, `a`, and `l₂`, and the list obtained upon erasing the first element in `l` that satisfies `p` equals the concatenation of `l₁` and `l₂`. In other words, if a list contains an element that satisfies a certain predicate, we can split the list into two parts where the first part contains no element satisfying the predicate and the second part starts with the first element satisfying the predicate; then, removing the first satisfying element from the list will result in the concatenation of the two parts.

If a list `l` of type `α` contains an element `a` such that `p(a) = true` and there exists no `b` in the prefix of `l` with `p(b) = true`, then removing the first such `a` from `l` results in the concatenation of the list of elements with `p(x) = false` and the list starting with `a`.


Summable.norm

/-- **Alias** of the reverse direction of `summable_norm_iff`.

---

In a finite dimensional vector space over `ℝ`, the series `∑ x, ‖f x‖` is unconditionally
summable if and only if the series `∑ x, f x` is unconditionally summable. One implication holds in
any complete normed space, while the other holds only in finite dimensional spaces.  -/
theorem Summable.norm :
    ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : FiniteDimensional ℝ E] {f : α → E}, Summable f → Summable fun x => ‖f x‖ :=
  by sorry

This theorem, named `Summable.norm`, states that in a finite-dimensional vector space over the real numbers (`ℝ`), a series whose terms are the norm of the function `f(x)`, denoted as `∑ x, ‖f x‖`, is unconditionally summable if and only if the series whose terms are the function `f(x)` itself, denoted as `∑ x, f x`, is unconditionally summable. It is important to note that one implication of this theorem is valid in any complete normed space, while the other implication is only valid in finite-dimensional spaces.

In a finite-dimensional real vector space, the unconditional summability of series of the functions' norms is equivalent to the unconditional summability of the functions themselves.


theorem Submodule.quotEquivOfEq.proof_1 :
    ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      (p p' : Submodule R M), p = p' → ∀ (a b : M), Setoid.r a b ↔ Setoid.r ((Equiv.refl M) a) ((Equiv.refl M) b) :=
  by sorry

The theorem `Submodule.quotEquivOfEq.proof_1` states that for any two submodules `p` and `p'` of a module `M` over a ring `R`, if `p` is equal to `p'`, then for any two elements `a` and `b` of the module `M`, the equivalence relation `Setoid.r` between `a` and `b` is the same as the equivalence relation `Setoid.r` between `a` and `b` under the identity equivalence relation on `M` (i.e., where each element of `M` is mapped to itself). In essence, it says that the identity map does not affect the equivalence relationship between elements of the module.

For any submodules `p` and `p'` of a module `M` over a ring `R`, if `p = p'`, then the equivalence relations `Setoid.r` on `M` induced by `p` and `p'` are equal.


theorem HasDerivWithinAt.congr_of_eventuallyEq :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
      HasDerivWithinAt f f' s x → f₁ =ᶠ[nhdsWithin x s] f → f₁ x = f x → HasDerivWithinAt f₁ f' s x :=
  by sorry

The theorem `HasDerivWithinAt.congr_of_eventuallyEq` states that for a given type `𝕜` with a nontrivial normed field, a type `F` with a normed additive commutative group and normed space over `𝕜`, two functions `f` and `f₁` from `𝕜` to `F`, a derivative function `f'` of type `F`, a point `x` of type `𝕜`, and a set `s` of type `𝕜`, if `f` has a derivative `f'` at the point `x` within the subset `s`, and `f₁` eventually equals `f` (i.e., `f₁` equals `f` in a neighborhood of `x` within `s`), and `f₁` at `x` equals `f` at `x`, then `f₁` also has the derivative `f'` at the point `x` within the set `s`.

In other words, if two functions coincide in a neighborhood of a point where the first function has a derivative, and they also have the same value at that point, then the second function has the same derivative at that point within the same neighborhood.

If `f` has a derivative `f'` at `x` within `s` in the normed space `F` over the nontrivial normed field `𝕜`, and `f₁` eventually equals `f` in `s` and `f₁(x) = f(x)`, then `f₁` has the derivative `f'` at `x` within `s`.


theorem BoxIntegral.Box.coe_splitUpper :
    ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {i : ι} {x : ℝ},
      ↑(BoxIntegral.Box.splitUpper I i x) = ↑I ∩ {y | x < y i} :=
  by sorry

This theorem states that for any given box `I`, index `i`, and real number `x`, the box obtained by splitting `I` at the hyperplane `{y : ι → ℝ | y i = x}` and taking the portion where `y i > x` (which is given by the `BoxIntegral.Box.splitUpper` function) is exactly equal to the intersection of the original box `I` with the set `{y | x < y i}`. In other words, `BoxIntegral.Box.splitUpper` function correctly computes the upper half of the box `I` split by the hyperplane determined by `i` and `x`.

For any box `I`, index `i`, and real number `x`, `BoxIntegral.Box.splitUpper I i x` equals the intersection of `I` with the set `{y : ι → ℝ | x < y i}` where `ι` is the type of indices of `I`.


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

This theorem, `inf_congr_right`, states that for any type `α` that is a semilattice with an infimum (or greatest lower bound) operation, and for any three elements `a`, `b`, and `c` of this type, if `b` infimum `c` is less than or equal to `a` and `a` infimum `c` is less than or equal to `b`, then `a` infimum `c` is equal to `b` infimum `c`. In other words, in a semilattice, if the infimum of `b` and `c` doesn't exceed `a` and the infimum of `a` and `c` doesn't exceed `b`, then both infimums are equal.

In a semilattice, if `a` has infimum both with `b` and `c` and these infima are equal, then `a` infimum `b` = `a` infimum `c` = `b` infimum `c`.


IsTrichotomous.swap

theorem IsTrichotomous.swap :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsTrichotomous α r], IsTrichotomous α (Function.swap r) := by sorry

The theorem `IsTrichotomous.swap` states that for any type `α` and a relation `r : α → α → Prop` such that `r` is trichotomous, the function `Function.swap r`, which reverses the order of the arguments of `r`, is also trichotomous. In mathematical terms, a relation is trichotomous if for any two elements `a` and `b` of type `α`, exactly one of the following is true: `r a b`, `r b a` or `a = b`. Thus, the theorem is saying that reversing the order of arguments doesn't affect the trichotomous property of the relation.

If `r : α → α → Prop` is a trichotomous relation, then `Function.swap r` is also a trichotomous relation.


theorem MeasureTheory.L1.integrable_coeFn :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
      (f : ↥(MeasureTheory.Lp β 1 μ)), MeasureTheory.Integrable (↑↑f) μ :=
  by sorry

This theorem states that for any measure space `(α, m, μ)`, and any normed addition commutative group `β`, if `f` is an element of the `Lp` space `L1` for `β` with respect to measure `μ`, then the function `f` (represented by its equivalence class under the almost-everywhere equivalence relation in `↥(MeasureTheory.Lp β 1 μ)`) is integrable. In more mathematical terms, `f` is both almost everywhere strongly measurable and has a finite integral, where the integral is defined as `∫⁻ a, ‖f a‖ ∂μ` and it is finite.

If `f` is an `L1` function in the `Lp` space `L1(μ, β)` of a measure space `(α, m, μ)`, then `f` is integrable, i.e., it is almost everywhere measurable and has a finite integral with respect to `μ`.


theorem CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex C} (h : CategoryTheory.ShortComplex.LeftHomologyData S)
      [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso h).inv
          (CategoryTheory.ShortComplex.iCycles S) =
        h.i :=
  by sorry

This theorem states that for any category `C` with zero morphisms, and for any short complex `S` in `C` that has a left homology, the composition of the inverse of the cycles isomorphism from the left homology data of `S` and the inclusion from the cycles to the second object in `S` is equal to the inclusion from the cycles to the left homology. In simpler terms, it's a statement about the relationship between the structure of a short complex (a specific type of diagram in a category) and its homology (a way to measure its 'holes').

For any short complex in a category with zero morphisms, the inclusion of cycles into the complex is equal to the composition of the cycles isomorphism and its inverse from the left homology data.


theorem Multiset.prod_eq_zero_iff :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NoZeroDivisors α] [inst_2 : Nontrivial α] {s : Multiset α},
      Multiset.prod s = 0 ↔ 0 ∈ s :=
  by sorry

This theorem states that for any multiset `s` of elements from a type `α`, where `α` is a commutative monoid with zero, has no zero divisors, and is nontrivial, the product of the elements in `s` equals zero if and only if zero is an element of `s`. In other words, the product of a multiset is zero if and only if the multiset contains zero, under the given conditions for the type of the elements.

For a commutative monoid with zero and no zero divisors and nontrivial elements, a multiset of such elements has product equal to zero if and only if it contains the zero element.


RingCon.refl

theorem RingCon.refl : ∀ {R : Type u_2} [inst : Add R] [inst_1 : Mul R] (c : RingCon R) (x : R), c x x := by sorry

This theorem, `RingCon.refl`, states that for all types `R` that have both addition and multiplication operations, and for any `RingCon` relation `c` on `R` and any element `x` from `R`, `c` is reflexive. In other words, `x` is related to itself under the `RingCon` relation `c`. This is analogous to the reflexive property in mathematics where for any element `x` in a set, `x` is always related to itself.

For any relation `c` on a type `R` with addition and multiplication operations, `c` is reflexive, that is, for all `x` in `R`, `x` is related to `x` under `c`.


theorem CliffordAlgebra.map_comp_map :
    ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} {M₃ : Type u_6} [inst_1 : AddCommGroup M₁]
      [inst_2 : AddCommGroup M₂] [inst_3 : AddCommGroup M₃] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
      [inst_6 : Module R M₃] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} {Q₃ : QuadraticForm R M₃}
      (f : Q₂ →qᵢ Q₃) (g : Q₁ →qᵢ Q₂),
      AlgHom.comp (CliffordAlgebra.map f) (CliffordAlgebra.map g) =
        CliffordAlgebra.map (QuadraticForm.Isometry.comp f g) :=
  by sorry

The theorem `CliffordAlgebra.map_comp_map` states that for any three types `M₁`, `M₂`, and `M₃` that are equipped with the structure of an additive commutative group and a module over a commutative ring `R`, and any three quadratic forms `Q₁`, `Q₂`, and `Q₃` over these respective modules, if there exists an isometry `f` from `Q₂` to `Q₃` and an isometry `g` from `Q₁` to `Q₂`, then the composition of the algebra homomorphisms induced by `map` operation on `f` and `g` in the Clifford algebra is equal to the algebra homomorphism induced by the `map` operation on the composition of `f` and `g`. This theorem essentially establishes the compatibility of the `map` operation in the Clifford algebra with the composition of isometries.

Given isometries \(f: Q₂ \to Q₃\) and \(g: Q₁ \to Q₂\) between quadratic forms over additive commutative groups \(M₁, M₂, M₃\) over a commutative ring \(R\), the induced homomorphisms in the Clifford algebra commute: \(Cl(g) \circ Cl(f) = Cl(f \circ g)\).


theorem hasDerivAt_inv :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜}, x ≠ 0 → HasDerivAt (fun y => y⁻¹) (-(x ^ 2)⁻¹) x := by
  sorry

This theorem states that for any non-zero point `x` from a non-trivially normed field `𝕜`, the function given by the reciprocal of `y` has a derivative at `x`, where the derivative is the negative reciprocal of the square of `x`. In mathematical terms, if `y = y⁻¹` then the derivative of `y` at `x` is `-(x ^ 2)⁻¹`, provided `x ≠ 0`.

For any non-zero element `x` in a non-trivially normed field, the reciprocal function has a derivative equal to the negative reciprocal of the square of `x` at `x`.


theorem existsUnique_add_zsmul_mem_Ioc :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [inst_1 : Archimedean α] {a : α},
      0 < a → ∀ (b c : α), ∃! m, b + m • a ∈ Set.Ioc c (c + a) :=
  by sorry

This theorem, `existsUnique_add_zsmul_mem_Ioc`, states that for any type `α` which forms a linear ordered additive commutative group and is Archimedean, given any element `a` of that type such that `0 < a`, for any two elements `b` and `c` of that type, there exists a unique integer `m` such that `b + m • a` lies in the left-open right-closed interval from `c` to `c + a`. This means that by multiplying `a` by some integer `m` and adding the result to `b`, we end up with a value that is strictly greater than `c` and less than or equal to `c + a`.

For any Archimedean additive commutative group type `α` with a positive element `a`, and for all `b` and `c` in `α` with `0 < a` and `c < b`, there exists a unique integer `m` such that `b + m*a ∈ (c, c + a]`.


theorem Finset.subset_iff_eq_of_card_le : ∀ {α : Type u_1} {s t : Finset α}, t.card ≤ s.card → (s ⊆ t ↔ s = t) := by
  sorry

This theorem states that for any two finite sets `s` and `t` of any type `α`, if the cardinality (or size) of `t` is less than or equal to the cardinality of `s`, then `s` is a subset of `t` if and only if `s` is equal to `t`. Essentially, it's saying that if a set `t` has the same size or larger compared to another set `s`, the only way for `s` to be a subset of `t` is that they are actually the same set.

For finite sets `s` and `t` of type `α`, if `|s| ≤ |t|`, then `s ⊆ t` if and only if `s = t`.


theorem MvPolynomial.bind₁_bind₁ :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [inst : CommSemiring R] {υ : Type u_6} (f : σ → MvPolynomial τ R)
      (g : τ → MvPolynomial υ R) (φ : MvPolynomial σ R),
      (MvPolynomial.bind₁ g) ((MvPolynomial.bind₁ f) φ) =
        (MvPolynomial.bind₁ fun i => (MvPolynomial.bind₁ g) (f i)) φ :=
  by sorry

The theorem `MvPolynomial.bind₁_bind₁` states that for any types `σ`, `τ`, `υ`, and `R` with `R` being a commutative semiring, and for any functions `f : σ → MvPolynomial τ R`, `g : τ → MvPolynomial υ R`, and a multivariate polynomial `φ : MvPolynomial σ R`, the composition of the binding operation `bind₁` with `g` and then with `f` applied to φ is the same as the binding operation `bind₁` applied to the composition of `g` and `f` applied to each element `i`, then applied to `φ`.

In other words, this theorem assures the associativity property of the `bind₁` operation in the context of multivariate polynomials.

For any commutative semiring R and multivariate polynomials φ : MvPolynomial σ R, f : σ → MvPolynomial τ R, and g : τ → MvPolynomial υ R, the binding operations bind₁(g)∘bind₁(f)(φ) and bind₁(g∘f)(φ) are equal.


theorem Monoid.exponent_eq_zero_iff :
    ∀ {G : Type u} [inst : Monoid G], Monoid.exponent G = 0 ↔ ¬Monoid.ExponentExists G := by sorry

The theorem `Monoid.exponent_eq_zero_iff` states that for any given monoid `G`, the exponent of `G` is zero if and only if there does not exist a positive integer `n` such that raising any element of `G` to the power `n` results in the identity element. In terms of the monoid, this means there is no common positive exponent to which every element in the monoid can be raised to yield the identity.

A monoid has exponent 0 if and only if there is no positive integer n such that every element raised to the power n equals the identity.


theorem Set.mem_star : ∀ {α : Type u_1} {s : Set α} {a : α} [inst : Star α], a ∈ star s ↔ star a ∈ s := by sorry

This theorem, `Set.mem_star`, states that for all types `α` and any set `s` of type `α` and any element `a` of the same type, given that `α` has a star operation, then `a` is in the star of `s` if and only if the star of `a` is in `s`. Here the "star" could be any unary operation that forms a semigroup or monoid on the type `α`. For example, in the case of strings, "star" could be the operation of reversing the string.

For any type `α` with a star operation, and set `s` of type `α`, an element `a` is in the star of `s` if and only if the star of `a` is in `s`.


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

This theorem, named `Mathlib.Data.Finset.Basic._auxLemma.99`, asserts that for any three propositions 'a', 'b', and 'c', the conditional that 'c' follows from 'a' and 'b' being true simultaneously, is logically equivalent to the statement that if 'a' is true then 'c' follows from 'b' being true. In other words, `(a ∧ b → c)` is the same as `(a → b → c)`.

The theorem asserts that `(a ∧ b → c)` is logically equivalent to `(a → (b → c))`.


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

This theorem states that in the realm of propositional logic, the order of conjunctions does not affect the truth value of the overall statement. More specifically, for any propositions `a`, `b`, and `c`, the conjunction `a ∧ b ∧ c` (read as "a and b and c") is logically equivalent to the conjunction `b ∧ a ∧ c` (read as "b and a and c"). This is a demonstration of the commutative property of conjunction in logic.

In propositional logic, the order of conjuncted propositions does not affect their truth value, i.e., `a ∧ b ∧ c` is logically equivalent to `b ∧ a ∧ c` for all propositions `a`, `b`, and `c`.


theorem NormedField.exists_lt_norm : ∀ (α : Type u_1) [inst : NontriviallyNormedField α] (r : ℝ), ∃ x, r < ‖x‖ := by
  sorry

This theorem states that for any real number `r` and any non-trivial normed field `α`, there exists an element `x` in `α` such that the norm of `x` is greater than `r`. In other words, in every non-trivial normed field, one can find an element whose norm (also known as length or magnitude) exceeds any given real number.

In every non-trivial normed field, there exists an element with a norm greater than any given real number.


Filter.Tendsto.cons

theorem Filter.Tendsto.cons :
    ∀ {β : Type u_2} [inst : TopologicalSpace β] {α : Type u_3} {f : α → β} {g : α → List β} {a : Filter α} {b : β}
      {l : List β},
      Filter.Tendsto f a (nhds b) →
        Filter.Tendsto g a (nhds l) → Filter.Tendsto (fun a => f a :: g a) a (nhds (b :: l)) :=
  by sorry

This theorem, denoted as `Filter.Tendsto.cons`, states that for any two functions `f` and `g` mapping from a type `α` to a topological space `β` and a list of `β` respectively, and given a filter `a` on `α` and elements `b` of `β` and `l` being a list of `β`, if `f` tends to `b` with respect to filter `a` and `g` tends to `l` with respect to filter `a`, then the function that takes an element of `α` and maps it to the list obtained by adding `f(a)` in front of `g(a)` also tends to the list obtained by adding `b` in front of `l` with respect to filter `a`. In simpler terms, it states that if each function tends to its respective limit under a particular filter, then the function that forms a list by combining the outputs also tends to the list formed by combining the limits.

If functions `f : α -> β` and `g : α -> β^List` tend to `b : β` and `l : β^List` respectively under filter `a : Filter α`, then the function that concatenates `[f a]` and `g a` tends to `[b] ++ l` under filter `a`. (Here, `++` denotes list concatenation, `β^List` denotes the type of lists of `β`, and `[x]` denotes the singleton list containing `x`.)


theorem Mathlib.Data.Finset.Basic._auxLemma.10 : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (↑s₁ ⊆ ↑s₂) = (s₁ ⊆ s₂) := by
  sorry

This theorem from the Mathlib library in Lean 4 states that for any two finite sets (`Finset`) `s₁` and `s₂` of any type `α`, the condition that the set `s₁` is a subset of `s₂` (expressed as `↑s₁ ⊆ ↑s₂`, where `↑` denotes the coercion of a `Finset` to a `Set`) is equivalent to the condition that `s₁` is a subset of `s₂` in the `Finset` sense (expressed as `s₁ ⊆ s₂`). Thus, the subset relation holds in the same way for finite sets whether they are considered as `Set`s or as `Finset`s.

The theorem asserts that for any two finite sets `s₁` and `s₂` of type `α`, the relation `s₁ ⊆ s₂` holding in the `Finset` sense is equivalent to `↑s₁ ⊆ ↑s₂` holding as sets, where `↑` denotes the coercion of `Finset` to `Set`.


/-- The first of two points lies in their affine span.  -/
theorem left_mem_affineSpan_pair :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] (p₁ p₂ : P), p₁ ∈ affineSpan k {p₁, p₂} :=
  by sorry

This theorem states that for any given ring `k` and a set of two points `p₁` and `p₂` in an affine space `P` (where `P` is an additive torsor over a vector space `V`, which in turn is a module over the ring `k`), the first point `p₁` always lies in the affine span of these two points. The affine span of a set of points is the smallest affine subspace that contains those points.

For any ring `k`, affine space `P` over a vector space `V` as an additive torsor over `k`, and two points `p₁` and `p₂` in `P`, `p₁` lies in the affine span of `p₁` and `p₂`.


theorem Pi.support_single_subset :
    ∀ {A : Type u_1} {B : Type u_2} [inst : DecidableEq A] [inst_1 : Zero B] {a : A} {b : B},
      Function.support (Pi.single a b) ⊆ {a} :=
  by sorry

The `Pi.support_single_subset` theorem states that for any types `A` and `B`, where `A` has decidable equality and `B` has a zero element, and any elements `a` of type `A` and `b` of type `B`, the support of the function `Pi.single a b` (which is the function that equals `b` at `a` and zero elsewhere) is a subset of the set containing only `a`. In other words, the only point where `Pi.single a b` is non-zero is at `a`.

The support of `Pi.single a b` in Lean, where `A` has decidable equality and `B` has a zero element, is the singleton set `{a}`.


theorem Mathlib.Data.Finset.Basic._auxLemma.25 : ∀ {α : Type u_1} {s : Finset α}, (¬s.Nonempty) = (s = ∅) := by sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.25`, states that for any type `α` and any finite set `s` of type `α`, the property that `s` is not nonempty is equivalent to the property that `s` is empty. In other words, a finite set is not nonempty if and only if it is the empty set.

A finite set is nonempty if and only if it is not empty. (Equivalently, a finite set is empty if and only if it is not nonempty.)


theorem Mathlib.Data.Finset.Basic._auxLemma.26 : ∀ {α : Type u_1} {s : Finset α}, (↑s = ∅) = (s = ∅) := by sorry

This theorem, `Mathlib.Data.Finset.Basic._auxLemma.26`, states that for any type `α` and any finite set `s` of that type, the condition that the coercion of `s` to a set is equivalent to an empty set is the same as saying that `s` itself is an empty set. In other words, a finite set `s` is empty if and only if its set-coerced version is also empty. This is a property of the coercion function for finite sets in Lean.

For any type α, a finite set s of type α is empty if and only if its set-coerced version is an empty set.


theorem IntermediateField.finrank_eq_one_iff :
    ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
      {K : IntermediateField F E}, FiniteDimensional.finrank F ↥K = 1 ↔ K = ⊥ :=
  by sorry

The theorem `IntermediateField.finrank_eq_one_iff` states that, for any field `F`, field `E`, and algebra structure for `E` over `F`, and for any intermediate field `K` of `E` over `F`, the rank of the module `K` over `F` (or in other words, the finite dimension of the vector space `K` over `F`) is equal to 1 if and only if `K` is the bottom intermediate field. The "bottom intermediate field" here refers to the smallest possible intermediate field, usually containing just the zero element and the multiplicative identity.

For any field extension `F`⊆`E` and algebra structure on `E` over `F`, the rank of the intermediate field `K` over `F` equals 1 if and only if `K` is the smallest intermediate field containing only the zero element and the multiplicative identity.


theorem Ordinal.IsFundamentalSequence.cof_eq :
    ∀ {a o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{u}},
      Ordinal.IsFundamentalSequence a o f → Cardinal.ord (Ordinal.cof a) = o :=
  by sorry

The theorem `Ordinal.IsFundamentalSequence.cof_eq` states that for any ordinal `a` and `o`, and a function `f` from an ordinal `b` less than `o` to an ordinal, if `f` forms a fundamental sequence for `a` with length `o`, then the ordinal corresponding to the cofinality of `a` is `o`. In other words, if `f` describes a sequence that converges to `a` and has `o` as its length, which is less than or equal to the order type of the cofinality of `a`, then the smallest ordinal that has the cofinality of `a` as its cardinal is indeed `o`.

If a function from an ordinal less than the cofinality of an ordinal `a` to `a` forms a fundamental sequence of length `o`, then the cofinality of `a` is exactly `o`.


theorem Int.testBit_bitwise :
    ∀ (f : Bool → Bool → Bool) (m n : ℤ) (k : ℕ),
      Int.testBit (Int.bitwise f m n) k = f (Int.testBit m k) (Int.testBit n k) :=
  by sorry

This theorem states that for any Boolean function `f`, any two integers `m` and `n`, and any natural number `k`, the `k+1`-st least significant bit of the result of applying `f` bitwise to `m` and `n` is equal to the result of applying `f` to the `k+1`-st least significant bits of `m` and `n`. In other words, it states that the function `Int.bitwise` applies the function `f` to each pair of corresponding bits in `m` and `n` and its result's `k+1`-st least significant bit can be computed by applying `f` to the `k+1`-st least significant bits of `m` and `n`.

For any Boolean function `f`, the `k+1`-th bit of `Int.bitwise f m n` is equal to `f` applied to the `k+1`-th bits of `m` and `n`.


theorem MeasureTheory.Integrable.prod_mk :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
      MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → MeasureTheory.Integrable (fun x => (f x, g x)) μ :=
  by sorry

The theorem `MeasureTheory.Integrable.prod_mk` states that for any types `α`, `β`, `γ`, measurable space `m` on `α`, and a measure `μ` on this measurable space, given a normed additive commutative group on `β` and `γ`, and functions `f` and `g` from `α` to `β` and `γ` respectively, if both `f` and `g` are integrable with respect to the measure `μ`, then the function that maps each element of `α` to the tuple `(f x, g x)` is also integrable with respect to the measure `μ`. In more intuitive terms, if two functions are separately integrable, then the function that pairs their outputs is also integrable.

If `μ` is a measure on the measurable space `(α, m)`, and `f : α → β` and `g : α → γ` are integrable functions with respect to `μ`, then the function `x ↦ (f x, g x)` from `α` to `β × γ` is integrable with respect to `μ`.


/-- If an element `b` becomes left-regular after multiplying it on the left by a left-regular
element, then `b` is left-regular.  -/
theorem IsLeftRegular.of_mul :
    ∀ {R : Type u_1} [inst : Semigroup R] {a b : R}, IsLeftRegular (a * b) → IsLeftRegular b := by sorry

The theorem `IsLeftRegular.of_mul` states that for any semigroup `R`, and any elements `a` and `b` from that semigroup, if `b` becomes a left-regular element after being multiplied on the left by a left-regular element `a`, then `b` itself is a left-regular element. Here, a left-regular element refers to an element `c` such that the function that multiplies `c` on the left to any given element is injective, meaning that it preserves distinctness of elements in the semigroup.

If `a` is a left-regular element in semigroup `R` and left multiplying `b` by `a` results in a left-regular element, then `b` is a left-regular element in `R`.


theorem isCoprime_one_right : ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime x 1 := by sorry

This theorem states that for any commutative semiring `R` and for any element `x` from `R`, `x` and `1` are coprime. Here, two elements `x` and `y` of a commutative semiring `R` are said to be coprime if there exist two elements `a` and `b` in `R` such that `a * x + b * y = 1`. In this case, since `1` is the multiplicative identity in `R`, every element `x` in `R` is coprime with `1`.

In any commutative semiring, every element is coprime with the multiplicative identity.


theorem MeasureTheory.VectorMeasure.of_disjoint_iUnion_nat :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      [inst_2 : T2Space M] (v : MeasureTheory.VectorMeasure α M) {f : ℕ → Set α},
      (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → ↑v (⋃ i, f i) = ∑' (i : ℕ), ↑v (f i) :=
  by sorry

This theorem, `MeasureTheory.VectorMeasure.of_disjoint_iUnion_nat`, states that given a measurable space `α`, a type `M` with an addition commutative monoid structure and a topology such that every singleton set is a closed set (i.e., `M` is a T2 space), and a vector measure `v` from `α` to `M`, if we have a sequence of measurable sets `f : ℕ → Set α` such that each pair of sets in the sequence is disjoint, then the measure of the countable union of these sets (`⋃ i, f i`) under the vector measure `v` is equal to the sum of the measures of each individual set in the sequence (i.e., `∑' (i : ℕ), ↑v (f i)`). This is a generalization of the additivity property of measures to vector measures and disjoint countable unions of measurable sets.

Given a measurable space, a T2 space with a commutative monoid structure and every singleton set closed, and a vector measure, the measure of the disjoint countable union of measurable sets under the vector measure equals the sum of the measures of each individual set.


theorem mem_rightAddCoset_iff :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : Set α} {x : α} (a : α), x ∈ AddOpposite.op a +ᵥ s ↔ x + -a ∈ s := by sorry

This theorem states that for any type `α` which forms an additive group, any set `s` of elements from this type, any element `x` in `α`, and any element `a` in `α`, `x` belongs to the right coset formed by adding `a` to each element of `s` if and only if the element obtained by adding the additive inverse of `a` to `x` belongs to `s`. The '+' operation refers to the addition defined in the additive group, and 'ᵥ' is used to denote the operation of adding an element to every member of a set, forming a coset.

For any additive group `α`, set `s ⊆ α`, element `x ∈ α`, and `a ∈ α`, `x ∈ s + a` if and only if `x - a ∈ s`.


theorem Set.coe_setOf : ∀ {α : Type u} (p : α → Prop), ↑{x | p x} = { x // p x } := by sorry

This theorem states that for any type `α` and any property `p` that elements of this type may satisfy, the set of all elements `x` of type `α` that satisfy `p` (symbolized by `{x | p x}`) is equivalent to the set of all elements `x` along with a proof that `x` satisfies `p` (symbolized by `{ x // p x }`). This is essentially a type-level statement that these two ways of defining a subset of a type are interchangeable.

The type of subsets of any type `α` defined as `{x | p x}` is equivalent to the type of pairs `{x // p x}` where `x` is an element of `α` and `p x` is a proof that `p` holds for `x`.


theorem Localization.mk_eq_monoidOf_mk'_apply :
    ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (x : M) (y : ↥S),
      Localization.mk x y = Submonoid.LocalizationMap.mk' (Localization.monoidOf S) x y :=
  by sorry

This theorem states that, for any commutative monoid `M` and any submonoid `S` of `M`, and for any elements `x` in `M` and `y` in `S`, the localization of `M` at `S` created by the `Localization.mk` function applied to `x` and `y` is equal to the result of applying the `Submonoid.LocalizationMap.mk'` function to the natural homomorphism `Localization.monoidOf S` and the elements `x` and `y`. In other words, these two methods of creating a localization of a commutative monoid at a submonoid yield the same result.

For any commutative monoid M and submonoid S, the localization of M at S using `Localization.mk` equals the localization of the submonoid homomorphism from M to S using `Submonoid.LocalizationMap.mk`.


theorem MeasureTheory.set_integral_mono_set :
    ∀ {X : Type u_1} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {f : X → ℝ} {s t : Set X},
      MeasureTheory.IntegrableOn f t μ →
        0 ≤ᶠ[MeasureTheory.Measure.ae (μ.restrict t)] f →
          s ≤ᶠ[MeasureTheory.Measure.ae μ] t → ∫ (x : X) in s, f x ∂μ ≤ ∫ (x : X) in t, f x ∂μ :=
  by sorry

This theorem states that for any measurable space `X`, any measure `μ` on `X`, and any real-valued function `f` defined on `X`, if `f` is integrable on a set `t` with respect to `μ`, and `f` is non-negative almost everywhere in the restriction of `μ` to `t`, and if a set `s` is almost everywhere a subset of `t` with respect to `μ`, then the integral of `f` over `s` with respect to `μ` is less than or equal to the integral of `f` over `t` with respect to `μ`. In other words, if a function is non-negative and integrable on a set, the integral over any subset of that set is less than or equal to the integral over the set.

If `f` is a non-negative integrable function on measurable set `t` with respect to measure `μ`, and `s` is almost everywhere a subset of `t`, then the integral of `f` over `s` is less than or equal to the integral of `f` over `t`.


theorem Equiv.Perm.extendDomain_apply_subtype :
    ∀ {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [inst : DecidablePred p] (f : α' ≃ Subtype p)
      {b : β'} (h : p b), (Equiv.Perm.extendDomain e f) b = ↑(f (e (f.symm { val := b, property := h }))) :=
  by sorry

The theorem `Equiv.Perm.extendDomain_apply_subtype` states that for any types `α'` and `β'`, a permutation `e` on `α'`, a decidable predicate `p` on `β'`, and a bijection `f` between `α'` and the subtype of `β'` satisfying `p`, the result of extending the domain of the permutation `e` using `f` and then applying it to any element `b` of `β'` that satisfies the predicate `p`, is equal to the result of applying `f` to the permutation `e` applied to the preimage of `{val := b, property := h}` under `f`.
In other words, the theorem describes how a permutation on a type `α'` can be extended to a permutation on a type `β'` using a bijection between `α'` and a subtype of `β'`.

Given a permutation on a type `α'`, a bijection to a subtype of `β'` satisfying a decidable predicate, and an element in the subtype, the permutation extended using the bijection and applied to the element is equal to applying the bijection to the permutation and then to the preimage under the bijection.


theorem AlgebraicGeometry.quasiCompact_stableUnderBaseChange :
    CategoryTheory.MorphismProperty.StableUnderBaseChange @AlgebraicGeometry.QuasiCompact := by sorry

The theorem `AlgebraicGeometry.quasiCompact_stableUnderBaseChange` states that the property of being quasi-compact in algebraic geometry is stable under base change. That means for any categories `X`, `Y`, `Y'`, and `S`, and morphisms `f: X ⟶ S`, `g: Y ⟶ S`, `f': Y' ⟶ Y`, `g': Y' ⟶ X`, if `(f', g')` is a pullback of `(g, f)` and `g` is quasi-compact, then `g'` is also quasi-compact.

If `g` is quasi-compact and `(f', g')` is the pullback of `(g, f)`, then `g'` is quasi-compact.


theorem Mathlib.Analysis.Asymptotics.Asymptotics._auxLemma.46 :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F}
      {l : Filter α}, f =O[l] g = ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ :=
  by sorry

This theorem, `Mathlib.Analysis.Asymptotics.Asymptotics._auxLemma.46`, states that for any types `α`, `E`, and `F`, where `E` and `F` are normed, given two functions `f : α → E` and `g : α → F` and a filter `l` on `α`, the function `f` is big O of `g` at the filter `l` if and only if there exists a constant `c` such that, eventually for every `x` in the filter `l`, the norm of `f(x)` is less than or equal to `c` times the norm of `g(x)`. This is a notion of limit used in analysis to describe the asymptotic behavior of functions.

For types `α`, `E`, and `F` where `E` and `F` are normed, and for functions `f : α → E` and `g : α → F` on filter `l` on `α`, `f` is big O of `g` at `l` if and only if there exists a constant `c` such that, for all `x` in `l`, ||`f(x)`|| ≤ c * ||`g(x)`||.


theorem CharP.char_ne_one :
    ∀ (R : Type u_1) [inst : NonAssocSemiring R] [inst_1 : Nontrivial R] (p : ℕ) [hc : CharP R p], p ≠ 1 := by sorry

This theorem states that for any type `R` that has a structure of a non-associative semiring and is nontrivial, if `R` has characteristic `p` (which is a natural number), then `p` cannot be equal to 1. In mathematical terms, a ring has characteristic `p` if every element of the ring, when added to itself `p` times, results in the zero element of the ring. Nontrivial means that there exists at least two distinct elements in the ring, and a non-associative semiring is a semiring where the multiplication is not necessarily associative.

A nontrivial non-associative semiring `R` with characteristic `1` is the empty set.


theorem Ordinal.limit_le : ∀ {o : Ordinal.{u_4}}, Ordinal.IsLimit o → ∀ {a : Ordinal.{u_4}}, o ≤ a ↔ ∀ x < o, x ≤ a :=
  by sorry

The theorem `Ordinal.limit_le` states that for every ordinal `o` which is a limit ordinal, and another ordinal `a`, the ordinal `o` is less than or equal to `a` if and only if all ordinals `x` that are less than `o` are also less than or equal to `a`. This means that, in the set of ordinals, a limit ordinal is less than or equal to another ordinal if every ordinal smaller than the limit ordinal is also less than or equal to that other ordinal.

A limit ordinal is less than or equal to another ordinal if and only if every ordinal less than the limit ordinal is less than or equal to that other ordinal.


theorem Part.assert.proof_1 : ∀ {α : Type u_1} (p : Prop) (f : p → Part α), (∃ (h : p), (f h).Dom) → p := by sorry

The theorem `Part.assert.proof_1` states that for any type `α`, any proposition `p`, and any function `f` from `p` to `Part α`, if there exists a proof `h` of `p` such that `(f h).Dom` is true, then `p` is true. In other words, if there is a proof of `p` for which `f` maps to a computationally meaningful value, then `p` must be true.

If there exists a proof `h` of proposition `p` such that the domain of the function `f(h)` from `p` to `Part α` is true, then proposition `p` is true.


theorem Part.assert.proof_2 : ∀ {α : Type u_1} (p : Prop) (f : p → Part α) (ha : ∃ (h : p), (f h).Dom), (f ⋯).Dom := by
  sorry

This theorem, `Part.assert.proof_2`, states that for any type `α`, any proposition `p`, and any function `f` from `p` to a partial function of `α`, if there exists a proof `h` of `p` such that the domain of `f(h)` is true, then the domain of the function `f` is also true. In other words, if there is some proof of the proposition for which the function `f` is defined, then the function `f` is defined in general.

If a partial function `f` from a proposition `p` to type `α` has a defined value at some proof `h` of `p`, then the domain of `f` includes the proposition `p`.


theorem Subgroup.nontrivial_iff_exists_ne_one :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 1 := by sorry

This theorem states that for any type `G` with a group structure and for any subgroup `H` of `G`, `H` is nontrivial (i.e., `H` contains at least two distinct elements) if and only if there exists an element `x` in `H` such that `x` is not the identity element of the group. In other words, a subgroup is nontrivial if it contains an element other than the group's identity.

A subgroup of a group is nontrivial if and only if it contains a non-identity element.


QuotientGroup.eq'

theorem QuotientGroup.eq' : ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {a b : α}, ↑a = ↑b ↔ a⁻¹ * b ∈ s := by
  sorry

This theorem, `QuotientGroup.eq'`, states that for any type `α` that forms a group, given a subgroup `s` of α and any two elements `a` and `b` of α, the quotient of `a` and `b` are equal if and only if the product of the inverse of `a` and `b` is an element of the subgroup `s`. This theorem uses the equivalence between two conditions: equality in the quotient group and belonging to a certain subgroup in the original group.

For any group `α` and subgroup `s`, two elements `a` and `b` of `α` are equivalent in the quotient group if and only if the product of the inverse of `a` and `b` belongs to `s`.


theorem Nat.le_succ_iff : ∀ {m n : ℕ}, m ≤ Nat.succ n ↔ m ≤ n ∨ m = Nat.succ n := by sorry

This theorem, `Nat.le_succ_iff`, states that for all natural numbers `m` and `n`, the condition `m` is less than or equal to `n + 1` is equivalent to either `m` is less than or equal to `n` or `m` is equal to `n + 1`. In other words, a natural number `m` being less than or equal to the successor of another natural number `n`, can happen either if `m` is less than or equal to `n`, or if `m` is exactly the successor of `n`.

For all natural numbers m and n, m is less than or equal to n + 1 if and only if m is less than or equal to n or m is equal to n + 1.


theorem Mathlib.Data.Int.ConditionallyCompleteOrder._auxLemma.1 :
    ∀ {α : Type u} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) := by sorry

This theorem states that for any type `α` that has a less than or equal to (`≤`) operation, and for any two elements `x` and `y` of that type, `x` is greater than or equal to (`≥`) `y` if and only if `y` is less than or equal to (`≤`) `x`. This is a fundamental property of ordered sets in mathematics.

For all types `α` with a `≤` operation and all `x, y` in `α`, `x ≥ y` if and only if `y ≤ x`.


theorem Finset.disjoint_sup_right :
    ∀ {α : Type u_2} {ι : Type u_5} [inst : DistribLattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α} {a : α},
      Disjoint a (Finset.sup s f) ↔ ∀ ⦃i : ι⦄, i ∈ s → Disjoint a (f i) :=
  by sorry

The theorem `Finset.disjoint_sup_right` states that for any types `α` and `ι`, any distributive lattice structure on `α` with a least element, any finite set `s` of type `ι`, any function `f` from `ι` to `α`, and any element `a` of `α`, the element `a` is disjoint from the supremum of the set `s` under `f` if and only if `a` is disjoint from `f i` for every element `i` in `s`. Here, two elements of a lattice are defined to be disjoint if their infimum is the bottom element. The supremum of a finite set `s` under `f` is the result of applying the binary operation (supremum) to each element of `s` in turn, starting from the least element of the lattice.

For any distributive lattice with least element, an element is disjoint from the supremum of a finite set under a function if and only if it is disjoint from the image of each element in the set.


/-- If `f` is an embedding, then `Nat.card α ≤ Nat.card β`. We must also assume
`Nat.card β = 0 → Nat.card α = 0` since `Nat.card` is defined to be `0` for infinite types.  -/
theorem Finite.card_le_of_embedding' :
    ∀ {α : Type u_1} {β : Type u_2}, (α ↪ β) → (Nat.card β = 0 → Nat.card α = 0) → Nat.card α ≤ Nat.card β := by sorry

This theorem states that for any two types `α` and `β`, if there exists an embedding function `f` from `α` to `β`, then the cardinality of `α` (denoted by `Nat.card α`) is less than or equal to the cardinality of `β` (denoted by `Nat.card β`). Additionally, it is assumed that if `β` is an infinite type (i.e., `Nat.card β = 0`), then `α` must also be an infinite type (i.e., `Nat.card α = 0`). This condition is necessary because `Nat.card` is defined to be `0` for infinite types.

If `α` embeds into `β`, then `Nat.card α ≤ Nat.card β`, under the assumption that `β` is infinite implies `α` is infinite.


theorem LinearMap.zero_apply :
    ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_9} {M₂ : Type u_11} [inst : Semiring R₁] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R₁ →+* R₂} (x : M), 0 x = 0 :=
  by sorry

The theorem `LinearMap.zero_apply` states that for any types `R₁`, `R₂`, `M`, and `M₂` along with their respective semiring, module, and addition commutative monoid structures, and any ring homomorphism `σ₁₂` from `R₁` to `R₂`, applying the zero linear map to any element `x` from `M` yields zero. In mathematical terms, if we have a zero linear map from one module to another, then the image of any element under this map is the zero element of the second module.

For any ring homomorphism σ₁₂ between semirings R₁ and R₂, and any zero linear map f : M → M₂ between modules M and M₂ over R₁ and R₂ respectively, we have f(x) = 0 for all x ∈ M.


Filter.HasBasis.nhds

theorem Filter.HasBasis.nhds :
    ∀ {ι : Sort u_1} {α : Type u_2} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
      Filter.HasBasis l p s → Filter.HasBasis (nhds l) p fun i => Set.Iic (Filter.principal (s i)) :=
  by sorry

The theorem `Filter.HasBasis.nhds` states that for any type `ι`, `α`, any filter `l` on `α`, and any two functions `p : ι → Prop` and `s : ι → Set α`, if the filter `l` has a basis characterized by the predicate `p` and the set-valued function `s`, then the neighborhood filter `nhds l` also has a basis characterized by `p` and the function `i ↦ Set.Iic (Filter.principal (s i))`. Here `Set.Iic (Filter.principal (s i))` represents the set of all elements less than or equal to the principal filter generated by `s i`.

If a filter on a type has a basis given by a predicate and a set-valued function, then its neighborhood filter also has a basis given by the same predicate and the function mapping each element to the closed interval filter generated by its basis element.


theorem monovaryOn_toDual_right :
    ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β}
      {s : Set ι}, MonovaryOn f (⇑OrderDual.toDual ∘ g) s ↔ AntivaryOn f g s :=
  by sorry

The theorem `monovaryOn_toDual_right` establishes a relationship between two concepts of monotonicity, monovariation and antivariation, on a given set. Specifically, it says that for all preorders `α` and `β`, and for all functions `f : ι → α` and `g : ι → β`, and for any set `s` of type `ι`, the function `f` monovaries with the function `g`, where `g` is mapped to its dual order, on the set `s` if and only if `f` antivaries with `g` on `s`. In simpler terms, if increasing values of `g` (in its dual order) lead to non-decreasing values of `f`, then this is the same as saying that increasing values of `g` in its original order lead to non-increasing values of `f`.

For all preorders α and β, functions f : ι -> α and g : ι -> β, and sets s of type ι, the function f monovaries with the dual of g on s if and only if f antivaries with g on s.


theorem PowerSeries.coeff_exp :
    ∀ {A : Type u_1} [inst : Ring A] [inst_1 : Algebra ℚ A] (n : ℕ),
      (PowerSeries.coeff A n) (PowerSeries.exp A) = (algebraMap ℚ A) (1 / ↑(Nat.factorial n)) :=
  by sorry

The theorem `PowerSeries.coeff_exp` expresses that for any ring `A`, equipped with an algebra structure over the rational numbers `ℚ`, and for any natural number `n`, the `n`-th coefficient of the power series for the exponential function at zero is equal to the algebraic map of `(1 / (n factorial))`, where `n factorial` is represented as `Nat.factorial n`. In other words, when we look at the `n`-th term of the exponential power series, it is equal to `1 / n!` transformed into our algebra `A` using the algebra's structure.

For any commutative ring `A` equipped with an algebra structure over the rational numbers, the `n`-th coefficient of the power series for the exponential function at zero equals `1 / (n!)|\_A`, where `n!` is the factorial of `n` and `|_A` denotes the algebra homomorphism from the rational numbers to `A`.


theorem commutator_eq_closure : ∀ (G : Type u) [inst : Group G], commutator G = Subgroup.closure (commutatorSet G) := by
  sorry

The theorem `commutator_eq_closure` states that for any group `G`, the commutator subgroup of `G` is equivalent to the subgroup generated by the set of all commutators in `G`. In other words, the subgroup of `G` generated by all expressions of the form `g1 * g2 * g1⁻¹ * g2⁻¹`, where `g1` and `g2` are in `G`, is precisely the same as the normal subgroup generated by the commutators of elements in `G`.

The commutator subgroup of a group is equal to the subgroup generated by all commutators in the group.


HasFDerivWithinAt.prod

theorem HasFDerivWithinAt.prod :
    ∀ {𝕜 : 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]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f₁ : E → F} {f₁' : E →L[𝕜] F} {x : E}
      {s : Set E} {f₂ : E → G} {f₂' : E →L[𝕜] G},
      HasFDerivWithinAt f₁ f₁' s x →
        HasFDerivWithinAt f₂ f₂' s x →
          HasFDerivWithinAt (fun x => (f₁ x, f₂ x)) (ContinuousLinearMap.prod f₁' f₂') s x :=
  by sorry

The theorem `HasFDerivWithinAt.prod` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E`, `F`, and `G`, along with normed spaces over `𝕜` for `E`, `F`, and `G`, given two functions `f₁ : E → F` and `f₂ : E → G` and their respective derivative functions `f₁' : E →L[𝕜] F` and `f₂' : E →L[𝕜] G`, as well as a point `x` in `E` and a set `s` of `E`. If `f₁` has derivative `f₁'` at `x` within `s` and `f₂` has derivative `f₂'` at `x` within `s`, then the function mapping `x` to the pair `(f₁ x, f₂ x)` also has a derivative at `x` within `s`, which is the product of `f₁'` and `f₂'` under the continuous linear map.

If functions `f₁ : E → F` and `f₂ : E → G` with derivatives `f₁' : E →L[𝕜] F` and `f₂' : E →L[𝕜] G`, respectively, have derivatives at `x` within `s` in the normed spaces `E`, `F`, and `G` over a non-trivially normed field `𝕜`, then the function `(\x : E) => (f₁ x, f₂ x) : E → F × G` has a derivative at `x` within `s` equal to the product of `f₁'` and `f₂'` under the continuous linear map.


theorem MeasureTheory.condexp_of_not_sigmaFinite :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → F'} (hm : m ≤ m0),
      ¬MeasureTheory.SigmaFinite (μ.trim hm) → MeasureTheory.condexp m μ f = 0 :=
  by sorry

The theorem `MeasureTheory.condexp_of_not_sigmaFinite` states that for any types `α` and `F'`, if we have a normed add commutative group structure, normed real space structure, and complete space structure on `F'`, and given `m` and `m0` as measurable spaces on `α`, `μ` as a measure on `α`, and `f` as a function mapping from `α` to `F'`, if `m` is a sub-σ-algebra of `m0` (denoted by hm : m ≤ m0) and if `μ` trimmed by `m` is not σ-finite (denoted by ¬MeasureTheory.SigmaFinite (μ.trim hm)), then the conditional expectation of `f` with respect to `m` and `μ`, denoted by `MeasureTheory.condexp m μ f`, is equal to zero.

If `m` is a sub-σ-algebra of `m0`, `μ` is a measure on `α`, `f` is a function from `α` to a normed add commutative group with a complete normed real space and complete space structure, and `μ.trim hm` is not σ-finite, then `MeasureTheory.condexp m μ f = 0`.


theorem MvPowerSeries.inv_eq_iff_mul_eq_one :
    ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] {φ ψ : MvPowerSeries σ k},
      (MvPowerSeries.constantCoeff σ k) ψ ≠ 0 → (ψ⁻¹ = φ ↔ φ * ψ = 1) :=
  by sorry

This theorem states that for any given types `σ` and `k`, where `k` is a field, and for any multivariate power series `φ` and `ψ` over these types, if the constant coefficient of `ψ` is not zero, then `ψ` is the multiplicative inverse of `φ` if and only if the product of `φ` and `ψ` is equal to one. In mathematical terms, if ψ₀ ≠ 0, then ψ⁻¹ = φ if and only if φψ = 1.

Given types `σ` and `k` with `k` a field, and multivariate power series `φ` and `ψ` over `σ` with non-zero constant coefficient for `ψ`, then `ψ` is the multiplicative inverse of `φ` if and only if `φψ = 1`.


theorem comap_swap_uniformity :
    ∀ {α : Type ua} [inst : UniformSpace α], Filter.comap Prod.swap (uniformity α) = uniformity α := by sorry

This theorem states that for any type `α` that has an instance of the `UniformSpace` structure, the filter obtained by applying the `Prod.swap` function through the `Filter.comap` function on the uniformity of `α` is equal to the uniformity of `α`. In simpler terms, swapping the pairs in the uniformity of a uniform space does not change the uniformity. This property is important in the context of uniform spaces, where the concept of "uniformity" is used to generalize the notions of a metric space and topological space, and this property ensures that the uniformity is symmetric.

For any uniform space `(α, U)`, the filters `U` and `( Прод.swap ∘ Filter.comap U) (pair ∘ pair)` are equal.


theorem Finset.prod_eq_mul_prod_diff_singleton :
    ∀ {α : Type u_3} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq α] {s : Finset α} {i : α},
      i ∈ s → ∀ (f : α → β), (Finset.prod s fun x => f x) = f i * Finset.prod (s \ {i}) fun x => f x :=
  by sorry

This theorem states that for any type `α`, and a commutative monoid `β`, given a function `f` from `α` to `β` and a finite set `s` of type `α` with decidable equality, if an element `i` belongs to `s`, then the product of `f(x)` for each `x` in the set `s` is equal to `f(i)` times the product of `f(x)` for each `x` in the set `s` excluding `i`. In mathematical terms, it's asserting that $\prod_{x \in s} f(x) = f(i) * \prod_{x \in s \setminus \{i\}} f(x)$.

For any commutative monoid `β`, given a function `f` from type `α` to `β`, and a finite set `s` of type `α` with decidable equality, the product of `f(x)` for all `x` in `s` equals `f(i)` times the product of `f(x)` for all `x` in `s` except `i`. In symbolic form: $\prod\_{x \in s} f(x) = f(i) * \prod\_{x \in s \setminus \{i\}} f(x)$.


theorem TopCat.prodIsoProd_hom_fst :
    ∀ (X Y : TopCat),
      CategoryTheory.CategoryStruct.comp (TopCat.prodIsoProd X Y).hom TopCat.prodFst = CategoryTheory.Limits.prod.fst :=
  by sorry

This theorem states that for every pair of topological spaces, `X` and `Y`, in the category of topological spaces `TopCat`, the composition of the morphism from the categorical product `X ⨯ Y` to the set-theoretic product `↑X × ↑Y` (represented by `(TopCat.prodIsoProd X Y).hom`) and the first projection function `TopCat.prodFst` from this set-theoretic product back to `X` is equal to the first projection function `CategoryTheory.Limits.prod.fst` in the category of topological spaces. In other words, it asserts the compatibility of these mappings with respect to the categorical and set-theoretic notions of products in the category of topological spaces.

For every pair of topological spaces X and Y, the morphism from the topological product X ⨯ Y to the set-theoretic product ↑X × ↑Y, followed by the first projection function from the set-theoretic product, equals the first projection function of the topological product in the category of topological spaces.


theorem List.mem_of_mem_filter : ∀ {α : Type u} {p : α → Bool} {a : α} {l : List α}, a ∈ List.filter p l → a ∈ l := by
  sorry

The theorem `List.mem_of_mem_filter` states that for any type `α`, any boolean function `p` from `α` to `Bool`, any element `a` of type `α`, and any list `l` of elements of type `α`, if the element `a` is a member of the list obtained by filtering `l` with the function `p`, then `a` is also a member of the original list `l`. In other words, filtering a list does not introduce any new elements into the list.

If `a` is in the list obtained by filtering `l` with `p`, then `a` is in `l`.


theorem neg_abs_le :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α), -|a| ≤ a :=
  by sorry

This theorem, `neg_abs_le`, states that for any type `α` that is an additive group and linearly ordered, and for which addition is a covariant operation with respect to the order, the negative absolute value of any element `a` is less than or equal to `a` itself. In simple terms, in any linearly ordered additive group, any number is greater than or equal to its own negative absolute value.

In a linearly ordered additive group, for all elements `a`, we have `-|a| ≤ a`. (Here, `|a|` denotes the absolute value of `a`, and `-|a|` denotes the negative absolute value.)


theorem MeasureTheory.Measure.dirac_apply_of_mem :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α} {a : α}, a ∈ s → ↑↑(MeasureTheory.Measure.dirac a) s = 1 :=
  by sorry

This theorem states that for any type `α` with a `MeasurableSpace` instance and for any set `s` of type `α`, if an element `a` of type `α` belongs to the set `s`, then the dirac measure of `a` applied to the set `s` is equal to 1. The dirac measure is a function that assigns the value 1 to the set if `a` is in `s`, and 0 otherwise. The theorem essentially formalizes that when `a` belongs to the set `s`, the dirac measure of `a` on the set `s` is 1.

For any measurable space `(α, Σ)` and set `s ∈ Σ` of type `α` with a `MeasurableSpace` instance, the Dirac measure of any `a ∈ s` evaluates to 1 on `s`.


theorem edist_smul_left :
    ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X] [inst_2 : IsometricSMul M X] (c : M)
      (x y : X), edist (c • x) (c • y) = edist x y :=
  by sorry

This theorem, `edist_smul_left`, states that for any types `M` and `X`, where `X` forms a pseudo-emetric space and `M` is capable of scalar multiplication on `X` such that the scalar multiplication is isometric (i.e., it preserves the distance), the extended distance (edist) between the scalar multiplication of a scalar `c` and `x` and the scalar multiplication of `c` and `y` is the same as the extended distance between `x` and `y`. In mathematical terms, for all `c`, `x`, and `y`, `edist (c • x) (c • y) = edist x y`.

For any type `M` with scalar multiplication that preserves the pseudo-metric on `X`, the extended distance between `c • x` and `c • y` equals the extended distance between `x` and `y`, for all scalars `c` and elements `x`, `y` in `M`.


Odd.pos

theorem Odd.pos :
    ∀ {α : Type u_2} [inst : CanonicallyOrderedCommSemiring α] [inst_1 : Nontrivial α] {n : α}, Odd n → 0 < n := by
  sorry

This theorem states that for any type `α` that is a `CanonicallyOrderedCommSemiring` and is nontrivial, if a number `n` of type `α` is odd, then `n` is strictly greater than 0. In other words, all odd numbers in such a semiring are positive.

For any nontrivial `CanonicallyOrderedCommSemiring` type `α`, all odd elements `n` of `α` are strictly positive (i.e., `0 < n`).


theorem LocalRing.isUnit_or_isUnit_one_sub_self :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : LocalRing R] (a : R), IsUnit a ∨ IsUnit (1 - a) := by sorry

This theorem states that for any commutative ring `R` that is also a local ring, for any element `a` of `R`, either `a` is a unit (i.e., it has a multiplicative inverse in the ring) or `1 - a` is a unit. A unit is an element that has both a left and right inverse. In other words, in a local ring, every element and its complement with respect to 1 are units.

In a commutative local ring, every element and its complement with respect to 1 are units.


/-- Composing two additions on the left by `y` then `x`
is equal to an addition on the left by `x + y`. -/
theorem comp_add_left :
    ∀ {α : Type u_1} [inst : AddSemigroup α] (x y : α),
      ((fun x_1 => x + x_1) ∘ fun x => y + x) = fun x_1 => x + y + x_1 :=
  by sorry

This theorem, `comp_add_left`, asserts that for any two elements `x` and `y` in an additive semigroup, the composition of two addition functions, the first adding `y` to its argument and the second adding `x` to the result, is equivalent to a single addition function that adds `x + y` to its argument. In terms of standard mathematical notation, this can be expressed as for all `x` and `y` in the semigroup `(x + (y + z)) = ((x + y) + z)`, where `z` is the input to the function. This is essentially a statement of associativity for the addition operation in the semigroup.

For any additive semigroup and all elements `x` and `y`, the function `(λ (z : _), x + (y + z))` equals the function `(λ (z : _), (x + y) + z)`.


theorem Dense.inter_nhds_nonempty :
    ∀ {X : Type u} {x : X} {s t : Set X} [inst : TopologicalSpace X], Dense s → t ∈ nhds x → Set.Nonempty (s ∩ t) := by
  sorry

This theorem states that for any type `X` equipped with a topological space structure, for any point `x` in `X`, and for any sets `s` and `t` in `X`, if `s` is a dense set and `t` is a neighborhood of `x`, then the intersection of `s` and `t` is nonempty. In other words, there is at least one element of `X` that belongs to both the dense set `s` and the neighborhood `t` of `x`.

For any topological space `(X,τ)` and point `x ∈ X`, if `s ⊆ X` is dense and `t ∈ β(x)` is a neighborhood of `x`, then `s ∩ t ≠ ∅`.


theorem max_sub_min_eq_abs :
    ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α),
      max a b - min a b = |b - a| :=
  by sorry

The theorem `max_sub_min_eq_abs` states that for any type `α` that is an additive group and a linear order, and that satisfies two specific covariant properties (where addition is increasing with respect to the order), the difference between the maximum and minimum of two elements `a` and `b` is equal to the absolute value of `b - a`. In more mathematical terms, for all `a` and `b` in `α`, we have `max(a, b) - min(a, b) = |b - a|`.

For all additive groups and linearly ordered types `α` where addition is increasing with respect to the order, the difference between the maximum and minimum of any two elements `a` and `b` is equal to the absolute value of their difference: `|max(a, b) - min(a, b)| = |b - a|`.


theorem Set.iUnion_coe_set :
    ∀ {α : Type u_11} {β : Type u_12} (s : Set α) (f : ↑s → Set β),
      ⋃ i, f i = ⋃ i, ⋃ (h : i ∈ s), f { val := i, property := h } :=
  by sorry

This theorem states that for any types `α` and `β`, a given set `s` of type `α`, and a function `f` mapping elements of the coerced set `s` to sets of type `β`, the union over all elements of the function `f` is equal to the union over all elements `i` and all properties `h` (where `h` signifies that `i` is an element of `s`) of the function `f` applied to the element `i` with property `h`. In other words, this theorem expresses a property of unions in the context of function application over sets.

For any sets `α`, `β`, type `α` set `s`, and function `f` from `s` to sets of type `β`, the set union over `f` is equal to the set union over all elements `i` in `s` and their membership properties `h`, i.e., `⋃(f ↦ x in s) (f x) = ⋃(x : s) (h : x ∈ s) (f x)`.


CoheytingHom.ext

theorem CoheytingHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] {f g : CoheytingHom α β},
      (∀ (a : α), f a = g a) → f = g :=
  by sorry

This theorem states that for any two types `α` and `β`, where `α` and `β` are both instances of the Coheyting algebra, and for any two homomorphisms `f` and `g` from `α` to `β`, if for every element `a` in `α`, `f(a)` is equal to `g(a)`, then `f` is equal to `g`. In other words, it states the principle of function extensionality for Coheyting homomorphisms: two homomorphisms between Coheyting algebras are the same if and only if they map each element of the source algebra to the same element of the target algebra.

Given types `α` and `β` as instances of Coheyting algebras, and homomorphisms `f` and `g` from `α` to `β`, if for all `a` in `α`, `f(a) = g(a)`, then `f = g`.


theorem Seminorm.mem_closedBall_zero :
    ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
      (p : Seminorm 𝕜 E) {y : E} {r : ℝ}, y ∈ Seminorm.closedBall p 0 r ↔ p y ≤ r :=
  by sorry

This theorem states that for any seminorm `p` on a seminormed ring `𝕜` acting on an additive commutative group `E`, any element `y` of `E` and any real number `r`, `y` belongs to the closed ball of radius `r` at `0` with respect to the seminorm `p` if and only if the seminorm of `y` is less than or equal to `r`. In more mathematical terms, `y` is in the closed ball centered at `0` with radius `r` under the seminorm `p` (denoted as `Seminorm.closedBall p 0 r`) if and only if `p(y) ≤ r`.

For any seminorm `p` on a seminormed ring `𝕜` and any additive commutative group `E`, an element `y` in `E` lies in the closed ball of radius `r` with respect to `p` if and only if `p(y) ≤ r`.


EsakiaHom.ext

theorem EsakiaHom.ext :
    ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : TopologicalSpace β]
      [inst_3 : Preorder β] {f g : EsakiaHom α β}, (∀ (a : α), f a = g a) → f = g :=
  by sorry

The theorem `EsakiaHom.ext` states that for any two types `α` and `β` where `α` and `β` have a topological space and preorder structure, and for any two Esakia homomorphisms `f` and `g` from `α` to `β`, the two Esakia homomorphisms are equal if they map any `α` to the same `β`. That is, if for every element `a` of `α`, `f(a)` equals `g(a)`, then `f` equals `g`. In mathematical terms, it validates the extensionality property for Esakia homomorphisms.

If two Esakia homomorphisms between topological preordered types map every element to the same image, then they are equal.


theorem Int.natAbs_pow : ∀ (n : ℤ) (k : ℕ), Int.natAbs (n ^ k) = Int.natAbs n ^ k := by sorry

This theorem, `Int.natAbs_pow`, states that for any integer `n` and any natural number `k`, the absolute value of `n` raised to the power of `k` is equal to the absolute value of `n` itself raised to the power of `k`. In other words, if you first apply the power operation to an integer and then take the absolute value, you get the same result as if you first took the absolute value and then applied the power operation. We can write this mathematically as: $\left| n^k \right| = \left| n \right|^k$ for all integer `n` and natural number `k`.

For all integers `n` and natural numbers `k`, the absolute value of `n` raised to the power of `k` equals the absolute value of `n` raised to the power of `k`. In mathematical notation: $|n^k| = |n|^k$.


theorem isLindelof_range :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : LindelofSpace X]
      {f : X → Y}, Continuous f → IsLindelof (Set.range f) :=
  by sorry

The theorem `isLindelof_range` states that for any two types `X` and `Y`, given `X` has a topological space structure and `Y` also has a topological space structure, and if `X` is a Lindelöf space, then for any continuous function `f` from `X` to `Y`, the range of `f` is also a Lindelöf set.

In other words, if we have a continuous function mapping from a Lindelöf space to any other topological space, then the set of all possible outcomes of this function will always retain the Lindelöf property, i.e., every nontrivial filter with the countable intersection property that contains this range set has a cluster point in this range set.

If `X` is a Lindelöf topological space and `f : X -> Y` is a continuous function with `Y` being any topological space, then the range of `f` is a Lindelöf subset of `Y`.


theorem IsOpen.lowerSemicontinuous_indicator :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : Preorder β] {s : Set α} {y : β}
      [inst_2 : Zero β], IsOpen s → 0 ≤ y → LowerSemicontinuous (Set.indicator s fun _x => y) :=
  by sorry

The theorem `IsOpen.lowerSemicontinuous_indicator` states that for any type `α` with a topological space structure, any type `β` with a preorder structure and a zero element, any open set `s` of type `α`, and any nonnegative `y` of type `β`, the indicator function of the set `s` that takes value `y` for elements in `s` and `0` for elements not in `s` is lower semicontinuous. In other words, for any `ε > 0`, for any `x` in the topological space, for all `x'` close enough to `x`, then the value of this indicator function at `x'` is at least the value at `x - ε`.

Given a topological space (α, t), a preorder (β, ≤) with zero element, an open set s ∈ t(α), and a nonnegative real number y ∈ β, the indicator function of s with value y on s and 0 otherwise is lower semicontinuous.


theorem Set.range_quot_mk : ∀ {α : Type u_1} (r : α → α → Prop), Set.range (Quot.mk r) = Set.univ := by sorry

The theorem `Set.range_quot_mk` states that for any type `α` and a binary relation `r` on `α`, the range of the function `Quot.mk r`, which creates an equivalence class for `r`, is the universal set. In other words, every element of the universal set can be represented as an equivalence class under the relation `r`. This means that all possible equivalence classes for `r` on `α` cover the entire set of `α`, leaving no element of `α` unrepresented.

For any type `α` and binary relation `r` on `α`, the range of `Quot.mk r` is the universe `Set α`. In other words, every element of `Set α` can be expressed as an equivalence class under `r`.


theorem IsAntichain.image_relEmbedding :
    ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α},
      IsAntichain r s → ∀ (φ : r ↪r r'), IsAntichain r' (⇑φ '' s) :=
  by sorry

The theorem `IsAntichain.image_relEmbedding` states that for all types `α` and `β`, and for all relations `r` on `α` and `r'` on `β`, if `s` is an antichain with respect to `r`, then the image of `s` under any relation embedding `φ` from `r` to `r'` is an antichain with respect to `r'`. Informally, this means that if we have a set where no two distinct elements are related by a specific relation, then if we map this set to a new set using a function that preserves the relation, the new set also has the property that no two distinct elements are related.

If `s` is an antichain for relation `r` on type `α`, and `φ` is a relation embedding from `r` to `r'` on type `β`, then the image of `s` under `φ` is an antichain for relation `r'` on `β`.


theorem Mathlib.Data.DFinsupp.NeLocus._auxLemma.5 :
    ∀ {α : Type u_1} {N : α → Type u_2} [inst : DecidableEq α] [inst_1 : (a : α) → DecidableEq (N a)]
      [inst_2 : (a : α) → Zero (N a)] {f g : Π₀ (a : α), N a} {a : α}, (a ∈ DFinsupp.neLocus f g) = (f a ≠ g a) :=
  by sorry

This theorem states that for any types `α` and `N` (where `N` is a function on `α`), given the instances of decidable equality for `α` and `N a` for any `a` in `α`, and given the instance of the `Zero` type class for `N a`, if `f` and `g` are two functions of type `(Π₀ (a : α), N a)`, and `a` is of type `α`, then `a` is in the set where `f` and `g` differ (`DFinsupp.neLocus f g`) if and only if `f a` is not equal to `g a`. In other words, `DFinsupp.neLocus f g` consists exactly of those elements of `α` where `f` and `g` do not have the same value.

For functions `f` and `g` over a type `α` with decidable equality and where `N` is a function on `α`, the sets `{a : α | f a ≠ g a}` and `DFinsupp.neLocus f g` are equal.


theorem MvPolynomial.map_monomial :
    ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
      (s : σ →₀ ℕ) (a : R), (MvPolynomial.map f) ((MvPolynomial.monomial s) a) = (MvPolynomial.monomial s) (f a) :=
  by sorry

The theorem `MvPolynomial.map_monomial` states that for any commutative semirings `R` and `S₁`, any ring homomorphism `f` from `R` to `S₁`, any function `s` from a type `σ` to natural numbers, and any element `a` of `R`, applying the function `MvPolynomial.map f` to the result of `MvPolynomial.monomial s a` is the same as first applying `f` to `a` and then applying `MvPolynomial.monomial s` to the result. In other words, it asserts the compatibility of monomial construction and polynomial map across rings.

For any commutative semirings R and S₁, ring homomorphism f from R to S₁, function s : σ → ℕ, and element a in R, we have MvPolynomial.map f (MvPolynomial.monomial s a) = MvPolynomial.monomial s (f a).


theorem MeasureTheory.ae_eq_set_union :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t s' t' : Set α},
      s =ᶠ[MeasureTheory.Measure.ae μ] t →
        s' =ᶠ[MeasureTheory.Measure.ae μ] t' → s ∪ s' =ᶠ[MeasureTheory.Measure.ae μ] t ∪ t' :=
  by sorry

This theorem in Measure Theory, named `MeasureTheory.ae_eq_set_union`, states that for any type `α` with a `MeasurableSpace` instance and a measure `μ` of `MeasureTheory.Measure α`, and for any four sets `s`, `t`, `s'`, and `t'` of type `Set α`, if `s` is almost everywhere equal to `t` under the measure `μ`, and `s'` is almost everywhere equal to `t'` under the same measure, then the union of `s` and `s'` is also almost everywhere equal to the union of `t` and `t'` under the measure `μ`.

In more detail, "almost everywhere" is a concept in measure theory that means "everywhere except on a set of measure zero." If two sets are "almost everywhere equal," it means the set difference between them has measure zero. This theorem is then saying that if `s` and `t` differ only on a set of measure zero, and `s'` and `t'` do as well, then the union of `s` and `s'` and the union of `t` and `t'` also differ only on a set of measure zero.

If sets `s`, `t`, `s'`, and `t` in a measurable space `α` are almost everywhere equal to each other under a measure `μ`, then the unions of `s` and `s'` and of `t` and `t'` are almost everywhere equal.