theorem Real.hasDerivAt_arsinh : ∀ (x : ℝ), HasDerivAt Real.arsinh (Real.sqrt (1 + x ^ 2))⁻¹ x := by sorry

The theorem `Real.hasDerivAt_arsinh` states that for all real numbers `x`, the function `arsinh`, which is defined as `arsinh x = log (x + sqrt(1 + x^2))`, has a derivative at the point `x`, and the derivative is equal to the reciprocal of `sqrt (1 + x ^ 2)`. In mathematical terms, we have $\frac{d}{dx} \text{arsinh} (x) = \frac{1}{\sqrt{1 + x^2}}$.

The function `arsinh` has a derivative equal to the reciprocal of the square root of one plus the square of the argument at every real number. In mathematical notation, $\frac{d}{dx} \text{arsinh} (x) = \frac{1}{\sqrt{1 + x^2}}$.


theorem Mathlib.GroupTheory.Subgroup.Basic._auxAddLemma.43 : ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) := by sorry

This theorem states that for any two propositions `a` and `b`, the existence of `b` given `a` is equivalent to the conjunction of `a` and `b`. In other words, it asserts that 'there exists `b` such that `a` is true' is logically the same as 'both `a` and `b` are true'.

The theorem asserts that for all propositions `a` and `b`, `(∃ (x : Prop), b) ↔ (a ∧ b)`.


theorem MeasureTheory.Ioi_ae_eq_Ici' :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a : α},
      ↑↑μ {a} = 0 → Set.Ioi a =ᶠ[MeasureTheory.Measure.ae μ] Set.Ici a :=
  by sorry

This theorem states that for any type `α` with a partial order, given a measurable space `m0`, a measure `μ`, and a value `a` of type `α`, if the measure of the singleton set `{a}` is zero, then the set of all elements greater than `a` (`Set.Ioi a`) is almost everywhere equal (in the measure-theoretic sense) to the set of all elements greater than or equal to `a` (`Set.Ici a`). In other words, if the measure of the set containing only the element `a` is zero, then for almost all elements, it doesn't matter whether we include `a` in the set or not; the two sets are almost everywhere the same.

For any measurable space and measure, if the measure of a singleton set is zero, then the sets of elements strictly greater and greater than or equal to the element have equal measure almost everywhere.


theorem AddOpposite.continuous_unop : ∀ {M : Type u_1} [inst : TopologicalSpace M], Continuous AddOpposite.unop := by
  sorry

This theorem states that for any type `M` endowed with a topological space structure, the operation `AddOpposite.unop` is continuous. In other words, if we have a set `M` where we've defined a notion of "closeness" or "continuity" (i.e., it has a topological space structure), then the process of converting an element from the additive opposite of `M` back to `M` (performed by the function `AddOpposite.unop`) preserves this continuity.

For any topological space `M`, the function `AddOpposite.unop : M → M` is continuous.


theorem AddSubmonoid.mem_bot : ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, x ∈ ⊥ ↔ x = 0 := by sorry

This theorem states that for any type `M` that belongs to the `AddZeroClass` class (meaning that it has a zero element and an addition operation), an element `x` of type `M` belongs to the bottom AddSubmonoid (which contains only the zero element) if and only if `x` is equal to zero. In mathematical terms, this theorem is saying that the only element in the trivial additive submonoid is the zero element.

For any type `M` in the `AddZeroClass`, an element `x` of `M` belongs to the bottom AddSubmonoid if and only if `x = 0`.


theorem AEMeasurable.ennreal_toReal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ENNReal} {μ : MeasureTheory.Measure α},
      AEMeasurable f μ → AEMeasurable (fun x => (f x).toReal) μ :=
  by sorry

This theorem asserts that for any measurable space `α`, and any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), if `f` is almost everywhere measurable with respect to a measure `μ`, then the function obtained by applying the `toReal` operation to the output of `f` is also almost everywhere measurable with respect to the same measure `μ`. In simpler terms, the real part of an almost everywhere measurable function is itself almost everywhere measurable.

The real part of an almost everywhere measurable function from a measurable space to the extended nonnegative real numbers is almost everywhere measurable with respect to the same measure.


theorem List.rotate_mod : ∀ {α : Type u} (l : List α) (n : ℕ), List.rotate l (n % List.length l) = List.rotate l n := by
  sorry

The theorem `List.rotate_mod` states that for any list `l` of elements of any type `α` and any natural number `n`, rotating the list `l` by `n` modulo the length of `l` is equivalent to simply rotating the list `l` by `n`. In other words, the effect of rotating a list doesn't change if we replace the number of positions of rotation `n` with `n` modulo the length of the list.

For any list `l` of length `n` and natural number `k`, rotating list `l` by `k` is equivalent to rotating it by `k mod n`.


theorem AffineEquiv.apply_lineMap :
    ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
      [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
      [inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂) (a b : P₁) (c : k),
      e ((AffineMap.lineMap a b) c) = (AffineMap.lineMap (e a) (e b)) c :=
  by sorry

The theorem `AffineEquiv.apply_lineMap` states that for any ring `k`, any types `P₁`, `P₂`, `V₁`, and `V₂`, given certain algebraic structures (an additive commutative group and a module over the ring for each of `V₁` and `V₂`, and an affine space structure for each of `P₁` and `P₂`), and given an affine equivalence `e` from `P₁` to `P₂`, for any points `a` and `b` in `P₁` and any element `c` in `k`, applying the affine equivalence `e` to the point on the line from `a` to `b` determined by `c` (as computed by the function `AffineMap.lineMap`) is the same as first applying `e` to `a` and `b` to get points in `P₂`, and then using `AffineMap.lineMap` to find the corresponding point on the line from `e a` to `e b` determined by `c`. In other words, affine equivalences commute with the operation of finding a point on a line connecting two given points.

Given affine spaces `P₁` and `P₂` over a ring `k`, an affine equivalence `e : P₁ ≃ P₂`, and points `a, b : P₁` and `c : k`, the application of `e` to the points on the line between `a` and `b` determined by `c` is equal to the point on the line between `e a` and `e b` determined by `c`.


theorem HahnSeries.coeff_order_ne_zero :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero Γ] {x : HahnSeries Γ R},
      x ≠ 0 → x.coeff (HahnSeries.order x) ≠ 0 :=
  by sorry

The theorem `HahnSeries.coeff_order_ne_zero` states that for any Hahn series `x`, if `x` is not equal to zero, then the coefficient of `x` at its order, denoted by `HahnSeries.order x`, is not zero. Therefore, the theorem asserts that the non-zero Hahn series `x` will always have a non-zero coefficient at the order of the Hahn series.

If a Hahn series is non-zero, then its coefficient at the order of the series is non-zero.


/-- A pseudo-metric space is complete iff every Cauchy sequence converges.  -/
theorem Metric.complete_of_cauchySeq_tendsto :
    ∀ {α : Type u} [inst : PseudoMetricSpace α],
      (∀ (u : ℕ → α), CauchySeq u → ∃ a, Filter.Tendsto u Filter.atTop (nhds a)) → CompleteSpace α :=
  by sorry

This theorem states that a pseudo-metric space is complete if and only if every Cauchy sequence within that space converges. In the context of the theorem, a Cauchy sequence is defined as a sequence where the distance between any two later terms can be made arbitrarily small. Convergence here means that, given any sequence of elements in the pseudo-metric space, if the sequence is a Cauchy sequence, then there exists an element in the space such that the sequence approaches this element as it approaches infinity. The concept of approaching is defined using the notion of filters; in this case, `Filter.atTop` represents the limit of the sequence going to infinity, and `nhds a` represents the neighborhood of the element `a`. This theorem is a fundamental property of complete metric spaces in mathematics.

A pseudo-metric space is complete if and only if every Cauchy sequence in it converges to a limit within the space.


theorem Finsupp.count_toMultiset :
    ∀ {α : Type u_1} [inst : DecidableEq α] (f : α →₀ ℕ) (a : α), Multiset.count a (Finsupp.toMultiset f) = f a := by
  sorry

The theorem `Finsupp.count_toMultiset` states that for any type `α` with decidable equality, and for any function `f` from `α` to non-negative integers, and for any element `a` of `α`, the count of `a` in the multiset derived from `f` using `Finsupp.toMultiset` is equal to the value of `f` at `a`. In other words, the multiplicity of an element in the multiset that is converted from a function using `Finsupp.toMultiset` is the same as the value of the function at that element.

For any function `f` from type `α` to non-negative integers with decidable equality, the count of `a` in the multiset `Finsupp.toMultiset f` is equal to `f a`.


theorem RingHom.ext_zmod : ∀ {n : ℕ} {R : Type u_1} [inst : Semiring R] (f g : ZMod n →+* R), f = g := by sorry

This theorem, named `RingHom.ext_zmod`, states that for any natural number `n` and any type `R` that has a semiring structure, if `f` and `g` are two ring homomorphisms from the integers modulo `n` to `R`, then `f` and `g` must be the same. In other words, any two ring homomorphisms from the integers modulo `n` to a semiring are identical. This is a property about the uniqueness of ring homomorphisms between these two structures.

For any natural number `n` and any semiring `R`, any two ring homomorphisms from the integers modulo `n` to `R` are equal.


DirectSum.Decomposition.isInternal

theorem DirectSum.Decomposition.isInternal :
    ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M]
      [inst_2 : SetLike σ M] [inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ],
      DirectSum.IsInternal ℳ :=
  by sorry

The theorem `DirectSum.Decomposition.isInternal` asserts that for any type `ι`, any type `M` which forms an additive commutative monoid, and any type `σ` that is a set-like of `M` and forms an additive submonoid, given a function `ℳ` from `ι` to `σ` and provided that `ℳ` is a DirectSum.Decomposition, `ℳ` is also internal in the sense of forming a Direct Sum. The equality of elements in `ι` is required to be decidable.

Given an additive commutative monoid `M`, a set-like submonoid `σ`, a decidably-equivalent relation on `ι`, and a Direct Sum Decomposition `ℳ` from `ι` to `σ` of `M`, `ℳ` is an internal Direct Sum decomposition.


theorem List.zip_nil_right : ∀ {α : Type u_1} {l : List α} {β : Type u_2}, List.zip l [] = [] := by sorry

The theorem `List.zip_nil_right` states that for any type `α` and any list `l` of type `α`, and for any type `β`, when the `zip` function is applied to the list `l` and an empty list of type `β`, the result is always an empty list. This means that zipping any list with an empty list results in an empty list, irrespective of the types and contents of the lists.

For any types `α` and `β`, the zip of a list `l` of type `α` with an empty list of type `β` is an empty list.


theorem symmetric_disjoint : ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α], Symmetric Disjoint := by
  sorry

The `symmetric_disjoint` theorem states that for any type `α` that is a partial order and has a least element (denoted as `⊥`), the disjointness relation is symmetric. In other words, if two elements `a` and `b` of the type `α` are disjoint (meaning any element `x` that is less than or equal to both `a` and `b` is also less than or equal to `⊥`), then `b` and `a` are also disjoint.

If `α` is a partial order type with a least element `⊥`, then `a` and `b` are disjoint in `α` if and only if `b` and `a` are disjoint in `α`.


ContDiffWithinAt.add

/-- The sum of two `C^n` functions within a set at a point is `C^n` within this set
at this point.  -/
theorem ContDiffWithinAt.add :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
      {n : ℕ∞} {s : Set E} {f g : E → F},
      ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → ContDiffWithinAt 𝕜 n (fun x => f x + g x) s x :=
  by sorry

This theorem asserts that the sum of two functions, each of which is continuously differentiable to order `n` within a set `s` at a point `x`, is also continuously differentiable to order `n` at that point within the same set. Here, the underlying field is a nontrivial normed field `𝕜`, and the functions `f` and `g` both map from a normed additive commutative group `E`, which is also a normed space over the field `𝕜`, to another normed additive commutative group `F`, which is also a normed space over the field `𝕜`. The smoothness order `n` can be a natural number or infinity (`ℕ∞`).

If `f` and `g` are continuously differentiable to order `n` at `x` in the normed spaces `E` and `F` over the nontrivial normed field `𝕜`, then their sum `f + g` is also continuously differentiable to order `n` at `x`.


theorem Set.Infinite.exists_gt :
    ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrderBot α] {s : Set α},
      Set.Infinite s → ∀ (a : α), ∃ b ∈ s, a < b :=
  by sorry

This theorem states that for any type `α` that has a linear order and a locally finite order at the bottom, if we have an infinite set `s` of type `α`, then for any element `a` of `α`, there exists an element `b` in the set `s` such that `a` is less than `b`. In other words, given any element, there is always a larger element in the infinite set.

For any infinite, ordered type `α` with a locally finite order at the bottom, each element `a` in `α` has an element `b` in the set `α` strictly greater than `a`.


theorem RingHom.mem_range :
    ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] {f : R →+* S} {y : S},
      y ∈ RingHom.range f ↔ ∃ x, f x = y :=
  by sorry

This theorem states that for any given types `R` and `S` which have a ring structure, a ring homomorphism `f` from `R` to `S`, and an element `y` of `S`, `y` belongs to the range of `f` if and only if there exists an element `x` in `R` such that `f(x)` equals `y`. That is, `y` is in the image of `f` precisely when `y` is the image of some element under `f`.

For any ring homomorphisms $f : R \rightarrow S$ and $y \in S$, $y$ is in the image of $f$ if and only if there exists $x \in R$ such that $f(x) = y$.


theorem Finset.card_inter_add_card_union :
    ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∩ t).card + (s ∪ t).card = s.card + t.card := by sorry

The theorem `Finset.card_inter_add_card_union` states that for any type `α` with decidable equality and for any two finite sets `s` and `t` of type `α`, the cardinality of the intersection of `s` and `t` added to the cardinality of the union of `s` and `t` is equal to the sum of the cardinalities of `s` and `t`. This is essentially the principle of inclusion-exclusion for two sets, often expressed in set theory as $|A \cap B| + |A \cup B| = |A| + |B|$.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, the cardinality of `s ∩ t` plus the cardinality of `s ∪ t` equals the sum of the cardinalities of `s` and `t`.


theorem AList.mem_keys : ∀ {α : Type u} {β : α → Type v} {a : α} {s : AList β}, a ∈ s ↔ a ∈ AList.keys s := by sorry

This theorem, `AList.mem_keys`, states that for any type `α`, for any dependent type `β` that depends on `α`, for any value `a` of type `α`, and for any association list `s` of type `β`, `a` is in the list `s` if and only if `a` is in the list of keys of `s`. In other words, it states that an element belongs to an association list if and only if it is a key in that association list.

For any type `α` and dependent type `β`, an element `a` of type `α` is in an association list `s` of type `β` if and only if `a` is a key in `s`.


theorem Set.singleton_one : ∀ {α : Type u_2} [inst : One α], {1} = 1 := by sorry

This theorem states that for any type `α` that has an instance of the `One` typeclass (meaning it has a well-defined "one" or multiplicative identity), the set that contains only the element "one" (`{1}`) is equivalent to the "one" element itself (`1`). In mathematical terms, for any type with a multiplicative identity, the singleton set containing only the identity is equivalent to the identity.

For any type `α` with a multiplicative identity, the singleton set `{1 : α}` is equal to the identity `1 : α`.


theorem Equiv.symm_preimage_preimage :
    ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (s : Set β), ⇑e.symm ⁻¹' (⇑e ⁻¹' s) = s := by sorry

The theorem `Equiv.symm_preimage_preimage` states that for any two types `α` and `β`, and any equivalence `e` between them, and any set `s` of elements of type `β`, the preimage under `e.symm` (the inverse of `e`) of the preimage under `e` of `s` is equal to `s`. This essentially means that applying an equivalence and its inverse in succession to a set leaves the set unchanged.

For any equivalence $e : \alpha \cong \beta$ and set $s \subseteq \beta$, the preimages under the inverse $e.symm$ of $e(X)$ and $X$ are equal: $e.symm(e(s)) = s$.


theorem ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction_eq :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ} (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α)
      (r : ℚ), ↑(ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunction hf a) ↑r = f a r :=
  by sorry

This theorem states that for any given measurable space `α`, and a function `f` from `α` to the set of real numbers parameterized by rational numbers, if `f` satisfies the property `IsMeasurableRatCDF`, then the Stieltjes function obtained by extending `f` from rational numbers to real numbers produces the same output as `f` for every `α` and rational number input. More formally, for every `α` in `α`, and rational number `r`, the value of the Stieltjes function at `r` is equal to `f(α, r)`.

For any measurable space `α` and measurable function `f` from `α` to the real numbers parameterized by rational numbers, satisfying `IsMeasurableRatCDF`, the extended Stieltjes function of `f` equals `f` itself for every `α` in `α` and rational number `r`.


Associated.irreducible

theorem Associated.irreducible :
    ∀ {α : Type u_1} [inst : Monoid α] {p q : α}, Associated p q → Irreducible p → Irreducible q := by sorry

This theorem states that for any type `α` which has a `Monoid` structure, if two elements `p` and `q` of this structure are associated (meaning there exists a unit `u` such that `p` multiplied by `u` equals `q`), then if `p` is irreducible, `q` must be irreducible as well. In mathematical terms, irreducibility is preserved under association in a monoid.

If `α` is a type with a `Monoid` structure and `p` and `q` are associates in `α` with a common unit `u`, then `p` irreducible implies `q` is irreducible.


theorem abs_max_sub_max_le_max :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] (a b c d : α), |max a b - max c d| ≤ max |a - c| |b - d| := by
  sorry

This theorem establishes a relationship among the maximum values and absolute differences of four elements, `a`, `b`, `c`, and `d`, in any linear ordered additive commutative group, which is a mathematical structure that combines the properties of being a group and a linear order. The theorem states that the absolute value of the difference between the maximum of `a` and `b` and the maximum of `c` and `d` is always less than or equal to the maximum of the absolute differences of `a` and `c` and `b` and `d`. This property provides an upper bound for the absolute difference between two maxima.

In any linear ordered additive commutative group, |max(a, b) - max(c, d)| ≤ max(|a - c|, |b - d|).


theorem SchwartzMap.le_seminormAux :
    ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (k n : ℕ) (f : SchwartzMap E F) (x : E),
      ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ SchwartzMap.seminormAux k n f :=
  by sorry

This theorem states that, for any normed additively commutative groups E and F, which are also normed spaces over the real numbers, given any two natural numbers `k` and `n`, and a SchwartzMap `f` from E to F, the product of the `k`-th power of the norm of any element `x` in E and the norm of the `n`-th iterated Fréchet derivative of `f` at `x`, is less than or equal to the `k`-th and `n`-th seminorm of `f` in the Schwartz space.

For any SchwartzMap `f` between normed additively commutative groups E and F over the real numbers, and for all `x` in E, `k` in ℕ, and `n` in ℕ, the `k`-th power of the norm of `x` times the norm of the `n`-th Fréchet derivative of `f` at `x` is bounded above by the `k`-th seminorm and the `n`-th norm of `f`.


theorem Finset.val_toFinset : ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), Multiset.toFinset s.val = s := by
  sorry

This theorem, `Finset.val_toFinset`, states that for any type `α` that has decidable equality (denoted by `DecidableEq α`), for any `Finset` `s` of type `α`, if we convert the underlying multiset of `s` (represented by `s.val`) into a `Finset` using the `Multiset.toFinset` function, we get `s` itself. In other words, the operation of removing duplicates from the multiset of a `Finset` and converting it back to a `Finset` leaves the original `Finset` unchanged.

For any type `α` with decidable equality and any `Finset` `s` of type `α`, the conversion of `s.val` to a `Finset` using `Multiset.toFinset` equals `s`.


theorem dvd_pow : ∀ {α : Type u_1} [inst : Monoid α] {a b : α}, a ∣ b → ∀ {n : ℕ}, n ≠ 0 → a ∣ b ^ n := by sorry

This theorem states that for any type `α` that forms a monoid, given two elements `a` and `b` of this type, if `a` divides `b`, then `a` also divides `b` to the power `n` for any natural number `n` that is not zero. The notation `a ∣ b` represents the divisibility relation where `a` divides `b`. A monoid is a set equipped with an associative binary operation and an identity element.

For any monoid `α` and elements `a, b` in `α`, if `a` divides `b`, then `a` divides `b` raised to any natural power `n` (`n ≠ 0`).


theorem mem_groupoid_of_pregroupoid :
    ∀ {H : Type u} [inst : TopologicalSpace H] {PG : Pregroupoid H} {e : PartialHomeomorph H H},
      e ∈ Pregroupoid.groupoid PG ↔ PG.property (↑e) e.source ∧ PG.property (↑(PartialHomeomorph.symm e)) e.target :=
  by sorry

The theorem `mem_groupoid_of_pregroupoid` states that for any type `H` equipped with a topological space structure, a pregroupoid `PG` on `H`, and any partial homeomorphism `e` of `H` onto itself, `e` is a member of the groupoid associated to `PG` if and only if the property defined by `PG` holds both for `e` on its source and for the inverse of `e` on its target.

A partial homeomorphism between a topological space and itself is an object in the groupoid of a pregroupoid if and only if it satisfies the pregroupoid relation on both its source and target.


theorem Complex.cosh_add_sinh : ∀ (x : ℂ), Complex.cosh x + Complex.sinh x = Complex.exp x := by sorry

This theorem states that for any complex number `x`, the sum of the complex hyperbolic cosine of `x` and the complex hyperbolic sine of `x` is equal to the complex exponential of `x`. In mathematical terms, this can be written as: ∀x ∈ ℂ, cosh(x) + sinh(x) = exp(x). This property is an important identity in complex analysis, analogous to the identity for real numbers where the sum of exponential of a number and its negative inverse is equal to the hyperbolic cosine of the number.

For all complex numbers x, the sum of the complex hyperbolic cosine and sine functions of x is equal to the complex exponent function applied to x: cosh(x) + sinh(x) = exp(x).


theorem le_of_le_mul_right :
    ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] {a b c : α}, c ≠ 0 → a * c ≤ b * c → a ≤ b := by sorry

This theorem states that for any instance `α` of a type `u_1` that forms a linear ordered commutative group with zero, and for any three elements `a`, `b`, and `c` of this type, if `c` is not equal to zero and the product of `a` and `c` is less than or equal to the product of `b` and `c`, then `a` is less than or equal to `b`. Essentially, this theorem allows cancellation in inequalities for commutative groups with a linear order and zero element, under the condition that the element being 'cancelled' is not zero.

If `α` is a commutative group with a linear order and zero, and `a`, `b`, and `c` are elements of `α` with `c ≠ 0`, then `a ≤ b` if and only if `a * c ≤ b * c`.


theorem IsMax.eq_of_le : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMax a → a ≤ b → a = b := by sorry

The theorem `IsMax.eq_of_le` states that for any partially ordered set `α`, if `a` is a maximal element in `α` (meaning that no element in `α` is strictly greater than `a`) and `a` is less than or equal to another element `b` in `α`, then `a` must be equal to `b`. This theorem captures the idea that in a partially ordered set, if an element is maximal and it is not strictly greater than another element, then these two elements must be the same.

In a partially ordered set, if an element is maximal and less than or equal to another element, then they are equal.


theorem Mathlib.Order.Filter.Basic._auxLemma.119 :
    ∀ {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {P : β → Prop},
      (∃ᶠ (b : β) in Filter.map m f, P b) = ∃ᶠ (a : α) in f, P (m a) :=
  by sorry

This theorem states that for any types `α` and `β`, any filter `f` on `α`, any function `m` from `α` to `β`, and any property `P` on `β`, the condition "there eventually exists an element `b` in the filter obtained by applying the function `m` to `f` such that `P b` holds" is equivalent to the condition "there eventually exists an element `a` in `f` such that `P (m a)` holds". In other words, whether we check the property `P` after or before applying the function `m` doesn't change the eventual elements for which `P` holds.

For any filters `f` on type `α`, functions `m` from `α` to type `β`, and properties `P` on `β`, the filters `m '' f` and `{x | ∃y ∈ f, P y ∧ m x = y}` have the same eventual elements.


theorem List.foldrM_cons :
    ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [inst_1 : LawfulMonad m] (a : α)
      (l : List α) (f : α → β → m β) (b : β), List.foldrM f b (a :: l) = List.foldrM f b l >>= f a :=
  by sorry

The theorem `List.foldrM_cons` states that for any two types `m` and `α`, where `m` is a type constructor that takes a type and returns another type, and for any type `β`, given that `m` forms a Monad and a LawfulMonad, for any `a` of type `α`, any list `l` of elements of type `α`, a function `f` from type `α` and `β` to `m β`, and any `b` of type `β`, the fold right monadic operation on the list that consists of `a` followed by the list `l`, with function `f` and initial value `b`, is the same as performing the fold right monadic operation on the list `l` with the same function `f` and initial value `b`, and then binding the result with the function `f` applied to `a`. This theorem is essentially a property about how the fold right monadic operation distributes over the cons operator (i.e., list constructor).

For any monad and lawful monad `m`, type `α`, list `l` of type `α`, function `f : α → m β`, initial value `b` of type `β`, and element `a` of type `α`, the monadic fold right operation on the list `[a] @ l` using `f` and `b` is equivalent to binding the result of the monadic fold right operation on list `l` with `f(a)`.


theorem Set.Finite.absorbs_sInter :
    ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
      {t : Set α} {S : Set (Set α)}, Set.Finite S → (Absorbs G₀ (⋂₀ S) t ↔ ∀ s ∈ S, Absorbs G₀ s t) :=
  by sorry

The theorem `Set.Finite.absorbs_sInter` states that for any types `G₀` and `α`, where `G₀` is a group with zero and has a bornology, and `α` is a set on which `G₀` acts multiplicatively, given a set `t` of type `α` and a set `S` of sets of type `α`, if `S` is finite, then `t` is absorbed by the intersection over `S` (denoted as `⋂₀ S`) if and only if `t` is absorbed by every set `s` in `S`.

In this context, a set `s` absorbs another set `t` if `t` is contained in all scalings of `s` by all but a bounded set of elements of `G₀`.

For a group with zero and bornology `G₀` acting multiplicatively on set `α`, a set `t` is absorbed by the intersection of finite sets `S` if and only if it is absorbed by each set `s` in `S`.


theorem MeasureTheory.VectorMeasure.of_union :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
      [inst_2 : T2Space M] {v : MeasureTheory.VectorMeasure α M} {A B : Set α},
      Disjoint A B → MeasurableSet A → MeasurableSet B → ↑v (A ∪ B) = ↑v A + ↑v B :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.of_union` states that for any type `α` with a associated measurable space `m`, a type `M` which is an additive commutative monoid as well as a topological space, and a T2 (Hausdorff) space, given a vector measure `v` over `α` with values in `M`, and two disjoint sets `A` and `B` that are both measurable, the measure of the union of `A` and `B` with respect to the vector measure `v` is equal to the sum of the measures of `A` and `B` individually. This is a generalization of the principle that the measure of the union of two disjoint sets is the sum of their individual measures.

For any measurable spaces `(α, m)`, additive commutative monoid and T2 space `M`, vector measure `v` over `α` with values in `M`, and disjoint measurable sets `A` and `B`, the measure of `A ∪ B` is equal to `v(A) + v(B)`.


theorem AddLocalization.induction_on :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Prop}
      (x : AddLocalization S), (∀ (y : M × ↥S), p (AddLocalization.mk y.1 y.2)) → p x :=
  by sorry

This theorem states that, given an additive commutative monoid `M`, a submonoid `S` of `M`, a property `p` that applies to elements of the localization of `M` at `S`, and an element `x` of this localization, if every pair `(y.1, y.2)` where `y.1` belongs to `M` and `y.2` belongs to `S` satisfies this property when passed to `AddLocalization.mk`, then the property `p` is satisfied by `x`. Essentially, this theorem provides an induction principle for reasoning about all elements of the localization of a commutative monoid at one of its submonoids.

Given an additive commutative monoid `M`, a submonoid `S`, and a property `p`, if for all `y` with `y.1` in `M` and `y.2` in `S`, `p(AddLocalization.mk y)` holds, then `p(x)` holds for every element `x` in the localization of `M` at `S`.


theorem sign_apply :
    ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableRel fun x x_1 => x < x_1] {a : α},
      SignType.sign a = if 0 < a then 1 else if a < 0 then -1 else 0 :=
  by sorry

The theorem `sign_apply` states that for any type `α` which has a zero element and a preorder relation (a binary relation that is reflexive and transitive), and for which it is decidable whether one element is less than another, the sign of any element `a` from `α` is determined as follows: if `a` is greater than zero, then the sign is `1`; if `a` is less than zero, then the sign is `-1`; if `a` is neither greater than nor less than zero, then the sign is `0`.

For any type with a zero element and a decidable preorder relation, the sign function maps elements greater than zero to 1, elements less than zero to -1, and zero to 0.


theorem Module.End.mem_eigenspace_iff :
    ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
      {μ : R} {x : M}, x ∈ Module.End.eigenspace f μ ↔ f x = μ • x :=
  by sorry

This theorem states that for any commutative ring `R`, an additive commutative group `M`, and a module `M` over the ring `R`, given a linear transformation `f` from `M` to `M`, a scalar `μ` from the ring `R`, and a vector `x` from `M`, `x` is an element of the eigenspace of `f` corresponding to the eigenvalue `μ` if and only if `f` acting on `x` equals `μ` scaled by `x`. In mathematical terms, this states that $x$ is an eigenvector of the linear transformation $f$ with eigenvalue $μ$ if and only if $f(x) = μx$.

For any commutative ring `R`, additive commutative group `M`, and `R`-module `M`, a linear transformation `f` from `M` to `M`, scalar `μ` in `R`, and vector `x` in `M`, `x` is an eigenvector of `f` with eigenvalue `μ` if and only if `f(x) = μ × x`.


CategoryTheory.Factorisation.Hom.ext

theorem CategoryTheory.Factorisation.Hom.ext :
    ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y}
      {d e : CategoryTheory.Factorisation f} (x y : CategoryTheory.Factorisation.Hom d e), x.h = y.h → x = y :=
  by sorry

This theorem states that in the context of a category theory, given a category 'C' with objects 'X' and 'Y' and a morphism 'f' from 'X' to 'Y', for any two factorisations 'd' and 'e' of 'f', if we have two morphisms 'x' and 'y' from 'd' to 'e', then if the hom-set of 'x' equals the hom-set of 'y', 'x' and 'y' are themselves equal. This is essentially a statement of the uniqueness of such a morphism under these conditions.

In a category, if two morphisms between factorizations of a given morphism have equal hom-sets, then they are equal.


theorem AddLocalization.mk_eq_mk_iff :
    ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {a c : M} {b d : ↥S},
      AddLocalization.mk a b = AddLocalization.mk c d ↔ (AddLocalization.r S) (a, b) (c, d) :=
  by sorry

The theorem `AddLocalization.mk_eq_mk_iff` states that for any type `M` that is an instance of `AddCommMonoid`, any `AddSubmonoid` `S` of `M`, and any elements `a` and `c` of `M` and `b` and `d` of `S`, the equality of the localization of `a` at `b` and the localization of `c` at `d` is equivalent to the congruence of the pair `(a, b)` and the pair `(c, d)` under the relation `AddLocalization.r S`. In other words, two localized elements of an additive commutative monoid are equal if and only if their corresponding pairs in the original monoid are congruent under the localization relation.

For any additive commutative monoid `M` with submonoid `S`, and elements `a`, `c` of `M` and `b` of `d` of `S`, the localization of `a` at `b` equals the localization of `c` at `d` if and only if `(a, b)` and `(c, d)` are congruent under `AddLocalization.r S`.


theorem Cardinal.lift_lt_univ' : ∀ (c : Cardinal.{u}), Cardinal.lift.{max (u + 1) v, u} c < Cardinal.univ.{u, v} := by
  sorry

The theorem `Cardinal.lift_lt_univ'` states that for any cardinal number `c` in the universe `u`, when this cardinal number `c` is lifted to the higher universe `max (u + 1) v`, it is strictly less than the cardinality of the universe (denoted by 'Cardinal.univ'). In other words, the cardinality of any set (represented as a `Cardinal`) in a smaller universe is strictly less than the cardinality of the whole larger universe in which it is embedded.

For any cardinal number `c` in universe `u`, `c` is strictly less than `Cardinal.univ` when lifted to the higher universe `max (u + 1) v`.


Primrec.pair

theorem Primrec.pair :
    ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable γ] {f : α → β} {g : α → γ}, Primrec f → Primrec g → Primrec fun a => (f a, g a) :=
  by sorry

The theorem `Primrec.pair` states that for any types `α`, `β`, and `γ` and any functions `f : α → β` and `g : α → γ`, if `f` and `g` are primitive recursive (i.e., their computations can be implemented using a limited set of operations and they terminate after a finite number of steps), then the function that takes an input `a` of type `α` and returns the pair `(f a, g a)` is also primitive recursive. This means that we can construct a new primitive recursive function by pairing the outputs of two given primitive recursive functions.

If functions `f : α → β` and `g : α → γ` are primitive recursive, then the function `x ↦ (f x, g x)` from `α` to `β × γ` is also primitive recursive.


theorem Finsupp.coe_sub :
    ∀ {α : Type u_1} {G : Type u_9} [inst : SubNegZeroMonoid G] (g₁ g₂ : α →₀ G), ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂ := by sorry

This theorem states that for any two `g₁` and `g₂`, which are finitely supported functions from a type `α` to a type `G` (where `G` is a subtraction and negation zero monoid), the function obtained by subtracting `g₂` from `g₁` is the same as subtracting the function `g₂` from the function `g₁`. In simpler words, the subtraction operation on finitely supported functions corresponds to pointwise subtraction of the functions.

For any two finitely supported functions `g₁` and `g₂` from type `α` to a subtraction and negation zero monoid `G`, `g₁ - g₂` equals `g₁ - g₂` pointwise.


theorem bddAbove_Icc : ∀ {α : Type u} [inst : Preorder α] {a b : α}, BddAbove (Set.Icc a b) := by sorry

This theorem states that for any type `α` that has an order structure (preorder), and for any two elements `a` and `b` of this type, the closed interval `Set.Icc a b` (which includes all elements `x` such that `a ≤ x` and `x ≤ b`) is bounded above. This means there exists an element which is greater than or equal to every element in the closed interval `Set.Icc a b`.

For any type `α` with an order structure and any `a, b ∈ α` with `a ≤ b`, the closed interval `[a, b] = {x | a ≤ x ≤ b}` has a supreme element.


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

The theorem `PartialEquiv.symm_source` states that for any partial equivalence `e` between two types `α` and `β`, the source of the inverse of `e` (denoted as `PartialEquiv.symm e`) is equivalent to the target of `e`. In other words, it reverses the roles of the source and target in the partial equivalence.

For any partial equivalence `e` between types `α` and `β`, `PartialEquiv.symm e` is the partial equivalence with source `β` and target `α` such that `e (x : α) ≈ y : β <=> (x ≈ y) ≈ (y ≈ x)`.


theorem UpperHalfPlane.cmp_dist_eq_cmp_dist_coe_center :
    ∀ (z w : UpperHalfPlane) (r : ℝ),
      cmp (dist z w) r = cmp (dist ↑z ↑(UpperHalfPlane.center w r)) (UpperHalfPlane.im w * Real.sinh r) :=
  by sorry

This theorem is stating that for all points `z` and `w` in the open upper half plane and any real number `r`, the comparison (ordered as less than, equal, or greater than) of the Euclidean distance between `z` and `w` with `r` is the same as the comparison of the Euclidean distance between `z` and the center of the circle with center `w` and radius `r` in the hyperbolic metric, with the product of the imaginary part of `w` and the hyperbolic sine of `r`. In other words, this theorem is comparing distances in two different geometric contexts: the usual Euclidean plane and a hyperbolic metric.

For all `z` and `w` in the open upper half plane and real number `r`, the Euclidean distance between `z` and `w` is less than, equal to, or greater than `r` if and only if the hyperbolic distance between `z` and the center of the circle with center `w` and radius `r` is less than, equal to, or greater than the product of the imaginary part of `w` and the hyperbolic sine of `r`.


theorem Set.singleton_mul : ∀ {α : Type u_2} [inst : Mul α] {t : Set α} {a : α}, {a} * t = (fun x => a * x) '' t := by
  sorry

The theorem `Set.singleton_mul` states that for any type `α` that has a multiplication operation (`Mul α`), and for any set `t` of this type, and any element `a` of this type, the result of multiplying the singleton set containing `a` and the set `t` is equivalent to the image of the set `t` under the function that multiplies each element by `a`. In mathematical terms, this is saying that `{a} * t = {a * x | x ∈ t}`.

The theorem asserts that for any type `α` with multiplication and for any set `t` of `α`, the singleton set `{a}` multiplied by `t` equals the image of `t` under the function `x => a * x`.


theorem Ordinal.one_opow : ∀ (a : Ordinal.{u_1}), 1 ^ a = 1 := by sorry

The theorem `Ordinal.one_opow` states that for any ordinal `a`, the ordinal exponentiation of `1` to the power `a` is always `1`. In other words, regardless of the ordinal `a`, when `1` is raised to any ordinal power, the result is always `1`. This is analogous to the rule in conventional mathematics where any number raised to the power of zero is one, and here it is generalized to ordinals.

For any ordinal `a`, the ordinal exponentiation `1^a` equals `1`.


theorem norm_eq_zero'' : ∀ {E : Type u_6} [inst : NormedGroup E] {a : E}, ‖a‖ = 0 ↔ a = 1 := by sorry

This theorem states that for any type `E` that forms a Normed Group, the norm of an element `a` of `E` is equal to zero if and only if `a` is equal to one. In mathematical terms, given a Normed Group `(E, ‖·‖)`, it states that `‖a‖ = 0` if and only if `a = 1`. This theorem provides a characterization of the zero element in the Normed Group in terms of its norm.

In a Normed Group `(E, ‖·‖)`, the element `a` has norm 0 if and only if `a` is the additive identity (i.e., `a = 1`).


PartialEquiv.mapsTo

theorem PartialEquiv.mapsTo :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), Set.MapsTo (↑e) e.source e.target := by sorry

This theorem states that for any partial equivalence relation `e` between types `α` and `β`, the function from `α` to `β` determined by `e` maps every element of `e.source` to an element in `e.target`. In other words, all elements in the source of `e` are mapped to elements in the target of `e`, respecting the partial equivalence relation. Here, `Set.MapsTo` is a function that checks this property of mapping between sets.

For any partial equivalence relation `e` between types `α` and `β`, the function determined by `e` maps every element in `e.source` to some element in `e.target`.


/-- `AnalyticAt.comp` for functions on product spaces  -/
theorem AnalyticAt.comp₂ :
    ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
      [inst_4 : NormedSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G]
      [inst_7 : NormedAddCommGroup H] [inst_8 : NormedSpace 𝕜 H] {h : F × G → H} {f : E → F} {g : E → G} {x : E},
      AnalyticAt 𝕜 h (f x, g x) → AnalyticAt 𝕜 f x → AnalyticAt 𝕜 g x → AnalyticAt 𝕜 (fun x => h (f x, g x)) x :=
  by sorry

The theorem `AnalyticAt.comp₂` states that for a given non-trivially normed field `𝕜` and normed add commutative groups `E`, `F`, `G`, `H` with `𝕜` as their scalar field, if a function `h` from product space `F × G` to `H` is analytic at a point `(f x, g x)`, and the functions `f` and `g` from `E` to `F` and `G` respectively, are analytic at a point `x`, then the composition function `(fun x => h (f x, g x))` which maps `x` to `h (f x, g x)` is also analytic at the point `x`. In other words, the analyticity is preserved under function composition in product spaces.

If functions `f` and `g` are analytic at a point `x` in normed add commutative groups `E` and `F`, `G`, respectively, over a non-trivially normed field `𝕜`, and the function `h` from `F × G` to `H` is analytic at `(f x, g x)`, then the composition function `(fun x => h (f x, g x))` is analytic at `x` in `E`.


theorem List.length_pos_of_mem : ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → 0 < List.length l := by sorry

The theorem `List.length_pos_of_mem` states that for any type `α`, any element `a` of type `α`, and any list `l` of elements of type `α`, if `a` is an element in `l` (denoted by `a ∈ l`), then the length of the list `l` is greater than zero. In other words, if a list contains an element, its length must be positive.

If `a` is an element of list `l` of length `n`, then `n` is a positive natural number.


theorem Nat.Ico_succ_right_eq_insert_Ico : ∀ {a b : ℕ}, a ≤ b → Finset.Ico a (b + 1) = insert b (Finset.Ico a b) := by
  sorry

This theorem states that for any pair of natural numbers `a` and `b` where `a` is less than or equal to `b`, the set of natural numbers `x` such that `a ≤ x` and `x < b + 1` is equal to the union of the set `{b}` and the set of natural numbers `x` such that `a ≤ x` and `x < b`. In mathematical terms, if $a \leq b$, then $[a, b+1) = b \cup [a, b)$.

For any natural numbers `a` and `b` with `a <= b`, the set `{x | a <= x < b + 1}` equals the set `{x | a <= x < b} union {b}`. In mathematical notation, `[a, b+1) = b union [a, b)`.


/-- Uses `right` co(ntra)variant. -/
theorem Right.nonneg_neg_iff :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a : α}, 0 ≤ -a ↔ a ≤ 0 :=
  by sorry

This theorem, `Right.nonneg_neg_iff`, states that for all elements `a` of a type `α`, which is an additive group and has a defined less than or equal to (`LE`) operation, such that the operation is right-covariant (i.e., reversing the order of the operation and then adding doesn't change the order of comparison), the non-negativity of the negation of `a` is equivalent to `a` being less than or equal to zero. In other words, if we have a right-covariant additive group, then `0` is less than or equal to the negation of `a` if and only if `a` is less than or equal to `0`.

For all elements `a` in an additive group with right-covariant order relation, `a ≤ 0` if and only if `-a ≤ 0`.


theorem Rat.denseEmbedding_coe_real : DenseEmbedding Rat.cast := by sorry

The theorem `Rat.denseEmbedding_coe_real` asserts that the canonical homomorphism from the rational numbers (`Rat`) into a division ring `K` is a dense embedding. This essentially means that for any two elements in `K`, there exists a rational number that lies between them, signifying the dense property of rational numbers in any division ring. The proof of the theorem is suppressed in this context.

The canonical homomorphism from the rational numbers into any division ring is a dense embedding.


theorem Function.Periodic.int_mul_eq :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Ring α],
      Function.Periodic f c → ∀ (n : ℤ), f (↑n * c) = f 0 :=
  by sorry

The theorem `Function.Periodic.int_mul_eq` asserts that for any type `α` which forms a ring, and any function `f` from `α` to an arbitrary type `β`, if `f` is periodic with period `c`, then for any integer `n`, the value of `f` at the product of `n` (coerced to `α`) and `c` is equal to `f` at zero. In other words, if a function is periodic, the value of the function at any integral multiple of the period is the same as the value of the function at zero.

For any ring type `α` and periodic function `f` from `α` to a type `β`, the value `f (n * c)` equals `f 0` for all integers `n`, where `c` is the period of `f`.


/-- If `g : α → β` is a measurable embedding and `f : β → ℝ≥0∞` is any function (not necessarily
measurable), then `∫⁻ a, f a ∂(map g μ) = ∫⁻ a, f (g a) ∂μ`. Compare with `lintegral_map` which
applies to any measurable `g : α → β` but requires that `f` is measurable as well.  -/
theorem MeasurableEmbedding.lintegral_map :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasurableSpace β]
      {g : α → β},
      MeasurableEmbedding g →
        ∀ (f : β → ENNReal), ∫⁻ (a : β), f a ∂MeasureTheory.Measure.map g μ = ∫⁻ (a : α), f (g a) ∂μ :=
  by sorry

The theorem `MeasurableEmbedding.lintegral_map` states that, given a measurable space `α`, a measure `μ` on `α`, a measurable space `β`, and a function `g : α → β` which is a measurable embedding, for any function `f : β → ENNReal` (where `ENNReal` is the extended nonnegative real numbers, typically denoted as `[0, ∞]`), the Lebesgue integral of `f` with respect to the pushforward measure `map g μ` is equal to the Lebesgue integral of the function `f ∘ g` with respect to the measure `μ`. This is a generalization of the theorem `lintegral_map`, except it does not require `f` to be measurable.

Given a measurable space `α`, a measure `μ` on `α`, a measurable embedding `g : α → β`, and a function `f : β → [0, ∞]`, the Lebesgue integrals of `f` with respect to the measures `μ` and `map g μ` are equal.


theorem iff_iff_eq : ∀ {a b : Prop}, (a ↔ b) ↔ a = b := by sorry

This theorem states that for any two propositions 'a' and 'b', the proposition that 'a' is logically equivalent to 'b' is itself logically equivalent to the proposition that 'a' equals 'b'. In other words, stating that two propositions are logically equivalent is the same as saying that they are equal.

The proposition "a is logically equivalent to b" is equivalent to the proposition "a = b" for any propositions a and b.


theorem Function.support_zero : ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M], (Function.support fun x => 0) = ∅ := by
  sorry

The theorem `Function.support_zero` states that for any types `α` and `M` where `M` has a zero element, the function support of a constant zero function (a function mapping any element from `α` to zero) is an empty set. In other words, there are no elements `x` in `α` for which the function value `f x` is not equal to zero, since all elements map to zero.

For any type `α` and any constant function `f : α → ℤ` with value 0, the function support of `f` is empty.


Monotone.Iic

theorem Monotone.Iic :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
      Monotone f → Monotone fun x => Set.Iic (f x) :=
  by sorry

The theorem `Monotone.Iic` states that for any types `α` and `β` with preorder relations, and any monotone function `f` mapping from `α` to `β`, the function `f` remains monotone when mapped to the set of all elements less than or equal to `f(x)`. In other words, if `a ≤ b` in `α`, then the set of all elements less than or equal to `f(a)` is a subset of the set of all elements less than or equal to `f(b)`.

For any monotonic function $f$: $\alpha \to \beta$ between preordered types, the image under $f$ of a lower element is an upper bound of its image. In other words, if $a \leq b$ in $\alpha$, then $f(a) \leq f(b)$ and $\{x \in \beta \mid x \leq f(a)\} \subseteq \{x \in \beta \mid x \leq f(b)\}$.


/-- A filter lies below the neighborhood filter at `x` iff it contains every open set around `x`.  -/
theorem le_nhds_iff :
    ∀ {X : Type u} {x : X} [inst : TopologicalSpace X] {f : Filter X},
      f ≤ nhds x ↔ ∀ (s : Set X), x ∈ s → IsOpen s → s ∈ f :=
  by sorry

The theorem `le_nhds_iff` states that for any topological space `X`, any point `x` in `X`, and any filter `f` on `X`, the filter `f` is less than or equal to the neighborhood filter at `x` if and only if for every set `s` such that `x` is an element of `s` and `s` is open, `s` is an element of the filter `f`. In other words, a filter is subsumed by the neighborhood filter of a point if it contains every open set that contains that point.

A filter on a topological space is contained in the neighborhood filter of a point if and only if it contains every open set containing that point.


/-- Alias for `Or.inr`.  -/
theorem Or.intro_right : ∀ {b : Prop} (a : Prop), b → a ∨ b := by sorry

This theorem, `Or.intro_right`, is an alias for `Or.inr` in Lean. Given two propositional variables, a and b, it states that if we have a proof of b, then we can establish the proof of the logical disjunction "a OR b". Note that there isn't any necessity for a to be true for this theorem.

If we have a proof of proposition b, then we can derive a proof of the logical disjunction a OR b in Lean.


theorem isOpenMap_sigmaMk :
    ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpenMap (Sigma.mk i) := by
  sorry

The theorem `isOpenMap_sigmaMk` states that for every index set `ι` and a corresponding function `σ` that maps each index to a topological space, for any given index `i` from `ι`, the function `Sigma.mk i` is an open map. Here, `Sigma.mk i` is a function that takes an element from the topological space associated with the given index `i` and produces a sigma type (or dependent pair) consisting of the index `i` and the element from the topological space. An open map, in this context, means that the image of any open set under the function `Sigma.mk i` is also an open set.

For any index set `ι` and a function `σ : ι → Top`, the function `Σ.mk : ∀ i : ι, σ i → Σ i × σ i` is an open map.


theorem Mathlib.Order.Heyting.Basic._auxLemma.1 :
    ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, (a ≤ b ⇨ c) = (a ⊓ b ≤ c) := by sorry

This theorem is from the Mathlib library in the Order/Heyting/Basic module. It states that for all types `α` that are instances of `GeneralizedHeytingAlgebra`, and for all elements `a`, `b`, and `c` of this type, the proposition `a ≤ b ⇨ c` is equivalent to `a ⊓ b ≤ c`. In other words, the implication from `a` being less than or equal to `b` to `c` is the same as the infimum (greatest lower bound) of `a` and `b` being less than or equal to `c` in a Generalized Heyting algebra.

In a Generalized Heyting algebra, for all elements `a`, `b`, and `c`, the implication `a ≤ b` implies `a ⊓ b ≤ c` is equivalent to `a ≤ c` given `c ≤ b`.


theorem Algebra.id.smul_eq_mul : ∀ {R : Type u} [inst : CommSemiring R] (x y : R), x • y = x * y := by sorry

This theorem states that for any commutative semiring `R` and any two elements `x` and `y` of `R`, the operation of scalar multiplication of `x` and `y` is the same as their standard multiplication. In mathematical terms, for all `x` and `y` in `R`, `x` scalar multiplied by `y` is equal to `x` times `y`.

For any commutative semiring `R`, the operation of scalar multiplication of `x` and `y` equals the standard multiplication of `x` and `y`, for all `x` and `y` in `R`.


theorem MeasureTheory.lintegral_eq_zero_iff :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
      Measurable f → (∫⁻ (a : α), f a ∂μ = 0 ↔ f =ᶠ[MeasureTheory.Measure.ae μ] 0) :=
  by sorry

The theorem `MeasureTheory.lintegral_eq_zero_iff` states that for all measurable spaces `α` with `m` as its measure and `μ` as its measure, and for any function `f` from `α` to the extended nonnegative real numbers, if `f` is measurable, then the integral of `f` with respect to measure `μ` is equal to zero if and only if the function `f` is almost everywhere equal to zero (that is, equal to zero except on a set of measure zero).

A measurable function `f` from a measurable space `(α, m)` to the extended nonnegative real numbers equals the integral of `f` with respect to measure `μ` if and only if it is almost everywhere equal to zero.


theorem Stream'.WSeq.liftRel_destruct_iff :
    ∀ {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β},
      Stream'.WSeq.LiftRel R s t ↔
        Computation.LiftRel (Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)) (Stream'.WSeq.destruct s)
          (Stream'.WSeq.destruct t) :=
  by sorry

The theorem `Stream'.WSeq.liftRel_destruct_iff` establishes an equivalence between two conditions when given two weak sequences, `s` and `t`, of types `α` and `β` respectively and a relation `R` between `α` and `β`. The conditions are:
1. The weak sequences `s` and `t` are `LiftRel R` related, meaning either both are empty, or they are both non-empty and the first elements of each are `R` related and the rest of the sequences are `LiftRel R` related.
2. The computations resulting from destructing `s` and `t` are `LiftRel` related with respect to the relation `Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)`, meaning that if the destruction of `s` terminates with a certain value, then the destruction of `t` terminates with a value that is related to the former by this relation, and vice versa.

This theorem provides a connection between sequence-relatedness and the relatedness of their deconstructed computations, which can be used to simplify proofs involving streams and computations.

Given two weak sequences `s` and `t` of types `α` and `β` respectively, and a relation `R` between `α` and `β`, the weak sequences `s` and `t` are `LiftRel R` related if and only if the computations resulting from their destructive recursion are `LiftRel` related with respect to `Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)`.


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

This theorem states that for any given types `ι`, `M` and a type dependent function `α : ι → Type`, where each `α i` is a module over `M` for all `i : ι`, the scalar multiplication `•` distributes over the creation of a sigma type, `{ fst := i, snd := b }`, which is a pair consisting of an element `i` from `ι` and an element `b` from `α i`. Specifically, multiplying `a : M` with a sigma type constructed with `i : ι` and `b : α i` is the same as creating a sigma type with `i : ι` and `a • b : α i`.

For any type `ι`, module `M` over `ι`, and type-dependent function `α : ι → Type` such that each `α i` is an `M`-module, the scalar multiplication `• : M × α i → α i` distributes over the formation of sigma types: `a • {i : ι, b : α i} = {i : ι, a • b : α i}`.


IsPrimitiveRoot.isUnit

theorem IsPrimitiveRoot.isUnit :
    ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → 0 < k → IsUnit ζ := by sorry

This theorem states that for any commutative monoid `M`, any natural number `k` and any element `ζ` of `M`, if `ζ` is a primitive root of order `k` and `k` is a positive number, then `ζ` is a unit of `M`. In other words, if `ζ` is an element of `M` such that raising `ζ` to the power `k` gives the identity element, and `k` is positive, then there exists an inverse of `ζ` in `M`.

If `ζ` is a primitive root of order `k` in a commutative monoid `M` with `k` being a positive natural number, then `ζ` is a unit in `M` with an inverse.


theorem toZ_of_ge :
    ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
      {i0 i : ι} (hi : i0 ≤ i), toZ i0 i = ↑(Nat.find ⋯) :=
  by sorry

The theorem `toZ_of_ge` states that for all types ι with a linear order, a successor order, an Archimedean successor property, and a predecessor order, and for all elements i0 and i of type ι such that i0 is less than or equal to i, the function `toZ` applied to i0 and i returns the integer representation of the value obtained by applying the `Nat.find` function to some unspecified argument.

For all types ι with a linear order, successor order, Archimedean successor property, and a predecessor order, the function `toZ` maps the predecessor of any element i to the integer representation of the index of i in the order.


theorem Polynomial.sum_C_mul_X_pow_eq :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R),
      (Polynomial.sum p fun n a => Polynomial.C a * Polynomial.X ^ n) = p :=
  by sorry

This theorem states that for any polynomial `p` over a semiring `R`, the sum of each of its coefficients `a` multiplied by the constant polynomial `C a` and the polynomial variable `X` raised to the power of the corresponding exponent `n`, equals the original polynomial `p`. In mathematical notation, this can be expressed as $\sum_{n} (C a) \cdot X^n = p$, where the summation ranges over all terms in the polynomial `p`.

For any polynomial $p$ over a semiring $R$, the expression $\sum\_n (C \cdot a) \cdot X^n$ equals $p$, where $C$ is the constant associated with coefficient $a$ in $p$.


theorem Algebra.adjoin_eq_span :
    ∀ (R : Type uR) {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A),
      Subalgebra.toSubmodule (Algebra.adjoin R s) = Submodule.span R ↑(Submonoid.closure s) :=
  by sorry

This theorem states that for any commutative semiring `R` and any semiring `A` over `R`, for any set `s` of elements from `A`, the submodule corresponding to the subalgebra generated by adjoining `R` to `s` (obtained via the `Subalgebra.toSubmodule` map) is equal to the submodule spanned by the closure of `s` as a submonoid (obtained via `Submonoid.closure` followed by `Submodule.span`). In other words, the process of adjoined algebra generation followed by submodule mapping yields the same result as the process of submonoid closure followed by submodule span generation.

For any commutative semiring `R`, set `s` of elements from a semiring `A` over `R`, the submodule of `A` generated by adjoining `R` to `s` is equal to the submodule spanned by the closure of `s` as a submonoid.


/-- **Alias** of the forward direction of `Finset.image_nonempty`. -/
theorem Finset.Nonempty.of_image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α},
      (Finset.image f s).Nonempty → s.Nonempty :=
  by sorry

This theorem, referred to as an alias of the forward direction of `Finset.image_nonempty`, asserts that for any two types `α` and `β`, given a function `f` from `α` to `β` and a finite set `s` of type `α`, if the forward image of `s` under `f` is nonempty, then `s` is nonempty. In other words, if the set formed by applying `f` to each element of `s` has at least one element, then `s` must also have at least one element. The equality of elements in type `β` is assumed to be decidable.

If `f` is a function from a non-empty type `α` to a type `β` and the image of a finite set `s` under `f` is nonempty, then `s` is nonempty.


theorem IsLUB.mem_closure :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α} {s : Set α},
      IsLUB s a → Set.Nonempty s → a ∈ closure s :=
  by sorry

This theorem, `IsLUB.mem_closure`, states that for any type `α` that is a topological space and also a linear order with an order topology, and for any set `s` of elements of type `α` and an element `a` of type `α`, if `a` is the least upper bound of the set `s` and if the set `s` is not empty, then `a` is an element of the closure of the set `s`. In other words, the least upper bound of a non-empty set belongs to the closure of that set in a linearly ordered topological space.

In a linearly ordered topological space, the least upper bound of any non-empty set is an element of the closure of that set.


/-- $\lim_{x\to-\infty}|x|=+\infty$  -/
theorem Filter.tendsto_abs_atBot_atTop :
    ∀ {α : Type u_3} [inst : LinearOrderedAddCommGroup α], Filter.Tendsto abs Filter.atBot Filter.atTop := by sorry

The theorem `Filter.tendsto_abs_atBot_atTop` states that for any type `α` that forms a linearly ordered additive commutative group, the limit of the absolute value function `abs` as `x` approaches negative infinity (`Filter.atBot`) is positive infinity (`Filter.atTop`). In other words, the absolute value of `x` increases without bound as `x` becomes increasingly negative. The notation used in the comment, $\lim_{x\to-\infty}|x|=+\infty$, is a standard mathematical way to express the same statement.

For any linearly ordered additive commutative group type `α`, the absolute value function `abs` is unbounded below as `x` approaches negative infinity (`Filter.atBot`), i.e., `∀∞ x: α, abs x > 0`.


theorem TopologicalSpace.exists_countable_basis :
    ∀ (α : Type u) [t : TopologicalSpace α] [inst : SecondCountableTopology α],
      ∃ b, Set.Countable b ∧ ∅ ∉ b ∧ TopologicalSpace.IsTopologicalBasis b :=
  by sorry

This theorem states that for any type `α` and any topological space `t` defined over `α`, if the topology is second-countable (i.e. it has a countable base), then there exists a basis `b` for this topological space such that `b` is a countable set, the empty set is not an element of `b`, and `b` forms a topological basis in the sense that every open set in the topological space can be written as a union of some elements of `b`.

If `α` is a type and `t` is a second-countable topology on `α`, then there exists a countable, basis `b` for `t` that is a cover of the topology, i.e., every open set in `t` can be written as a union of some elements of `b`, with the empty set not being an element of `b`.


theorem CategoryTheory.epi_of_epi :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
      [inst_1 : CategoryTheory.Epi (CategoryTheory.CategoryStruct.comp f g)], CategoryTheory.Epi g :=
  by sorry

This theorem states that in any category `C`, if the composition of two morphisms `f` and `g`, where `f` goes from object `X` to object `Y`, and `g` goes from object `Y` to object `Z`, is an epimorphism, then the morphism `g` is also an epimorphism. In the language of category theory, an epimorphism is a morphism that is "right-cancellable", meaning that if the composition of that morphism with any other morphism equals the composition of that morphism with a different other morphism, then the two other morphisms must be equal.

If a composition of morphisms `f: X → Y` and `g: Y → Z` in a category `C` is an epimorphism, then `g: Y → Z` is an epimorphism. (An epimorphism in a category is a morphism that is right-cancellable.)


/-- ## The chain complex relation `d ≫ d`
 -/
theorem AlgebraicTopology.AlternatingFaceMapComplex.d_squared :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (X : CategoryTheory.SimplicialObject C) (n : ℕ),
      CategoryTheory.CategoryStruct.comp (AlgebraicTopology.AlternatingFaceMapComplex.objD X (n + 1))
          (AlgebraicTopology.AlternatingFaceMapComplex.objD X n) =
        0 :=
  by sorry

This theorem, named `AlgebraicTopology.AlternatingFaceMapComplex.d_squared`, is a statement about the chain complex relation `d ≫ d` in algebraic topology. It states that for any category `C` with preadditive structure, and any simplicial object `X` in `C`, the composition of the differentials (the face maps of the alternating face map complex) `objD` at levels `n+1` and `n` is equal to zero. This satisfies the property that the composition of the boundary maps in a chain complex is zero, often written as `d^2 = 0` in mathematical notation.

For any simplicial object `X` in a preadditive category `C`, the composition of the face maps `d` of the alternating face map complex of `X` at levels `n+1` and `n` is zero: `objD(n+1) ∘ objD(n) = 0`.


theorem Mathlib.Data.Finset.Pi._auxLemma.1 :
    ∀ {α : Type u_1} {β : α → Type u} [inst : DecidableEq α] {s : Finset α} {t : (a : α) → Finset (β a)}
      {f : (a : α) → a ∈ s → β a}, (f ∈ Finset.pi s t) = ∀ (a : α) (h : a ∈ s), f a h ∈ t a :=
  by sorry

This theorem states that for any type `α`, a function `β` from `α` to another type, a finite set `s` of `α`, and a function `t` mapping each element of `α` to a finite set of `β a`, if we have a function `f` that maps each element of `α` in `s` to `β a`, then `f` belongs to the set of all functions defined by `Finset.pi s t` if and only if for all elements `a` in `s`, the function `f` maps `a` to an element in `t a`. In other words, `f` is in the set produced by `Finset.pi` when `f` takes each element in `s` to an element in the corresponding set produced by `t`.

For any type `α`, finite set `s` of `α`, function `t` mapping each `α` to a finite set of `β`, and function `f` from `s` to `β`, `f` is in the image of `Finset.pi s t` if and only if for all `a` in `s`, `f a` is in `t a`.


/-- The Jacobi symbol is multiplicative in its first argument.  -/
theorem jacobiSym.mul_left : ∀ (a₁ a₂ : ℤ) (b : ℕ), jacobiSym (a₁ * a₂) b = jacobiSym a₁ b * jacobiSym a₂ b := by sorry

The theorem `jacobiSym.mul_left` states that the Jacobi symbol is multiplicative in its first argument. In other words, for any two integers `a₁` and `a₂` and a natural number `b`, the Jacobi symbol of the product of `a₁` and `a₂` with respect to `b` is equal to the product of the Jacobi symbol of `a₁` with respect to `b` and the Jacobi symbol of `a₂` with respect to `b`. This property is a key aspect of the Jacobi symbol's behavior and is analogous to the multiplicativity property in other number-theoretical functions like the Legendre symbol and the Möbius function.

The Jacobi symbol is multiplicative in its first argument, i.e., for integers `a₁`, `a₂`, and a natural number `b`, `(a₁ * a₂) % b ≡ (a₁ % b) * (a₂ % b) (mod p)`.


theorem StieltjesFunction.measure_Iic :
    ∀ (f : StieltjesFunction) {l : ℝ},
      Filter.Tendsto (↑f) Filter.atBot (nhds l) →
        ∀ (x : ℝ), ↑↑(StieltjesFunction.measure f) (Set.Iic x) = ENNReal.ofReal (↑f x - l) :=
  by sorry

The theorem `StieltjesFunction.measure_Iic` states that for any Stieltjes function `f` and any real number `l`, if `f` tends to `l` as we go to negative infinity (meaning that for any neighborhood of `l`, there is a sufficiently large negative number such that the function values in the interval extending from this negative number to infinity are all in this neighborhood), then for any real number `x`, the measure associated to `f` of the interval from negative infinity to `x` (inclusive) is equal to the non-negative part of `f(x) - l`. This theorem basically describes how the measure of an interval under a Stieltjes function behaves as the function tends to a limit at negative infinity.

For any Stieltjes function `f` and real number `l`, if `f(x)` approaches `l` as `x` approaches negative infinity, then the measure of the interval from negative infinity to `x` under `f` equals `max(0, f(x) - l)`.


/-- If `a` commutes with both `b` and `c`, then it commutes with their sum. -/
theorem AddCommute.add_right :
    ∀ {S : Type u_2} [inst : AddSemigroup S] {a b c : S}, AddCommute a b → AddCommute a c → AddCommute a (b + c) := by
  sorry

The theorem states that for any type `S` that forms an additive semigroup, if an element `a` of `S` commutes additively with two elements `b` and `c` (i.e., `a + b = b + a` and `a + c = c + a`), then `a` also commutes additively with the sum of `b` and `c` (i.e., `a + (b + c) = (b + c) + a`).

If `a` commutes additively with `b` and `c` in an additive semigroup `S`, then `a` commutes additively with their sum `b + c`.


theorem sup_congr_right : ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, a ≤ b ⊔ c → b ≤ a ⊔ c → a ⊔ c = b ⊔ c :=
  by sorry

The theorem `sup_congr_right` states that for any type `α` that forms a semilattice under the "sup" operation, given three elements `a`, `b`, `c` from this type, if `a` is less than or equal to the supremum of `b` and `c`, and `b` is less than or equal to the supremum of `a` and `c`, then the supremum of `a` and `c` is equal to the supremum of `b` and `c`. In other words, if `a` and `b` both have the same supremum when joined with `c`, then these two supremums are equal.

If `α` is a semilattice with supremum, and `a`, `b`, `c` are in `α` such that `a ≤ sup(b, c)` and `b ≤ sup(a, c)`, then `sup(a, c) = sup(b, c)`.


theorem Mathlib.Order.SuccPred.Basic._auxLemma.20 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α} [inst_2 : NoMinOrder α],
      (a ≤ Order.pred b) = (a < b) :=
  by sorry

This theorem states that for any type `α` that has a preorder and a predecessor order, and for any elements `a` and `b` of type `α` in a structure that has no minimum element, `a` being less than or equal to the predecessor of `b` is equivalent to `a` being less than `b`. In other words, if `α` is a type where we can talk about order and "the greatest element less than", and where there is no smallest element, then an element `a` is less than or equal to the "greatest element less than `b`" if and only if `a` is strictly less than `b`.

For any type `α` with a preorder and a predecessor order and no minimum element, `a ≤ prev b` if and only if `a < b`.


theorem List.length_pos : ∀ {α : Type u_1} {l : List α}, 0 < List.length l ↔ l ≠ [] := by sorry

This theorem states that for any list `l` of elements of an arbitrary type `α`, the length of `l` is greater than 0 if and only if `l` is not an empty list. In other words, a list in Lean 4 has a positive length if and only if that list is not empty.

For any list `l` in Lean 4 of type `α`, the length of `l` is non-zero if and only if `l` is non-empty.


theorem Mathlib.Order.SuccPred.Basic._auxLemma.19 :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α} [inst_2 : NoMinOrder α],
      (Order.pred a < b) = (a ≤ b) :=
  by sorry

This theorem states that for any type `α` which has a preorder and a predecessor order, and for any elements `a` and `b` of this type, if `α` also has no minimal element (NoMinOrder), then the predecessor of `a` is less than `b` if and only if `a` is less than or equal to `b`. This essentially establishes a relationship between the predecessor order and the standard preorder in the given context.

If `α` is a type with a preorder and a predecessor order and no minimal element, then `a < b` if and only if `a <= b` or `a = b` for any `a, b : α`.


/-- Characterization of the boundedness of the range of a function  -/
theorem Metric.isBounded_range_iff :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α},
      Bornology.IsBounded (Set.range f) ↔ ∃ C, ∀ (x y : β), dist (f x) (f y) ≤ C :=
  by sorry

This theorem characterizes the boundedness of the range of a function in a pseudo-metric space. It states that for any types `α` and `β`, given `α` is a pseudo-metric space and `f` is a function from `β` to `α`, the range of function `f` is bounded if and only if there exists a real number `C` such that for all `x` and `y` in `β`, the distance between `f(x)` and `f(y)` in `α` is less than or equal to `C`. In other words, the range of `f` is bounded if and only if `f` is uniformly continuous.

A function from a pseudo-metric space to another pseudo-metric space is bounded if and only if it is uniformly continuous.


theorem Nat.zero_lt_of_ne_zero : ∀ {a : ℕ}, a ≠ 0 → 0 < a := by sorry

This theorem states that for any natural number `a`, if `a` is not equal to zero, then zero is less than `a`. In other words, any non-zero natural number is greater than zero.

For any natural number `a`, if `a` is non-zero then 0 < `a`.


/-- Pythagorean theorem, vector inner product form.  -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_real :
    ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] {x y : F},
      ⟪x, y⟫_ℝ = 0 → ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ :=
  by sorry

This theorem is a variant of the Pythagorean Theorem, in the context of Real Inner Product Spaces. It states that for any two vectors `x` and `y` in a normed additive commutative group `F` which also forms a Real Inner Product Space, if the inner product of `x` and `y` is zero, then the square of the norm (magnitude) of the sum of `x` and `y` is equal to the sum of the squares of the norms of `x` and `y`. In mathematical terms, if `⟪x, y⟫_ℝ = 0`, then `‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖`. This is analogous to the Pythagorean theorem's statement that in a right-angled triangle, the square of the length of the hypotenuse (`c`) is equal to the sum of the squares of the other two sides (`a` and `b`), often expressed as `c^2 = a^2 + b^2`.

In a real inner product space, if the inner product of two vectors is zero, then the norm of their sum is equal to the sum of their norms.


ContDiff.sub

/-- The difference of two `C^n` functions is `C^n`.  -/
theorem ContDiff.sub :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      {f g : E → F}, ContDiff 𝕜 n f → ContDiff 𝕜 n g → ContDiff 𝕜 n fun x => f x - g x :=
  by sorry

This theorem states that for any infinitely differentiable function (`C^n` function) `f` and `g` that map from a normed additive commutative group `E` to another normed additive commutative group `F` over a nontrivially normed field `𝕜`, the difference function `(f - g)` is also infinitely differentiable. The theorem holds for any `n` in `ℕ∞`, the set of natural numbers including infinity, indicating the level of differentiability.

For any infinitely differentiable functions `f` and `g` from a normed additive commutative group `E` to another normed additive commutative group `F` over a nontrivially normed field `𝕜`, their difference `f - g` is also infinitely differentiable.


theorem IsometryEquiv.map_hausdorffMeasure :
    ∀ {X : Type u_2} {Y : Type u_3} [inst : EMetricSpace X] [inst_1 : EMetricSpace Y] [inst_2 : MeasurableSpace X]
      [inst_3 : BorelSpace X] [inst_4 : MeasurableSpace Y] [inst_5 : BorelSpace Y] (e : X ≃ᵢ Y) (d : ℝ),
      MeasureTheory.Measure.map (⇑e) (MeasureTheory.Measure.hausdorffMeasure d) =
        MeasureTheory.Measure.hausdorffMeasure d :=
  by sorry

The given theorem, `IsometryEquiv.map_hausdorffMeasure`, states that for any isometric equivalence, `e`, between two e-Metric spaces `X` and `Y`, and a real number `d`, the Hausdorff measure of `d` on `X` mapped under the isometry to `Y` is the same as the Hausdorff measure of `d` on `Y`. That is, the Hausdorff measure of `d` is preserved under an isometric mapping. This is a property of the Hausdorff measure in the context of e-Metric spaces.

For any isometric equivalence between two e-Metric spaces and a real number, the Hausdorff measure of radius `d` in one space is equal to the Hausdorff measure of the image of that radius under the isometric mapping in the other space.


theorem FractionalIdeal.coe_zero :
    ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
      ↑0 = ⊥ :=
  by sorry

This theorem states that for any commutative ring `R` and any submonoid `S` of `R`, and for any commutative ring `P` with an algebra structure over `R`, the Fractional Ideal of `0` in `R` is equivalent to the bottom element (`⊥`) in the lattice structure of Fractional Ideals. In simpler terms, the ideal generated by `0` is the smallest possible ideal in the lattice of fractional ideals under these conditions.

For any commutative ring R, submonoid S of R, and commutative R-algebra P, the ideal (0) in R equals the bottom element in the lattice of fractional ideals of R over P.


Continuous.div'

theorem Continuous.div' :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Div G] [inst_2 : ContinuousDiv G]
      [inst_3 : TopologicalSpace α] {f g : α → G}, Continuous f → Continuous g → Continuous fun x => f x / g x :=
  by sorry

This theorem states that for any two continuous functions `f` and `g` that map from a certain type `α` to a type `G`, the function that maps `x` to the quotient of `f(x)` and `g(x)` is also continuous. This is the case for all `G` that are topological spaces and have defined division operation, and for all `α` that are topological spaces. The continuity of division in `G` (`ContinuousDiv G`) is also required.

If `f` and `g` are continuous functions from a topological space `α` to the topological space `G` with a defined division operation and continuous division, then the function that maps `x` to the quotient `f(x) / g(x)` is continuous.


theorem LieSubmodule.Quotient.mk_bracket :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {I : LieIdeal R L}
      (x y : L), LieSubmodule.Quotient.mk ⁅x, y⁆ = ⁅LieSubmodule.Quotient.mk x, LieSubmodule.Quotient.mk y⁆ :=
  by sorry

The theorem `LieSubmodule.Quotient.mk_bracket` states that for any commutative ring `R`, Lie ring `L`, and Lie algebra of `L` over `R`, the Lie bracket of two elements `x` and `y` in the Lie ideal `I` of `L` remains the same even when the elements are mapped to the quotient space `M/N` of the Lie submodule `N`. In other words, the Lie bracket operation is well-defined under the quotient map of the Lie submodule.

The Lie bracket of elements in a Lie ideal of a Lie algebra is invariant under the quotient map of the Lie submodule.


theorem MeasureTheory.VectorMeasure.restrict_not_measurable :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {M : Type u_3} [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
      (v : MeasureTheory.VectorMeasure α M) {i : Set α},
      ¬MeasurableSet i → MeasureTheory.VectorMeasure.restrict v i = 0 :=
  by sorry

The theorem `MeasureTheory.VectorMeasure.restrict_not_measurable` states that for any given measurable space `α`, any type `M` with an additive commutative monoid structure and a topological space structure, any vector measure `v` from `α` to `M`, and any set `i` in `α`, if the set `i` is not measurable, then the restriction of the vector measure `v` onto the set `i` is equal to the zero measure. In other words, we cannot restrict a vector measure onto a set that is not measurable; if we try to do so, we just get the zero measure.

If `α` is a measurable space, `M` is a type with additive commutative monoid and topological space structures, `v` is a vector measure from `α` to `M`, and `i` is a non-measurable set in `α`, then `v.restrict i = ⫀m : M, ∫x : i, v x = m`.


theorem Finset.piecewise_eq_of_not_mem :
    ∀ {ι : Type u_1} {π : ι → Sort u_2} (s : Finset ι) (f g : (i : ι) → π i) [inst : (j : ι) → Decidable (j ∈ s)]
      {i : ι}, i ∉ s → Finset.piecewise s f g i = g i :=
  by sorry

The theorem `Finset.piecewise_eq_of_not_mem` states that for any type `ι`, any sort `π` indexed by `ι`, any finite set `s` of type `ι`, and any two functions `f` and `g` from `ι` to `π`, if a given element `i` of type `ι` does not belong to the finite set `s`, then the piecewise function defined by `s`, `f`, and `g` at `i` is equal to the value of function `g` at `i`. Here, a piecewise function refers to a function that behaves like `f` for elements in `s`, and behaves like `g` for elements not in `s`. The membership of an element in `s` is determined using a decidable predicate.

If `i` is not an element of finite set `s` and `f` is the piecewise function defined by `s`, `f`, and `g`, then `f i = g i`.


/-- If the algebra map `R →+* A` is injective and `R` has characteristic zero then so does `A`.  -/
theorem charZero_of_injective_algebraMap :
    ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
      Function.Injective ⇑(algebraMap R A) → ∀ [inst : CharZero R], CharZero A :=
  by sorry

The theorem `charZero_of_injective_algebraMap` states that if the algebra map (`algebraMap`) from a commutative semiring `R` to a semiring `A` is injective (meaning that it preserves distinctness: if `f(x) = f(y)`, then `x = y`), and the commutative semiring `R` has characteristic zero (meaning that the number `n` in `R` such that `n * 1_R = 0_R` is `0`), then the semiring `A` also has characteristic zero.

If `R` is a commutative semiring with characteristic zero and `algebraMap : R -> A` is an injective algebra homomorphism, then `A` has characteristic zero.


theorem EReal.coe_neg : ∀ (x : ℝ), ↑(-x) = -↑x := by sorry

This theorem, `EReal.coe_neg`, states that for any real number `x`, the negation of `x` before it is coerced into an extended real number is the same as first coercing `x` into an extended real number and then taking the negation. In mathematical terms, for any real number `x`, `-(x)` and `-x` are identical even after they are converted from real numbers to extended real numbers.

For any real number `x`, the negation of its extended real number representation is equivalent to the extended real number representation of `-x`.


theorem Filter.le_generate_iff : ∀ {α : Type u} {s : Set (Set α)} {f : Filter α}, f ≤ Filter.generate s ↔ s ⊆ f.sets :=
  by sorry

This theorem states that for any type `α`, any set of sets `s` of type `α`, and any filter `f` on `α`, the filter `f` is less than or equal to the filter `generate s` if and only if `s` is a subset of the sets in `f`. In other words, the filter `f` is contained within the filter generated by `s` exactly when all sets in `s` are also in `f`.

For any type `α`, filter `f` on `α`, and set of sets `s` over `α`, `f ⊆ generate s` if and only if `s ⊆ f`.


theorem div_sub_div :
    ∀ {K : Type u_3} [inst : Field K] (a : K) {b : K} (c : K) {d : K},
      b ≠ 0 → d ≠ 0 → a / b - c / d = (a * d - b * c) / (b * d) :=
  by sorry

This theorem states that for any field `K` and any elements `a`, `b`, `c`, `d` of `K` where `b` and `d` are not zero, the difference between the fraction `a / b` and the fraction `c / d` is equal to the fraction whose numerator is the difference of the product of `a` and `d` and the product of `b` and `c`, and whose denominator is the product of `b` and `d`. In mathematical notation, this would be expressed as $\frac{a}{b} - \frac{c}{d} = \frac{a*d - b*c}{b*d}$, assuming $b \neq 0$ and $d \neq 0$.

The difference of fractions $\frac{a}{b}$ and $\frac{c}{d}$ is equal to the fraction $\frac{a\cdot d - b\cdot c}{b\cdot d}$, provided $b \neq 0$ and $d \neq 0$.


/-- The real exponential function tends to `+∞` at `+∞`.  -/
theorem Real.tendsto_exp_atTop : Filter.Tendsto Real.exp Filter.atTop Filter.atTop := by sorry

This theorem states that the real exponential function tends towards positive infinity as its variable tends towards positive infinity. In other words, as we input larger and larger real numbers into the exponential function, the output of the function also grows without bound. In terms of filters, this is formally represented by stating that the map of the exponential function over the filter representing all large real numbers is contained within that same filter, indicating the function's growth towards positive infinity.

The real exponential function, when applied to the filter of all positive real numbers, is contained in the filter of all positive numbers tending to infinity.


theorem isOpenMap_iff_nhds_le :
    ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
      IsOpenMap f ↔ ∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x) :=
  by sorry

The theorem `isOpenMap_iff_nhds_le` establishes an equivalence between two conditions for a map `f` from a topological space `X` to another topological space `Y`. The first condition is that `f` is an open map, which means that the image of any open set in `X` under `f` is open in `Y`. The second condition is a property of the neighborhood filters at each point `x` in `X`: for all `x` in `X`, the neighborhood filter at `f(x)` in `Y` is smaller than or equal to the filter obtained by applying `f` to the neighborhood filter at `x` in `X`. The "smaller than or equal to" relation here is in the sense of filter inclusion, meaning that every set in the neighborhood filter at `f(x)` is also in the image of the neighborhood filter at `x` under `f`.

A continuous function \(f : X \to Y\) between topological spaces is open if and only if for all \(x \in X\), the neighborhood filter of \(f(x)\) in \(Y\) is contained in the filter generated by \(f(\text{N}_{\delta}(x))\), where \(\text{N}_{\delta}(x)\) denotes the open neighborhood of \(x\) in \(X\) with respect to the given topology.


theorem FreeAddMonoid.hom_eq :
    ∀ {α : Type u_1} {M : Type u_4} [inst : AddMonoid M] ⦃f g : FreeAddMonoid α →+ M⦄,
      (∀ (x : α), f (FreeAddMonoid.of x) = g (FreeAddMonoid.of x)) → f = g :=
  by sorry

This theorem, `FreeAddMonoid.hom_eq`, states that for any type `α` and another type `M` that is equipped with an addition operation (an additive monoid), given any two additive monoid homomorphisms `f` and `g` from `FreeAddMonoid α` to `M`, if `f` and `g` agree on the result when applied to any single element of `α` embedded into `FreeAddMonoid α` (i.e., `f (FreeAddMonoid.of x)` is equal to `g (FreeAddMonoid.of x)` for all `x` in `α`), then the two homomorphisms `f` and `g` are equal.

If `f` and `g` are additive monoid homomorphisms from `FreeAddMonoid α` to an additive monoid `M` such that `f (FreeAddMonoid.of x) = g (FreeAddMonoid.of x)` for all `x` in `α`, then `f = g`.


OrthonormalBasis.orthonormal

theorem OrthonormalBasis.orthonormal :
    ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
      [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E), Orthonormal 𝕜 ⇑b :=
  by sorry

The theorem `OrthonormalBasis.orthonormal` states that for any set of vectors in an inner product space `E` over field `𝕜`, indexed by type `ι`, if these vectors form an orthonormal basis `b`, then the function `b` mapping from `ι` to `E` possesses the property of orthonormality. The property of orthonormality means that for every vector in the set, the norm is one, and the inner product of any two distinct vectors in the set is zero. This theorem applies to finite types `ι`, and `𝕜` is a field that behaves like real or complex numbers in its operations.

If `b` is an orthonormal basis of the inner product space `E` over field `𝕜`, then for all `i, j ∈ ι` with `i ≠ j`, we have `∥bi∥ = 1` and `〈bi, bj〉 = 0`.


theorem CategoryTheory.Abelian.factorThruImage.proof_2 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      [inst_2 : CategoryTheory.Limits.HasCokernels C] {P Q : C} (f : P ⟶ Q),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.cokernel.π f) = 0 :=
  by sorry

This theorem states that for any category `C` with zero morphisms and cokernels, and any two objects `P` and `Q` in `C`, the composition of any morphism `f` from `P` to `Q` and the cokernel of `f` is equal to the zero morphism.

In mathematical terms, if we have a category with zero morphisms and cokernels i.e., the category has all cokernels (which are a kind of colimit), then for any two objects `P` and `Q` in the category, and a morphism `f: P -> Q`, the composition of `f` with the cokernel of `f`, denoted as `f ≫ cokernel.π f`, is the zero morphism.
The cokernel of a morphism is a universal object that essentially captures the 'quotient' or 'residual' structure when we mod out by the image of the morphism.

For any morphism `f` in a category with zero morphisms and cokernels, the composition of `f` with its cokernel's projection is the zero morphism.


theorem Polynomial.roots_C_mul :
    ∀ {R : Type u} {a : R} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
      a ≠ 0 → Polynomial.roots (Polynomial.C a * p) = Polynomial.roots p :=
  by sorry

This theorem states that for any type `R`, given a commutative ring structure and a domain structure on `R`, for any non-zero element `a` of `R` and any polynomial `p` over `R`, the roots of the polynomial obtained by multiplying `p` by the constant polynomial `a` are the same as the roots of `p`. In other words, scaling a polynomial by a non-zero constant does not change its roots.

For any commutative ring `R`, non-zero element `a` in `R`, and polynomial `p` over `R`, the roots of the polynomial `a * p` are equal to the roots of `p`.


theorem CategoryTheory.ShortComplex.cyclesMap'_i :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : CategoryTheory.ShortComplex.LeftHomologyData S₁)
      (h₂ : CategoryTheory.ShortComplex.LeftHomologyData S₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' φ h₁ h₂) h₂.i =
        CategoryTheory.CategoryStruct.comp h₁.i φ.τ₂ :=
  by sorry

This theorem states that for any category 'C' with zero morphisms and any two short complexes 'S₁' and 'S₂' in 'C', as well as a morphism 'φ' from 'S₁' to 'S₂', and the left homology data 'h₁' and 'h₂' of 'S₁' and 'S₂' respectively, the composition of the 'cyclesMap' of 'φ', 'h₁', and 'h₂' with 'h₂.i' is equal to the composition of 'h₁.i' and 'φ.τ₂'. Essentially, this theorem expresses a certain commutativity property in the category of short complexes.

For any category 'C' with zero morphisms, given short complexes 'S₁' and 'S₂', morphism 'φ' from 'S₁' to 'S₂', and their respective left homology data 'h₁' and 'h₂', the commutativity of their cycles maps holds: 'h₁.i ∘ φ.τ₂ = φ.τ₁ ∘ h₂.i'.


theorem Finset.card_def : ∀ {α : Type u_1} (s : Finset α), s.card = Multiset.card s.val := by sorry

The theorem `Finset.card_def` states that for any given set `s` of arbitrary type `α`, the cardinality of the set `s` (denoted by `s.card`) is equal to the cardinality of the multiset representation of that set (denoted by `Multiset.card s.val`). Here, the cardinality of a set or a multiset refers to the sum of the multiplicities of all its elements. For a set, this is simply the number of elements in that set, whereas for a multiset, this includes the repetitions of elements.

For any set `s` of type `α`, the cardinality of `s` equals the sum of multiplicities of elements in its multiset representation `s.val`. In other words, `#s = Multiset.card s.val`, where `#s` denotes the cardinality of `s`.


BumpCovering.locallyFinite

theorem BumpCovering.locallyFinite :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : BumpCovering ι X s),
      LocallyFinite fun i => Function.support ⇑(f i) :=
  by sorry

The theorem `BumpCovering.locallyFinite` states that for any type `ι`, any topological space `X`, and any set `s` of `X`, if `f` is a bump covering (a mathematical tool often used in differential geometry) of `s` indexed by `ι`, then the family of supports of the functions of `f` is locally finite. In other words, for every point in the topological space, there exists a neighborhood of that point that intersects with the support of only finitely many functions from the bump covering.

Given a bump covering `f` of a set `s` in a topological space `X` indexed by type `ι`, the family of supports of its functions is locally finite.


theorem CategoryTheory.GradedObject.ι_mapMap :
    ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C]
      {X Y : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (p : I → J) [inst_1 : CategoryTheory.GradedObject.HasMap X p]
      [inst_2 : CategoryTheory.GradedObject.HasMap Y p] (i : I) (j : J) (hij : p i = j),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapObj X p i j hij)
          (CategoryTheory.GradedObject.mapMap φ p j) =
        CategoryTheory.CategoryStruct.comp (φ i) (CategoryTheory.GradedObject.ιMapObj Y p i j hij) :=
  by sorry

The theorem `CategoryTheory.GradedObject.ι_mapMap` is about the composition of morphisms in a categorical context. Specifically, for any types `I`, `J`, and `C`, with `C` behaving as a category, and for any `I`-graded objects `X` and `Y` in `C`, a morphism `φ` from `X` to `Y`, a function `p` from `I` to `J`, and for all `i` in `I` and `j` in `J` such that `p` maps `i` to `j`, if both `X` and `Y` have the property `HasMap` with respect to `p` (meaning that for each `j`, the coproduct of all objects `X i` or `Y i` for which `p i = j` exists), then the composition of the morphism that maps `X i` to the coproduct for `j` in `X` and the morphism that maps this coproduct to `Y j` is equal to the composition of the morphism `φ i` and the morphism that maps `Y i` to the coproduct for `j` in `Y`. This theorem highlights a specific property of these compositions in the context of category theory.

Given categories `C` with types `I`, `J`, `C`-graded objects `X` and `Y`, morphism `φ: X ⟶ Y`, function `p: I ⟶ J`, and `HasMap` instance for both `X` and `Y` with respect to `p`, the morphism composition `φ ∘ (∑ i, p = j, X i ⟶ ∑ j, Y j)` is equal to `∑ i, p = j, φ i ∘ (X i ⟶ Y j)`.


ContDiff.mul

/-- The product of two `C^n`functions is `C^n`.  -/
theorem ContDiff.mul :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {n : ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸]
      {f g : E → 𝔸}, ContDiff 𝕜 n f → ContDiff 𝕜 n g → ContDiff 𝕜 n fun x => f x * g x :=
  by sorry

The theorem `ContDiff.mul` states that if we have two functions `f` and `g` from a normed space `E` over a non-trivially normed field `𝕜` to a normed ring `𝔸`, which is also a normed algebra over `𝕜`, and if both these functions are `C^n` (i.e., continuously differentiable up to the `n`th derivative), then the product function `(x => f x * g x)` is also `C^n`.

If two `C^n` functions from a normed space to a normed algebra over a non-trivially normed field satisfy the commutative multiplication property, then their product is also a `C^n` function.


theorem List.disjoint_comm : ∀ {α : Type u_1} {l₁ l₂ : List α}, List.Disjoint l₁ l₂ ↔ List.Disjoint l₂ l₁ := by sorry

The theorem `List.disjoint_comm` states that for any two lists, `l₁` and `l₂`, of elements of an arbitrary type `α`, the property of the lists being disjoint is commutative. In other words, `l₁` and `l₂` have no elements in common if and only if `l₂` and `l₁` have no elements in common. This means that the order in which we consider the lists does not affect whether or not they are disjoint.

For any lists `l₁` and `l₂` over an arbitrary type `α`, `l₁` and `l₂` have no common elements if and only if `l₂` and `l₁` have no common elements.


theorem Inducing.inseparable_iff :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x y : X} {f : X → Y},
      Inducing f → (Inseparable (f x) (f y) ↔ Inseparable x y) :=
  by sorry

The theorem `Inducing.inseparable_iff` states that for any two points `x` and `y` in a topological space `X` and a function `f` from `X` to another topological space `Y` that induces the topology of `Y`, the points `f(x)` and `f(y)` in `Y` are inseparable if and only if the original points `x` and `y` in `X` are inseparable. In other words, the property of being inseparable is preserved under topology-inducing functions between two topological spaces. Here, inseparable points are those for which the neighborhoods around them in the topological space are the same.

For any topology-inducing function `f` between topological spaces `X` and `Y`, and any points `x` and `y` in `X`, `x` and `y` are inseparable in `X` if and only if `f(x)` and `f(y)` are inseparable in `Y`.