theorem Int.floor_sub_int :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] (a : α) (z : ℤ), ⌊a - ↑z⌋ = ⌊a⌋ - z := by sorry

This theorem states that for any type `α` which is a linear ordered ring and has a floor function (i.e., the largest integer less than or equal to a real number), and for any element `a` of this type and any integer `z`, the floor of the difference between `a` and `z` (when `z` is considered as an element of the type `α` using the coercion function) is equal to the difference between the floor of `a` and `z`. In LaTeX terms, this reads: For all $a$ in $α$ and $z$ in $\mathbb{Z}$, $⌊a - z⌋ = ⌊a⌋ - z$.

For any linear ordered ring `α` with a floor function and for all `a` in `α` and `z` in `ℤ`, `⌊a - z⌋ = ⌊a⌋ - z`.


theorem aeSeq.measure_compl_aeSeqSet_eq_zero :
    ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {f : ι → α → β} {μ : MeasureTheory.Measure α} {p : α → (ι → β) → Prop} [inst_2 : Countable ι]
      (hf : ∀ (i : ι), AEMeasurable (f i) μ), (∀ᵐ (x : α) ∂μ, p x fun n => f n x) → ↑↑μ (aeSeqSet hf p)ᶜ = 0 :=
  by sorry

This theorem states that for any type `ι`, `α`, and `β`, given measurable spaces over `α` and `β`, a function `f` from `ι` to a function from `α` to `β`, a measure `μ` on `α`, and a predicate `p` on `α` and a function from `ι` to `β`, given that `ι` is countable and for all `i` in `ι`, `f i` is almost everywhere measurable with respect to `μ`, if almost everywhere for `x` in `α`, `p x` applied to the function `n => f n x` holds, then the measure of the complement of the set where the sequence `f` is almost everywhere equal to a measurable sequence with respect to the predicate `p` is zero.

This essentially means that if we have a countable collection of functions that are almost everywhere measurable, and a property that holds almost everywhere, then the set of points where our sequence differs from a measurable sequence satisfying the property has measure zero.

Given a countable family of almost everywhere measurable functions `f_i : ι → α → β` from a countable index type `ι` to measurable spaces `(α, Σα)` and `(β, Σβ)`, a measurable predicate `p : α → Prop`, and a measure `μ : Σα`, if for all `i` in `ι` and almost every `x` in `α`, `p x` holds for `f_i x`, then the measure of the set where the sequence `f_i` fails to converge almost everywhere to a measurable function satisfying `p` is zero.


theorem Set.union_diff_left : ∀ {α : Type u} {s t : Set α}, (s ∪ t) \ s = t \ s := by sorry

The theorem `Set.union_diff_left` states that for any type `α` and any two sets `s` and `t` of type `α`, the difference of the union of `s` and `t` and `s` is equal to the difference of `t` and `s`. In other words, if you take the union of two sets and then remove the elements of one of the sets, you end up with the same result as if you just removed the elements of that set from the other set to begin with: $(s \cup t) \setminus s = t \setminus s$.

The theorem `Set.union_diff_left` asserts that for any sets `s` and `t` of type `α`, the difference between `s` and the set difference of `s` and `t` is equal to the set difference of `t` and `s`, that is, `s \ ((s \cup t)) = t \ s`.


theorem CategoryTheory.Limits.PushoutCocone.condition_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      (t : CategoryTheory.Limits.PushoutCocone f g),
      t.ι.app CategoryTheory.Limits.WalkingSpan.zero =
        CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.PushoutCocone.inl t) :=
  by sorry

The theorem `CategoryTheory.Limits.PushoutCocone.condition_zero` states that for any category `C` and objects `X`, `Y`, `Z` in `C` along with morphisms `f: X ⟶ Y` and `g: X ⟶ Z`, given a pushout cocone `t` of `f` and `g`, the morphism corresponding to the central point of the walking span in `t` is equal to the composition of `f` and the first inclusion of the pushout cocone `t`. In other words, in the context of category theory, this theorem expresses a fundamental property of pushout cocones concerning their compositions and inclusions.

In any category, the morphism from the pushout of two given morphisms to their common domain is equal to the composition of those morphisms with the respective inclusions into the pushout object.


theorem mul_dvd_mul_right : ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α}, a ∣ b → ∀ (c : α), a * c ∣ b * c := by
  sorry

This theorem, `mul_dvd_mul_right`, states that for any type `α` which is a commutative monoid, and any elements `a`, `b`, and `c` of type `α`, if `a` divides `b`, then `a` multiplied by `c` divides `b` multiplied by `c`. Here, the concept of "divides" is used in the sense of divisibility in commutative monoid, meaning that there exists some `k` of type `α` such that `b` equals `a` multiplied by `k`.

If `a` divides `b` in a commutative monoid `α`, then `a * c` divides `b * c` for all `c` in `α`.


theorem add_neg_le_neg_add_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b c d : α},
      a + -b ≤ -d + c ↔ d + a ≤ c + b :=
  by sorry

The theorem `add_neg_le_neg_add_iff` is a statement about elements in an additive group that is ordered and has certain covariance properties. Specifically, suppose we have an additive group `α`, and four elements `a`, `b`, `c`, `d` in `α`. The theorem states that the inequality `a + -b ≤ -d + c` holds if and only if the inequality `d + a ≤ c + b` holds. This theorem generalizes certain properties of inequalities involving addition and negation in the context of ordered groups.

In an ordered additive group, the sum of an element and its negation is less than or equal to the sum of another element and its negation if and only if the second sum is less than or equal to the first.


theorem uniformContinuousOn_iff_restrict :
    ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} {s : Set α},
      UniformContinuousOn f s ↔ UniformContinuous (Set.restrict s f) :=
  by sorry

This theorem states that for any types `α` and `β` with uniform space structures, a function `f` from `α` to `β`, and a set `s` of `α`, the function `f` is uniformly continuous on `s` if and only if the restriction of `f` to `s` (i.e., the function obtained by considering `f` only on the elements of `s`) is uniformly continuous. In other words, `f` behaves uniformly on the set `s` precisely when its restriction to `s` is a uniformly continuous function.

For any uniform spaces `α` and `β`, any uniformly continuous function `f` from `α` to `β`, and any subset `s` of `α`, the restriction of `f` to `s` is uniformly continuous if and only if `f` is uniformly continuous on `s`.


theorem Mathlib.MeasureTheory.Measure.LevyProkhorovMetric._auxLemma.1 :
    ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True := by sorry

This theorem, named `Mathlib.MeasureTheory.Measure.LevyProkhorovMetric._auxLemma.1`, states that for any type `α` that has a less than or equal to (`LE`) relation and a greatest element (`OrderTop`), any element `a` of this type is always less than or equal to the top element (`⊤`). This is always true regardless of the specific type `α` or the element `a` selected.

For any type `α` with a LE relation and a greatest element `⊤`, every element `a` in `α` satisfies `a ≤ ⊤`.


theorem Int.dvd_neg : ∀ {a b : ℤ}, a ∣ -b ↔ a ∣ b := by sorry

This theorem states that for all integers `a` and `b`, `a` divides `-b` if and only if `a` divides `b`. In other words, the divisibility relationship between two integers is not affected by the sign of the dividend. This is because, in integer arithmetic, a number is considered to divide another number if there is an integer quotient such that the product of the divisor and the quotient equals the dividend. Changing the sign of the dividend simply changes the sign of the quotient, but does not affect the fundamental divisibility relationship.

For all integers `a` and `b`, `a` divides `b` if and only if `a` divides `-b`.


/-- An induction principle for permutations. If `P` holds for the identity permutation, and
is preserved under composition with a non-trivial swap, then `P` holds for all permutations.  -/
theorem Equiv.Perm.swap_induction_on :
    ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Finite α] {P : Equiv.Perm α → Prop} (f : Equiv.Perm α),
      P 1 → (∀ (f : Equiv.Perm α) (x y : α), x ≠ y → P f → P (Equiv.swap x y * f)) → P f :=
  by sorry

This theorem provides an induction principle for permutations. It states that for any type `α` with decidable equality and finiteness, given a property `P` of permutations of `α`, if `P` is true for the identity permutation and remains true after composition with a non-trivial swap (swapping two distinct elements), then `P` is true for all permutations. In other words, we can prove a property about all permutations by proving it for the identity permutation and for the result of composing any permutation (already assumed to have the property) with a swap.

If `P` is a property of permutations of a type `α` with decidable equality and finiteness such that `P` holds for the identity permutation and is closed under swapping distinct elements, then `P` holds for all permutations.


theorem StrictMono.id_le : ∀ {φ : ℕ → ℕ}, StrictMono φ → ∀ (n : ℕ), n ≤ φ n := by sorry

The theorem `StrictMono.id_le` states that for all functions `φ` from natural numbers to natural numbers, if `φ` is strictly monotone (i.e., for any two natural numbers `a` and `b` such that `a < b`, `φ(a) < φ(b)`), then for any natural number `n`, `n` is less than or equal to `φ(n)`. This implies that a strictly monotone function on natural numbers always maps a number to itself or a larger number.

If `φ` is a strictly monotone function from natural numbers to natural numbers, then for all `n`, `n ≤ φ(n)`.


/-- Any partial order can be extended to a linear order.
 -/
theorem extend_partialOrder :
    ∀ {α : Type u} (r : α → α → Prop) [inst : IsPartialOrder α r], ∃ s, IsLinearOrder α s ∧ r ≤ s := by sorry

This theorem states that for any given partial order on a set, it can always be extended to a linear order. The partial order is represented by a relation 'r' on a type 'α'. The theorem guarantees the existence of a relation 's' such that 's' is a linear order on 'α', and every relation in 'r' is also in 's'. In other words, the linear order 's' extends the partial order 'r'.

Given any partial order relation on a set, there exists a linear order relation that extends it.


theorem Ordinal.mex_le_of_ne :
    ∀ {ι : Type u_4} {f : ι → Ordinal.{max u_5 u_4}} {a : Ordinal.{max u_5 u_4}},
      (∀ (i : ι), f i ≠ a) → Ordinal.mex f ≤ a :=
  by sorry

The theorem `Ordinal.mex_le_of_ne` states that for any type `ι`, any function `f` mapping from `ι` to Ordinals, and any ordinal `a`, if `a` is not equal to `f(i)` for all `i` in `ι`, then the minimum excluded ordinal in the family of ordinals given by `f` is less than or equal to `a`. In other words, if `a` is an ordinal that is not in the range of `f`, then `a` is greater than or equal to the smallest ordinal that is also not in the range of `f`.

For any type `ι`, function `f` from `ι` to Ordinals, and ordinal `a`, if `a` is not in the image of `f`, then there exists an ordinal `x` in the image of `f` such that `x < a`.


theorem HahnSeries.support_zero :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R], HahnSeries.support 0 = ∅ := by sorry

This theorem states that for any types `Γ` and `R`, where `Γ` is a partially ordered set and `R` has a zero element, the support of a zero Hahn series is an empty set. In other words, the set of indices whose coefficients are nonzero in a zero Hahn series is empty, since all coefficients in a zero Hahn series are zero.

For any partially ordered set Γ and type R with a zero element, the coefficients of a zero Hahn series over (Γ, R) are all zero, implying an empty support.


theorem nhdsWithin_eq_map_subtype_coe :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {a : α} (h : a ∈ s),
      nhdsWithin a s = Filter.map Subtype.val (nhds { val := a, property := h }) :=
  by sorry

This theorem states that for any topological space `α`, any set `s` in `α`, and any element `a` in `α` such that `a` belongs in `s`, the neighborhood of `a` within `s` is equal to the filter map of the subtype value function on the neighborhood of the subtype of `a` with the property `h` (i.e., `a` belongs in `s`). In other words, it is saying that the concept of neighborhood within a set in topological space corresponds to applying the filter map to the neighborhood of the subtype that consists of elements in the set.

For any topological space `α`, set `s ∈ α`, and `a ∈ s`, the neighborhood filter of `a` in `s` is equal to the filter map of the subtype value function on the neighborhood filter of the subtype of `a` in `s`.


/-- The basis of open subgroups for the topology on a ring determined by a valuation.  -/
theorem Valuation.subgroups_basis :
    ∀ {R : Type u} [inst : Ring R] {Γ₀ : Type v} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀),
      RingSubgroupsBasis fun γ => Valuation.ltAddSubgroup v γ :=
  by sorry

This theorem asserts that for any ring `R` and any `Γ₀` which is a linearly ordered commutative group with zero, given any valuation `v` from `R` to `Γ₀`, the set of subgroups of `R` which consist of elements whose valuation is less than a certain unit form a basis for the topology on the ring `R` determined by the valuation `v`. This means that each open set in this topological space can be represented as a union of these subgroups.

For any ring `R` and linearly ordered commutative group with zero `Γ₀`, the subgroups of `R` consisting of elements with valuation less than a fixed unit form a basis for the topology on `R` determined by any valuation from `R` to `Γ₀`.


Set.WellFoundedOn.subset

theorem Set.WellFoundedOn.subset :
    ∀ {α : Type u_2} {r : α → α → Prop} {s t : Set α}, Set.WellFoundedOn t r → s ⊆ t → Set.WellFoundedOn s r := by sorry

This theorem states that for any type `α`, any relation `r` on `α`, and any two sets `s` and `t` of type `α`, if the relation `r` is well-founded on set `t` and set `s` is a subset of `t`, then the relation `r` is also well-founded on set `s`. Here, a relation `r` is said to be well-founded on a set if every non-empty subset has a minimal element under the relation.

If relation `r` is well-founded on set `t` and `s` is a subset of `t`, then `r` is well-founded on `s`.


theorem inv_mul_lt_iff :
    ∀ {α : Type u_2} [inst : LinearOrderedSemifield α] {a b c : α}, 0 < b → (b⁻¹ * a < c ↔ a < b * c) := by sorry

This theorem, `inv_mul_lt_iff`, states that for any type `α` that forms a linear ordered semiring, given any three elements `a`, `b`, and `c` of this type with `b` being positive, the statement "the inverse of `b` multiplied by `a` is less than `c`" is equivalent to the statement "`a` is less than `b` multiplied by `c`".

For any linear ordered semiring type `α` and positive elements `a`, `b`, and `c` of `α`, `a < b * c` if and only if `b⁻¹ * a < c`.


/-- Adding a multiple of the first vector passed to `oangle` to the second vector does not change
the sign of the angle.  -/
theorem Orientation.oangle_sign_smul_add_right :
    ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V) (r : ℝ),
      Real.Angle.sign (Orientation.oangle o x (r • x + y)) = Real.Angle.sign (Orientation.oangle o x y) :=
  by sorry

The theorem `Orientation.oangle_sign_smul_add_right` states that for any real number `r` and vectors `x` and `y` in a real 2-dimensional inner product space `V` with an orientation `o`, the sign of the oriented angle from `x` to `r • x + y` (i.e., the vector obtained by scaling `x` by `r` and adding `y`) is the same as the sign of the oriented angle from `x` to `y`. Here, the "sign" of an angle is defined as `0` if the angle is `0` or `π`, `1` if the angle is strictly between `0` and `π`, and `-1` if the angle is strictly between `-π` and `0`. This property essentially says that adding a scalar multiple of one vector to another doesn't change the overall direction of the angle between them.

The sign of the oriented angle between vectors `x` and `r * x + y` in a 2-dimensional inner product space with orientation `o` is equal to the sign of the oriented angle between `x` and `y`.


theorem CategoryTheory.ι_preservesColimitsIso_inv :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) {J : Type w}
      [inst_2 : CategoryTheory.Category.{w', w} J] (F : CategoryTheory.Functor J C)
      [inst_3 : CategoryTheory.Limits.PreservesColimit F G] [inst_4 : CategoryTheory.Limits.HasColimit F] (j : J),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp F G) j)
          (CategoryTheory.preservesColimitIso G F).inv =
        G.map (CategoryTheory.Limits.colimit.ι F j) :=
  by sorry

The theorem `CategoryTheory.ι_preservesColimitsIso_inv` states that for any category `C` and `D`, given a functor `G` from `C` to `D` and another functor `F` from a category `J` to `C`, if `G` preserves colimits of `F` and `F` has a colimit, then for any object `j` in `J`, the composition of the morphism from `F` composed with `G` to the colimit object of `F` composed with `G` and the inverse of the isomorphism induced by the preservation of colimits of `F` by `G`, is equal to the morphism induced by `G` mapping the morphism from `F` to the colimit object of `F`.
In other words, this theorem asserts the commutativity of the relevant diagram in the context of category theory.

Given functors `G: C -> D` and `F: J -> C` with `G` preserving colimits of `F` and `F` having a colimit, the diagram commutes: `(F i) ⊣ (G X) ≈ (G (F i) ∨)_∘ G (i -> X)`, where `i` is an object in `J`, `X` is the colimit of `F`, and `→` denotes the composition of morphisms.


IsOpen.uniqueDiffWithinAt

theorem IsOpen.uniqueDiffWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E}, IsOpen s → x ∈ s → UniqueDiffWithinAt 𝕜 s x :=
  by sorry

The theorem `IsOpen.uniqueDiffWithinAt` states that for any nontrivially normed field `𝕜`, any normed additively commutative group `E` that is also a normed space over `𝕜`, any element `x` of `E`, and any set `s` of `E` that is open in the topological space of `E`, if `x` is an element of `s`, then `s` is uniquely differentiable at `x`. In other words, it asserts the uniqueness of differentiation within an open set in a normed space at a particular point that belongs to the set.

In a normed space over a nontrivially normed field, if an element is differentiable and belongs to an open set, then the set is uniquely differentiable at that element.


ContinuousWithinAt.congr

theorem ContinuousWithinAt.congr :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f f₁ : α → β} {s : Set α}
      {x : α}, ContinuousWithinAt f s x → (∀ y ∈ s, f₁ y = f y) → f₁ x = f x → ContinuousWithinAt f₁ s x :=
  by sorry

The theorem `ContinuousWithinAt.congr` states that for any types `α` and `β` equipped with topological structures, given two functions `f` and `f₁` from `α` to `β`, a subset `s` of `α` and a point `x` in `α`, if `f` is continuous at `x` within the subset `s` and `f₁` equals `f` for every point in `s` (i.e., `f₁ y = f y` for all `y` in `s`) and also at the point `x`, then `f₁` is also continuous at `x` within the subset `s`. In other words, the continuity of a function at a point within a subset is preserved under a pointwise equivalent function on that subset.

If a function is continuous at a point in a subset and pointwise equal to another function on that subset, then the second function is also continuous at that point in the subset.


theorem CategoryTheory.ShortComplex.RightHomologyData.p_descQ_assoc :
    ∀ {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.RightHomologyData S) {A : C} (k : S.X₂ ⟶ A)
      (hk : CategoryTheory.CategoryStruct.comp S.f k = 0) {Z : C} (h_1 : A ⟶ Z),
      CategoryTheory.CategoryStruct.comp h.p
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.descQ h k hk) h_1) =
        CategoryTheory.CategoryStruct.comp k h_1 :=
  by sorry

The theorem `CategoryTheory.ShortComplex.RightHomologyData.p_descQ_assoc` states that in the context of a category `C` which has zero morphisms, for any short complex `S` in `C` and any right homology data `h` of `S`, given a morphism `k` from `S.X₂` to some object `A` in `C` such that the composition of `S.f` and `k` is zero, and another morphism `h_1` from `A` to some object `Z` in `C`, the composition of `h.p` with the composition of the description `descQ` of `h` with `k` and `h_1` is equal to the composition of `k` and `h_1`. In simpler terms, it is a property of composition of morphisms in the context of a short complex and its right homology data in a category with zero morphisms.

In a category with zero morphisms, for any short complex and its right homology data, the composition of the homology data's `p` map with the description of `h` through a zero-composing morphism and another morphism is equal to the composition of those morphisms.


LipschitzWith.eval

theorem LipschitzWith.eval :
    ∀ {ι : Type x} {α : ι → Type u} [inst : (i : ι) → PseudoEMetricSpace (α i)] [inst_1 : Fintype ι] (i : ι),
      LipschitzWith 1 (Function.eval i) :=
  by sorry

This theorem states that for any type `ι`, any function `α` from `ι` to a type, where each type `α i` is a pseudoemetric space, and for any `ι` that is a finite type, the evaluation function at any `ι` is Lipschitz continuous with constant 1. In other words, the distance between the function values at any two points is less than or equal to the distance between the points themselves in the pseudoemetric space.

For any finite type `ι` and a function `α:` `ι` → `M` with each `M(i)` being a pseudo-metric space, the evaluation function `α` is Lipschitz continuous with constant 1.


/-- Möbius inversion for functions to an `AddCommGroup`, where the equalities only hold on a
well-behaved set.  -/
theorem ArithmeticFunction.sum_eq_iff_sum_smul_moebius_eq_on :
    ∀ {R : Type u_1} [inst : AddCommGroup R] {f g : ℕ → R} (s : Set ℕ),
      (∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s) →
        ((∀ n > 0, n ∈ s → (Finset.sum (Nat.divisors n) fun i => f i) = g n) ↔
          ∀ n > 0,
            n ∈ s → (Finset.sum (Nat.divisorsAntidiagonal n) fun x => ArithmeticFunction.moebius x.1 • g x.2) = f n) :=
  by sorry

This theorem, named `ArithmeticFunction.sum_eq_iff_sum_smul_moebius_eq_on`, is about the Möbius inversion principle for functions mapping to an additive commutative group (denoted by `R`), but the principle only holds on a well-behaved set (`s`).

For given functions `f` and `g` from natural numbers to `R`, and a set `s` of natural numbers which is 'closed' under divisors (i.e., if `m` divides `n` and `n` is in `s`, then `m` must also be in `s`), the theorem states the following:

The condition that, for every natural number `n` greater than zero in the set `s`, the sum of `f` over the divisors of `n` equals `g(n)`, is equivalent to the condition that, for every such `n`, the sum over the divisors' antidiagonal of the Möbius function applied to the first element of the antidiagonal pair, scaled by `g` applied to the second element of the pair, equals `f(n)`.

In other words, it provides a way of 'inverting' the operation of summing a function over the divisors of a number, using the Möbius function. The term 'antidiagonal' refers to pairs of numbers (`x`, `y`) such that `x * y = n`.

For functions `f` and `g` from natural numbers to an additive commutative group, and a set `s` of natural numbers closed under divisors, the sum of `f` over the divisors of each `n` in `s` equals `g(n)` if and only if the sum of the Möbius function scaled by `g` over the antidiagonals of `s` equals `f`.


theorem MeasureTheory.measurePreserving_mul_right :
    ∀ {G : Type u_2} [inst : MeasurableSpace G] [inst_1 : Mul G] [inst_2 : MeasurableMul G]
      (μ : MeasureTheory.Measure G) [inst_3 : MeasureTheory.Measure.IsMulRightInvariant μ] (g : G),
      MeasureTheory.MeasurePreserving (fun x => x * g) μ μ :=
  by sorry

This theorem states that for any type `G` that has a measurable space, a multiplication operation, and a measurable multiplication operation, along with a measure `μ` that is right invariant under multiplication, the function that multiplies each element by a fixed element `g` from `G` preserves the measure `μ`. In other words, the measure of any set under this multiplication operation is the same as the measure of the original set.

For any measurable space `(G, Σ, μ)` with right-invariant measure `μ` under multiplication and measurable multiplication operation, the function `x ↦ g * x` preserves the measure `μ`, i.e., `μ(g * E) = μ(E)` for every set `E ∈ Σ`.


theorem Commute.right_comm :
    ∀ {S : Type u_2} [inst : Semigroup S] {b c : S}, Commute b c → ∀ (a : S), a * b * c = a * c * b := by sorry

This theorem, named `Commute.right_comm`, states that for any type `S` that forms a semigroup, if two elements `b` and `c` commute (i.e., `b * c = c * b`), then for any element `a` from the same semigroup, the multiplication `a * b * c` is equal to `a * c * b`. Essentially, this theorem is asserting the right multiplication commutivity when `b` and `c` commute.

For any semigroup `S` and elements `a`, `b`, and `c` in `S` such that `b * c = c * b`, it follows that `a * b * c = a * c * b`.


theorem AddSubgroup.coe_zero : ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), ↑0 = 0 := by sorry

This theorem states that for any given additive subgroup `H` of a given type `G` (where `G` is an additive group), the additive identity (zero) in the additive group `G` is the same as the additive identity in the underlying set of `H`. In mathematical terms, this means that for any additive subgroup `H` of an additive group `G`, the identity element 0 of `G` is the same as the identity element 0 of `H` when `H` is considered as a subset of `G`.

The additive identity of an additive subgroup is the same as the additive identity of its underlying set in an additive group.


theorem AddSubgroup.addSubgroupOf_inj :
    ∀ {G : Type u_1} [inst : AddGroup G] {H₁ H₂ K : AddSubgroup G},
      AddSubgroup.addSubgroupOf H₁ K = AddSubgroup.addSubgroupOf H₂ K ↔ H₁ ⊓ K = H₂ ⊓ K :=
  by sorry

This theorem states that for any additive group `G` and any subgroups `H₁`, `H₂`, and `K` from `G`, the function `AddSubgroup.addSubgroupOf` is injective if and only if the intersection of `H₁` and `K` is equal to the intersection of `H₂` and `K`. In other words, two subgroups `H₁` and `H₂` of a given group `G` are viewed identically from the perspective of another subgroup `K` (i.e., `AddSubgroup.addSubgroupOf H₁ K = AddSubgroup.addSubgroupOf H₂ K`) if and only if their intersections with `K` are the same (i.e., `H₁ ⊓ K = H₂ ⊓ K`).

The function `AddSubgroup.addSubgroupOf` from `AddSubgroup` is injective on subgroups of an additive group `G` if and only if the intersections of any two subgroups with a fixed subgroup `K` are equal.


IsLocalHomeomorph.isOpenMap

/-- A local homeomorphism is an open map.  -/
theorem IsLocalHomeomorph.isOpenMap :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
      IsLocalHomeomorph f → IsOpenMap f :=
  by sorry

The theorem `IsLocalHomeomorph.isOpenMap` states that for any two types `X` and `Y` with topological space structures, any function `f` from `X` to `Y` that is a local homeomorphism is also an open map. In other words, if for every point `x` in `X`, there is a partial homeomorphism `e` such that `x` is in the source of `e` and `f` is equivalent to `e`, then the image of any open set in `X` under `f` is an open set in `Y`.

A local homeomorphism between topological spaces is an open map.


theorem SimpleGraph.Embedding.map_adj_iff :
    ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ↪g G') {v w : V},
      G'.Adj (f v) (f w) ↔ G.Adj v w :=
  by sorry

This theorem states that for any types `V` and `W`, and any simple graphs `G` of type `V` and `G'` of type `W`, and for any embedding `f` from `G` to `G'`, and any vertices `v` and `w` in `G`, the vertices `f(v)` and `f(w)` in `G'` are adjacent if and only if `v` and `w` in `G` are adjacent. In other words, the embedding `f` preserves adjacency relationships between vertices.

For any simple graph embeddings f between types V and W, if v and w are adjacent vertices in the graph V, then f(v) and f(w) are adjacent vertices in the graph W.


theorem Mathlib.Data.List.Basic._auxLemma.24 :
    ∀ {α : Type u} {l : List α}, (Option.isNone (List.getLast? l) = true) = (l = []) := by sorry

This theorem, `Mathlib.Data.List.Basic._auxLemma.24`, states that for all types `α` and all lists `l` of type `α`, the function `Option.isNone` applied to the result of the function `List.getLast?` on `l` is equal to `true` if and only if the list `l` is empty. In other words, the last element of a list cannot be retrieved (and the retrieval results in `none`) if and only if the list is empty.

The theorem `Mathlib.Data.List.Basic._auxLemma.24` in Lean 4 states that the last element of an empty list is `none` (i.e., `Option.isNone (List.getLast? l)` holds if and only if `l` is empty.


theorem Order.isSuccLimit_of_succ_lt :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] {b : α},
      (∀ a < b, Order.succ a < b) → Order.IsSuccLimit b :=
  by sorry

The theorem `Order.isSuccLimit_of_succ_lt` states that for any type `α` with a partial order and a successor order, if for any element `a` that is less than a given element `b`, the successor of `a` is also less than `b`, then `b` is a successor limit. In other words, `b` is a successor limit if it is not the successor of any element that is less than it.

If for all `a` such that `a < b` in a partially ordered type `α`, it holds that `a < succ(b)`, then `b` is a successor limit.


theorem SmoothBumpFunction.tsupport_subset_symm_image_closedBall :
    ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
      {H : Type uH} [inst_3 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM}
      [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {c : M} (f : SmoothBumpFunction I c)
      [inst_6 : T2Space M],
      tsupport ↑f ⊆
        ↑(PartialEquiv.symm (extChartAt I c)) '' (Metric.closedBall (↑(extChartAt I c) c) f.rOut ∩ Set.range ↑I) :=
  by sorry

This theorem states that for any normed additive commutative group `E`, which is a normed space over ℝ and is finite dimensional, and for any topological space `H` with a model with corners `I` to `E`, any "charted space" `M` over `H` with a specific point `c` in `M`, and a smooth bump function `f` based on `I` and centered at `c`, in a T2 (Hausdorff) space `M`, the topological support of `f` is a subset of the set obtained by mapping the intersection of the closed ball of radius `f.rOut` centered at the image of `c` under the extension of the chart at `c` and the range of `I` under the inverse of the extension of the chart at `c`.

In other words, the set of all points where the smooth bump function does not vanish is contained within a certain region defined by the model with corners, the chart at the point `c`, and the radius `f.rOut` of the smooth bump function. This region is within the inverse image of the intersection of a closed ball in the model space and the range of the model with corners under the extension of the chart at `c`.

For any finite-dimensional normed space `E` over ℝ, charted space `M` over a T2 topological space `H` with a smooth bump function `f` and radius `rOut`, the support of `f` is contained in the inverse image of the intersection of the closed ball of radius `rOut` around `f(c)` in `E` and the range of `I` under the extension of the chart at `c`.


theorem map_fst_nhds :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (x : X × Y),
      Filter.map Prod.fst (nhds x) = nhds x.1 :=
  by sorry

This theorem, `map_fst_nhds`, states that for any types `X` and `Y` with topological space structures, and for any point `x` in the product space `X × Y`, the map of the neighborhood filter at `x` under the first projection `Prod.fst` is the neighborhood filter at `x.1` (i.e., `Prod.fst x`). In other words, if we take the filter of all neighborhoods of a point in the product space `X × Y`, and then project each of these neighborhoods onto the `X` space, we get the neighborhood filter of the projection of the point in `X`.

For any topological spaces X and Y and point (x, y) in X × Y, the neighborhood filter of x in X under the first projection is equal to the neighborhood filter of y in X × Y under the first projection.


theorem EuclideanSpace.single_apply :
    ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] (i : ι) (a : 𝕜) (j : ι),
      EuclideanSpace.single i a j = if j = i then a else 0 :=
  by sorry

The theorem `EuclideanSpace.single_apply` states that for any types `ι` and `𝕜`, where `𝕜` is RCLike and `ι` has decidable equality, given elements `i` and `j` of `ι` and an element `a` of `𝕜`, the application of the `EuclideanSpace.single` function to `i` and `a` at the point `j` is `a` if `j` equals `i` and `0` otherwise. In other words, the function `EuclideanSpace.single` assigns the value `a` to the coordinate indexed by `i` and assigns `0` to all other coordinates in a Euclidean space.

For any type `ι` with decidable equality and `𝕜` an RCLike ring, the function `EuclideanSpace.single` assigns the value `a` to the `i`-th coordinate and `0` to all other coordinates in a Euclidean space.


/-- A version of `dist_le_Ico_sum_dist` with each intermediate distance replaced
with an upper estimate.  -/
theorem dist_le_Ico_sum_of_dist_le :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {f : ℕ → α} {m n : ℕ},
      m ≤ n →
        ∀ {d : ℕ → ℝ},
          (∀ {k : ℕ}, m ≤ k → k < n → dist (f k) (f (k + 1)) ≤ d k) →
            dist (f m) (f n) ≤ Finset.sum (Finset.Ico m n) fun i => d i :=
  by sorry

This theorem, `dist_le_Ico_sum_of_dist_le`, states that in a pseudo metric space `α`, for any function `f` from natural numbers to `α`, and for any two natural numbers `m` and `n` such that `m` is less than or equal to `n`, if for every natural number `k` between `m` and `n` (exclusive), the distance between `f(k)` and `f(k+1)` is less than or equal to `d(k)`, then the distance between `f(m)` and `f(n)` is less than or equal to the sum of `d(i)` for each `i` in the finite set of natural numbers from `m` to `n` (including `m` but excluding `n`). Essentially, the total distance from `f(m)` to `f(n)` is bounded above by the sum of the upper estimates for each individual step from `f(k)` to `f(k+1)`.

In a pseudo metric space, given a function from natural numbers to the space and natural numbers m <= n, if the distance between successive function values is less than or equal to the given distance d(i) for all i from m to n-1, then the distance between the function values at m and n is less than or equal to the sum of the distances d(i) from m to n.


theorem Mathlib.MeasureTheory.Measure.Stieltjes._auxLemma.15 :
    ∀ {p q : ℝ}, 0 ≤ p → 0 ≤ q → ENNReal.ofReal p + ENNReal.ofReal q = ENNReal.ofReal (p + q) := by sorry

This theorem, from the Measure Theory module in Mathlib, states that for any two real numbers `p` and `q` that are both nonnegative, the function `ENNReal.ofReal` (which returns the input if it is nonnegative, otherwise returns `0`) preserves addition. In mathematical terms, applying the `ENNReal.ofReal` function to the sum of `p` and `q` (`p + q`) gives the same result as individually applying `ENNReal.ofReal` to `p` and `q` and then adding those results.

For all nonnegative real numbers `p` and `q`, `ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q`.


theorem Submodule.mk_eq_zero :
    ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
      (p : Submodule R M) {x : M} (h : x ∈ p), { val := x, property := h } = 0 ↔ x = 0 :=
  by sorry

This theorem states that for any semiring `R`, commutative add monoid `M`, and `M` as an `R`-module, given a submodule `p` of `M` and an element `x` of `M` such that `x` belongs to the submodule `p`, the submodule element denoted by `{ val := x, property := h }` is equal to the zero element if and only if `x` itself is the zero element. Essentially, it asserts that an element of a submodule is zero if and only if the corresponding element in the original module is zero.

For any semiring R, commutative add monoid M, and R-module structure on M, an element x of M belongs to the submodule p if and only if the submodule element {val := x, property := h} equals the zero element. In other words, x is in the submodule p if and only if the submodule element representing x is zero.


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

The theorem `ContMDiffOn.of_le` states that, for all types `𝕜`, `E`, `H`, `I`, `M`, `E'`, `H'`, `I'`, `M'`, `f`, `s`, `m` and `n`, if the space `𝕜` is a nontrivially normed field, `E` and `E'` are normed additive commutative groups, `E` and `E'` are normed over `𝕜`, `H`, `H'`, `M`, and `M'` are topological spaces, `I` and `I'` are models with corners over `𝕜`, `E`, `H`, `E'` and `H'` respectively, `M` and `M'` are charted spaces over `H` and `H'` respectively, `f` is a function from `M` to `M'`, `s` is a set in `M`, and `n` is a smoothness level, if `f` is `n` times continuously differentiable on `s`, and `m` is less than or equal to `n`, then `f` is `m` times continuously differentiable on `s`.

If `𝕜` is a nontrivially normed field, `f` is `n` times continuously differentiable on a set `s` in the charted spaces `M` and `M'` over topological spaces `H` and `H'`, respectively, then `f` is `m` times continuously differentiable on `s` for any `m` less than or equal to `n`.


theorem HahnSeries.zero_coeff :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] {a : Γ}, 0.coeff a = 0 := by sorry

The theorem `HahnSeries.zero_coeff` states that for any given types `Γ` and `R`, where `Γ` is a partial order and `R` is a zero object, the coefficient of any element `a` of type `Γ` in the zero Hahn series is zero. In other words, the zero Hahn series has all its coefficients equal to zero.

For any partial order `Γ` and zero object `R`, the zero Hahn series has all coefficients equal to zero.


theorem SimpleGraph.Walk.fst_mem_support_of_mem_edges :
    ∀ {V : Type u} {G : SimpleGraph V} {t u v w : V} (p : SimpleGraph.Walk G v w),
      s(t, u) ∈ SimpleGraph.Walk.edges p → t ∈ SimpleGraph.Walk.support p :=
  by sorry

The theorem `SimpleGraph.Walk.fst_mem_support_of_mem_edges` states that, for any type `V`, any simple graph `G` of type `V`, and any vertices `t`, `u`, `v`, `w` of type `V`, if a walk `p` exists in the graph `G` from `v` to `w`, and the edge `(t, u)` is in the list of edges visited by the walk `p`, then the vertex `t` is in the list of vertices visited by the walk `p`. In other words, if a particular edge is visited during a walk, then the first vertex of that edge is definitely visited during the walk.

If a simple graph walk visits an edge (t, u), then the vertex t is in the visited set of the walk.


theorem ENNReal.rpow_ofNat : ∀ (x : ENNReal) (n : ℕ) [inst : Nat.AtLeastTwo n], x ^ OfNat.ofNat n = x ^ OfNat.ofNat n :=
  by sorry

This theorem states that for any extended nonnegative real number 'x' and any natural number 'n' that is at least two, the power of 'x' raised to the value 'n' (converted to the relevant type via the `OfNat.ofNat` function) is equal to itself. In other words, for any given values of 'x' and 'n', the operation 'x' raised to the power of 'n' is idempotent in the space of extended nonnegative real numbers.

 For any extended nonnegative real number x and natural number n ≥ 2, x^(OfNat.ofNat n) = x^(OfNat.ofNat n)^(OfNat.ofNat n).

Or, in simpler mathematical notation:

For any x ∈ ℝᵀ⁺ and n ∈ ℕ with n ≥ 2, x^n = x^n ^ n.


theorem SmoothBumpCovering.apply_ind :
    ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : FiniteDimensional ℝ E] {H : Type uH} [inst_3 : TopologicalSpace H] {I : ModelWithCorners ℝ E H}
      {M : Type uM} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M}
      (fs : SmoothBumpCovering ι I M s) (x : M) (hx : x ∈ s), ↑(fs.toFun (SmoothBumpCovering.ind fs x hx)) x = 1 :=
  by sorry

The theorem `SmoothBumpCovering.apply_ind` states that, given a smooth bump covering `fs` (a partition of unity by smooth functions with compact support) of a set `s` in a differentiable manifold `M`, for any point `x` in `s`, the value of the function associated with the index `(SmoothBumpCovering.ind fs x hx)` at `x` is equal to 1. The context assumes `M` to be a charted space modeled on a finite-dimensional normed space `E` over real numbers, and the set `s` is a subset of `M`.

For any smooth bump covering `fs` of a subset `s` in a differentiable manifold `M`, the function associated with the index of `x` in `s` according to `fs` equals 1 at `x`.


theorem CochainComplex.HomComplex.Cocycle.homOf.proof_1 : ∀ (i : ℤ), i + 0 = i := by sorry

This theorem, `CochainComplex.HomComplex.Cocycle.homOf.proof_1`, states that for any integer `i`, adding zero to `i` results in `i` itself. This is essentially the additive identity property, which asserts that the sum of any number and zero is the original number.


theorem ProbabilityTheory.kernel.iIndepSet.indep_generateFrom_le :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : LinearOrder ι]
      [inst_1 : ProbabilityTheory.IsMarkovKernel κ] {s : ι → Set Ω},
      (∀ (n : ι), MeasurableSet (s n)) →
        ProbabilityTheory.kernel.iIndepSet s κ μ →
          ∀ (i : ι) {k : ι},
            i < k →
              ProbabilityTheory.kernel.Indep (MeasurableSpace.generateFrom {s k})
                (MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}) κ μ :=
  by sorry

This theorem states that for all types `α`, `Ω`, `ι` equipped with measurable spaces `_mα`, `_mΩ` respectively, and any kernel `κ` from a probability theory, measure `μ` from measure theory and a family of sets `s` indexed by `ι`, if for all `n` in `ι`, `s n` is a measurable set and the family of sets `s` is independent, then for any `i` in `ι` and any `k` in `ι` such that `i` is less than `k`, the independence holds between the measure space generated by `{s k}` and the measure space generated by the set of all `t` such that there exists `j` less than or equal to `i` for which `s j` equals `t`. Here, the independence is in the context of a probability theory kernel and a measure from measure theory. The independence of a family of sets is defined by the independence of the family of measurable space structures they generate.

Given measurable spaces `αm`, `Ωm`, a probability kernel `κ`, a measure `μ`, and a family `s` of measurable sets indexed by `ι` that is independent and has each member `sn` measurable, for all `i < k` in `ι`, the measure spaces generated by `{sk}` and `{t | ∃j ≤ i. sj = t}` are independent.


theorem Polynomial.nthRootsFinset_zero :
    ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R], Polynomial.nthRootsFinset 0 R = ∅ := by sorry

The theorem `Polynomial.nthRootsFinset_zero` states that for any commutative ring `R` that is also an integral domain, the set of zeroth roots of unity in `R` is the empty set. In other words, there are no elements in `R` that satisfy the equation `x^0 = 1` where `x` is an element in `R`, except the case where `0 = 0`.

In an integral domain, there are no non-zero zeroth roots of unity.


/-- If `‖φ‖` is eventually bounded by `c`, and `u =ᶠ[l] φ * v`, then we have `IsBigOWith c u v l`.
This does not require any assumptions on `c`, which is why we keep this version along with
`IsBigOWith_iff_exists_eq_mul`.  -/
theorem Asymptotics.isBigOWith_of_eq_mul :
    ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] {c : ℝ} {l : Filter α} {u v : α → R} (φ : α → R),
      (∀ᶠ (x : α) in l, ‖φ x‖ ≤ c) → u =ᶠ[l] φ * v → Asymptotics.IsBigOWith c l u v :=
  by sorry

The theorem `Asymptotics.isBigOWith_of_eq_mul` states that if the norm of a function `φ` is eventually bounded by a constant `c`, and another function `u` is equal to the product of `φ` and `v` almost everywhere with respect to a filter `l`, then `u` is big-O of `v` with constant `c` and filter `l`. This signifies that the magnitude of `u` is eventually, for `l`, at most `c` times the magnitude of `v`. This theorem does not require any conditions on `c`, which differentiates it from `IsBigOWith_iff_exists_eq_mul`.

If a function `φ` is eventually bounded by a constant `c` and equals the product of functions `φ` and `v` almost everywhere with respect to a filter `l`, then `φ` is big-O of `v` with constant `c` and filter `l`.


theorem CategoryTheory.MonoidalCategory.tensorHom_def' :
    ∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X₁ Y₁ X₂ Y₂ : C}
      (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
      CategoryTheory.MonoidalCategory.tensorHom f g =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X₁ g)
          (CategoryTheory.MonoidalCategory.whiskerRight f Y₂) :=
  by sorry

This theorem in category theory states that for any category `C` with monoidal structure, and any four objects `X₁`, `Y₁`, `X₂`, `Y₂` in `C`, and morphisms `f : X₁ ⟶ Y₁` and `g : X₂ ⟶ Y₂`, the tensor product of `f` and `g` is equal to the composition of the left whiskering of `g` with `X₁` and the right whiskering of `f` with `Y₂`. Here, whiskering refers to a certain operation involving a morphism and an object in a category, and the tensor product of morphisms is a way of combining two morphisms into one.

For any category with monoidal structure, the tensor product of morphisms `f : X₁ ⟶ Y₁` and `g : X₂ ⟶ Y₂` is equal to the composition of the left whiskering of `g` with `X₁` and the right whiskering of `f` with `Y₂`.


/-- A morphism into the opposite monoid acts on the product by acting on the reversed elements.  -/
theorem unop_map_list_prod :
    ∀ {M : Type u_3} {N : Type u_4} [inst : Monoid M] [inst_1 : Monoid N] {F : Type u_9} [inst_2 : FunLike F M Nᵐᵒᵖ]
      [inst_3 : MonoidHomClass F M Nᵐᵒᵖ] (f : F) (l : List M),
      MulOpposite.unop (f (List.prod l)) = List.prod (List.reverse (List.map (MulOpposite.unop ∘ ⇑f) l)) :=
  by sorry

The theorem `unop_map_list_prod` states that for any two monoids `M` and `N`, a function `F` that is a homomorphism from `M` to the opposite monoid of `N`, and a list `l` of elements of `M`, the application of the function `F` to the product of the elements in `l`, when unop'ed (i.e., converted back from the opposite monoid), gives the same result as the product of the reversed list obtained by mapping the unop'ed function `F` over `l`. In simpler terms, it states that a morphism into the opposite monoid affects the product of a list of monoid elements by acting on the elements in the reversed order.

For any monoids M and N, a homomorphism F from M to the opposite monoid of N preserves the product of lists, that is, F (prod xs) = prod (reverse (map F (unop xs))) where unop denotes the operation of converting an element from the opposite monoid back to the original monoid.


theorem MvPolynomial.C_injective :
    ∀ (σ : Type u_2) (R : Type u_3) [inst : CommSemiring R], Function.Injective ⇑MvPolynomial.C := by sorry

The theorem `MvPolynomial.C_injective` states that for any type `σ` and any type `R` (where `R` is a commutative semiring), the function `MvPolynomial.C`, which generates a constant polynomial with value from `R`, is injective. This means that if two constant polynomials are equal, then their corresponding values from `R` are also equal. In other words, no two different values from the commutative semiring `R` can yield the same constant polynomial when passed through the `MvPolynomial.C` function.

The function `MvPolynomial.C` mapping elements of a commutative semiring `R` to the constant polynomials over a type `σ` is an injection.


Asymptotics.IsBigO.sub

theorem Asymptotics.IsBigO.sub :
    ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
      {l : Filter α} {f₁ f₂ : α → E'}, f₁ =O[l] g → f₂ =O[l] g → (fun x => f₁ x - f₂ x) =O[l] g :=
  by sorry

This theorem, `Asymptotics.IsBigO.sub`, is stating a property about Big O notation in the context of limits in functional analysis. Specifically, it states that for any types `α`, `F`, and `E'` where `F` is a normed space and `E'` is a semi-normed additive commutative group, and for any function `g : α → F` and filter `l : Filter α` and functions `f₁, f₂ : α → E'`, if `f₁ =O[l] g` and `f₂ =O[l] g` (that is, `f₁` and `f₂` are Big O of `g` with respect to the filter `l`), then the function `(fun x => f₁ x - f₂ x)` (which represents the pointwise difference of `f₁` and `f₂`) is also Big O of `g` with respect to the filter `l`. That is, if two functions are both bounded by the same function in the limit, then their difference is also bounded by that same function in the limit.

If functions `f₁` and `f₂` are both Big O of `g` with respect to filter `l` in the context of functional analysis, then their pointwise difference `(x mapsto f₁ x - f₂ x)` is also Big O of `g` with respect to `l`.


theorem Ideal.IsPrime.mul_mem_iff_mem_or_mem :
    ∀ {α : Type u} [inst : CommSemiring α] {I : Ideal α}, Ideal.IsPrime I → ∀ {x y : α}, x * y ∈ I ↔ x ∈ I ∨ y ∈ I := by
  sorry

This theorem states that for any commutative semiring `α` and any ideal `I` of `α` that is prime, for any elements `x` and `y` in `α`, the product `x * y` is in `I` if and only if either `x` is in `I` or `y` is in `I`. In other words, in a prime ideal of a commutative semiring, if the product of two elements is in the ideal, then at least one of the elements must also be in the ideal.

In a commutative semiring with a prime ideal, the product of two elements is in the ideal if and only if one of them is in the ideal.


theorem Polynomial.coeff_natDegree_eq_zero_of_degree_lt :
    ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
      Polynomial.degree p < Polynomial.degree q → Polynomial.coeff p (Polynomial.natDegree q) = 0 :=
  by sorry

This theorem states that for any semiring `R` and any two polynomials `p` and `q` over `R`, if the degree of `p` is less than the degree of `q`, then the coefficient of the term in `p` with exponent equal to the "natural degree" of `q` (i.e., the degree of `q` coerced to a natural number) is zero. This means that `p` does not have a term with the same degree as the highest degree term of `q`.

For any semiring `R` and polynomials `p` and `q` over `R` with `deg p < deg q`, the coefficient of the term of highest degree in `p` is zero.


/-- All n-simplices among cospherical points in an n-dimensional
subspace have the same circumradius.  -/
theorem EuclideanGeometry.exists_circumradius_eq_of_cospherical_subset :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {s : AffineSubspace ℝ P} {ps : Set P},
      ps ⊆ ↑s →
        ∀ [inst_4 : Nonempty ↥s] {n : ℕ} [inst_5 : FiniteDimensional ℝ ↥(AffineSubspace.direction s)],
          FiniteDimensional.finrank ℝ ↥(AffineSubspace.direction s) = n →
            EuclideanGeometry.Cospherical ps →
              ∃ r, ∀ (sx : Affine.Simplex ℝ P n), Set.range sx.points ⊆ ps → Affine.Simplex.circumradius sx = r :=
  by sorry

The theorem `EuclideanGeometry.exists_circumradius_eq_of_cospherical_subset` states that for a set of points `ps` in an n-dimensional subspace `s`, if these points are cospherical (equidistant from some point), then all n-simplices (a simplex is a generalization of a triangle to n-dimensions) created from points in `ps` have the same circumradius. In other words, all these simplices fit in a sphere of the same radius. The theorem assumes that the set `ps` is in the subspace `s`, the subspace `s` is nonempty, and the dimension of the subspace (as a vector space) is `n`.

Given a nonempty n-dimensional subspace s in a Euclidean space and a set of n+1 points in s that are equidistant from a point, all n-simplices formed by these points have the same circumradius.


theorem Multiset.card_attach : ∀ {α : Type u_1} {m : Multiset α}, Multiset.card (Multiset.attach m) = Multiset.card m :=
  by sorry

The theorem `Multiset.card_attach` states that for any multiset `m` of a certain type `α`, the cardinality (or the number of elements) of the multiset obtained by attaching to each element `a` in `m` a proof that `a` belongs to `m` is equal to the cardinality of `m` itself. In other words, it specifies that the process of attaching proofs to the elements of a multiset does not affect its cardinality.

The cardinality of a multiset and the multiset obtained by attaching proofs of membership to each element are equal.


theorem NonUnitalStarAlgebra.mem_top :
    ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
      [inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
      [inst_7 : StarModule R A] {x : A}, x ∈ ⊤ :=
  by sorry

This theorem states that for any `x` of type `A`, `x` is an element of top element `⊤`. Here, `R` is a type with the structure of a commutative semiring and a star ring, `A` is a type with the structure of a non-unital semiring, star ring, module over `R`, and star module over `R`. The scalar multiplications in `R` and `A` are assumed to be compatible, forming a scalar tower and satisfying the commutative property.

For any element `x` of type `A` in a commutative semiring `R` with star ring structure, `x` belongs to the top element `⊤` of the non-unital semiring `A`, which is also a star module and a star ring over `R`, with compatible scalar multiplications.


/-- If all points are equal to a given point `x`, then `α` is a subsingleton.  -/
theorem subsingleton_of_forall_eq : ∀ {α : Sort u_1} (x : α), (∀ (y : α), y = x) → Subsingleton α := by sorry

This theorem states that for any type (or sort) `α` and given an element `x` of this type, if all elements `y` in `α` are equal to `x`, then `α` is a subsingleton. In mathematical terms, a subsingleton is a set (or type in Lean 4) that has at most one element. Here, the theorem is stating that if every element of a type is identical (specifically, identical to `x`), then the type must be a subsingleton, as it contains at most one distinct element.

If every element of a type `α` is equal to a given element `x`, then `α` is a subsingleton (has at most one element).


theorem Subgroup.subgroupOf_self : ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), Subgroup.subgroupOf H H = ⊤ := by
  sorry

This theorem states that, for any group `G` and subgroup `H` of `G`, the subgroup of `H` viewed as a subgroup of itself (`H`), using the `Subgroup.subgroupOf` function, is the top subgroup (i.e., the whole group `H`). In other words, the intersection of a subgroup with itself is the subgroup itself.

For any subgroup `H` of a group `G`, `H.subgroupOf H` equals `H`.


/-- Bound for `zetaKernel₁` for large `t`.  -/
theorem isBigO_atTop_zetaKernel₁ : zetaKernel₁ =O[Filter.atTop] fun t => Real.exp (-Real.pi * t) := by sorry

This theorem states a bound for the function `zetaKernel₁` for large `t`. Specifically, it establishes that `zetaKernel₁` is a function that has Big O notation at the filter representing the limit towards infinity (`Filter.atTop`), equal to the function `fun t => Real.exp (-Real.pi * t)`. In other words, the growth rate of `zetaKernel₁` as `t` approaches infinity is at most the same as the growth rate of the function `fun t => Real.exp (-Real.pi * t)`. This implies that for large enough `t`, the absolute value of `zetaKernel₁(t)` is less than or equal to a constant multiple of `|Real.exp (-Real.pi * t)|`. The specific constant depends on `t`, but is independent of `zetaKernel₁` and the exponential function.

The growth rate of `zetaKernel₁` as `t` approaches infinity is at most that of `Real.exp (-π*t)`.


theorem QuaternionAlgebra.im_star :
    ∀ {R : Type u_3} [inst : CommRing R] {c₁ c₂ : R} (a : QuaternionAlgebra R c₁ c₂),
      QuaternionAlgebra.im (star a) = -QuaternionAlgebra.im a :=
  by sorry

This theorem states that for any commutative ring `R` and any quaternion `a` in the Quaternion Algebra over `R` with coefficients `c₁` and `c₂`, the imaginary part of the conjugate of `a` (denoted `star a`) is equal to the negation of the imaginary part of `a`. In mathematical terms, it states that `Im(a*) = -Im(a)`, where `a*` denotes the conjugate of a quaternion `a`, `Im` denotes the imaginary part of a quaternion, and `-` denotes negation in the ring `R`.

The imaginary part of the conjugate of a quaternion is the negation of its imaginary part.


theorem MeasureTheory.condexp_add :
    ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F']
      [inst_2 : CompleteSpace F'] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → F'},
      MeasureTheory.Integrable f μ →
        MeasureTheory.Integrable g μ →
          MeasureTheory.condexp m μ (f + g) =ᶠ[MeasureTheory.Measure.ae μ]
            MeasureTheory.condexp m μ f + MeasureTheory.condexp m μ g :=
  by sorry

This theorem, `MeasureTheory.condexp_add`, states that, for any types `α` and `F'`, where `F'` is a normed additive commutative group, and `α` is a type with a specified measure, under the assumption that `F'` is a normed space over the field of real numbers and is also a complete space. If we have two measurable spaces `m` and `m0`, a measure `μ`, and two functions `f` and `g` mapping from `α` to `F'`, and both `f` and `g` are integrable with respect to `μ`, then the conditional expectation of the sum of `f` and `g` is almost everywhere equal to the sum of the conditional expectations of `f` and `g` with respect to the measure `μ`. Here, "almost everywhere" is with respect to the filter of co-null sets of `μ`. In other words, this theorem asserts the linearity of the conditional expectation in the setting of measure theory.

Given measurable spaces `m`, `m0`, a complete normed additive commutative group `F'`, a measure `μ` on `α`, and integrable functions `f` and `g` from `α` to `F'`, the conditional expectations of `f + g` and `f + g` almost everywhere equal each other with respect to `μ`.


theorem FirstOrder.Language.Substructure.coe_closure_eq_range_term_realize :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {s : Set M},
      ↑((FirstOrder.Language.Substructure.closure L).toFun s) =
        Set.range (FirstOrder.Language.Term.realize Subtype.val) :=
  by sorry

This theorem states that for any first-order language `L` and any type `M` with a `FirstOrder.Language.Structure` instance, the substructure generated by a set `s` of `M` (i.e., `(FirstOrder.Language.Substructure.closure L).toFun s`) is equal to the range of the function that realizes a term of `L` in `M` (i.e., `FirstOrder.Language.Term.realize Subtype.val`). In other words, if you generate a substructure by closing a set under the operations of a first-order language, you obtain the same set of elements as if you apply every term of the language to every element of your set.

For any first-order language L and type M with a structure instance, the substructure generated by a set s of M equals the range of the function realizing every term of L applied to s.


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

This theorem states that for any type `α` and for any two lists `l₁` and `l₂` of type `α`, `l₂` is a suffix of the concatenation of `l₁` and `l₂`. In other words, if you append `l₂` to `l₁`, you will always end up with a list where `l₂` is the end part. This holds true for all types and lists.

For all types `α` and lists `l₁` and `l₂` of type `α`, `l₂` is a suffix of `l₁ ++ l₂`.


theorem ENNReal.mul_pos : ∀ {a b : ENNReal}, a ≠ 0 → b ≠ 0 → 0 < a * b := by sorry

This theorem states that for any two extended nonnegative real numbers `a` and `b`, if neither `a` nor `b` is equal to zero, then the product of `a` and `b` is greater than zero. In other words, the multiplication of any two nonzero extended nonnegative real numbers always results in a positive number. This is consistent with the property of real numbers where the product of two positive numbers is always positive.

For any two nonzero extended nonnegative real numbers `a` and `b`, their product is positive.


theorem ContinuousLinearMap.zero_apply :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
      [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
      [inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] (x : M₁), 0 x = 0 :=
  by sorry

This theorem states that for any semirings `R₁` and `R₂`, any continuous linear map `σ₁₂` from `R₁` to `R₂`, any topological space and additive commutative monoid `M₁` over `R₁`, and any topological space and additive commutative monoid `M₂` over `R₂`, applying the zero continuous linear map to any element `x` in `M₁` results in the zero element of `M₂`.

For any continuous linear maps σ₁₂ between semirings R₁ and R₂, and additive commutative monoids M₁ over R₁ and M₂ over R₂, we have σ₁₂(0ₘ₁) = 0ₘ₂, where 0ₘ₁ denotes the zero element of M₁ and 0ₘ₂ denotes the zero element of M₂.


theorem Ordinal.opow_one_add : ∀ (a b : Ordinal.{u_1}), a ^ (1 + b) = a * a ^ b := by sorry

This theorem states that for any two well-orders `a` and `b` in a given type `Type u_1`, the ordinal exponentiation of `a` to the power of `1 + b` is equal to `a` times the ordinal exponentiation of `a` to the power of `b`. In other words, it's asserting the property similar to the law of exponents $(a^{1+b} = a*a^{b})$ but in the context of ordinals.

For any ordinals `a` and `b`, `a ^ (1 + b) = a ^ b * a`.


theorem HolderOnWith.edist_le_of_le :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal}
      {f : X → Y} {s : Set X},
      HolderOnWith C r f s →
        ∀ {x y : X}, x ∈ s → y ∈ s → ∀ {d : ENNReal}, edist x y ≤ d → edist (f x) (f y) ≤ ↑C * d ^ ↑r :=
  by sorry

This theorem states that for any types `X` and `Y` with `PseudoEMetricSpace` structures, given any nonnegative real numbers `C` and `r`, a function `f` from `X` to `Y`, and a set `s` of `X`, if the function `f` is Hölder continuous with constant `C` and exponent `r` on the set `s`, then for any elements `x` and `y` in the set `s` and any extended nonnegative real number `d`, if the extended distance between `x` and `y` is less than or equal to `d`, the extended distance between `f(x)` and `f(y)` is less than or equal to `C` times `d` to the power of `r`. This theorem thus provides a bound on the distance between the images under `f` of two points in the set `s` based on the distance between the points and the Hölder continuity of `f`.

Given two Pseudo-Metric Spaces X and Y, a Hölder continuous function f from X to Y with constant C and exponent r on a set s, and any x, y in s, the extended distance between f(x) and f(y) is less than or equal to C * (extended distance between x and y) ^ r.


theorem Irrational.int_add : ∀ {x : ℝ}, Irrational x → ∀ (m : ℤ), Irrational (↑m + x) := by sorry

The theorem `Irrational.int_add` states that for every real number `x`, if `x` is an irrational number, then for every integer `m`, the sum of the integer `m` and `x` is also an irrational number. In other words, the sum of an irrational number and any integer is still irrational.

If `x` is an irrational real number, then `m + x` is also an irrational real number for every integer `m`.


theorem Continuous.subtype_map :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X → Prop} {f : X → Y},
      Continuous f → ∀ {q : Y → Prop} (hpq : ∀ (x : X), p x → q (f x)), Continuous (Subtype.map f hpq) :=
  by sorry

The theorem `Continuous.subtype_map` states that for any two types `X` and `Y` equipped with topological spaces, and a property `p` on `X`, if a function `f : X → Y` is continuous, then for any property `q` on `Y` such that `q` holds for `f(x)` whenever `p` holds for `x`, the restricted function `Subtype.map f hpq`, which maps each subtype `x` of `X` satisfying `p` to subtype `f(x)` of `Y` satisfying `q`, is also continuous. This means the continuity of a function is preserved when it is restricted to subsets of its domain and codomain defined by properties `p` and `q` respectively.

If `f : X → Y` is a continuous function between topological spaces `X` and `Y`, and `p : Prop` and `q : Prop` are properties such that `q` holds for `f(x)` whenever `p` holds for `x`, then the function `Subtype.map f (Prop p) : Subtype X p → Subtype Y (Prop.and p (image p _ f))` is continuous.


theorem CategoryTheory.IsKernelPair.mono_of_isIso_fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X},
      CategoryTheory.IsKernelPair f a b → ∀ [inst_1 : CategoryTheory.IsIso a], CategoryTheory.Mono f :=
  by sorry

The theorem `CategoryTheory.IsKernelPair.mono_of_isIso_fst` states that for any objects R, X, Y, and morphisms f, a, b in some category C, if `(a, b)` forms a kernel pair for `f` (i.e., both `a` and `b` are morphisms from `R` to `X` such that `a` composed with `f` equals `b` composed with `f` and the square formed by `R` to `X`, `R` to `X`, `X` to `Y`, and `X` to `Y` is a pullback square), and `a` is an isomorphism (i.e., it has an inverse under composition in the category), then `f` is a monomorphism (i.e., `f` is left-cancellable: for any morphisms `g` and `h`, if `f` composed with `g` equals `f` composed with `h`, then `g` equals `h`).

If in a category, a morphism `f` has an isomorphism `a` as its kernel pair, then `f` is a monomorphism.


theorem QuotientAddGroup.induction_on :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x :=
  by sorry

This theorem, `QuotientAddGroup.induction_on`, defines an induction principle for elements of the quotient group of an additive group `α` by an additive subgroup `s`. Given a property `C` that applies to elements of the quotient group `α ⧸ s`, if every element `z` of the original group `α` satisfies the property `C` when considered in the quotient group (i.e., `C ↑z`), then every element `x` of the quotient group also satisfies `C`. This allows us to reason about all elements of the quotient group by only considering elements of the original group.

If a property holds for every coset representative of an additive subgroup of an abelian group, then it holds for all elements in the quotient group.


theorem normalize_eq_one :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α},
      normalize x = 1 ↔ IsUnit x :=
  by sorry

This theorem, `normalize_eq_one`, states that for any type `α` that is a cancel commutative monoid with zero and a normalization monoid, a given element `x` of type `α` satisfies the property that its normalization equals `1` if and only if `x` is a unit in the monoid. In other words, an element of the monoid is a unit if it has a two-sided inverse and its normalization (which is achieved by multiplying it with the norm unit of `x`) is equal to `1`.

For any cancel commutative monoid with zero and a normalization monoid, an element is a unit if and only if its normalization equals the monoid's identity element.


theorem CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_inv_comp_rightHomologyι :
    ∀ {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.RightHomologyData S)
      [inst_2 : CategoryTheory.ShortComplex.HasRightHomology S],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso h).inv
          (CategoryTheory.ShortComplex.rightHomologyι S) =
        CategoryTheory.CategoryStruct.comp h.ι (CategoryTheory.ShortComplex.RightHomologyData.opcyclesIso h).inv :=
  by sorry

The given theorem is about categories, morphisms, and complexes in category theory. It states that for any type `C` that forms a category with zero morphisms, and for any `ShortComplex` `S` of this category `C`, the inverse of the right homology isomorphism composed with the right homology ι function is equal to the composition of the ι function of the right homology data and the inverse of the opcycles isomorphism of the right homology data.

This theorem essentially discusses the relationship between the inverse of the right homology isomorphism, the right homology ι function, and the inverse of the opcycles isomorphism in the context of short complexes in a category.

For any category `C` with zero morphisms and any short complex `S` in `C`, the inverse of the right homology isomorphism and the right homology ι function, followed by the inverse of the opcycles isomorphism of the right homology data, is equal to the composition of the ι function of the right homology data and the inverse of the opcycles isomorphism.


theorem GroupSeminorm.mul_bddBelow_range_add :
    ∀ {E : Type u_4} [inst : CommGroup E] {p q : GroupSeminorm E} {x : E},
      BddBelow (Set.range fun y => p y + q (x / y)) :=
  by sorry

The theorem `GroupSeminorm.mul_bddBelow_range_add` states that for any type `E` forming a commutative group, and for any two group seminorms `p` and `q` on `E`, and for any element `x` in `E`, the set of all values resulting from applying the function `y => p y + q (x / y)` to all possible `y` values is bounded below. Here, `BddBelow` denotes the property of a set being bounded below, `Set.range` denotes the range of a function, and `y => p y + q (x / y)` is a function mapping a group element `y` to the sum of `p y` and `q (x / y)`.

For any commutative group `E`, and group seminorms `p` and `q` on `E`, the set of values `{p y + q (x / y) | y ∈ E\*\*:1}` is bounded below for all `x` in `E`.


ContDiffWithinAt.contDiffAt

theorem ContDiffWithinAt.contDiffAt :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
      {f : E → F} {x : E} {n : ℕ∞}, ContDiffWithinAt 𝕜 n f s x → s ∈ nhds x → ContDiffAt 𝕜 n f x :=
  by sorry

The theorem `ContDiffWithinAt.contDiffAt` states that for a given nontrivially normed field `𝕜`, a normed additive commutative group `E`, a normed space over `𝕜` and `E`, another normed additive commutative group `F`, and a normed space over `𝕜` and `F`, if a function `f` from `E` to `F` is continuously differentiable within a set `s` at a point `x` for a given smoothness degree `n`, and if the set `s` is a neighborhood of `x` (that is, it contains an open set around `x`), then the function `f` is also continuously differentiable at that point `x`. The smoothness degree `n` can be a natural number or infinity (`ℕ∞`). This theorem links the concept of continuous differentiability within a neighborhood of a point and at the point itself.

If a function between two normed spaces is continuously differentiable within a neighborhood of a point with some smoothness degree, then it is continuously differentiable at that point.


theorem ContractingWith.one_sub_K_ne_zero :
    ∀ {α : Type u_1} [inst : EMetricSpace α] {K : NNReal} {f : α → α}, ContractingWith K f → 1 - ↑K ≠ 0 := by sorry

The theorem `ContractingWith.one_sub_K_ne_zero` states that for any type `α` equipped with an extended metric space structure, any nonnegative real number `K`, and any function `f` from `α` to `α` that is `ContractingWith K`, the real number `1 - K` is not equal to zero. This essentially means that if `f` is a contracting map with a contraction factor `K` (where `K` is less than 1), then `1 - K` will never be zero. This prevents the contraction factor from being 1, which would cause the distance between `f(x)` and `f(y)` to be the same as the distance between `x` and `y`, contradicting the property of a contracting map.

For any type with an extended metric space structure, if `f` is a contracting function with contraction factor `K` (`0 < K < 1`), then `1 - K` is not equal to zero.


theorem Matrix.range_empty : ∀ {α : Type u} (u : Fin 0 → α), Set.range u = ∅ := by sorry

This theorem states that for any function `u` from an empty finite set (of type `Fin 0`) to any type `α`, the range of the function `u` is the empty set. In other words, there are no elements in the codomain `α` that `u` can map to from an empty domain. This is expressed mathematically as: for all functions `u` from `Fin 0` to `α`, the range of `u` equals the empty set.

For any function from a finite empty set to any type, its range is the empty set.


theorem RingHom.to_isAddGroupHom :
    ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S), IsAddGroupHom ⇑f := by sorry

This theorem states that for any two types `R` and `S` which have a ring structure, if `f` is a ring homomorphism from `R` to `S`, then `f` is also an additive group homomorphism. In other words, it shows that the addition operation in the domain ring `R` is preserved under the ring homomorphism `f` to the ring `S`. This is a fundamental property in algebraic structures known as rings.

A ring homomorphism between rings `R` and `S` is an additive group homomorphism from `R` to `S`.


theorem TensorProduct.rid_tmul :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
      (r : R), (TensorProduct.rid R M) (m ⊗ₜ[R] r) = r • m :=
  by sorry

This theorem states that for any commutative semiring `R` and an `R`-module `M`, given any element `m` of `M` and any element `r` of `R`, applying the `TensorProduct.rid R M` operation to the tensor product of `m` and `r`, i.e., `(m ⊗ₜ[R] r)`, is equivalent to scaling `m` by `r`, denoted by `r • m`. In other words, the `TensorProduct.rid R M` operation behaves as a right identity for the tensor product of modules, up to linear equivalence.

For any commutative semiring `R` and `R`-module `M`, the tensor product `(m ⊗ₜ[R] r)` of an element `m` of `M` and an element `r` of `R` is linear equivalent to the scalar multiplication `r • m` of `m` by `r`.


theorem DFinsupp.mem_support_toFun :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
      [inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (f : Π₀ (i : ι), β i) (i : ι),
      i ∈ DFinsupp.support f ↔ f i ≠ 0 :=
  by sorry

The theorem `DFinsupp.mem_support_toFun` states that for any type ι, for any function `β` mapping elements of ι to some other types, given that equality is decidable on ι, and that for every `i` in ι, the type `β i` has a zero element and whether `x` (an element of `β i`) is non-zero is decidable, then for any function `f` of type `Π₀ (i : ι), β i` (a direct sum of `β i` as `i` varies over ι) and any `i` in ι, `i` is in the support of `f` if and only if `f(i)` is non-zero. In simpler terms, the theorem states that an index `i` is in the support of the direct sum function `f` if `f` at `i` is non-zero.

For any type ι and function β from ι to types with decidable equality and for each i in ι, if β i has a decidably non-zero element, then an index i is in the support of the direct sum function f if and only if f(i) is non-zero.


/-- If a monotone function sending `bot` to `bot` is continuous at the indexed supremum over
a `Sort`, then it sends this indexed supremum to the indexed supremum of the composition.  -/
theorem Monotone.map_iSup_of_continuousAt :
    ∀ {α : Type u} {β : Type v} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α]
      [inst_3 : CompleteLinearOrder β] [inst_4 : TopologicalSpace β] [inst_5 : OrderClosedTopology β] {ι : Sort u_1}
      {f : α → β} {g : ι → α}, ContinuousAt f (iSup g) → Monotone f → f ⊥ = ⊥ → f (⨆ i, g i) = ⨆ i, f (g i) :=
  by sorry

This theorem states that if we have a function `f` which is monotone (meaning that if `a ≤ b` then `f(a) ≤ f(b)`) and sends the bottom element (`bot`) to bottom, and if this function is continuous at the supremum (`iSup`) of some indexed function `g` over a certain sort `ι`, then `f` sends this supremum to the supremum of the composition of `f` and `g`. In other words, applying `f` to the supremum of values generated by `g` (denoted as `⨆ i, g i`) yields the same result as taking the supremum of the values generated by applying `f` to each value of `g` (denoted as `⨆ i, f (g i)`). The theorem requires the preconditions that the types `α` and `β` are both complete linear orders and topological spaces, and that `β` has an order-closed topology.

If `f` is a monotone, continuous function from a complete linear order and topological space `α` to another complete linear order and topological space `β` with order-closed topology, such that `f(bot) = bot`, then `f(⨆ i, g i) = ⨆ i, f(g i)`, where `g` is a function from `ι` to `α`.


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

This theorem states that for any group G and any three of its subgroups H, K, and L, if H is a subgroup of K and the relative index of K and L is zero (which means either K is not a subgroup of L or K and L have infinite index), then the relative index of H and L is also zero. This theorem captures a certain transitivity property of the relative index in the context of subgroups of a given group.

If H is a subgroup of K and the index of K in L is infinite, then the index of H in L is also infinite. (Or, more precisely, if the index of K in L is 0, then the index of H in L is also 0, under the assumption that H is a subgroup of K.)


theorem Membership.get_elem_helper : ∀ {i n : ℕ} {r : Std.Range}, i ∈ r → r.stop = n → i < n := by sorry

This theorem, "Membership.get_elem_helper", states that for any natural numbers `i` and `n`, and any standard range `r`, if `i` is an element of `r` and the stop value of `r` is `n`, then `i` is less than `n`. In simpler terms, it means any element of a specified range is less than the upper boundary of that range.

For any natural number `i`, if `i` is an element of a standard range `r` with stop value `n`, then `i` < `n`.


theorem Ioo_subset_openSegment :
    ∀ {𝕜 : Type u_1} [inst : LinearOrderedField 𝕜] {x y : 𝕜}, Set.Ioo x y ⊆ openSegment 𝕜 x y := by sorry

This theorem states that for any linearly ordered field `𝕜` and any two elements `x` and `y` of `𝕜`, the left-open right-open interval between `x` and `y` (denoted as `Set.Ioo x y`) is a subset of the open segment between `x` and `y` in the vector space over `𝕜` (denoted as `openSegment 𝕜 x y`). Here, `Set.Ioo x y` is a set of all elements that are strictly greater than `x` and strictly less than `y`, and `openSegment 𝕜 x y` is a set of all points that can be expressed as a non-trivial convex combination of `x` and `y`.

For any linearly ordered field `𝕜`, the set of all points that can be expressed as a non-trivial convex combination of two elements `x` and `y` in `𝕜` (`openSegment 𝕜 x y`) is a subset of the set of all elements strictly between `x` and `y` (`Set.Ioo x y`).


theorem Nat.gcd_eq_left_iff_dvd : ∀ {m n : ℕ}, m ∣ n ↔ Nat.gcd m n = m := by sorry

This theorem states that for any two natural numbers `m` and `n`, `m` divides `n` if and only if the greatest common divisor (gcd) of `m` and `n` is `m` itself. In other words, if `m` is a divisor of `n`, then `m` must be the greatest common divisor of `m` and `n`; conversely, if the gcd of `m` and `n` is `m`, then `m` is a divisor of `n`.

The natural numbers `m` and `n` are equivalent, up to ordering, to `m` being a divisor of `n` if and only if the greatest common divisor of `m` and `n` equals `m`.


theorem Filter.prod_pure_pure : ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β}, pure a ×ˢ pure b = pure (a, b) := by
  sorry

This theorem, `Filter.prod_pure_pure`, states that for all types `α` and `β`, and for all values `a` of type `α` and `b` of type `β`, the product of the filters `pure a` and `pure b` is equal to the filter `pure (a, b)`. In other words, it asserts the equality between the filter of the product of two pure values, and the pure filter of the pair of these values.

For all types `α` and `β`, and for all `a : α` and `b : β`, the filters `pure a` and `pure b` over their respective types have product equal to the filter `pure (a, b)` over their cartesian product type `α × β`.


theorem CategoryTheory.generate_discretePresieve_mem :
    ∀ (α : Type u),
      CategoryTheory.Sieve.generate (CategoryTheory.discretePresieve α) ∈
        CategoryTheory.typesGrothendieckTopology.sieves α :=
  by sorry

This theorem states that for any type `α`, the smallest sieve generated by the discrete presieve on `α` is a member of the sieves of the Grothendieck topology associated with the category of all types for `α`. In other words, the smallest sieve that contains all arrows in the discrete presieve (which only includes arrows whose domain is a singleton) is included in the collection of sieves that cover every element of `α` in the Grothendieck topology for the category of all types.

The smallest sieve containing the discrete presieve is a sub-sieve of every sieve in the Grothendieck topology for the category of all types.


theorem List.nthLe_map' :
    ∀ {α : Type u} {β : Type v} (f : α → β) {l : List α} {n : ℕ} (H : n < List.length (List.map f l)),
      List.nthLe (List.map f l) n H = f (List.nthLe l n ⋯) :=
  by sorry

The theorem `List.nthLe_map'` states that for any types `α` and `β`, given a function `f` from `α` to `β`, a list `l` of type `α`, and an integer `n` with the condition that `n` is less than the length of the list obtained by applying `f` to each element of `l`, the `n`-th element of the mapped list is equal to the result of applying `f` to the `n`-th element of the original list. This theorem describes a property of the `map` function in the context of accessing elements at specific locations in the list.

For any types `α` and `β`, function `f` from `α` to `β`, list `l` of length `n+1` over `α`, and integer `n`, if `0 ≤ n`, then `(List.map f l).nth n = f (l.nth n)`.


theorem unitInterval.symm_zero : unitInterval.symm 0 = 1 := by sorry

This theorem states that the central symmetry of the unit interval at the point 0 yields the value 1. In other words, under the operation defined by the function `unitInterval.symm`, which maps each point in the unit interval to its symmetric counterpart with respect to the center of the interval, the point 0 is mapped to the point 1.

The central symmetry of the unit interval maps point 0 to point 1. (In Lean: `unit_interval.symm 0 = 1`)


/-- Every Yoneda-presheaf is a sheaf for the coherent topology.  -/
theorem CategoryTheory.coherentTopology.isSheaf_yoneda_obj :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Precoherent C] (W : C),
      CategoryTheory.Presieve.IsSheaf (CategoryTheory.coherentTopology C) (CategoryTheory.yoneda.obj W) :=
  by sorry

This theorem states that for any category `C` that is both precoherent and a category (in the sense of Category Theory), and for any object `W` in that category `C`, the Yoneda functor applied to that object `W` is a sheaf with respect to the coherent topology on `C`.

In other words, the Yoneda functor, which maps each object to the set of morphisms from that object to `W`, preserves the property of being a sheaf under the coherent topology. This means that it satisfies the sheaf condition for every sieve in the topology, where a sieve is a collection of morphisms that is closed under precomposition with morphisms within the category. This theorem is significant because sheaves are central to many areas of mathematics, including algebraic geometry and number theory.

The Yoneda functor maps any object in a precoherent category to a sheaf with respect to the coherent topology.


theorem exists_Ico_subset_of_mem_nhds :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      s ∈ nhds a → (∃ u, a < u) → ∃ u, a < u ∧ Set.Ico a u ⊆ s :=
  by sorry

This theorem states that for any type `α` equipped with both a topological space structure and a linear order structure that is consistent with the topology (i.e. it is an order topology), given any element `a` of type `α` and a set `s` of type `α`, if `s` is a neighborhood of `a` and there exists some element `u` in `α` such that `a` is less than `u`, then there exists another element `u` such that `a` is less than this `u` and the left-closed right-open interval from `a` to `u` is a subset of `s`. Basically, it guarantees the existence of an interval around `a` which is contained inside a given neighborhood whenever `a` is not a maximal element.

Given a topological space `(α, τ)` with a compatible linear order `≤`, if `a ∈ α`, `s ⊆ α` is a neighborhood of `a`, and there exists `u ∈ α` with `a < u`, then there exists `u' < u` such that `[a, u) ⊆ s`.


theorem TopologicalSpace.generateFrom_anti :
    ∀ {α : Type u_1} {g₁ g₂ : Set (Set α)},
      g₁ ⊆ g₂ → TopologicalSpace.generateFrom g₂ ≤ TopologicalSpace.generateFrom g₁ :=
  by sorry

This theorem states that for any type `α` and any two collections of sets `g₁` and `g₂` of `α`, if `g₁` is a subset of `g₂`, then the smallest topological space containing `g₂` is a smaller (or equal) topological space than the smallest topological space containing `g₁`. In other words, adding more basic sets to generate a topological space can only result in a larger (or equal) topological space.

For any type `α` and any collections `g₁` and `g₂` of subsets of `α` with `g₁` being a subset of `g₂`, the smallest topological space containing `g₂` is no larger than the smallest topological space containing `g₁`.


theorem List.bind_append_perm :
    ∀ {α : Type u_1} {β : Type u_2} (l : List α) (f g : α → List β),
      List.Perm (List.bind l f ++ List.bind l g) (List.bind l fun x => f x ++ g x) :=
  by sorry

The theorem `List.bind_append_perm` states that for any list `l` of elements of some type `α` and any two functions `f` and `g` from `α` to lists of elements of some type `β`, the list resulting from first binding `l` with `f`, then appending the result to the list resulting from binding `l` with `g`, is a permutation of the list resulting from binding `l` with a function that, for each element in `l`, applies `f` to it and appends the result to the result of applying `g` to it. In simpler terms, changing the order in which we append the lists doesn't change the overall list, up to permutation.

For any list `l` of type `α`, functions `f: α → βlist` and `g: α → βlist`, the list `(l >>= f) @ (l >>= g)` is a permutation of `(l >>= (λ x => f x @ g x))`.


ContMDiffWithinAt.smul

theorem ContMDiffWithinAt.smul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {n : ℕ∞}
      {V : Type u_18} [inst_6 : NormedAddCommGroup V] [inst_7 : NormedSpace 𝕜 V] {f : M → 𝕜} {g : M → V},
      ContMDiffWithinAt I (modelWithCornersSelf 𝕜 𝕜) n f s x →
        ContMDiffWithinAt I (modelWithCornersSelf 𝕜 V) n g s x →
          ContMDiffWithinAt I (modelWithCornersSelf 𝕜 V) n (fun p => f p • g p) s x :=
  by sorry

This theorem, `ContMDiffWithinAt.smul`, states that for every nontrivially normed field `𝕜`, normed additive commutative group `E` that forms a normed space over `𝕜`, a topological space `H`, a model with corners `I` from `𝕜` to `E` and `H`, a topological space `M` which is a charted space over `H`, a set `s` of `M`, a point `x` in `M`, possibly infinite natural number `n`, and a normed additive commutative group `V` that forms a normed space over `𝕜`, if a function `f` from `M` to `𝕜` is continuously differentiable within `s` at `x` up to order `n` and a function `g` from `M` to `V` is also continuously differentiable within `s` at `x` up to order `n`, then the function `p => f p • g p` is continuously differentiable within `s` at `x` up to order `n`. This theorem is a generalization of the product rule in differential calculus to the context of continuously differentiable manifolds.

If functions `f` and `g` are continuously differentiable up to order `n` at a point `x` in a charted space `M` over a topological space `H`, then their product `p => f p • g p` is also continuously differentiable up to order `n` at `x`.


theorem Mathlib.Data.Set.Basic._auxLemma.104 :
    ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x := by sorry

This theorem states that for any type `α` and any two properties `p` and `q` that elements of `α` can have, the statement "all elements of `α` have property `p` and all elements of `α` have property `q`" is equivalent to the statement "all elements of `α` have both property `p` and property `q`". In other words, it formalizes the idea that if every element of a set satisfies two conditions separately, then every element of that set satisfies both conditions simultaneously.

For any type `α` and properties `p` and `q` on `α`, the statements "forall x : α, p x" and "forall x : α, q x" are equivalent to "forall x : α, p x ∧ q x".


theorem Filter.tendsto_bot : ∀ {α : Type u} {β : Type v} {f : α → β} {l : Filter β}, Filter.Tendsto f ⊥ l := by sorry

The theorem `Filter.tendsto_bot` states that for any types `α` and `β`, any function `f` from `α` to `β`, and any filter `l` on `β`, the function `f` tends from the bottom filter of `α` to `l`. In other words, for every neighborhood `a` of `l` in `β`, the preimage under `f` of `a` is a neighborhood in the bottom filter of `α`. This theorem is a specific instance of the general concept of a function tending towards a certain limit, where the limit is defined via filters.

For any functions `f: α -> β`, `l: Filter β`, and neighborhood `a` of `l` in `β`, the preimage `f ^^-1 (a)` is a neighborhood in the bottom filter of `α`.


theorem lub_Iio_le : ∀ {α : Type u} [inst : Preorder α] {b : α} (a : α), IsLUB (Set.Iio a) b → b ≤ a := by sorry

This theorem states that for any type `α` that has a preorder structure, and for any elements `b` and `a` of that type, if `b` is a least upper bound (also known as supremum) of the set of all elements less than `a` (i.e., the left-infinite right-open interval up to `a`), then `b` is less than or equal to `a`. In simple terms, the smallest number that's larger than all numbers less than `a` is always less than or equal to `a` itself.

For any type `α` with a preorder structure and any element `a` of `α`, if `b` is the least upper bound of the elements less than `a`, then `b` is less than or equal to `a`.


theorem CategoryTheory.mapPair_equifibered :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
      {F F' : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C} (α : F ⟶ F'),
      CategoryTheory.NatTrans.Equifibered α :=
  by sorry

The theorem `CategoryTheory.mapPair_equifibered` states that for any category `C` and any two functors `F` and `F'` from the discrete category associated with the walking pair to `C`, any natural transformation `α` from `F` to `F'` is equifibered. In other words, given any two objects `i` and `j` in the walking pair and any morphism `f` from `i` to `j`, the square involving `F.map f`, `α.app i`, `α.app j`, and `F'.map f` is a pullback.

For any category C and functors F and F' from the discrete walking pair to C, and any natural transformation α from F to F', the square formed by F.map, α.app, and F'.map is a pullback for all morphisms in the walking pair.


theorem List.prod_ne_zero :
    ∀ {M₀ : Type u_8} [inst : MonoidWithZero M₀] [inst_1 : Nontrivial M₀] [inst_2 : NoZeroDivisors M₀] {L : List M₀},
      0 ∉ L → List.prod L ≠ 0 :=
  by sorry

This theorem states that for any type `M₀` which is a non-trivial monoid with zero and no zero divisors (i.e., the multiplication of any two non-zero elements of `M₀` is never zero), the product of any list `L` of elements of `M₀` is never zero, given the condition that the element zero does not belong to `L`. Here, "non-trivial" means that there exists at least one element in `M₀` which is not equal to zero, while "monoid with zero" is a mathematical structure that includes an operation that is associative, an identity element (which is zero in this case), and every element having an inverse with respect to this identity.

If `M₀` is a non-trivial monoid with zero and no zero divisors, then the product of any finite list of non-zero elements from `M₀` is non-zero.


theorem MeasureTheory.meas_le_ae_eq_meas_lt :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {R : Type u_3} [inst_1 : LinearOrder R]
      [inst_2 : MeasurableSpace R] (ν : MeasureTheory.Measure R) [inst_3 : MeasureTheory.NoAtoms ν] (g : α → R),
      (fun t => ↑↑μ {a | t ≤ g a}) =ᶠ[MeasureTheory.Measure.ae ν] fun t => ↑↑μ {a | t < g a} :=
  by sorry

This theorem states that for any type `α` with a `MeasurableSpace` instance, any measure `μ` on `α`, any type `R` with a `LinearOrder` and `MeasurableSpace` instances, any measure `ν` on `R` where `ν` has no atoms (i.e., each singleton set has measure zero), and any function `g` from `α` to `R`, the measure `μ` of the set of elements `α` such that `t` is less than or equal to `g(a)` is almost everywhere equal (with respect to the measure `ν`) to the measure `μ` of the set of elements `α` such that `t` is less than `g(a)`. In mathematical terms, for almost all `t`, we have `μ({a | t ≤ g a}) = μ({a | t < g a})`.

For any measurable space `(α, μ)`, any measurable function `g : α → ℝ` with values in a linearly ordered and measurable space `(ℝ, ν)` having no atoms, and `ν`-almost every `t ∈ ℝ`, we have `μ({a | t ≤ g a}) = μ({a | t < g a})`.


theorem ExistsUnique.intro₂ :
    ∀ {α : Sort u_2} {p : α → Sort u_3} [inst : ∀ (x : α), Subsingleton (p x)] {q : (x : α) → p x → Prop} (w : α)
      (hp : p w), q w hp → (∀ (y : α) (hy : p y), q y hy → y = w) → ∃! x hx, q x hx :=
  by sorry

This theorem states that given a type `α`, a predicate `p` on `α`, a property `q` that holds for an element `x` of `α` and a proof `p x`, and an object `w` of type `α` for which `p w` holds, if `q w p` also holds, and for all other `y` in `α` for which `p y` and `q y p` holds, `y` equals `w`, then there exists a unique `x` with a proof `p x` for which `q x p` holds. In simpler terms, it says that if a property holds uniquely for an element (under a certain predicate), then there exists a unique element for which the property holds. The uniqueness is guaranteed by the `Subsingleton` clause which ensures that there is at most one proof of `p x` for any `x`.

Given a type `α`, a predicate `p` on `α`, a property `q` on `α` x `Prop`, and assuming `Subsingleton α`, if for all `x` and `y` in `α` with `p x` and `p y` and `q x p x` and `q y p y` imply `x = y`, then there exists a unique `x` with `p x` and `q x p x`.


theorem iff_true_iff : ∀ {a : Prop}, (a ↔ True) ↔ a := by sorry

This theorem states that for any proposition 'a', the biconditional (a ↔ True) is equivalent to the proposition 'a' itself. In plain words, it means that if 'a' is equivalent to 'True', then 'a' must be true, and vice versa. This theorem hence acts like a bridge between the logical equivalence to 'True' and the truth of a proposition.

For any proposition 'a' in Lean, 'a' is logically equivalent to 'a' ↔ True.