/-- The currying process is a continuous map between function spaces.  -/
theorem ContinuousMap.continuous_curry :
    ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      [inst_2 : TopologicalSpace Z] [inst_3 : LocallyCompactSpace (X × Y)], Continuous ContinuousMap.curry :=
  by sorry

The theorem `ContinuousMap.continuous_curry` states that for any three types `X`, `Y`, and `Z` (which are representing spaces) with the condition that each type has a topology and the product space of `X` and `Y` is locally compact, the process of currying (transforming a function that takes multiple arguments into a function that takes a single argument and returns another function) is a continuous mapping. In other words, this theorem is saying that the currying operation preserves the continuity of functions in these topological spaces.

The currying operation preserves continuity for functions between locally compact topological spaces.


theorem max_eq_bot :
    ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : OrderBot α] {a b : α}, max a b = ⊥ ↔ a = ⊥ ∧ b = ⊥ := by sorry

This theorem states that for any type `α` that has a linear order and a least element (`OrderBot`), the maximum of any two elements `a` and `b` of `α` is the least element if and only if both `a` and `b` are the least element. In other words, in a linearly ordered set with a minimum, the maximum value of any two elements is the minimum value if and only if both elements are the minimum value.

In a linearly ordered set with a minimum element, the maximum of any two elements is equal to the minimum if and only if both elements are minimum.


theorem List.Ico.succ_singleton : ∀ {n : ℕ}, List.Ico n (n + 1) = [n] := by sorry

This theorem states that for any natural number `n`, the list of natural numbers `n ≤ x < n + 1` (as defined by `List.Ico`) is a singleton list containing just the number `n`. In other words, when the interval is from `n` to `n+1`, the only natural number that lies within this interval is `n` itself.

For any natural number `n`, the list of natural numbers `[n .. n+1]` (or `n ≤ x < n+1`) contains only the single element `n`.


theorem MeasureTheory.SimpleFunc.extend_apply :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      (f₁ : MeasureTheory.SimpleFunc α γ) {g : α → β} (hg : MeasurableEmbedding g) (f₂ : MeasureTheory.SimpleFunc β γ)
      (x : α), ↑(MeasureTheory.SimpleFunc.extend f₁ g hg f₂) (g x) = ↑f₁ x :=
  by sorry

This theorem states that, given two simple functions `f₁` and `f₂` with domains `α` and `β` respectively and the same codomain `γ`, alongside a measurable embedding function `g` from `α` to `β`, when we extend `f₁` along `g` to obtain a new simple function, then for any point `x` in `α`, the value of the extended function at the image of `x` under `g` is the same as the value of `f₁` at `x`. This is true under the assumption that `α` and `β` are equipped with measurable spaces.

Given measurable spaces `(α, Σα)` and `(β, Σβ)`, measurable embeddings `g : α → β`, simple functions `f₁ : α → γ`, and `f₂ : β → γ` with `f₁ = f₂ ∘ g`, we have `(f₁ ! g x) = f₂ x` for all `x : α`.


theorem Mathlib.MeasureTheory.Measure.Lebesgue.Basic._auxLemma.9 :
    ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i := by sorry

This theorem is about the membership of elements in a union of sets. It states that: for any type `α`, any indexing type `ι`, any element `x` of type `α`, and any indexed family of sets `s` of type `ι → Set α`, an element `x` belongs to the union over `i` of the sets `s i` if and only if there exists an index `i` such that `x` belongs to `s i`. In mathematical notation, this theorem states that
\[ x \in \bigcup_{i} s_{i} \iff \exists i, x \in s_{i}. \]
This is a fundamental result in set theory, expressing that an element belongs to a union of sets exactly when it belongs to at least one of the sets.

An element belongs to the union of a family of sets if and only if it is an element of at least one set in the family.


theorem Nat.lt_asymm : ∀ {a b : ℕ}, a < b → ¬b < a := by sorry

This theorem, `Nat.lt_asymm`, states that for all natural numbers `a` and `b`, if `a` is less than `b`, then it is not the case that `b` is less than `a`. Essentially, it asserts the asymmetry of the "less than" relation for natural numbers: if `a` is less than `b`, then `b` cannot be less than `a` at the same time.

For all natural numbers `a` and `b`, if `a` is less than `b`, then `b` is not less than `a`.


/-- The star operation on `Subalgebra` commutes with `Algebra.adjoin`.  -/
theorem Subalgebra.star_adjoin_comm :
    ∀ (R : Type u_2) {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
      [inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (s : Set A),
      star (Algebra.adjoin R s) = Algebra.adjoin R (star s) :=
  by sorry

This theorem states that for any type `R` with a commutative semiring structure, any type `A` with a semiring structure, an algebra structure over `R`, and a star ring structure, and any set `s` of elements of type `A`, the star operation (which is the operation defined in the context of star rings or star modules) commutes with the operation of adjoining elements to an algebra. In other words, taking the star of the algebra derived from adjoining `s` to `R` is the same as adjoining the star of `s` to `R`.

For any commutative semiring `R`, type `A` with semiring and algebra structures over `R` and star ring structure, and set `s ⊆ A`, the star operation on `A` commutes with the algebra adjoining operation, i.e., adjoining the stars of elements in `s` to `R` is equivalent to adjoining the elements in `s` to the star ring derived from `R`.


/-- `(x, y) ↦ x ^ y` is strictly differentiable at `p : ℝ × ℝ` such that `0 < p.fst`.  -/
theorem Real.hasStrictFDerivAt_rpow_of_pos :
    ∀ (p : ℝ × ℝ),
      0 < p.1 →
        HasStrictFDerivAt (fun x => x.1 ^ x.2)
          ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
            (p.1 ^ p.2 * Real.log p.1) • ContinuousLinearMap.snd ℝ ℝ ℝ)
          p :=
  by sorry

The theorem `Real.hasStrictFDerivAt_rpow_of_pos` states that, given a pair of real numbers `p`, if the first element of the pair is positive, then the function `(x, y) ↦ x ^ y`, which maps a pair of real numbers to the first element raised to the power of the second element, has a strict derivative at `p`. The derivative is given by `((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ + (p.1 ^ p.2 * Real.log p.1) • ContinuousLinearMap.snd ℝ ℝ ℝ)`. Here, `•` denotes scalar multiplication, `ContinuousLinearMap.fst ℝ ℝ ℝ` and `ContinuousLinearMap.snd ℝ ℝ ℝ` are the continuous linear functions that map a pair of real numbers to its first and second elements respectively, and `Real.log` is the real logarithm function.

If `p` is a positive real number, then the function `x ^ y` has a strict derivative `p.2 * p.1 ^ (p.2 - 1) * x + p.1 ^ p.2 * log(p.1) * y` at `(p, _)`.


theorem Subsemigroup.mem_closure :
    ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {x : M},
      x ∈ Subsemigroup.closure s ↔ ∀ (S : Subsemigroup M), s ⊆ ↑S → x ∈ S :=
  by sorry

This theorem states that for any type `M` with multiplication, any set `s` of elements of this type, and any element `x` of this type, `x` is in the subsemigroup generated by `s` if and only if for any subsemigroup `S` containing the set `s`, `x` is also in `S`. In other words, an element is in the closure of a set in a multiplication structure if it belongs to every subsemigroup that contains the set.

An element is in the closure of a set in a multiplicative structure if and only if it belongs to every subsemigroup containing the set.


theorem Matroid.Indep.exists_insert_of_not_base :
    ∀ {α : Type u_1} {M : Matroid α} {I B : Set α},
      M.Indep I → ¬M.Base I → M.Base B → ∃ e ∈ B \ I, M.Indep (insert e I) :=
  by sorry

This theorem states that for any type `α` and any given `Matroid` `M` over `α`, if `I` and `B` are sets of elements in `α` with `I` being independent in `M` but not a basis, and `B` being a basis, then there exists an element `e` from the set `B` distinct from `I` such that inserting `e` into `I` still results in an independent set in `M`. In other words, we can always add a new element from a basis to an independent set which is not yet a basis, without violating the independence property.

For any matroid M over type α and any independent set I that is not a basis, there exists an element e in basis B such that I ∪ {e} remains independent in M.


theorem toZ_nonneg :
    ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
      {i0 i : ι}, i0 ≤ i → 0 ≤ toZ i0 i :=
  by sorry

The theorem `toZ_nonneg` states that for any type `ι` equipped with a linear order, a successor order, a predecessor order, and the Archimedean property for successors, if `i0` and `i` are elements of `ι` such that `i0` is less than or equal to `i`, then the integer value obtained by applying the `toZ` function to `i0` and `i` is nonnegative. In other words, the function `toZ` produces a nonnegative integer when its second argument is greater than or equal to its first argument.

For any type equipped with a linear order, successor order, predecessor order, and the Archimedean property for successors, the integer value obtained from any element less than or equal to another element using the `toZ` function is nonnegative.


/-- **Alias** of `Decidable.not_imp_symm`. -/
theorem Not.decidable_imp_symm : ∀ {a b : Prop} [inst : Decidable a], (¬a → b) → ¬b → a := by sorry

This theorem, `Not.decidable_imp_symm`, is an alias for `Decidable.not_imp_symm`. It states that for any two propositions `a` and `b` where `a` is decidable, if `b` can be derived when `a` is not true (`¬a → b`), and if `b` is not true (`¬b`), then `a` must be true. In other words, it represents the logical principle that if the negation of a proposition implies another proposition, and that other proposition is false, then the original proposition must be true.

If `a` is a decidable proposition and `b` implies `¬a` whenever `¬b` holds, then `a` is true.


theorem bit1_add :
    ∀ {M : Type u} [inst : AddCommSemigroup M] [inst_1 : One M] (a b : M), bit1 (a + b) = bit0 a + bit1 b := by sorry

The theorem `bit1_add` states that for any type `M` that has an addition operation satisfying the commutative and associative laws (`AddCommSemigroup`) and also has an element designated as "one" (`One`), for any two elements `a` and `b` of that type, the operation `bit1` applied to the sum of `a` and `b` is equal to the sum of `bit0 a` and `bit1 b`. Here, `bit1 x` means `2*x + 1` and `bit0 x` means `2*x`.

For any `AddCommSemigroup` type `M` with a `One` element, `bit1 (a + b) = bit0 a + bit1 b` for all `a, b ∈ M`.


theorem MeasureTheory.upperCrossingTime_stabilize :
    ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n m : ℕ} {ω : Ω},
      n ≤ m → MeasureTheory.upperCrossingTime a b f N n ω = N → MeasureTheory.upperCrossingTime a b f N m ω = N :=
  by sorry

This theorem states that for any types `Ω` and real numbers `a` and `b`, any function `f` from natural numbers to `Ω` to real numbers, any natural numbers `N`, `n`, and `m`, and any `ω` of type `Ω`, if `n` is less than or equal to `m` and the upper crossing time of `a`, `b`, `f`, `N`, `n` at `ω` equals `N`, then the upper crossing time of `a`, `b`, `f`, `N`, `m` at `ω` also equals `N`.

In mathematical terms, an upper crossing time is a concept used in measure theory that represents the least time that a given stochastic process crosses a certain upper level.

For any types `Ω`, real numbers `a` and `b`, function `f` from natural numbers to `Ω` to real numbers, natural numbers `N`, `n`, `m`, and `ω` of type `Ω`, if `n ≤ m` and the upper crossing time of `a`, `b`, `f`, `N` at `ω` equals `N`, then the upper crossing time of `a`, `b`, `f`, `N`, `m` at `ω` also equals `N`.


theorem AEMeasurable.sum_measure :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
      [inst_1 : Countable ι] {μ : ι → MeasureTheory.Measure α},
      (∀ (i : ι), AEMeasurable f (μ i)) → AEMeasurable f (MeasureTheory.Measure.sum μ) :=
  by sorry

This theorem, `AEMeasurable.sum_measure`, states that for any types `ι`, `α`, and `β`, given a measurable space on `α`, a measurable space on `β`, a function `f` from `α` to `β`, a countable index set `ι`, and a family of measures `μ` indexed by `ι`, if the function `f` is "almost everywhere measurable" with respect to each measure `μ i` for every index `i`, then `f` is also "almost everywhere measurable" with respect to the sum of the measures `μ`.

In other terms, "almost everywhere measurable" means that the function `f` coincides almost everywhere with a measurable function. The term "almost everywhere" is defined with respect to a measure, and means "everywhere except on a set of measure zero". The theorem therefore asserts that the property of being "almost everywhere measurable" is preserved under taking the sum of measures.

Given measurable spaces on types `α` and `β`, a measurable function `f` from `α` to `β`, a countable index set `ι`, and a family of measures `μ i` on `α` indexed by `ι`, if `f` is almost everywhere measurable with respect to each `μ i`, then `f` is almost everywhere measurable with respect to the sum of the `μ i`.


theorem AddCommute.right_comm :
    ∀ {S : Type u_2} [inst : AddSemigroup S] {b c : S}, AddCommute b c → ∀ (a : S), a + b + c = a + c + b := by sorry

The theorem `AddCommute.right_comm` states that for any type `S` that is an additive semigroup, if two elements `b` and `c` of `S` commute under addition (i.e., `b + c = c + b`), then for any other element `a` of `S`, the sum `a + b + c` is equal to the sum `a + c + b`. In other words, if `b` and `c` commute, then adding `b` and `c` to `a` in any order results in the same sum.

For any additive semigroup `S` and commuting elements `b` and `c` in `S`, `b + c = c + b` implies `a + b + c = a + c + b` for all `a` in `S`.


theorem Monoid.fg_iff_add_fg : ∀ {M : Type u_1} [inst : Monoid M], Monoid.FG M ↔ AddMonoid.FG (Additive M) := by sorry

This theorem, `Monoid.fg_iff_add_fg`, states that for any type `M` that has a `Monoid` structure, `M` is finitely generated as a monoid if and only if the additive version of `M` (i.e., `Additive M`), which carries the corresponding additive monoid structure, is finitely generated as an additive monoid. In other words, the theorem establishes an equivalence between the finite generation of the multiplicative structure on `M` and the finite generation of the associated additive structure on `Additive M`.

For any type `M` with a `Monoid` structure, `M` is finitely generated as a monoid if and only if `Additive M` is finitely generated as an additive monoid.


theorem Set.indicator_add :
    ∀ {α : Type u_1} {M : Type u_4} [inst : AddZeroClass M] (s : Set α) (f g : α → M),
      (Set.indicator s fun a => f a + g a) = fun a => Set.indicator s f a + Set.indicator s g a :=
  by sorry

The theorem `Set.indicator_add` states that for any set `s` of elements of a certain type `α` and any two functions `f` and `g` from `α` to another type `M` (where `M` is a type with an addition operation and a zero element), the indicator function of `s` applied to the sum of `f` and `g` at a point `a` is equal to the sum of the indicator functions of `s` applied to `f` and `g` respectively at `a`. In mathematical terms, this can be written as: for all `a` in `α`, `Set.indicator s (f(a) + g(a)) = Set.indicator s f(a) + Set.indicator s g(a)`. This theorem essentially distributes the indicator function over the addition of the two functions.

For any set `s` and functions `f` and `g` from a type `α` to a type `M` with addition, the indicator function of `s` applied to the sum of `f` and `g` equals the sum of the indicator functions of `s` applied to `f` and `g`: `Set.indicator s (f + g) = Set.indicator s f + Set.indicator s g`.


theorem tsum_mul_left :
    ∀ {ι : Type u_1} {α : Type u_4} [inst : DivisionSemiring α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalSemiring α] {f : ι → α} {a : α} [inst_3 : T2Space α],
      ∑' (x : ι), a * f x = a * ∑' (x : ι), f x :=
  by sorry

This theorem states that for any type `ι`, and any type `α` that is a division semiring, a topological space, and a topological semiring, and for any function `f` from `ι` to `α`, and any element `a` of `α`, in a Hausdorff space (`T2Space`), the sum of the product of `a` and `f x` over all `x` in `ι` is equal to the product of `a` and the sum of `f x` over all `x` in `ι`. In simpler terms, this theorem asserts the distributivity of multiplication over infinite summation in a certain mathematical context.

In a Hausdorff space, for any type `α` that is a division semiring, topological space, and topological semiring, and for any function `f` from `ι` to `α` and element `a` of `α`, the infinite sum of `a * f x` over `x` in `ι` equals the product of `a` and the infinite sum of `f x` over `x` in `ι`.


Algebra.IsAlgebraic.trans

/-- If L is an algebraic field extension of K and A is an algebraic algebra over L,
then A is algebraic over K.  -/
theorem Algebra.IsAlgebraic.trans :
    ∀ {K : Type u_1} {L : Type u_2} {A : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Ring A]
      [inst_3 : Algebra K L] [inst_4 : Algebra L A] [inst_5 : Algebra K A] [inst_6 : IsScalarTower K L A],
      Algebra.IsAlgebraic K L → Algebra.IsAlgebraic L A → Algebra.IsAlgebraic K A :=
  by sorry

The theorem `Algebra.IsAlgebraic.trans` states that if we have a field `L` that is an algebraic field extension of another field `K`, and if `A` is an algebraic algebra over `L`, then `A` is also algebraic over `K`. This is assuming that we have the appropriate algebra structures between the types, and that there exists a scalar tower between `K`, `L`, and `A`. In simpler terms, if `L` is constructed from `K` by adding elements that are roots of polynomials with coefficients in `K`, and `A` is similarly constructed from `L`, then `A` can also be seen as being constructed from `K` in a similar manner.

If `L` is an algebraic field extension of `K`, then every algebraic element of an algebra `A` over `L` is also algebraic over `K`.


theorem Equiv.self_comp_ofInjective_symm :
    ∀ {α : Sort u_1} {β : Type u_2} {f : α → β} (hf : Function.Injective f),
      f ∘ ⇑(Equiv.ofInjective f hf).symm = Subtype.val :=
  by sorry

The theorem `Equiv.self_comp_ofInjective_symm` states that for any injective function `f` from type `α` to type `β`, the composition of `f` and the inverse of the equivalence relation obtained from `f` being injective is equal to the subtype value function. In essence, this means that if `f` is an injective function, then applying `f` to the result of the inverse equivalence operation gives you the original element in the domain `α`, encapsulating the idea of retracing the steps of the injective function.

For any injective function `f`: `f ∘ inv_eq_of_injective f = subtype.val`. Here, `inv_eq_of_injective f` denotes the inverse of the equivalence relation induced by `f`, and `subtype.val` is the value function for the subtype induced by `f`.


theorem Complex.isCauSeq_re : ∀ (f : CauSeq ℂ ⇑Complex.abs), IsCauSeq abs fun n => (↑f n).re := by sorry

The theorem `Complex.isCauSeq_re` states that for any Cauchy sequence `f` of complex numbers, when we consider the sequence formed by taking the real part of each term in `f`, this new sequence is also a Cauchy sequence. In other words, if `f` is a Cauchy sequence in the complex numbers (with respect to the complex absolute value function), then the sequence of real parts of `f` is a Cauchy sequence (with respect to the absolute value function for real numbers).

If `f` is a Cauchy sequence of complex numbers, then the sequence of real parts of `f` is a Cauchy sequence of real numbers.


theorem indicator_ae_eq_of_ae_eq_set :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α} {f : α → β}
      [inst_1 : Zero β],
      s =ᶠ[MeasureTheory.Measure.ae μ] t → Set.indicator s f =ᶠ[MeasureTheory.Measure.ae μ] Set.indicator t f :=
  by sorry

The theorem `indicator_ae_eq_of_ae_eq_set` states that for all types `α` and `β`, given a measurable space on `α`, a measure `μ` on `α`, sets `s` and `t` of `α`, and a function `f` from `α` to `β`, if the two sets `s` and `t` are almost everywhere equal with respect to the measure `μ`, then the indicator functions of `s` and `t` with respect to `f` are also almost everywhere equal with respect to the measure `μ`. Here, an indicator function of a set, given a function, outputs the value of the function at a point if the point is in the set, and `0` otherwise. The term "almost everywhere" means that the property holds everywhere except possibly on a set of measure zero.

Given measurable sets $s, t \subseteq \alpha$ and a measurable function $f:\alpha \to \beta$, if $s$ and $t$ are almost equal to each other with respect to the measure $\mu$ on $\alpha$, then their indicator functions $1\_s$ and $1\_t$ with respect to $f$ are almost everywhere equal with respect to $\mu$.


DifferentiableWithinAt.neg

theorem DifferentiableWithinAt.neg :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E}, DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 (fun y => -f y) s x :=
  by sorry

This theorem, `DifferentiableWithinAt.neg`, states that for every function `f` which is differentiable at a point `x` within a set `s` in a normed field `𝕜`, the negated function `-f` is also differentiable at the same point `x` within the same set `s`. Specifically, the normed field `𝕜`, the normed space `E` for the domain of `f`, and the normed space `F` for the codomain of `f` need to be nontrivial with a normed additive commutative group structure. In mathematical terms, if `f` is differentiable at a point `x` in a set `s`, then `-f` is also differentiable at `x` in `s`.

If `f` is differentiable at a point `x` in a normed set `s` of a normed field `𝕜`, then the negated function `-f` is also differentiable at `x` in `s`.


theorem SubMulAction.smul_of_tower_mem :
    ∀ {S : Type u'} {R : Type u} {M : Type v} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : SMul S R]
      [inst_3 : SMul S M] [inst_4 : IsScalarTower S R M] (p : SubMulAction R M) (s : S) {x : M}, x ∈ p → s • x ∈ p :=
  by sorry

This theorem states that for any types `S`, `R`, and `M`, where `R` is a monoid and `M` is a mulaction of `R`, and `S` interacts with `R` and `M` through scalar multiplication. If `S`, `R` and `M` form a scalar tower, and `p` is a submulaction of `R` on `M`, then for any element `s` of `S` and any element `x` of `M` that belongs to `p`, the result of scalar multiplication of `s` and `x` is also in `p`. This is essentially saying that the scalar multiplication operation is closed in the submulaction `p`.

For any monoid `R` with mulaction `M`, scalar tower `S`, and submulaction `p` of `R` on `M`, if `s ∈ S` and `x ∈ p`, then `s * x ∈ p`, where `*` denotes scalar multiplication.


theorem IsNilpotent.eq_zero :
    ∀ {R : Type u_1} {x : R} [inst : Zero R] [inst_1 : Pow R ℕ] [inst_2 : IsReduced R], IsNilpotent x → x = 0 := by
  sorry

This theorem states that for any type `R` that has a zero element, an exponentiation operation, and satisfies the property of being 'reduced' (i.e., having no non-zero nilpotent elements), if an element `x` of `R` is nilpotent (meaning there exists a natural number `n` such that `x` to the power `n` equals zero), then that element `x` must be zero.

In a reduced ring with zero multiplicative identity and exponentiation operation, every nilpotent element is the additive identity.


theorem List.dlookup_isSome :
    ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {l : List (Sigma β)},
      Option.isSome (List.dlookup a l) = true ↔ a ∈ List.keys l :=
  by sorry

This theorem, `List.dlookup_isSome`, states that for any type `α` with decidable equality, and for any dependent type `β` indexed by `α`, for all elements `a` of type `α` and for all lists `l` of key-value pairs where the keys are of type `α` and the values are of the type `β` indexed by the corresponding key, the statement "the option returned by `List.dlookup` of `a` in `l` is not `none`" is equivalent to "the element `a` is in the list of keys of `l`". In other words, a key `a` is in the list of keys of `l` if and only if looking up `a` in the list `l` using `List.dlookup` returns some value rather than `none`.

For any type `α` with decidable equality and dependent type `β` indexed by `α`, the option returned by `List.dlookup` on list `l` of key-value pairs with keys of type `α` and values of type `β` indexed by keys, is `some (β a)` for some `a` in `α` if and only if `a` is an element of the list of keys.


theorem mem_closure_of_gauge_le_one :
    ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} {x : E} [inst_2 : TopologicalSpace E]
      [inst_3 : ContinuousSMul ℝ E], Convex ℝ s → 0 ∈ s → Absorbent ℝ s → gauge s x ≤ 1 → x ∈ closure s :=
  by sorry

The theorem `mem_closure_of_gauge_le_one` states that given a set `s` in a real vector space `E`, if `s` is convex, contains the origin, and is absorbent, then for any element `x` in `E`, if the Minkowski functional or gauge of `s` at `x` is less than or equal to one, `x` is in the closure of `s`. In other words, if `s` satisfies these properties, then any point scaled by `s` by a factor not exceeding one belongs to the smallest closed set containing `s`.

If a convex, origin-containing, absorbent set `s` in a real vector space has Minkowski functional at `x` less than or equal to 1, then `x` is in the closure of `s`.


theorem DFinsupp.single_zero :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)] (i : ι),
      DFinsupp.single i 0 = 0 :=
  by sorry

This theorem states that, given a type `ι`, a type function `β : ι → Type v`, a decidable equality on `ι`, and a zero value for every `i : ι` in the codomain of `β`, for every `i : ι`, applying the `DFinsupp.single` function to `i` and `0` yields the zero function. In other words, if we create a function using `DFinsupp.single` that sends `i` to `0` and all other points to `0`, we get the zero function.

For any type `ι`, decidable equality, type function `β : ι → Type v`, and zero value `z : ∀ i : ι, β i`, the function `DFinsupp.single i z` is equal to the zero function `0 : β i → β i`.


ContDiffOn.contDiffAt

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

This theorem states that if a function `f` of type `E → F` is continuously differentiable to any order `n` on a set `s` in a normed additive commutative group `E` equipped with a nontrivially normed field `𝕜` (this set belongs to the normed space `𝕜 E`), and if the set `s` is a neighborhood of a point `x` (i.e., it contains an open set around `x`), then the function `f` is continuously differentiable to the order `n` at the point `x`. The spaces `E` and `F` are assumed to be normed additive commutative groups over the field `𝕜` and equipped with the normed space structure.

In simpler terms, this theorem is a formal statement of the intuition that if a function is continuously differentiable everywhere in a certain neighborhood, then it is continuously differentiable at any particular point within that neighborhood.

If a function `f : E → F` is continuously differentiable to order `n` on a neighborhood `s` of a point `x` in the normed additive commutative groups `E` and `F` over a nontrivially normed field `𝕜`, then `f` is continuously differentiable to order `n` at `x`.


theorem Real.Angle.sin_neg : ∀ (θ : Real.Angle), Real.Angle.sin (-θ) = -Real.Angle.sin θ := by sorry

This theorem states that for any angle `θ` of the type `Real.Angle`, the sine of the negative of `θ` is equal to the negative of the sine of `θ`. In mathematical terms, this is saying that $\sin(-θ) = -\sin(θ)$ for any real angle `θ`. This is essentially the property of the sine function being an odd function in trigonometry.

The sine function is an odd function, that is, $\sin(-θ) = -\sin(θ)$ for all real angles `θ`.


theorem NNReal.coe_list_prod : ∀ (l : List NNReal), ↑(List.prod l) = List.prod (List.map NNReal.toReal l) := by sorry

This theorem, `NNReal.coe_list_prod`, states that for any list of nonnegative real numbers (`NNReal`), the real number representation (`toReal`) of the product of the list is equal to the product of the list obtained by mapping each nonnegative real number in the list to its real number representation. In other words, converting a list of nonnegative real numbers to their real number equivalents and then taking the product is the same as taking the product of the nonnegative real numbers first and then converting the result to a real number.

For any list of non-negative real numbers, the product of their real number representations is equal to the real number representation of the product of the numbers in the list.


theorem indicator_ae_eq_restrict_compl :
    ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
      [inst_1 : Zero β], MeasurableSet s → Set.indicator s f =ᶠ[MeasureTheory.Measure.ae (μ.restrict sᶜ)] 0 :=
  by sorry

The theorem `indicator_ae_eq_restrict_compl` states that for any type `α` and `β`, where `α` is equipped with a measurable space structure, and given a measure `μ` on `α`, a set `s` of `α`, and a function `f` from `α` to `β` such that `β` is equipped with a zero structure and `s` is a measurable set, the indicator function of `s` and `f` is almost everywhere equal to `0` on the measure space restricted to the complement of `s`. In other words, it says that outside the set `s`, the indicator function is `0` almost everywhere according to the measure `μ`.

For any measurable set `s` and measurable function `f` from a measure space `(α, μ) to a zero-structured type `β`, the indicator function of `s` is almost everywhere equal to the zero function `0` on the complement of `s`.


Function.Bijective.comp

theorem Function.Bijective.comp :
    ∀ {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} {g : β → φ} {f : α → β},
      Function.Bijective g → Function.Bijective f → Function.Bijective (g ∘ f) :=
  by sorry

The theorem `Function.Bijective.comp` states that for any three types `α`, `β`, and `φ`, and any two functions `f : α → β` and `g : β → φ`, if `g` is bijective (both injective and surjective) and `f` is also bijective, then the composition of `g` and `f` (denoted as `g ∘ f`) is also bijective. In other words, the composition of two bijective functions is always a bijective function.

If functions `f : α → β` and `g : β → φ` are both bijective, then their composition `g ∘ f` is also bijective.


/-- A family with at most one point is affinely independent.  -/
theorem affineIndependent_of_subsingleton :
    ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {ι : Type u_4} [inst_4 : Subsingleton ι] (p : ι → P), AffineIndependent k p :=
  by sorry

The theorem `affineIndependent_of_subsingleton` establishes that, for any type `k` (which is a ring), and given types `V` and `P` (such that `V` is an additive commutative group, `P` is an additively translatable space with `V` as the space of translations, and `V` is a `k`-module), if the index set `ι` is a subsingleton (i.e., has at most one element), then any function from `ι` to `P` is affinely independent. In other words, if a family of points in `P` has at most one point, it is affinely independent, meaning that no nontrivial weighted subtraction of the points (where the sum of weights is 0) equals 0.

Given a ring `k`, an additive commutative group `V` (a `k`-module), and an additively translatable space `P` over `V`, if `ι` is a subsingleton, then any function from `ι` to `P` consists of affinely independent points.


theorem Finsupp.mapDomain_smul :
    ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} {R : Type u_11} {x : Monoid R} [inst : AddCommMonoid M]
      [inst_1 : DistribMulAction R M] {f : α → β} (b : R) (v : α →₀ M),
      Finsupp.mapDomain f (b • v) = b • Finsupp.mapDomain f v :=
  by sorry

The theorem `Finsupp.mapDomain_smul` states that for any types `α`, `β`, `M`, `R`, a monoid `x` on `R`, an additive commutative monoid `M`, and a distributive multiplication action of `R` on `M`, and given a function `f` from `α` to `β`, a scalar `b` from `R`, and a function `v` from `α` to `M` that is finitely supported, the map domain of the scalar multiplication of `b` and `v` is equal to the scalar multiplication of `b` and the map domain of `f` and `v`. In other words, scalar multiplication commutes with the map domain operation.

In mathematical terms, this can be written as for any `f : α → β`, `b : R` and `v : α →₀ M`, we have `Finsupp.mapDomain f (b • v) = b • Finsupp.mapDomain f v`.

For any monoid action of a ring `R` on an additive commutative monoid `M`, function `f : α → β`, scalar `b : R`, and finitely supported function `v : α → M`, we have `Finsupp.mapDomain (f :: α → β) (b • v) = b • Finsupp.mapDomain f v`.


theorem Subgroup.map_comap_eq :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) (H : Subgroup N),
      Subgroup.map f (Subgroup.comap f H) = MonoidHom.range f ⊓ H :=
  by sorry

The theorem `Subgroup.map_comap_eq` states that for any group homomorphism `f` from a group `G` to another group `N` and any subgroup `H` of `N`, the image under `f` of the preimage under `f` of `H` is equal to the intersection of the range of `f` and `H`. In other words, if we first take the preimage of `H` under `f` in `G` and then map it back to `N` using `f`, we get exactly the elements in the range of `f` that are also in `H`.

The image of the preimage of a subgroup under a group homomorphism is equal to the intersection of the range of the homomorphism and the subgroup.


theorem Complex.abs_mul_exp_arg_mul_I : ∀ (x : ℂ), ↑(Complex.abs x) * Complex.exp (↑(Complex.arg x) * Complex.I) = x :=
  by sorry

The theorem `Complex.abs_mul_exp_arg_mul_I` states that for any complex number `x`, the product of the absolute value of `x` and the complex exponential of the imaginary unit `Complex.I` multiplied by the argument of `x` is equal to `x` itself. In mathematical terms, for any complex number `x`, `|x| * e^(arg(x) * i) = x`. This theorem essentially provides a polar form representation of a complex number, where `|x|` is the magnitude (or absolute value) and `arg(x)` is the angle (or argument) in the complex plane.

For any complex number x, the product of its absolute value and the complex exponential of its argument times the imaginary unit is equal to x. |x| * exp(arg(x) * I) = x.


theorem LocalizedModule.induction_on :
    ∀ {R : Type u} [inst : CommSemiring R] {S : Submonoid R} {M : Type v} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {β : LocalizedModule S M → Prop},
      (∀ (m : M) (s : ↥S), β (LocalizedModule.mk m s)) → ∀ (x : LocalizedModule S M), β x :=
  by sorry

This theorem, called `LocalizedModule.induction_on`, states that for any commutative semiring `R`, a multiplicative subset `S` of `R`, an `R`-module `M`, and a property `β` defined on the localized module of `M` by `S`, if the property `β` holds for every element of the form `(m/s)` where `m` is an element of `M` and `s` is an element of the submonoid `S`, then the property `β` holds for every element of the localized module. This theorem essentially provides a method of induction for proving properties on the localized module.

If a property holds for all elements of the form `m/s` in the localized module `M/S` of an `R`-module `M` over a commutative semiring `R` with multiplicative subset `S`, then the property holds for all elements in `M/S`.


theorem Subgroup.coe_mk :
    ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (x : G) (hx : x ∈ H), ↑{ val := x, property := hx } = x := by
  sorry

This theorem, `Subgroup.coe_mk`, states that for any given type `G` that forms a group, any subgroup `H` of `G`, and any element `x` of `G` that belongs to `H`, the coercion of a structure that consists of `x` and the proof of `x` belonging to `H` to `G` is equal to `x` itself. In mathematical terms, this theorem specifies the behavior of the coercion function (denoted by `↑`) from the set of elements in the subgroup `H` to the group `G`.

For any group `G` and subgroup `H` of `G`, and for any element `x` in `H`, the coercion of `(x, ‹x ∈ H›)` to `G` equals `x`.


theorem StructureGroupoid.LocalInvariantProp.liftPropOn_of_mem_maximalAtlas :
    ∀ {H : Type u_1} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
      [inst_2 : ChartedSpace H M] {G : StructureGroupoid H} {e : PartialHomeomorph M H} {Q : (H → H) → Set H → H → Prop}
      [inst_3 : HasGroupoid M G],
      StructureGroupoid.LocalInvariantProp G G Q →
        (∀ (y : H), Q id Set.univ y) →
          e ∈ StructureGroupoid.maximalAtlas M G → ChartedSpace.LiftPropOn Q (↑e) e.source :=
  by sorry

The theorem `StructureGroupoid.LocalInvariantProp.liftPropOn_of_mem_maximalAtlas` asserts that for any topological spaces `H` and `M`, with `M` having a charted space structure with respect to `H` and a groupoid `G`, a partial homeomorphism `e` from `M` to `H`, and a property `Q` of maps from `H` to `H`, sets of `H` and points of `H`, if `Q` is a local invariant property with respect to the groupoid `G` and `Q` holds universally for the identity map of `H`, then if `e` is in the maximal atlas of `M` with respect to the groupoid `G`, the property `Q` lifts on the source of `e` under the embedding of `e`. In simpler terms, if a property holds for all points under the identity map and is invariant under the groupoid, then it holds for all points in the source of any map in the maximal atlas.

If `Q` is a local invariant property of maps between topological spaces `H` that holds for all identity maps and is respecting groupoid `G`, then for any charted space `M` with respect to `H`, partial homeomorphism `e` from `M` to `H` in the maximal atlas of `M` with respect to `G`, the property `Q` holds for all points in the source of `e`.


theorem ONote.lt_def : ∀ {x y : ONote}, x < y ↔ ONote.repr x < ONote.repr y := by sorry

The theorem `ONote.lt_def` states that for any two ordinal notations `x` and `y`, `x` is less than `y` if and only if the ordinal represented by `x` is less than the ordinal represented by `y`. Here, `ONote.repr` is a function that takes an ordinal notation and returns the corresponding ordinal. The comparison between `x` and `y` is made in terms of the mathematical concept of ordinal numbers, which generalize the concept of natural numbers to include notions of "infinity" and their arithmetic.

For any ordinal notations x and y, x < y if and only if ONote.repr x < ONote.repr y.


theorem Filter.sInter_mem :
    ∀ {α : Type u} {f : Filter α} {s : Set (Set α)}, Set.Finite s → (⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f) := by sorry

The theorem, `Filter.sInter_mem`, states that for any type `α`, any filter `f` on `α`, and any finite set `s` of subsets of `α`, the intersection of all elements in the set `s` belongs to the filter `f` if and only if all elements (subsets `U`) in the set `s` belong to the filter `f`. This theorem essentially captures the principle that a filter contains the intersection of any finite collection of its elements.

A filter `f` on a type `α` contains the intersection of any finite number of its elements if and only if each element in the finite set of subsets belongs to the filter. In Lean 4, this is expressed as the theorem `Filter.sInter_mem`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.86 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (Multiset.count a s = 0) = (a ∉ s) := by sorry

This theorem, named `Mathlib.Data.Multiset.Basic._auxLemma.86`, states that for any type `α` that has a decidable equality, and any element `a` of type `α` and any multiset `s` of type `α`, the count of `a` in `s` is zero if and only if `a` does not belong to `s`. In other words, an element `a` is not a member of a multiset `s` if its count in `s` is zero. The theorem employs a characteristic feature of multisets, which are essentially sets that allow duplicate elements. The count function is used to determine the multiplicity of an element in a multiset.

For any type `α` with decidable equality and any multiset `s` of type `α`, the element `a` is not in `s` if and only if the count of `a` in `s` is zero.


theorem MvPolynomial.coe_monomial :
    ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (n : σ →₀ ℕ) (a : R),
      ↑((MvPolynomial.monomial n) a) = (MvPowerSeries.monomial R n) a :=
  by sorry

The theorem `MvPolynomial.coe_monomial` states that for any commutative semiring `R` and for any `n` of type `σ →₀ ℕ` (which refers to a function which maps from a generic type `σ` to non-negative integers) and any `a` of type `R`, the coerced result of applying the multivariate polynomial monomial function `MvPolynomial.monomial` to `n` and `a` equals the result of applying the multivariate power series monomial function `MvPowerSeries.monomial` to `R`, `n` and `a`. Essentially, this theorem establishes a connection between monomials in the context of multivariate polynomials and multivariate power series within a commutative semiring.

For any commutative semiring R, function n : σ →₀ ℕ, and element a in R, the coerced result of MvPolynomial.monomial applying to n and a equals the result of MvPowerSeries.monomial applying to R, n, and a.


theorem DifferentiableWithinAt.sub_const :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E} {s : Set E},
      DifferentiableWithinAt 𝕜 f s x → ∀ (c : F), DifferentiableWithinAt 𝕜 (fun y => f y - c) s x :=
  by sorry

The theorem `DifferentiableWithinAt.sub_const` states that for any non-trivially normed field `𝕜`, normed additive commutative group `E`, normed space `𝕜 E`, normed additive commutative group `F`, normed space `𝕜 F`, function `f` from `E` to `F`, point `x` in `E`, and subset `s` of `E`, if the function `f` is differentiable at the point `x` within the set `s`, then for any element `c` in `F`, the function `f(y) - c` is also differentiable at the point `x` within the set `s`. In simple terms, the theorem states that the difference between a differentiable function and a constant is also differentiable.

If a function is differentiable at a point in a normed space with respect to a subset, then the difference of the function and a constant is also differentiable at that point with respect to the same subset.


/-- If `l : Filter ℂ` is an "exponential comparison filter", then for any complex `a₁`, `a₂` and any
real `b₁ < b₂`, we have `(fun z ↦ z ^ a₁ * exp (b₁ * z)) =o[l] (fun z ↦ z ^ a₂ * exp (b₂ * z))`.  -/
theorem Complex.IsExpCmpFilter.isLittleO_cpow_mul_exp :
    ∀ {l : Filter ℂ} {b₁ b₂ : ℝ},
      Complex.IsExpCmpFilter l →
        b₁ < b₂ →
          ∀ (a₁ a₂ : ℂ), (fun z => z ^ a₁ * Complex.exp (↑b₁ * z)) =o[l] fun z => z ^ a₂ * Complex.exp (↑b₂ * z) :=
  by sorry

The theorem `Complex.IsExpCmpFilter.isLittleO_cpow_mul_exp` states that if `l` is an exponential comparison filter, for any two complex numbers `a₁` and `a₂`, and any two real numbers `b₁` and `b₂` where `b₁ < b₂`, the function `z ↦ z ^ a₁ * exp(b₁ * z)` is little o of the function `z ↦ z ^ a₂ * exp(b₂ * z)` at the filter `l`. In other words, the growth rate of the first function is significantly smaller than the second one as `z` goes to the limit of the filter `l`.

For an exponential comparison filter `l`, if complex numbers `a₁` and `a₂` and real numbers `b₁` and `b₂` satisfy `b₁ < b₂`, then `z ^ a₁ * exp(b₁ * z) = o(z ^ a₂ * exp(b₂ * z))` as `z` approaches the limit of `l`.


theorem Subgroup.isComplement_iff_existsUnique :
    ∀ {G : Type u_1} [inst : Group G] {S T : Set G}, Subgroup.IsComplement S T ↔ ∀ (g : G), ∃! x, ↑x.1 * ↑x.2 = g := by
  sorry

This theorem states that for any group `G` and sets `S` and `T` of elements in `G`, the property of `S` and `T` being complements (`Subgroup.IsComplement S T`) is equivalent to the condition that for every element `g` in `G`, there exists a unique pair `x` such that the product of the first and second elements of `x` equals `g`. In other words, `S` and `T` are complements if and only if each `g` in `G` can be uniquely expressed as the product of an element of `S` and an element of `T`.

For any group `G` and sets `S` and `T` of elements in `G`, `Subgroup.IsComplement S T` if and only if for each `g` in `G`, there exists a unique pair `(s, t)` in `S × T` such that `g = s * t`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.22 :
    ∀ {α : Type u_1} {s t : Multiset α}, (s ⊆ t) = ∀ ⦃x : α⦄, x ∈ s → x ∈ t := by sorry

This theorem states that for any type `α` and multisets `s` and `t` of type `α`, the condition that `s` is a subset of `t` is equivalent to the property that every element `x` of `s` is also an element of `t`. In other words, a multiset `s` is a subset of another multiset `t` if and only if every element in `s` also appears in `t`.

For any type `α` and multisets `s` and `t` of type `α`, `s ⊆ t` if and only if for all `x ∈ s`, `x ∈ t`.


theorem Mathlib.Data.Multiset.Basic._auxLemma.17 : ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) := by sorry

This theorem states that for any type `α` and any two elements `a` and `b` of that type, the proposition `a = b` is equivalent to the proposition `b = a`. In other words, equality is symmetric in Lean 4, meaning if `a` equals `b`, then `b` also equals `a`.

For any type `α` and elements `a, b : α`, the proposition `a = b` is equivalent to `b = a`. (Equality is reflexive and symmetric.)


theorem MeasureTheory.SimpleFunc.add_lintegral :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f g : MeasureTheory.SimpleFunc α ENNReal),
      MeasureTheory.SimpleFunc.lintegral (f + g) μ =
        MeasureTheory.SimpleFunc.lintegral f μ + MeasureTheory.SimpleFunc.lintegral g μ :=
  by sorry

The theorem `MeasureTheory.SimpleFunc.add_lintegral` states that for any measure space `α` with a measure `μ`, and for any two simple functions `f` and `g` mapping from `α` to the extended nonnegative real numbers, the integral of the sum of the two simple functions (i.e., `f + g`) with respect to the measure `μ` equals the sum of the integrals of the individual simple functions `f` and `g` with respect to the measure `μ`. In mathematical terms, this theorem asserts linearity of the integral on simple functions, namely ∫(f + g) dμ = ∫f dμ + ∫g dμ.

The integral of the sum of two simple functions with respect to a measure is equal to the sum of their individual integrals with respect to the same measure.


theorem Nat.gcd_add_self_left : ∀ (m n : ℕ), Nat.gcd (m + n) n = Nat.gcd m n := by sorry

The theorem `Nat.gcd_add_self_left` states that for any two natural numbers `m` and `n`, the greatest common divisor (GCD) of `m + n` and `n` is equal to the GCD of `m` and `n`. In other words, adding `n` to `m` does not change the greatest common divisor of `m` and `n`. This is a property of the greatest common divisor in number theory.

The theorem asserts that for all natural numbers m and n, the greatest common divisor of m + n and n is equal to the greatest common divisor of m and n. In Lean notation: `(∀ m n : ℕ, gcd m (m + n) = gcd m n)`.


/-- Given a pullback square assembled from a commuting square on the left and
a pullback square on the right, the left square is a pullback square.  -/
theorem CategoryTheory.IsPullback.of_right :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X₁₁ X₁₂ X₁₃ X₂₁ X₂₂ X₂₃ : C} {h₁₁ : X₁₁ ⟶ X₁₂}
      {h₁₂ : X₁₂ ⟶ X₁₃} {h₂₁ : X₂₁ ⟶ X₂₂} {h₂₂ : X₂₂ ⟶ X₂₃} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₁₃ : X₁₃ ⟶ X₂₃},
      CategoryTheory.IsPullback (CategoryTheory.CategoryStruct.comp h₁₁ h₁₂) v₁₁ v₁₃
          (CategoryTheory.CategoryStruct.comp h₂₁ h₂₂) →
        CategoryTheory.CategoryStruct.comp h₁₁ v₁₂ = CategoryTheory.CategoryStruct.comp v₁₁ h₂₁ →
          CategoryTheory.IsPullback h₁₂ v₁₂ v₁₃ h₂₂ → CategoryTheory.IsPullback h₁₁ v₁₁ v₁₂ h₂₁ :=
  by sorry

This theorem, `CategoryTheory.IsPullback.of_right`, states that in the context of a Category Theory, given a type `C` that forms a category, and six objects `X₁₁, X₁₂, X₁₃, X₂₁, X₂₂, X₂₃` in this category, along with morphisms between these objects (`h₁₁, h₁₂, h₂₁, h₂₂` as horizontal morphisms and `v₁₁, v₁₂, v₁₃` as vertical morphisms), if we have a commuting square formed by `h₁₁, h₁₂, v₁₁, v₁₃` on the left and a pullback square formed by `h₂₁, h₂₂, v₁₂, v₁₃` on the right such that the compositions of `h₁₁` with `v₁₂` and `v₁₁` with `h₂₁` are equal, then the left square (formed by `h₁₁, v₁₁, v₁₂, h₂₁`) is also a pullback square. In simpler words, it states that if the right square is a pullback square, then the left square is also a pullback square under certain conditions.

If a commutative diagram in a category with given morphisms and objects forms a pullback square on the right and the conditions of commutativity and vertical compositions with the morphisms on the left side are met, then the diagram forms a pullback square on the left.


theorem MeasurableSpace.generateFrom_sup_generateFrom :
    ∀ {α : Type u_1} {s t : Set (Set α)},
      MeasurableSpace.generateFrom s ⊔ MeasurableSpace.generateFrom t = MeasurableSpace.generateFrom (s ∪ t) :=
  by sorry

This theorem states that for any type `α` and any two sets of sets `s` and `t` of the type `α`, the supremum of the measure spaces generated from `s` and the measure space generated from `t` is equal to the measure space generated from the union of `s` and `t`. In other words, combining the measure spaces created from two collections of basic sets results in the same measure space as that created from the combined collection of basic sets.

Given any type `α` and sets of sets `s` and `t` of type `α`, the measure spaces generated from `s` and `t` have the same supremum as the measure space generated from the union of `s` and `t`.


theorem WithTop.preimage_coe_Iio_top : ∀ {α : Type u_1} [inst : Preorder α], WithTop.some ⁻¹' Set.Iio ⊤ = Set.univ := by
  sorry

This theorem states that for any type `α` endowed with a preorder structure, the preimage of the left-infinite right-open interval `Set.Iio ⊤` under the canonical map `WithTop.some : α → WithTop α` is the universal set `Set.univ`. In other words, every element of `α` is mapped to a value less than `⊤` (top) in the `WithTop α` structure. It essentially shows that all elements of the original set `α` are considered less than infinity (`⊤`) in the extended set `WithTop α`.

For any type `α` with a preorder structure, the image of `α` under the canonical map to `WithTop α` is the set of elements less than the top element in `WithTop α`, i.e., `WithTop.some'' Set.univ = Set.Iio ⊤`.


theorem Primrec.list_concat : ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ fun l a => l ++ [a] := by sorry

The theorem `Primrec.list_concat` states that for any type `α` that is 'Primcodable' (can be encoded as a natural number), the function that takes a list `l` and an element `a` of type `α`, and appends `a` to the end of `l` to form a new list, is a binary primitive recursive function. In other words, given a list of elements and a single element, both of `Primcodable` type `α`, the operation of appending the single element to the end of the list is a primitive recursive operation.

The function that appends an element to the end of a list, given a list and an element of a Primcodable type, is a primitive recursive function.


theorem CochainComplex.single₀_map_f_zero :
    ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
      [inst_2 : CategoryTheory.Limits.HasZeroObject V] {A B : V} (f : A ⟶ B),
      ((CochainComplex.single₀ V).map f).f 0 = f :=
  by sorry

This theorem states that for any category `V` with zero morphisms and a zero object, given two objects `A` and `B` in `V` and a morphism `f` from `A` to `B`, if we apply the functor `CochainComplex.single₀ V` to the morphism `f` and then apply the morphism function `.f` at degree 0, we obtain the original morphism `f`. In simpler terms, when we map a morphism using the functor that creates a cochain complex supported in degree zero, the morphism at degree zero remains the same in the cochain complex.

For any category with zero morphisms and a zero object, the morphism function at degree 0 of the cochain complex created by `CochainComplex.single₀` for a given morphism is equal to the original morphism.


theorem Asymptotics.isBigOWith_abs_right :
    ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {c : ℝ} {f : α → E} {l : Filter α} {u : α → ℝ},
      (Asymptotics.IsBigOWith c l f fun x => |u x|) ↔ Asymptotics.IsBigOWith c l f u :=
  by sorry

This theorem, `Asymptotics.isBigOWith_abs_right`, states that for any types `α` and `E`, with `E` possessing a norm, any real constant `c`, any function `f` from `α` to `E`, any filter `l` on `α`, and any function `u` from `α` to real numbers, the property that `f` is big O with respect to the absolute value of `u` (i.e., the function value `|u(x)|`) under the filter `l` with constant `c` (denoted as `Asymptotics.IsBigOWith c l f (λ x => |u x|)`) is equivalent to the property that `f` is big O with respect to `u itself` under the same filter with the same constant (denoted as `Asymptotics.IsBigOWith c l f u`). In other words, the Landau notation `IsBigOWith` is invariant under taking the absolute value of the function on the right-hand side.

The theorem `Asymptotics.isBigOWith_abs_right` in Lean 4 states that for any type `α`, real constant `c`, function `f` from `α` to a normed type `E`, filter `l` on `α`, and function `u` from `α` to real numbers, `Asymptotics.IsBigOWith c l f (λ x => |u x|)` is equivalent to `Asymptotics.IsBigOWith c l f u`. In other words, the Landau notation `IsBigOWith` is invariant under taking the absolute value of the right-hand side function.


theorem Mathlib.Data.Finset.Prod._auxLemma.30 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α × α},
      (x ∈ Finset.offDiag s) = (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) :=
  by sorry

The theorem `Mathlib.Data.Finset.Prod._auxLemma.30` asserts that for any type `α` with decidable equality, any finite set `s` of type `α`, and any pair `x` of type `α × α`, the pair `x` belongs to the off-diagonal of set `s` if and only if both elements of the pair belong to `s` and they are not equal to each other. In other words, a pair `(a, b)` is in the off-diagonal of a finite set `s` precisely when `a` and `b` are distinct elements of `s`.

For any decidably equal type `α` and finite set `s` of `α`, a pair `(a, b)` is in the off-diagonal of `s` if and only if `a` and `b` are distinct elements of `s`.


theorem NNReal.rpow_lt_rpow : ∀ {x y : NNReal} {z : ℝ}, x < y → 0 < z → x ^ z < y ^ z := by sorry

This theorem states that for any two nonnegative real numbers `x` and `y`, and any real number `z`, if `x` is less than `y` and `z` is greater than zero, then `x` raised to the power of `z` is less than `y` raised to the power of `z`. In mathematical terms, if $x < y$ and $z > 0$, then $x^z < y^z$.

For any nonnegative real numbers $x$ and $y$ with $x < y$, and any positive real number $z$, $x^z < y^z$.


theorem CauSeq.eq_lim_of_const_equiv :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] {β : Type u_2} [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] [inst_3 : CauSeq.IsComplete β abv] {f : CauSeq β abv} {x : β},
      CauSeq.const abv x ≈ f → x = CauSeq.lim f :=
  by sorry

The theorem `CauSeq.eq_lim_of_const_equiv` states that for any linearly ordered field `α`, a ring `β`, an absolute value function `abv` from `β` to `α`, a completeness instance for Cauchy sequences over `β` with respect to the absolute value `abv`, and a Cauchy sequence `f` over `β` with respect to the absolute value `abv` and an element `x` of `β`, if the constant Cauchy sequence at `x` is equivalent to `f`, then `x` is equal to the limit of the Cauchy sequence `f`. In other words, if a constant sequence and another sequence are 'close enough' (in the sense of Cauchy equivalence), then the value of the constant sequence is the limit of the other sequence.

If a constant sequence is Cauchy equivalent to a sequence in a linearly ordered field with respect to an absolute value function and completeness instance, then the limit of the sequence equals the constant value.


theorem Mathlib.Algebra.Quaternion._auxLemma.6 :
    ∀ {R : Type u_1} {a b : R} (x y : QuaternionAlgebra R a b),
      (x = y) = (x.re = y.re ∧ x.imI = y.imI ∧ x.imJ = y.imJ ∧ x.imK = y.imK) :=
  by sorry

This theorem, `Mathlib.Algebra.Quaternion._auxLemma.6`, states that for any given type `R` and any two elements `a` and `b` of `R`, and for any two elements `x` and `y` of the Quaternion Algebra of `R` with coefficients `a` and `b`, `x` is equal to `y` if and only if the real part of `x` is equal to the real part of `y`, the 'i' imaginary part of `x` is equal to the 'i' imaginary part of `y`, the 'j' imaginary part of `x` is equal to the 'j' imaginary part of `y`, and the 'k' imaginary part of `x` is equal to the 'k' imaginary part of `y`.

Two quaternions of type `R` with real and imaginary parts `(xℜ, xI, xJ, xK)` and `(yℜ, yI, yJ, yK)` are equal if and only if their real parts are equal and their corresponding imaginary parts are equal.


Smooth.smul

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

The theorem `Smooth.smul` states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `V`, and a topological space `H`, if we have a smooth function `f` from a topological manifold `M` with corners to `𝕜` and another smooth function `g` from `M` to `V`, then the function `p => f p • g p` which maps every point `p` of the manifold to the scalar multiplication of the function values `f(p)` and `g(p)` is also smooth. Here, smoothness is relative to the model with corners `I` for `M` and the standard model with corners for either `𝕜` or `V`.

If `f` is a smooth function from a topological manifold `M` with corners to a non-trivially normed field, and `g` is another smooth function from `M` to a normed additive commutative group, then the function `p => f(p) • g(p)` is smooth.


theorem Nat.testBit_and : ∀ (x y i : ℕ), Nat.testBit (x &&& y) i = (Nat.testBit x i && Nat.testBit y i) := by sorry

The theorem `Nat.testBit_and` states that for all natural numbers `x`, `y`, and `i`, the `i`-th least significant bit of the bitwise AND operation between `x` and `y` is determined by the logical AND operation between the `i`-th least significant bit of `x` and the `i`-th least significant bit of `y`. This means that when comparing the bit representation at a certain position for both `x` and `y`, if both bits are 1, the result will also have 1 in that position; otherwise, it will be 0.

For all natural numbers x, y, and i, the i-th bit of x AND y is equal to the logical AND of the i-th bits of x and y.


theorem Mathlib.Data.Finset.Prod._auxLemma.22 :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) := by sorry

This theorem, `Mathlib.Data.Finset.Prod._auxLemma.22`, states that for any type `α` which has decidable equality, and any two finite sets `s` and `t` of type `α`, and any element `a` of type `α`, the statement "element `a` is in the union of `s` and `t`" is equivalent to the statement "element `a` is in `s` or `a` is in `t`". Essentially, it corresponds to the standard set theory fact that an element is in the union of two sets if and only if it is in one of the sets.

For any type `α` with decidable equality and finite sets `s` and `t` of type `α`, the element `a` is in the union of `s` and `t` if and only if `a` is in `s` or `a` is in `t`.


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

This theorem, `Mathlib.Data.Finset.Prod._auxLemma.15`, states that for any three propositions `a`, `b`, and `c`, the assertion that `a` and `b` are true and `c` is true is logically equivalent to the assertion that `a` is true, and `b` and `c` are also true. This is a property of logical conjunction (the "and" operation denoted by `∧`), demonstrating the associative property of conjunction in propositional logic.

The theorem `Mathlib.Data.Finset.Propositional.and_assoc` states that for all propositions `a`, `b`, and `c`, `(a ∧ b) ∧ c` is logically equivalent to `a ∧ b ∧ c`.


theorem Subgroup.mem_rightTransversals_iff_bijective :
    ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {S : Set G},
      S ∈ Subgroup.rightTransversals ↑H ↔ Function.Bijective (Set.restrict S Quotient.mk'') :=
  by sorry

This theorem states that for any group `G`, subgroup `H` of `G`, and set `S` of type `G`, the set `S` is in the right transversals of the subgroup `H` if and only if the restriction of the function `Quotient.mk''` to the set `S` is bijective. The function `Quotient.mk''` generates an equivalence class for each element of `G`. Therefore, in simpler terms, the theorem states that a set `S` can be considered a right transversal of a subgroup `H` if every equivalence class of `G` elements contains exactly one element from `S`.

A set `S` is a right transversal of a subgroup `H` in a group `G` if and only if the restriction of `Quotient.mk''` to `S` is a bijection.


theorem Set.image_mul_right' :
    ∀ {α : Type u_2} [inst : Group α] {t : Set α} {b : α}, (fun x => x * b⁻¹) '' t = (fun x => x * b) ⁻¹' t := by sorry

The theorem `Set.image_mul_right'` states that, for all types `α` that form a group, for any set `t` of `α` and any element `b` of `α`, the set obtained by taking every element `x` in `t` and multiplying it by the inverse of `b` is the same as the preimage of `t` under the function that multiplies each element by `b`. In other words, multiplying each element of a set by the inverse of a chosen element results in the same set as taking those elements that would land in the original set when multiplied by the chosen element.

For any group type `α`, set `t` of `α`, and element `b` of `α`, the sets {x : α | ∃ (x' : α), x = x' * b^(-1) ∧ x' ∈ t} and {x : α | x ∈ t ∧ x * b ∈ α} are equal.


theorem MeasureTheory.IntegrableOn.continuousOn_mul :
    ∀ {X : Type u_1} {R : Type u_5} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      {μ : MeasureTheory.Measure X} [inst_2 : OpensMeasurableSpace X] {K : Set X} [inst_3 : NormedRing R]
      [inst_4 : SecondCountableTopologyEither X R] {g g' : X → R} [inst_5 : T2Space X],
      ContinuousOn g K →
        MeasureTheory.IntegrableOn g' K μ → IsCompact K → MeasureTheory.IntegrableOn (fun x => g x * g' x) K μ :=
  by sorry

The theorem `MeasureTheory.IntegrableOn.continuousOn_mul` states that for any measurable space `X` which also has a topological space structure (`inst_1`), a measure `μ` on `X`, a set `K` of `X` which is compact, and a normed ring `R`, if a function `g` from `X` to `R` is continuous on `K` and another function `g'` from `X` to `R` is integrable on `K` (almost everywhere strongly measurable on `K` and the integral of its pointwise norm over `K` is less than infinity), then the function that maps `x` in `X` to the product of `g(x)` and `g'(x)` is also integrable on `K`. The additional conditions `inst_2 : OpensMeasurableSpace X` and `inst_3 : NormedRing R` are technical conditions needed to make the definitions of integrability and continuity work correctly in this context.
In simple terms, if one function is continuous and another is integrable on a compact set, then their pointwise product is also integrable on that set.

If a function is continuous on a compact set and another function is integrable on that set in a measurable space with a topological structure and a normed ring of scalars, then their pointwise product is integrable on that set.


/-- Expand the square  -/
theorem norm_sub_sq :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      (x y : E), ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * RCLike.re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2 :=
  by sorry

The theorem `norm_sub_sq` states that for any type `𝕜` that is a real-coefficient-like structure (`RCLike`) and any normed add commutative group `E` that is also an inner product space over `𝕜`, the squared norm (essentially the length squared) of the difference between two elements `x` and `y` of `E` is equal to the squared norm of `x` minus twice the real part of the inner product of `x` and `y` over `𝕜`, plus the squared norm of `y`. This can be seen as a variant of the Pythagorean theorem in an inner product space.

For any RCLike structure `𝕜` and inner product space `E` over `𝕜`, the squared norm of `x - y` in `E` equals the squared norm of `x` minus twice the inner product of `x` and `y` over `𝕜` plus the squared norm of `y`.


/-- The restriction of a compatible family is compatible.  -/
theorem CategoryTheory.Presieve.FamilyOfElements.Compatible.restrict :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R₁ R₂ : CategoryTheory.Presieve X} (h : R₁ ≤ R₂) {x : CategoryTheory.Presieve.FamilyOfElements P R₂},
      CategoryTheory.Presieve.FamilyOfElements.Compatible x →
        CategoryTheory.Presieve.FamilyOfElements.Compatible (CategoryTheory.Presieve.FamilyOfElements.restrict h x) :=
  by sorry

This theorem states that in the context of category theory, if we have a category `C` and a functor `P` from the opposite category `Cᵒᵖ` to the category of types `Type w`, along with two presieves `R₁` and `R₂` on an object `X` in `C` such that `R₁` is a subset of `R₂`, then the restriction of a family of elements `x` of `P` that is compatible with `R₂` to `R₁` remains a compatible family of elements. In other words, if a family of elements of a presheaf is compatible with a certain presieve, it remains compatible when restricted to any smaller presieve.

If `C` is a category, `P` is a functor from `Cᵒᵖ` to `Type w`, `X` is an object in `C`, `R₁` and `R₂` are two presheaves on `X` with `R₁ ⊆ R₂`, and `x` is a family of elements of `P` compatible with `R₂`, then `x` is also compatible with `R₁`.


theorem monovary_inv_right₀ :
    ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrderedSemifield α] [inst_1 : LinearOrderedSemifield β]
      {f : ι → α} {g : ι → β}, StrongLT 0 g → (Monovary f g⁻¹ ↔ Antivary f g) :=
  by sorry

The theorem `monovary_inv_right₀` states that for any types `ι`, `α`, and `β`, and for any functions `f : ι → α` and `g : ι → β`, where `α` and `β` are both linear ordered semifields, if the function `g` is strongly greater than 0 (i.e., all its values are positive), then `f` monovaries with the inverse of `g` if and only if `f` antivaries with `g`. In other words, if `g` increases, then `f` follows the inverse of `g` in the sense that it decreases when `g` increases and vice versa, and this condition is equivalent to `f` being antivariant with `g`, meaning `f` decreases when `g` increases.

For functions `f : ι -> α` and `g : ι -> β` between linear ordered semifields, `f` monovaries with the inverse of `g` if and only if `f` antivaries with `g`, given that `g` is strictly positive.


theorem Ideal.isMaximal_def : ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, Ideal.IsMaximal I ↔ IsCoatom I := by
  sorry

The theorem `Ideal.isMaximal_def` states that for any type `α` with a semiring structure and any ideal `I` of `α`, the ideal `I` is maximal if and only if `I` is a coatom. In the context of the definitions provided, an ideal is maximal if there is no other ideal between it and the entire ring (not counting the entire ring itself), which matches the definition of coatom in a poset with a greatest element.

A ideal in a semiring is maximal if and only if it is a coatom (an element with no superior element except the top element in the lattice of ideals).


theorem CategoryTheory.effectiveEpiFamilyStructIsoComp_aux :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {B : C} {α : Type u_2} (X Y : α → C)
      (π : (a : α) → X a ⟶ B) (i : (a : α) → Y a ⟶ X a) [inst_1 : ∀ (a : α), CategoryTheory.IsIso (i a)] {W : C}
      (e : (a : α) → Y a ⟶ W),
      (∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ Y a₁) (g₂ : Z ⟶ Y a₂),
          CategoryTheory.CategoryStruct.comp g₁ (CategoryTheory.CategoryStruct.comp (i a₁) (π a₁)) =
              CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.CategoryStruct.comp (i a₂) (π a₂)) →
            CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)) →
        ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
          CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
            CategoryTheory.CategoryStruct.comp g₁
                ((fun a => CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (i a)) (e a)) a₁) =
              CategoryTheory.CategoryStruct.comp g₂
                ((fun a => CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (i a)) (e a)) a₂) :=
  by sorry

The theorem `CategoryTheory.effectiveEpiFamilyStructIsoComp_aux` states that within a category `C` with objects of type `B` and morphisms determined by an index set `α`, given families of objects `X` and `Y` and morphisms `π` from `X` to `B`, and `i` from `Y` to `X` (where each `i a` is an isomorphism), as well as another family of morphisms `e` from `Y` to `W`, if the composition of morphisms `g₁` or `g₂` with the composition of `i a` and `π a` leads to the same result for any object `Z` and any indices `a₁` and `a₂`, then the resulting compositions with `e a` are also the same. This implies that if the composition of `g₁` or `g₂` with `π a` leads to the same result, then the composition of `g₁` or `g₂` with the composition of the inverse of `i a` and `e a` will also lead to the same result.

Given families of objects and morphisms in a category with isomorphisms between them, if the compositions of certain morphisms with objects' projections lead to the same result and the isomorphisms and those morphisms commute with given additional morphisms, then the compositions with the inverses of the isomorphisms and the additional morphisms also lead to the same result.


theorem Finset.ssubset_iff :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ⊂ t ↔ ∃ a ∉ s, insert a s ⊆ t := by sorry

The theorem `Finset.ssubset_iff` states that for any type `α` with decidable equality and any two finite sets `s` and `t` of type `α`, `s` is a strict subset of `t` if and only if there exists an element `a` not in `s` such that adding `a` to `s` results in a set that is a subset of `t`. In other words, there's at least one element in `t` that's not in `s`, and adding it to `s` would still keep it within `t`.

For finite sets `s` and `t` of type `α` with decidable equality, `s` is a strict subset of `t` if and only if there exists an element `a` in `t` not in `s` such that `s ∪ {a} ⊆ t`.


theorem TopologicalSpace.isOpen_generateFrom_of_mem : ∀ {α : Type u} {g : Set (Set α)} {s : Set α}, s ∈ g → IsOpen s :=
  by sorry

The theorem `TopologicalSpace.isOpen_generateFrom_of_mem` declares that for any type `α`, any collection of sets `g` of type `Set α`, and any set `s` of type `Set α`, if `s` belongs to `g`, then `s` is an open set in the topological space generated by `g`. The term "open set" here is used in the context of topology, where an open set is a set that, intuitively, does not include its boundary.

In the topology generated by a collection of sets `g` of type `Set α`, any set `s` that belongs to `g` is an open set.


theorem gaugeRescale_self_apply :
    ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [inst_3 : T1Space E]
      {s : Set E}, Absorbent ℝ s → Bornology.IsVonNBounded ℝ s → ∀ (x : E), gaugeRescale s s x = x :=
  by sorry

This theorem states that, for any type `E` that forms an additive commutative group and a module over the real numbers, and additionally has a topological space structure and a T1 space structure (meaning that for any two distinct points, there is an open set containing one but not the other), if we have a set `s` of type `E` that is absorbent and Von Neumann bounded, then for any element `x` of type `E`, the gauge rescale of `s` with respect to itself at `x` is just `x`. In other words, gauge rescale doesn't change the points of the set `s` provided `s` is absorbent and Von Neumann bounded. This can be thought as a kind of normalization property for absorbent and Von Neumann bounded sets in such a structured space.

Given a type `E` that forms an additive commutative group and a module over the real numbers, is a T1 topological space, and contains an absorbent and Von Neumann bounded set `s`, for all `x` in `E`, the gauge rescale of `s` with respect to itself at `x` equals `x`.


theorem DFinsupp.filter_single :
    ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)] (p : ι → Prop)
      [inst_2 : DecidablePred p] (i : ι) (x : β i),
      DFinsupp.filter p (DFinsupp.single i x) = if p i then DFinsupp.single i x else 0 :=
  by sorry

The theorem `DFinsupp.filter_single` states that for any type `ι`, any type family `β` indexed over `ι`, and any predicate `p` on `ι`, provided that `ι` has decidable equality and every type in the family `β` has a zero element, if we have a decidable predicate `p` and elements `i` of type `ι` and `x` of type `β i`, then filtering the function that sends `i` to `x` and all other points to `0` according to the predicate `p` results in either the original function (if `p i` holds) or the constantly zero function (if `p i` does not hold).

For any type `ι`, type family `β` indexed over `ι`, decidable equality on `ι`, and a zero element in each `β i`, if `p` is a decidable predicate on `ι` and `x` is an element of `β i`, then the function that maps `i` to `x` and all other points to `0`, filtered by `p`, is equal to the original function if `p(i)` holds, or the constantly zero function otherwise.


theorem SetTheory.PGame.lf_moveRight :
    ∀ {x : SetTheory.PGame} (j : SetTheory.PGame.RightMoves x), SetTheory.PGame.LF x (SetTheory.PGame.moveRight x j) :=
  by sorry

This theorem states that for any pre-game `x` and any allowable right move `j` in this game, if `x` is less fuzzy than the new game resulting after Right makes the move `j`, then Left can win the new game as the first player. In other words, this theorem is capturing a particular dynamic of the pre-game: if the game after Right's allowed move is in a "fuzzy" relation with the original game (not clearly greater or less), then Left has a winning strategy for the new game.

If a pre-game `x` is less fuzzy than the game resulting after Right makes an allowable move `j`, then Left has a winning strategy as the first player in the new game.


MeasureTheory.IntegrableOn.restrict

theorem MeasureTheory.IntegrableOn.restrict :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {f : α → E} {s t : Set α}
      {μ : MeasureTheory.Measure α},
      MeasureTheory.IntegrableOn f s μ → MeasurableSet s → MeasureTheory.IntegrableOn f s (μ.restrict t) :=
  by sorry

This theorem states that for any two sets `s` and `t` of elements of type `α`, a function `f : α → E` that maps elements from `α` to a normed add commutative group `E`, and a measure `μ` defined on `α`, if `f` is almost everywhere strongly measurable on `s` and the integral of its pointwise norm over `s` is less than infinity (i.e., `f` is "integrable on `s` with respect to `μ`"), and if `s` is a measurable set, then `f` is also integrable on `s` with respect to the measure `μ` restricted to `t`. In other words, if a function is integrable on a measurable set, it remains integrable even when the underlying measure is restricted to another set.

If `s` and `t` are sets of elements of type `α`, `f : α → E` is a strongly measurable function from `s` to a normed add commutative group `E`, `μ` is a measure on `α`, and `s` is measurable with `∫₡(‖f‖) ds < ∞`, then `f` is integrable on `s` with respect to `μ` restricted to `t`.


theorem CategoryTheory.Idempotents.Karoubi.hom_ext_iff :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
      {f g : P ⟶ Q}, f = g ↔ f.f = g.f :=
  by sorry

This theorem states that for any two morphisms `f` and `g` from `P` to `Q` in the Karoubi enlargement of a category `C`, `f` is equal to `g` if and only if the underlying functions of `f` and `g` (represented as `f.f` and `g.f`) are equal. The Karoubi enlargement of a category is a construction in category theory that includes all idempotents of the category.

In the Karoubi enlargement of a category `C`, two morphisms `f` and `g` from `P` to `Q` are equal if and only if their underlying functions `f.f` and `g.f` are equal.


theorem Mathlib.Topology.MetricSpace.HausdorffDistance._auxLemma.26 :
    ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) := by sorry

This theorem states that for every extended nonnegative real number `x` (which is usually denoted [0, ∞] and is the codomain of a measure), `x` being converted to a real number equals zero if and only if `x` equals zero or `x` equals positive infinity. In other words, in the extended nonnegative real numbers, the only values that become zero when converted to real numbers are zero and positive infinity.

In the extended nonnegative real numbers, a number converts to zero in the real numbers if and only if it is either zero or positive infinity.


theorem eq_div_iff_mul_eq' : ∀ {G : Type u_3} [inst : Group G] {a b c : G}, a = b / c ↔ a * c = b := by sorry

This theorem states that for any type `G` that forms a group, and for any elements `a`, `b`, and `c` of that group, `a` is equal to `b` divided by `c` if and only if `a` multiplied by `c` is equal to `b`. This provides a connection between division and multiplication in a group, allowing one to transition between these two operations under certain conditions.

For any group `G` and elements `a`, `b`, and `c` in `G`, `a = b / c` if and only if `a * c = b`.


theorem Filter.tendsto_congr :
    ∀ {α : Type u} {β : Type v} {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β},
      (∀ (x : α), f₁ x = f₂ x) → (Filter.Tendsto f₁ l₁ l₂ ↔ Filter.Tendsto f₂ l₁ l₂) :=
  by sorry

The theorem `Filter.tendsto_congr` states that for any two functions `f₁` and `f₂` from a type `α` to type `β`, and given filters `l₁` on `α` and `l₂` on `β`, if every element of `α` is mapped to the same value by both `f₁` and `f₂`, then `f₁` tends towards `l₂` along `l₁` if and only if `f₂` also tends towards `l₂` along `l₁`. In other words, if two functions are equal at each input, their corresponding limits with respect to the same input and output filters are also equivalent.

If two functions map the same element to the same value for all elements in filters `l₁` on `α` and `l₂` on `β`, then `f₁` tends towards `l₂` along `l₁` if and only if `f₂` also tends towards `l₂` along `l₁`.


theorem Polynomial.rootMultiplicity_le_iff :
    ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R},
      p ≠ 0 → ∀ (a : R) (n : ℕ), Polynomial.rootMultiplicity a p ≤ n ↔ ¬(Polynomial.X - Polynomial.C a) ^ (n + 1) ∣ p :=
  by sorry

This theorem states that for any commutative ring `R`, and any non-zero polynomial `p` with coefficients in `R`, for any element `a` of `R` and natural number `n`, the root multiplicity of `a` in `p` is less than or equal to `n` if and only if the polynomial `(X - C a)` to the power `(n + 1)` does not divide `p`. Here, `X` denotes the polynomial variable and `C a` is the constant polynomial `a`. In other words, the theorem provides a condition to check whether the root multiplicity of a certain value in a polynomial is less than or equal to a given natural number.

For any commutative ring R, polynomial p with non-zero leading coefficient, and element a in R, the root multiplicity of a in p is less than or equal to n if and only if (X - a)^(n+1) does not divide p.


theorem Finset.card_biUnion_le :
    ∀ {α : Type u_3} {β : Type u_4} [inst : DecidableEq β] {s : Finset α} {t : α → Finset β},
      (Finset.biUnion s t).card ≤ Finset.sum s fun a => (t a).card :=
  by sorry

This theorem is stating that for any two types, `α` and `β`, where `β` has a decidable equality, and for any finite set `s` of type `α` and a function `t` that maps elements of `α` to finite sets of `β`, the cardinality (or size) of the biUnion of `s` and `t` is less than or equal to the sum of the cardinalities of the sets `t a` for each `a` in `s`. In other words, the size of the union of the sets `t a` for each `a` in `s` is less than or equal to the sum of the sizes of these sets. This is an application of the general principle that the size of a union of sets is less than or equal to the sum of the sizes of the sets.

For any finite set `s` of type `α` and function `t` from `α` to finite sets of type `β` with decidable equality, the cardinality of the biUnion of `s` and the image of `t` is less than or equal to the sum of the cardinalities of the images of `t` on each element of `s`.


theorem Turing.PartrecToTM2.supports_union :
    ∀ {K₁ K₂ S : Finset Turing.PartrecToTM2.Λ'},
      Turing.PartrecToTM2.Supports (K₁ ∪ K₂) S ↔
        Turing.PartrecToTM2.Supports K₁ S ∧ Turing.PartrecToTM2.Supports K₂ S :=
  by sorry

This theorem in the Lean theorem prover language states that for any three finite sets `K₁`, `K₂`, and `S` of Turing.PartrecToTM2.Λ' (which is a type that represents a Turing machine's states), the Turing machine's set of supports `S` supports the union of `K₁` and `K₂` if and only if `S` supports `K₁` and `S` supports `K₂`. This theorem is an essential part of understanding how supports work in the context of Turing machines.

For any finite sets `K₁`, `K₂`, and `S` of Turing machine states, the set `S` supports the union of `K₁` and `K₂` if and only if it supports both `K₁` and `K₂`.


theorem ENNReal.iSup_add :
    ∀ {a : ENNReal} {ι : Sort u_4} {s : ι → ENNReal} [inst : Nonempty ι], iSup s + a = ⨆ b, s b + a := by sorry

The theorem `ENNReal.iSup_add` states that for any extended non-negative real number `a` and for any function `s` from an arbitrary index set `ι` to the set of extended non-negative real numbers, given that the index set `ι` is non-empty, the supremum (iSup) of `s` added to `a` equals the supremum over all `b` in the index set of the sum of `s b` and `a`. In other words, this theorem states the property that adding a fixed extended non-negative real number to the supremum of a set of extended non-negative real numbers is the same as taking the supremum of the set obtained by adding the fixed number to each element of the original set.

For any non-empty index set `ι` and extended non-negative real number `a`, the supremum of the function `s : ι → ℝ����fu` is equal to the supremum of `a + s(x)` over all `x` in `ι`.


theorem Composition.boundary.proof_1 :
    ∀ {n : ℕ} (c : Composition n) (i : Fin (Composition.length c + 1)), Composition.sizeUpTo c ↑i < Nat.succ n := by
  sorry

This theorem states that for any natural number `n` and any composition `c` of `n`, if `i` is a natural number less than or equal to the length of the composition `c` plus one, then the sum of the sizes of the blocks in the composition `c` up to `i` is strictly less than `n+1`. In other words, the total size of the first `i` blocks in any composition of `n` is always less than `n+1`.

For any natural number `n` and composition `c` of `n`, the sum of the sizes of the first `i` blocks in `c` is strictly less than `n + 1` for all `i` leq `length c + 1`.


theorem GaloisConnection.l_ciSup :
    ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
      [inst_1 : ConditionallyCompleteLattice β] [inst_2 : Nonempty ι] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ {f : ι → α}, BddAbove (Set.range f) → l (⨆ i, f i) = ⨆ i, l (f i) :=
  by sorry

The theorem `GaloisConnection.l_ciSup` states that for all types `α`, `β`, and `ι`, where `α` and `β` are conditionally complete lattices (meaning they are partially ordered sets in which every nonempty, bounded above subset has a least upper bound) and `ι` is nonempty, and for all functions `l : α → β` and `u : β → α` that form a Galois connection (i.e., for every `a : α` and `b : β`, `l a ≤ b` is equivalent to `a ≤ u b`), if the range of a function `f : ι → α` is bounded above, then applying `l` to the supremum (the least upper bound) of the function `f` over all `ι` is equal to the supremum of the function `l ∘ f` (i.e., the function that first applies `f`, then `l`) over all `ι`.

For any conditionally complete lattices α, β and nonempty ι, if l : α → β and u : β → α form a Galois connection and the range of f : ι → α is bounded above, then (l (⨆ x : ι, f x)) = ⨆ x : ι, (l (f x)).


/-- If a fundamental solution exists, then `d` must be positive.  -/
theorem Pell.IsFundamental.d_pos : ∀ {d : ℤ} {a : Pell.Solution₁ d}, Pell.IsFundamental a → 0 < d := by sorry

This theorem states that if a fundamental solution to the Pell equation `x^2 - d*y^2 = 1` exists, then the parameter `d` must be positive. A fundamental solution is defined as one where `x > 1` and `y > 0`, and the `x` value of this solution is the smallest among all solutions with `x > 1`. Therefore, if such a solution exists, it implies that `d` cannot be zero or negative.

If a positive integer `d` has a fundamental solution for the Pell equation `x^2 - d*y^2 = 1`, then `d` must be positive.


theorem MeasureTheory.submartingale_of_condexp_sub_nonneg_nat :
    ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
      [inst : MeasureTheory.IsFiniteMeasure μ] {f : ℕ → Ω → ℝ},
      MeasureTheory.Adapted 𝒢 f →
        (∀ (i : ℕ), MeasureTheory.Integrable (f i) μ) →
          (∀ (i : ℕ), 0 ≤ᶠ[MeasureTheory.Measure.ae μ] MeasureTheory.condexp (↑𝒢 i) μ (f (i + 1) - f i)) →
            MeasureTheory.Submartingale f 𝒢 μ :=
  by sorry

This theorem states that for any type `Ω` with a measurable space `m0`, a measure `μ`, a filtration `𝒢` over natural numbers on `m0`, and a sequence of functions `f` from natural numbers to `Ω` mapped to real numbers, if `f` is adapted to `𝒢`, all functions in the sequence `f` are integrable with respect to `μ`, and the conditional expectation of the difference between successive functions in the sequence `f` with respect to the measure `μ` is almost everywhere nonnegative, then `f` is a submartingale with respect to `𝒢` and `μ`.

In simpler terms, the theorem asserts that if we have a sequence of functions that satisfies certain measure-theoretical properties (being adapted to a filtration, being integrable, and having non-negative differences in conditional expectations), then this sequence forms a submartingale, a type of stochastic process with specific "fair game" properties.

Given a measurable space `(Ω, m0)`, a filtration `𝒢` over natural numbers, a measure `μ`, and a sequence of `μ`-integrable, `𝒢`-adapted functions `f : ℕ → Ω → ℝ`, if the difference `f (n+1) (x) - f (n) (x)` is almost everywhere nonnegative in the conditional expectation with respect to `μ` for all `n : ℕ` and `x : Ω`, then `f` is a submartingale with respect to `𝒢` and `μ`.


/-- **Alias** of the reverse direction of `antitoneOn_toDual_comp_iff`. -/
theorem MonotoneOn.dual_right :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
      MonotoneOn f s → AntitoneOn (⇑OrderDual.toDual ∘ f) s :=
  by sorry

The theorem `MonotoneOn.dual_right` states that given any types `α` and `β` that have a preorder relation, along with a function `f : α → β` and a set `s` of type `α`, if the function `f` is monotone on the set `s`, then the function `f` composed with the identity function to the dual order (i.e., `⇑OrderDual.toDual ∘ f`) is antitone on the same set `s`. In other words, if a function preserves the order of elements in a set, then flipping the order of the elements also flips the direction of the function, making it antitone.

If `f : α → β` is a monotone function on set `s ⊆ α`, then the composition `OrderDual.toDual �circ f` is an antitone function on `s`.


theorem measurable_derivWithin_Ici :
    ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] (f : ℝ → F) [inst_2 : CompleteSpace F]
      [inst_3 : MeasurableSpace F] [inst_4 : BorelSpace F], Measurable fun x => derivWithin f (Set.Ici x) x :=
  by sorry

This theorem, `measurable_derivWithin_Ici`, states that for any function `f` from real numbers to a normed additively commutative group `F`, that also forms a normed space over real numbers, and which is a complete and measureable space, the function that maps each real number `x` to the derivative of `f` at the point `x` within the set of real numbers greater than or equal to `x` (denoted by `Set.Ici x`), is a measurable function. Here, a measurable function is defined as a function whose preimage of every measurable set is also measurable. The derivative of `f` at `x` within `Set.Ici x` is defined as the rate at which `f` changes at `x`, considering only the values of `f` for inputs greater than or equal to `x`.

The derivative function of a complete, measureable, and normed function from real numbers to a normed additively commutative group, restricted to the set of real numbers greater than or equal to a given point, is a measurable function.


theorem add_lt_ack : ∀ (m n : ℕ), m + n < ack m n := by sorry

This theorem states that for all natural numbers `m` and `n`, the sum of `m` and `n` is less than the value of the two-argument Ackermann function applied to `m` and `n`. The Ackermann function, known for its rapid growth, is defined by three conditions: when the first argument is 0, it returns `n + 1`; when the first argument is `m + 1` and the second argument is 0, it returns the Ackermann function of `m` and 1; and when both arguments are `m + 1` and `n + 1` respectively, it returns the Ackermann function of `m` and the Ackermann function of `m + 1` and `n`. This theorem essentially points to the extreme growth rate of the Ackermann function.

For all natural numbers m and n, m + n is strictly less than Ackermann(m, n).


/-- The everywhere positive subset of a set is obtained by removing an open set.  -/
theorem MeasureTheory.Measure.exists_isOpen_everywherePosSubset_eq_diff :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
      ∃ u, IsOpen u ∧ μ.everywherePosSubset s = s \ u :=
  by sorry

This theorem states that, for any topological space `α` with the associated measurable space, and any measure `μ` and set `s` of type `α`, there exists an open set `u` such that the everywhere positive subset of `s` with respect to the measure `μ` is equivalent to the set difference of `s` and `u`. In other words, you can obtain the everywhere positive subset of `s` by removing an open set `u` from `s`.

For any topological space `α` with a measurable structure, measure `μ`, and set `s` of type `α`, there exists an open set `u` such that `s \ u` is equivalent to the everywhere positive subset of `s` with respect to `μ`.


theorem Equiv.Perm.mem_finPairsLT : ∀ {n : ℕ} {a : (_ : Fin n) × Fin n}, a ∈ Equiv.Perm.finPairsLT n ↔ a.snd < a.fst :=
  by sorry

The theorem `Equiv.Perm.mem_finPairsLT` states that for all natural numbers `n` and pairs `a` (consisting of elements from the set `Fin n`), the pair `a` belongs to the set `Equiv.Perm.finPairsLT n` if and only if the second element of `a` is less than the first element of `a`. In other words, it describes the membership condition for the set `Equiv.Perm.finPairsLT n` which is the set of all pairs in `Fin n` where the second component is less than the first component.

For natural number $n$, a pair $(a, b)$ in $Fin \ n \times Fin \ n$ belongs to $Equiv.Perm.finPairsLT \ n$ if and only if $b \ < \ a$.


theorem Complex.sinh_conj : ∀ (x : ℂ), Complex.sinh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.sinh x) := by sorry

The theorem `Complex.sinh_conj` states that for every complex number `x`, the complex hyperbolic sine of the complex conjugate of `x` is equal to the complex conjugate of the complex hyperbolic sine of `x`. In other words, the complex hyperbolic sine function commutes with complex conjugation. This can be represented in mathematical notation as follows: for all `x` in ℂ, sinh(conj(x)) = conj(sinh(x)), where "conj" denotes the complex conjugate operation, and "sinh" denotes the complex hyperbolic sine function.

For all complex numbers x, the complex conjugate of the hyperbolic sine of x is equal to the hyperbolic sine of the complex conjugate of x. In other words, sinh(conj(x)) = conj(sinh(x)) in the complex numbers.


/-- (Impl) The key property defining the map `λ : TL ⟶ L`.  -/
theorem CategoryTheory.Monad.ForgetCreatesColimits.commuting :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {J : Type u}
      [inst_1 : CategoryTheory.Category.{v, u} J] {D : CategoryTheory.Functor J (CategoryTheory.Monad.Algebra T)}
      (c : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.comp D (CategoryTheory.Monad.forget T)))
      (t : CategoryTheory.Limits.IsColimit c)
      [inst_2 :
        CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.comp D (CategoryTheory.Monad.forget T))
          T.toFunctor]
      (j : J),
      CategoryTheory.CategoryStruct.comp (T.map (c.ι.app j)) (CategoryTheory.Monad.ForgetCreatesColimits.lambda c t) =
        CategoryTheory.CategoryStruct.comp (D.obj j).a (c.ι.app j) :=
  by sorry

This theorem states that for any category `C` with a monad `T`, and any functor `D` from a category `J` to the category of `T`-algebras, given a cocone `c` under `D` followed by the functor that forgets the algebra structure, if `c` is a colimit cocone, then for every object `j` in `J`, the composition of the map induced by `T` and a certain map `λ` (defined in the context of the theorem) is equal to the composition of the algebra structure of `D.obj j` and the `j`-th component of the cocone `c`. This is a key property defining the map `λ`, ensuring that the forgetful functor `T` creates colimits.

For any monad `T` over a category `C`, functor `D` from a category `J` to `T`-algebras, and cocone `c` under `D`, if `c` is a colimit cocone, then for all objects `j` in `J`, the diagram `T(D.obj j) ∘ λ = D.obj j ∘ c.μ(j)` commutes, where `λ` is a specific map defined in the context of the theorem.


CategoryTheory.ShortComplex.Exact.unop

theorem CategoryTheory.ShortComplex.Exact.unop :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S : CategoryTheory.ShortComplex Cᵒᵖ},
      CategoryTheory.ShortComplex.Exact S → CategoryTheory.ShortComplex.Exact (CategoryTheory.ShortComplex.unop S) :=
  by sorry

The theorem `CategoryTheory.ShortComplex.Exact.unop` states that for any type `C` that forms a category with zero morphisms, if `S` is a short complex in the opposite category `Cᵒᵖ` that is exact, then the unopposite of `S` (obtained by applying the `CategoryTheory.ShortComplex.unop` function) is also an exact short complex in `C`. In other words, the exactness property is preserved when switching from the opposite category to the original category.

If `C` is a category with zero morphisms and `S` is an exact short complex in the opposite category `Cᵒᵖ`, then the unopposite `CategoryTheory.ShortComplex.unop S` is an exact short complex in `C`.


theorem TopologicalSpace.Opens.carrier_eq_coe :
    ∀ {α : Type u_2} [inst : TopologicalSpace α] (U : TopologicalSpace.Opens α), U.carrier = ↑U := by sorry

This theorem states that for any given type `α` and any open subset `U` of a topological space over `α`, the carrier of `U` is equivalent to the coercion of `U`. In other words, the carrier of an open set in a topological space is the same as the set itself when we ignore the additional structure provided by the topology. The topology on `α` and the open set `U` are implicit arguments in this theorem.

For any type `α` and open subset `U` of a topological space over `α`, the carrier of `U` is equal to the set `U` itself.


/-- Restriction of a measure to a subset is monotone both in set and in measure.  -/
theorem MeasureTheory.Measure.restrict_mono' :
    ∀ {α : Type u_2} {_m0 : MeasurableSpace α} ⦃s s' : Set α⦄ ⦃μ ν : MeasureTheory.Measure α⦄,
      s ≤ᶠ[MeasureTheory.Measure.ae μ] s' → μ ≤ ν → μ.restrict s ≤ ν.restrict s' :=
  by sorry

The theorem `MeasureTheory.Measure.restrict_mono'` asserts that the restriction of a measure to a subset is monotone in both the set and the measure. In particular, for any type `α` endowed with a `MeasurableSpace` structure, and for any two sets `s` and `s'` of type `α`, along with any two measures `μ` and `ν` on the `MeasurableSpace` of `α`; then if `s` is almost everywhere lesser than or equal to `s'` (under the measure `μ`), and if measure `μ` is lesser than or equal to measure `ν`, it follows that the restriction of measure `μ` to set `s` is lesser than or equal to the restriction of measure `ν` to set `s'`.

If `μ` is a measure that is less than or equal to `ν` on a measurable space `(α, Σ)`, and `s` is a subset of `α` that is almost everywhere less than or equal to another subset `s'` with respect to `μ`, then `μ(s)` is less than or equal to `ν(s')`.