theorem AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand₀ :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      (K : ChainComplex C ℕ) [inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] {Δ Δ' : SimplexCategoryᵒᵖ}
      (A : SimplicialObject.Splitting.IndexSet Δ) {θ : Δ ⟶ Δ'} {Δ'' : SimplexCategory} {e : Δ'.unop ⟶ Δ''}
      {i : Δ'' ⟶ A.fst.unop} [inst_3 : CategoryTheory.Epi e] [inst_4 : CategoryTheory.Mono i],
      CategoryTheory.CategoryStruct.comp e i =
          CategoryTheory.CategoryStruct.comp θ.unop (SimplicialObject.Splitting.IndexSet.e A) →
        CategoryTheory.CategoryStruct.comp
            (CategoryTheory.Limits.Sigma.ι (AlgebraicTopology.DoldKan.Γ₀.Obj.summand K Δ) A)
            (AlgebraicTopology.DoldKan.Γ₀.Obj.map K θ) =
          CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono K i)
            (CategoryTheory.Limits.Sigma.ι (AlgebraicTopology.DoldKan.Γ₀.Obj.summand K Δ')
              (SimplicialObject.Splitting.IndexSet.mk e)) :=
  by sorry

This theorem states that in the context of algebraic topology and specifically within the Dold-Kan correspondence, for a chain complex `K` in a category `C` with finite coproducts and a given simplex category morphism `θ` from `Δ` to `Δ'`, if we have an epimorphism `e` from `Δ'.unop` to `Δ''` and a monomorphism `i` from `Δ''` to `A.fst.unop` such that the composition of `e` and `i` is equal to the composition of `θ.unop` and the epimorphism associated to `A`, then the composition of the b-th inclusion into the sigma object over `Γ₀.Obj.summand K Δ` and `Γ₀.Obj.map K θ` is equal to the composition of `Γ₀.Obj.Termwise.mapMono K i` and the b-th inclusion into the sigma object over `Γ₀.Obj.summand K Δ'` associated to the splitting index set created by `e`. This theorem essentially establishes a sort of commutative diagram involving these morphisms in the bigger picture of Dold-Kan correspondence.

Given a chain complex `K` in a category `C` with finite coproducts, a simplex category morphism `θ` from `Δ` to `Δ'`, an epimorphism `e` from `Δ'.unop` to `Δ''`, and a monomorphism `i` from `Δ''` to `A.fst.unop`, if the composition of `e` and `i` is equal to the composition of `θ.unop` and the epimorphism associated to `A`, then the b-th inclusions into the sigma objects of `Γ₀.Obj.summand K Δ` and `Γ₀.Obj.summand K Δ'` are equal up to the composition of `Γ₀.Obj.Termwise.mapMono K i`.


theorem Cardinal.lift_monotone : Monotone Cardinal.lift.{u_2, u_1} := by sorry

The theorem `Cardinal.lift_monotone` states that the function `Cardinal.lift`, which performs a universe lift operation on cardinals, is monotone. In other words, if we have two cardinals `a` and `b` such that `a ≤ b`, it implies that `Cardinal.lift a ≤ Cardinal.lift b`. Here, the notation `≤` denotes a preorder (a relation that is reflexive and transitive) on the cardinals. This property ensures that lifting does not decrease cardinality, and if one cardinal is less than or equal to another, the same relationship holds after their respective lifts.

The `Cardinal.lift` function preserves the preorder relation between cardinals, that is, if `a ≤ b` then `Cardinal.lift a ≤ Cardinal.lift b`.


AbsoluteValue.ext

theorem AbsoluteValue.ext :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : OrderedSemiring S] ⦃f g : AbsoluteValue R S⦄,
      (∀ (x : R), f x = g x) → f = g :=
  by sorry

This theorem, `AbsoluteValue.ext`, states that for any two types `R` and `S`, with `R` being a semiring and `S` a ordered semiring, if you have two absolute value functions `f` and `g` from `R` to `S`, and for every value in `R` both `f` and `g` give the same result, then `f` and `g` must be the same function. Essentially, this theorem ensures that an absolute value function is uniquely determined by its action on all elements of `R`.

If `R` is a semiring and `S` an ordered semiring, and `f` and `g` are absolute value functions from `R` to `S` such that `f(x) = g(x)` for all `x` in `R`, then `f` and `g` are equal functions.


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

This theorem, `MonoidAlgebra.single_mul_apply_aux`, is about the monoid algebra generated over a semiring `k` by a monoid `G`. It states that for all instances `k` of a semiring, all instances `G` of a multiplicative monoid, any `f` in the monoid algebra of `k` and `G`, any element `r` of `k`, and any elements `x`, `y`, and `z` of `G`, such that for every element `a` in `G`, `x * a` equals `y` if and only if `a` equals `z`. Under these conditions, the theorem asserts that the convolution of the single-element monoid algebra generated by `x` and `r`, and `f`, evaluated at `y`, is equal to `r` multiplied by `f` evaluated at `z`.

For any semiring `k`, multiplicative monoid `G`, `f` in the monoid algebra of `k` and `G`, `r` in `k`, and `x`, `y`, `z` in `G` such that `x * a = y` if and only if `a = z`, the convolution of the single-element monoid algebra generated by `x` and `r`, and `f`, equals `r * f(z)`.


theorem Mathlib.Data.Finsupp.Defs._auxLemma.8 : (¬False) = True := by sorry

This theorem, `Mathlib.Data.Finsupp.Defs._auxLemma.8`, asserts that the negation of `False` equals `True`. In mathematical logic, this is a basic truth, stating that if something is not false, then it must be true.

The negation of False is equal to True. (In mathematical logic, ⊢ ⊥ → ⊥' where ⊥ is the proposition of False and ⊥' is the proposition of True.)


theorem Mathlib.Data.Finset.Pointwise._auxLemma.16 :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : InvolutiveNeg α] {s : Finset α} {a : α}, (a ∈ -s) = (-a ∈ s) := by
  sorry

This theorem, `Mathlib.Data.Finset.Pointwise._auxLemma.16`, states that for any type `α` with decidable equality and involutive negation, and for any finite set `s` of type `α` and any element `a` of type `α`, the element `a` belongs to the negation of the set `s` if and only if the negation of `a` belongs to the set `s`. Here, "involutive negation" means that negating any element twice returns the original element; in mathematical notation, for any `a` in `α`, `-(-a) = a`.

For any type `α` with decidable equality and involutive negation, the element `a` is in the complement of a finite set `s` of type `α` if and only if the negation of `a` is in `s`.


theorem Mathlib.Data.Finsupp.Defs._auxLemma.3 :
    ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {f : α →₀ M}, (f.support = ∅) = (f = 0) := by sorry

This theorem, named `Mathlib.Data.Finsupp.Defs._auxLemma.3`, states that for any type `α` and any type `M` equipped with a zero element, and given a function `f` from `α` to `M` with finite support (`f : α →₀ M`), the support of `f` being empty (i.e., `f` has no non-zero outputs) is equivalent to `f` being the zero function (i.e., `f` outputs zero for all inputs). In mathematical terms, for a function with finite support, it having no non-zero outputs (or `f.support = ∅`) is the same as it being the zero function (or `f = 0`).

A function with finite support from a type to a type equipped with a zero element is the zero function if and only if it has no non-zero outputs.


IsLowerSet.image

theorem IsLowerSet.image :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
      IsLowerSet s → ∀ (f : α ≃o β), IsLowerSet (⇑f '' s) :=
  by sorry

The theorem `IsLowerSet.image` states that for any types α and β, given a preorder (an order that is reflexive and transitive) on both α and β, if we have a set `s` on α that is a lower set (meaning, for any two elements in the set, if one is less than or equal to the other, the lesser one is also in the set), then the image of `s` under any order-preserving bijection `f` from α to β is also a lower set in β. This means that the property of being a lower set is preserved under an order-preserving bijection.

Given a preorder on types α and β, if s is a lower set on α and f is an order-preserving bijection from α to β, then the image of s under f is a lower set on β.


theorem Dense.denseRange_val :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, Dense s → DenseRange Subtype.val := by sorry

This theorem states that for any type `X` with a topological space structure, and any set `s` of `X`, if `s` is dense in `X`, then the range of the function `Subtype.val` (which extracts the underlying element from a subtype) is also dense in `X`. In other words, if every point in `X` belongs to the closure of `s`, then every point in `X` also belongs to the closure of the image of `Subtype.val`.

If `s` is a dense subset of the topological space `X`, then the image of `Subtype.val` on `s` is also a dense subset of `X`.


theorem ProbabilityTheory.kernel.indep_iSup_of_disjoint :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
      {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α} [inst : ProbabilityTheory.IsMarkovKernel κ]
      {m : ι → MeasurableSpace Ω},
      (∀ (i : ι), m i ≤ _mΩ) →
        ProbabilityTheory.kernel.iIndep m κ μ →
          ∀ {S T : Set ι}, Disjoint S T → ProbabilityTheory.kernel.Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.indep_iSup_of_disjoint` states that for every type `α`, `Ω`, and `ι`, and given a measurable space on `α` and `Ω`, a kernel `κ` in the probability theory, a measure `μ` on `α`, and a Markov kernel, and a function `m` which assigns a measurable space to each `ι`, if each measurable space `m i` is a sub-measurable space of `_mΩ` and the measurable spaces are independent with respect to the kernel `κ` and the measure `μ`, then for any two disjoint sets `S` and `T` of `ι`, the supremum of measurable spaces `m i` over `i` in `S` is independent of the supremum of measurable spaces `m i` over `i` in `T` with respect to the kernel `κ` and the measure `μ`. This is a result related to the independence of sigma-algebras in probability theory.

If `κ` is a probability kernel, `μ` is a measure, `m` is a Markov kernel assigning sub-measurable spaces to each index `ι`, and the measurable spaces `m i` are independent with respect to `κ` and `μ` for all `ι` in disjoint sets `S` and `T`, then the supremum of `m i` over `i` in `S` is independent of the supremum of `m i` over `i` in `T` with respect to `κ` and `μ`.


theorem Subgroup.normal_subgroupOf_iff :
    ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G},
      H ≤ K → (Subgroup.Normal (Subgroup.subgroupOf H K) ↔ ∀ (h k : G), h ∈ H → k ∈ K → k * h * k⁻¹ ∈ H) :=
  by sorry

The theorem `Subgroup.normal_subgroupOf_iff` states that, for any group `G` and any subgroups `H` and `K` of `G`, if `H` is a subgroup of `K`, then `H` is a normal subgroup of `K` (i.e., `Subgroup.subgroupOf H K` is a normal subgroup) if and only if for all elements `h` in `H` and `k` in `K`, the element `k * h * k⁻¹` (the conjugate of `h` by `k`) is also in `H`. In the language of group theory, this is saying that a subgroup is normal if and only if it is closed under conjugation by elements of the larger group.

A subgroup of a group is normal if and only if it is closed under conjugation by elements of the group.


theorem ContinuousMultilinearMap.le_mul_prod_of_le_opNorm_of_le :
    ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
      [inst_4 : SeminormedAddCommGroup G] [inst_5 : NormedSpace 𝕜 G] {f : ContinuousMultilinearMap 𝕜 E G}
      {m : (i : ι) → E i} {C : ℝ} {b : ι → ℝ},
      ‖f‖ ≤ C → (∀ (i : ι), ‖m i‖ ≤ b i) → ‖f m‖ ≤ C * Finset.prod Finset.univ fun i => b i :=
  by sorry

The theorem `ContinuousMultilinearMap.le_mul_prod_of_le_opNorm_of_le` states that for all types 𝕜, ι, E, and G, with 𝕜 being a nontrivially normed field, E and G being normed spaces over 𝕜, where E is indexed over ι (which is a finite type), and G being a seminormed add commutative group, if we have a continuous multilinear map `f` from E to G, a function `m` mapping every index in ι to E, a real number `C`, and a function `b` mapping every index in ι to a real number, such that the norm of `f` is less than or equal to `C`, and for every index in ι, the norm of `m` at that index is less than or equal to `b` at that index, then the norm of `f` at `m` will be less than or equal to `C` times the product of `b` at every index in the universal finite set of type `Finset ι`. This theorem essentially establishes an upper bound for the norm of a continuous multilinear map applied to a family of vectors.

For a continuous multilinear map from a finite-indexed normed space to a seminormed add commutative group, with input vectors bounded by real numbers, the norm of the map's application to the vectors is bounded by the product of the input bounds and the map's operator norm.


theorem List.rotate'_zero : ∀ {α : Type u} (l : List α), List.rotate' l 0 = l := by sorry

This theorem, `List.rotate'_zero`, states that for any list `l` of elements of an arbitrary type `α`, the `rotate'` operation applied to `l` with a rotation count of 0 results in the original list `l` itself. In other words, if you take any list and "rotate" it zero times (i.e., do nothing), you will end up with the original list.

For any list `l` of type `α`, `rotate' l 0` equals `l`.


/-- The quadratic character is quadratic as a multiplicative character.  -/
theorem quadraticChar_isQuadratic :
    ∀ (F : Type u_1) [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F],
      MulChar.IsQuadratic (quadraticChar F) :=
  by sorry

The theorem `quadraticChar_isQuadratic` states that for any type `F` which has a field structure, finite type structure, and a decidable equality, the quadratic character of `F` is indeed a quadratic multiplicative character. This means that for any element of `F`, the quadratic character of that element will always take the values `0`, `1`, or `-1`.

For any field `F` with a decidable equality, the quadratic character map on `F` is a multiplicative character taking values in {0, 1, -1}.


theorem MeasureTheory.Martingale.condexp_ae_eq :
    ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
      {μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
      [inst_3 : CompleteSpace E] {f : ι → Ω → E} {ℱ : MeasureTheory.Filtration ι m0},
      MeasureTheory.Martingale f ℱ μ →
        ∀ {i j : ι}, i ≤ j → MeasureTheory.condexp (↑ℱ i) μ (f j) =ᶠ[MeasureTheory.Measure.ae μ] f i :=
  by sorry

The theorem `MeasureTheory.Martingale.condexp_ae_eq` states that for any given `Ω`, `E`, and `ι` types, where `Ω` is a measurable space, `E` is a normed add-commutative group and a normed space over reals that is also complete, and `ι` is a preorder, and for any given measure `μ` on `Ω`, filtration `ℱ` and `f` which is a martingale with respect to `ℱ` and `μ`, the following holds: for all `i` and `j` in `ι` such that `i` is less than or equal to `j`, the conditional expectation of `f j` with respect to the `i`-th σ-algebra in the filtration `ℱ` is almost everywhere equal to `f i` under the measure `μ`. The "almost everywhere" here refers to the set of points where the equality holds, has the complement set with measure zero.

For any measure space `(Ω, ℱ, μ)`, normed add-commutative group and normed space `E` over reals that is complete, preorder `ι`, and martingale `f` with respect to filtration `ℱ` and measure `μ`: The conditional expectation of `f j` with respect to the `i`-th σ-algebra is almost everywhere equal to `f i`, where the equality holds for a set with complement having measure zero.


theorem Nat.binaryRec.proof_4 : ∀ {C : ℕ → Sort u_1} (n : ℕ), n = 0 → C n = C 0 := by sorry

This theorem states that for any natural number `n` and any function `C` from natural numbers to some sort `u_1`, if `n` is equal to zero, then the value of `C` at `n` is the same as the value of `C` at zero. In other words, for a given function `C`, the theorem asserts that the function's value at zero remains the same regardless if we input `0` directly or another number `n` that is equivalent to `0`.

For any function `C` from natural numbers to some sort `u_1`, `C(0) = C(n)` whenever `n` is equal to zero.


theorem Set.image_uncurry_prod :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) (s : Set α) (t : Set β),
      Function.uncurry f '' s ×ˢ t = Set.image2 f s t :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and for any function `f` from `α` and `β` to `γ`, and for any sets `s` of type `α` and `t` of type `β`, the image of the uncurried version of function `f` applied to the Cartesian product of sets `s` and `t` is equal to the image of the binary function `f` applied to the sets `s` and `t`. In other words, it asserts the equality of two ways of creating a set of elements in `γ`: one way is by uncurrying the function `f` and then applying it to each pair of elements in the Cartesian product of `s` and `t`, and the other way is by directly applying the binary function `f` to each pair of elements, with the first element from `s` and the second from `t`.

For any functions `f` from `α × β` to `γ`, sets `s` of type `α`, and `t` of type `β`, the image of `f` applied to the Cartesian product `s × t` is equal to the set of values obtained by applying `f` binary to each pair in `s × t`.


ContinuousLinearMap.contMDiff

theorem ContinuousLinearMap.contMDiff :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_8} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ∞}
      (L : E →L[𝕜] F), ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 F) n ⇑L :=
  by sorry

This theorem states that for any nontrivially normed field `𝕜`, given a continuous linear map `L` from a normed vector space `E` over `𝕜` to another normed vector space `F` over `𝕜`, the map `L` is continuously differentiable any number of times (`n` can be any natural number or infinity). The differentiability is checked in the context of the model with corners associated to the vector spaces `E` and `F`, which is the standard way to deal with differentiability in infinite-dimensional spaces.

Given a continuous linear map between two normed vector spaces over a nontrivially normed field, it is infinitely differentiable.


theorem isTop_iff_isMax :
    ∀ {α : Type u} [inst : Preorder α] {a : α} [inst_1 : IsDirected α fun x x_1 => x ≤ x_1], IsTop a ↔ IsMax a := by
  sorry

This theorem states that for any type `α` with a preorder relation and which also has the property that for any two elements `x` and `x_1`, `x` is less than or equal to `x_1`, an element `a` of `α` is a top element if and only if it is a maximal element. In mathematical terms, for a set `α` with a preorder, an element `a` is considered a top element (i.e., all other elements of the set are less than or equal to `a`) if and only if `a` is a maximal element (i.e., there's no other element in the set that's strictly greater than `a`).

A preorder type `α` element `a` is a top element if and only if it is a maximal element.


MeasureTheory.ProgMeasurable.adapted

theorem MeasureTheory.ProgMeasurable.adapted :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : TopologicalSpace β]
      [inst_1 : Preorder ι] {u : ι → Ω → β} {f : MeasureTheory.Filtration ι m} [inst_2 : MeasurableSpace ι],
      MeasureTheory.ProgMeasurable f u → MeasureTheory.Adapted f u :=
  by sorry

The theorem `MeasureTheory.ProgMeasurable.adapted` states that for any types `Ω`, `β`, and `ι`, given a measurable space `Ω`, a topological space `β`, and a preorder `ι`, if `u` is a function from `ι` to a function from `Ω` to `β` and `f` is a filtration on `m`, then if `u` is progressively measurable with respect to `f`, it follows that `u` is adapted to `f`. Here, being progressively measurable means `u` is measurable with respect to the increasing sequence of sigma-algebras defined by `f`, and being adapted to `f` means each function `u i` in the sequence is strongly measurable with respect to `f i`.

Given a measurable space `(Ω, Σ)`, a topological space `(β, τ)`, a preorder `(ι, ⋈)`, a filtration `(f : Filtration Σ ι)`, and a progressively measurable function `u : ι → Ω → β`, then `u` is adapted to `f`.


theorem QPF.Fix.rec_eq :
    ∀ {F : Type u → Type u} [inst : Functor F] [q : QPF F] {α : Type u} (g : F α → α) (x : F (QPF.Fix F)),
      QPF.Fix.rec g (QPF.Fix.mk x) = g (QPF.Fix.rec g <$> x) :=
  by sorry

The theorem `QPF.Fix.rec_eq` states that for any functor `F`, which forms a Quotient of Polynomial Functor (QPF), and any function `g : F α → α`, applying the recursor `QPF.Fix.rec g` to the result of the QPF constructor `QPF.Fix.mk x` on an `x : F (QPF.Fix F)` is the same as applying `g` to the result of transforming `x` with the functor map (`<$>`) of the same recursor `QPF.Fix.rec g`. In other words, the process of constructing and then destructing (recursion) an algebraic data type defined by a QPF commutes with applying the function `g`. This theorem provides the defining property of the recursion primitive for algebraic data types defined by QPFs.

For any QPF functor `F` and function `g : F α → α`, the application of `QPF.Fix.rec g` to `QPF.Fix.mk x` is equal to `g (<$> QPF.Fix.rec g x)`.


theorem NormedSpace.hasFPowerSeriesOnBall_exp_of_radius_pos :
    ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕂] [inst_1 : NormedRing 𝔸]
      [inst_2 : NormedAlgebra 𝕂 𝔸] [inst_3 : CompleteSpace 𝔸],
      0 < FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸) →
        HasFPowerSeriesOnBall (NormedSpace.exp 𝕂) (NormedSpace.expSeries 𝕂 𝔸) 0
          (FormalMultilinearSeries.radius (NormedSpace.expSeries 𝕂 𝔸)) :=
  by sorry

The theorem `NormedSpace.hasFPowerSeriesOnBall_exp_of_radius_pos` states that for any field `𝕂` which is a non-trivially normed field, and any type `𝔸` which is a normed ring over `𝕂`, and a normed algebra over `𝕂`, and is a complete space, if the radius of the exponential series `NormedSpace.expSeries 𝕂 𝔸` is positive, then the exponential function `NormedSpace.exp 𝕂` has an `F` power series on a ball centered at the origin with the same radius as that of the exponential series. Here, an `F` power series refers to a formal power series, and the ball refers to a set of points in `𝔸` within a certain distance from the origin.

For any complete, normed algebra `𝔸` over a non-trivially normed field `𝕂`, if the radius of convergence of the exponential series of `𝔸` is positive, then the exponential function has an `F` power series expansion that converges on the open ball of radius equal to the series's convergence radius.


theorem TopologicalSpace.Compacts.coe_bot : ∀ {α : Type u_1} [inst : TopologicalSpace α], ↑⊥ = ∅ := by sorry

This theorem states that for any type `α` equipped with a topological space structure, the compact subspace represented by the bottom element (denoted by `⊥`) is equal to the empty set. In other words, in the context of topological spaces, the compact subset represented by the least information (i.e., `⊥`) corresponds to having no elements at all (i.e., the empty set).

For any topological space `α`, the compact subspace containing the bottom element `⊥` is the empty set.


theorem Finset.le_card_of_inj_on_range :
    ∀ {α : Type u_1} {s : Finset α} {n : ℕ} (f : ℕ → α),
      (∀ i < n, f i ∈ s) → (∀ i < n, ∀ j < n, f i = f j → i = j) → n ≤ s.card :=
  by sorry

This theorem states that for any finite set `s` of type `α`, a natural number `n`, and a function `f` from natural numbers to `α`, if every number less than `n` is mapped by `f` to an element of `s` and `f` is injective on numbers less than `n` (meaning that if `f` maps two different numbers both less than `n` to the same element of `s`, then those two numbers must actually be the same), then `n` is less than or equal to the cardinality of `s`. In other words, it says that if a function maps a certain number of distinct natural numbers into a set, then the size of that set must be at least as large as that number.

If `f` is a function from natural numbers to a finite set `α` such that the image of every natural number less than `n` is in `s` and `f` is injective on those numbers, then `n ≤ |s|`.


theorem norm_mul_le_of_le :
    ∀ {E : Type u_6} [inst : SeminormedGroup E] {a₁ a₂ : E} {r₁ r₂ : ℝ}, ‖a₁‖ ≤ r₁ → ‖a₂‖ ≤ r₂ → ‖a₁ * a₂‖ ≤ r₁ + r₂ :=
  by sorry

This theorem states that for any seminormed group `E` and any elements `a₁` and `a₂` of `E`, along with any real numbers `r₁` and `r₂`, if the norm of `a₁` is less than or equal to `r₁` and the norm of `a₂` is less than or equal to `r₂`, then the norm of the product `a₁ * a₂` is less than or equal to `r₁ + r₂`. In mathematical terms, if ‖a₁‖ ≤ r₁ and ‖a₂‖ ≤ r₂, then ‖a₁ * a₂‖ ≤ r₁ + r₂.

For any seminormed group and elements `a₁, a₂` with norms less than or equal to `r₁` and `r₂` respectively, the norm of their product is less than or equal to the sum of `r₁` and `r₂`.


theorem dist_pi_lt_iff :
    ∀ {β : Type v} {π : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (π b)]
      {f g : (b : β) → π b} {r : ℝ}, 0 < r → (dist f g < r ↔ ∀ (b : β), dist (f b) (g b) < r) :=
  by sorry

This theorem, `dist_pi_lt_iff`, is stating a property about the distance between two functions `f` and `g` in a pseudo metric space over a finite type `β`. Specifically, for any positive real number `r`, the distance between these two functions `f` and `g` is less than `r` if and only if the distance between the values of `f` and `g` at any element of `β` is less than `r`. Here, `f` and `g` are functions mapping each element of `β` to the metric space `π b`.

For any functions `f` and `g` mapping a finite type `β` to a metric space `π b` and for any positive real number `r`, `∀ x ∈ β, d(f x, g x) < r` if and only if `d(f, g) < r`, where `d(f, g)` denotes the distance between `f` and `g`.


theorem MeasureTheory.Measure.haarMeasure_self :
    ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : TopologicalGroup G]
      [inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] {K₀ : TopologicalSpace.PositiveCompacts G},
      ↑↑(MeasureTheory.Measure.haarMeasure K₀) ↑K₀ = 1 :=
  by sorry

This theorem states that for any given type `G` that is a group, a topological space, a topological group, a measurable space, and a Borel space, and any positive compact `K₀` in this space, the Haar measure of `K₀` is equal to 1. The Haar measure is a special kind of measure that is used in the theory of locally compact topological groups.

For any type `G` that is a locally compact topological group endowed with a Haar measure, the Haar measure of any positive compact subset `K₀` is equal to 1.


theorem Nat.filter_range_nth_eq_insert :
    ∀ {p : ℕ → Prop} [inst : DecidablePred p] {k : ℕ},
      (∀ (hf : Set.Finite (setOf p)), k + 1 < (Set.Finite.toFinset hf).card) →
        Finset.filter p (Finset.range (Nat.nth p (k + 1))) =
          insert (Nat.nth p k) (Finset.filter p (Finset.range (Nat.nth p k))) :=
  by sorry

This theorem states that for any predicate `p` on natural numbers that is decidable, and for any natural number `k`, given that whenever the set of natural numbers satisfying the predicate `p` is finite, the number `k + 1` is strictly less than the size of the corresponding finite set. Then, the set of natural numbers less than the `(k + 1)`-th number that satisfies `p` and also satisfy `p` is equal to the set which is formed by adding the `k`-th number that satisfies `p` to the set of natural numbers less than the `k`-th number that satisfies `p` and also satisfy `p`. In other words, the set of the first `(k + 1)` numbers that satisfy `p` is obtained by adding the `(k + 1)`-th number that satisfies `p` to the set of the first `k` numbers that satisfy `p`.

If `p` is a decidable predicate on natural numbers such that the set of numbers satisfying `p` is finite when it exists, then the first `(k + 1)` numbers in this finite set are those that can be obtained by adding the `(k + 1)`-th number in the set to the first `k` numbers in the set.


/-- If a function `f` is continuous on a convex set `D ⊆ ℝ` and `f''` is strictly negative on the
interior, then `f` is strictly concave on `D`.
Note that we don't require twice differentiability explicitly as it already implied by the second
derivative being strictly negative, except at at most one point.  -/
theorem strictConcaveOn_of_deriv2_neg :
    ∀ {D : Set ℝ},
      Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → (∀ x ∈ interior D, deriv^[2] f x < 0) → StrictConcaveOn ℝ D f :=
  by sorry

This theorem states that if a real-valued function `f` is continuous on a convex subset `D` of the real numbers, and its second derivative is strictly negative on the interior of `D`, then `f` is strictly concave on `D`. The condition of the second derivative being strictly negative is already implying the twice differentiability of `f` at all but possibly one point within `D`.

In other words, the theorem establishes a sufficient condition for a function to be strictly concave, which is the combination of the function being continuous, the domain being convex, and the second derivative being negative on the interior of the domain.

If a real-valued, twice-differentiable function `f` is continuous on a convex subset `D` and has strictly negative second derivatives on the interior of `D`, then `f` is strictly concave on `D`.


theorem Computable₂.partrec₂ :
    ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β]
      [inst_2 : Primcodable σ] {f : α → β → σ}, Computable₂ f → Partrec₂ fun a => ↑(f a) :=
  by sorry

The theorem `Computable₂.partrec₂` states that for any two types `α` and `β`, and result type `σ`, all of which have instances of `Primcodable`, if a function `f` from `α` and `β` to `σ` is computable (as defined by the `Computable₂` definition), then a function that applies `f` to a pair of inputs and lifts the result to an optional value (using the `Partrec₂` definition) is partially recursive. In other words, the computability of a two-argument function implies the partial recursiveness of the corresponding function that maps inputs to optional outputs.

If `f : α × β -> σ` is a computable function between types `α`, `β`, and `σ` with `Primcodable` instances, then the function `x y => some (f x y)` is partially recursive.


theorem EMetric.inseparable_iff :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α}, Inseparable x y ↔ edist x y = 0 := by sorry

The theorem `EMetric.inseparable_iff` states that for any pair of points `x` and `y` in a pseudo-emetric space `α`, the points are inseparable if and only if the extended distance between `x` and `y` is zero. This means, in the context of a pseudo-emetric space, two points are considered inseparable exactly when they have zero distance between them.

In a pseudo-metric space, two points are inseparable if and only if their extended distance is zero.


theorem MulLECancellable.mul_le_mul_iff_left :
    ∀ {α : Type u_1} [inst : LE α] [inst_1 : Mul α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b c : α},
      MulLECancellable a → (a * b ≤ a * c ↔ b ≤ c) :=
  by sorry

The theorem `MulLECancellable.mul_le_mul_iff_left` states that for any type `α` that has a multiplication operation and a less than or equal to operation, and respects covariance under multiplication, given any three elements `a`, `b`, `c` of type `α`, if `a` is `MulLECancellable` (i.e., the function `x ↦ a * x` is order-reflecting), then the inequality `a * b ≤ a * c` is true if and only if `b ≤ c`. In simpler words, if `a` is `MulLECancellable`, then multiplying `a` with `b` or `c` doesn't change the order between `b` and `c`.

For any type `α` with covariant multiplication and order `≤`, if `a` is `MulLECancellable,` then `a * b ≤ a * c` if and only if `b ≤ c.`


/-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector.  -/
theorem Orthonormal.inner_right_finsupp :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {ι : Type u_4} {v : ι → E}, Orthonormal 𝕜 v → ∀ (l : ι →₀ 𝕜) (i : ι), ⟪v i, (Finsupp.total ι E 𝕜 v) l⟫_𝕜 = l i :=
  by sorry

The theorem `Orthonormal.inner_right_finsupp` states that for a given set of orthonormal vectors `v : ι → E` in an inner product space `E` over a field `𝕜`, and for any linear combination `l : ι →₀ 𝕜` of these vectors, the inner product of the vector `v i` (for any `i`) with the evaluated linear combination `(Finsupp.total ι E 𝕜 v) l` equals the coefficient `l i` of `v i` in the linear combination. Essentially, this theorem claims that taking the inner product with an orthonormal vector picks out the corresponding coefficient in the linear combination.

For any orthonormal sequence `v : ι → E` in an inner product space `E` over a field `𝕜` and any linear combination `l : ι →₀ 𝕜` of these vectors, the inner product `〈v i, (Finsupp.total ι E 𝕜 v) l〉 = l i` for all `i`.


theorem CategoryTheory.Limits.IsInitial.isIso_to :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasStrictInitialObjects C]
      {I : C}, CategoryTheory.Limits.IsInitial I → ∀ {A : C} (f : A ⟶ I), CategoryTheory.IsIso f :=
  by sorry

The theorem `CategoryTheory.Limits.IsInitial.isIso_to` states that for any category `C` that has strict initial objects, if `I` is an initial object in `C`, then any morphism `f` from any object `A` in `C` to `I` is an isomorphism. In other words, in a category with strict initial objects, all morphisms to an initial object are isomorphisms.

In a category with strict initial objects, every morphism to the initial object is an isomorphism.


/-- Given `f : β → ℝ≥0∞`, if `f` sends `{i | p i}` to a set of positive numbers
accumulating to zero, then closed `f i`-neighborhoods of the diagonal form a basis of `𝓤 α`.

For specific bases see `uniformity_basis_edist_le` and `uniformity_basis_edist_le'`.  -/
theorem EMetric.mk_uniformity_basis_le :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {β : Type u_2} {p : β → Prop} {f : β → ENNReal},
      (∀ (x : β), p x → 0 < f x) →
        (∀ (ε : ENNReal), 0 < ε → ∃ x, p x ∧ f x ≤ ε) →
          Filter.HasBasis (uniformity α) p fun x => {p | edist p.1 p.2 ≤ f x} :=
  by sorry

This theorem states that, given a function `f : β → ℝ≥0∞` mapping from an arbitrary type `β` to the extended nonnegative real numbers, if `f` maps the set of elements `{i | p i}` to a set of positive numbers that accumulate to zero, then the closed `f i`-neighborhoods of the diagonal constitute a basis for the uniformity `𝓤 α` on a pseudo-emetric space `α`. Here, a `f i`-neighborhood of the diagonal is defined as the set of pairs `p` such that the extended distance `edist` between the elements of `p` is less than or equal to `f i`. The theorem requires two conditions - all elements `x` in `{i | p i}` must map to a positive value through `f`, and for any positive extended nonnegative real number `ε`, there must exist an `x` in `{i | p i}` such that `f x` is less than or equal to `ε`. If these two conditions hold, then the set of `f i`-neighborhoods of the diagonal form a basis for the uniform structure on the pseudo-emetric space.

Given a function `f : β → ℝ≥0∞` and a pseudo-metric space `α`, if `f` maps the subset of `β` where `f(x) > 0` to positive numbers accumulating to zero, then the collection of `f i`-neighborhoods of the diagonal forms a basis for the uniformity on `α`.


theorem AddSubmonoid.eq_top_iff' :
    ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M), S = ⊤ ↔ ∀ (x : M), x ∈ S := by sorry

This theorem states that for any type `M` that has an addition and zero operation (i.e., an "AddZeroClass"), and for any additive submonoid `S` of `M`, `S` is equal to the top element (which represents the whole set in this context) if and only if every element `x` of type `M` is in `S`. In other words, an additive submonoid of `M` is the whole of `M` if and only if every element in `M` is also in the submonoid.

An additive submonoid of a type `M` with addition and zero is equal to the whole `M` if and only if every element of `M` is in the submonoid.


theorem deriv_mul_const_field :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_1} [inst_1 : NormedField 𝕜']
      [inst_2 : NormedAlgebra 𝕜 𝕜'] {u : 𝕜 → 𝕜'} (v : 𝕜'), deriv (fun y => u y * v) x = deriv u x * v :=
  by sorry

The theorem `deriv_mul_const_field` states that for any point `x` in a non-trivially normed field `𝕜`, and a function `u` from `𝕜` to another normed field `𝕜'` with a normed algebra structure over `𝕜`, the derivative at `x` of the function which multiplies `u` by a constant from `𝕜'` is equal to the product of the derivative of `u` at `x` and the constant. In mathematical terms, if we denote the derivative operation as `deriv`, the theorem states that: `deriv (λy . u(y) * v) x = deriv u(x) * v`.

The derivative of the multiplication of a function and a constant, both defined over a non-trivially normed field, is equal to the product of the function's derivative and the constant.


CategoryTheory.CommSq.unop

/-- The commutative square associated to a commutative square in the opposite category.  -/
theorem CategoryTheory.CommSq.unop :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {W X Y Z : Cᵒᵖ} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
      {i : Y ⟶ Z}, CategoryTheory.CommSq f g h i → CategoryTheory.CommSq i.unop h.unop g.unop f.unop :=
  by sorry

This theorem states that, given a commutative square in the opposite category, the corresponding square in the original category also commutes. For any category `C` and objects `W`, `X`, `Y`, `Z` in its opposite category `Cᵒᵖ`, if the morphisms `f`, `g`, `h`, `i` form a commutative square, then the ‘unop’ of these morphisms (which is a way of reversing the arrows from the opposite category back to the original category) also form a commutative square in `C`.

In any category, if the morphisms and their opposites in the corresponding commutative square in the opposite category form a commutative square, then the original morphisms in the category also commute.


theorem Polynomial.trinomial_def :
    ∀ {R : Type u_1} [inst : Semiring R] (k m n : ℕ) (u v w : R),
      Polynomial.trinomial k m n u v w =
        Polynomial.C u * Polynomial.X ^ k + Polynomial.C v * Polynomial.X ^ m + Polynomial.C w * Polynomial.X ^ n :=
  by sorry

The theorem `Polynomial.trinomial_def` states that for any semiring `R`, any natural numbers `k`, `m`, `n`, and any elements `u`, `v`, `w` of `R`, the trinomial polynomial function, `Polynomial.trinomial k m n u v w`, is equivalent to a sum of three terms: the first term is the constant `u` times `X` to the power of `k`, the second term is the constant `v` times `X` to the power of `m`, and the third term is the constant `w` times `X` to the power of `n`. Here, `Polynomial.C` is a ring homomorphism that maps an element of `R` to its corresponding constant polynomial, and `Polynomial.X` is the polynomial variable.

For any semiring `R`, `Polynomial.trinomial k m n u v w` equals the sum of `u * X^k`, `v * X^m`, and `w * X^n`, where `Polynomial.C(u)`, `Polynomial.C(v)`, and `Polynomian.C(w)` are the constant polynomials corresponding to `u`, `v`, and `w`, respectively, and `Polynomial.X` is the polynomial variable.


Associated.prime

theorem Associated.prime :
    ∀ {α : Type u_1} [inst : CommMonoidWithZero α] {p q : α}, Associated p q → Prime p → Prime q := by sorry

This theorem states that for any commutative monoid with zero, if two elements 'p' and 'q' are associated and 'p' is a prime element, then 'q' is also a prime element. Here, an element is said to be prime if it is non-zero, is not a unit, and if it divides a product of two elements, it must divide at least one of them. Two elements are associated if one can be obtained by multiplying the other by a unit element.

If two commutative monoid elements 'p' and 'q' are associated and 'p' is prime, then 'q' is also prime.


theorem Set.union_iUnion :
    ∀ {β : Type u_2} {ι : Sort u_4} [inst : Nonempty ι] (s : Set β) (t : ι → Set β), s ∪ ⋃ i, t i = ⋃ i, s ∪ t i := by
  sorry

This theorem states that for any type `β`, any indexed type `ι`, given that `ι` is nonempty, and any set `s` of type `β` and a function `t` from `ι` to sets of `β`, the union of `s` and the indexed union over all `t i` (for all `i` in `ι`) is equal to the indexed union over the union of `s` and `t i`. In mathematical terms, it's stating that $s \cup (\bigcup_{i} t_i) = \bigcup_{i} (s \cup t_i)$. This is a generalization of the distributive law for unions in set theory.

For any type `β` and nonempty indexed type `ι`, given sets `s` of type `β` and a function `t` from `ι` to sets of `β`, the indexed union of `s` with `t i` for all `i` in `ι` is equal to the union of `s` with the union of all `t i`. That is, $\bigcup\_i (s \cup t\_i) = s \cup (\bigcup\_i t\_i)$.


theorem ProbabilityTheory.kernel.iIndepSets.indepSets :
    ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {s : ι → Set (Set Ω)}
      {_mΩ : MeasurableSpace Ω} {κ : ↥(ProbabilityTheory.kernel α Ω)} {μ : MeasureTheory.Measure α},
      ProbabilityTheory.kernel.iIndepSets s κ μ →
        ∀ {i j : ι}, i ≠ j → ProbabilityTheory.kernel.IndepSets (s i) (s j) κ μ :=
  by sorry

The theorem `ProbabilityTheory.kernel.iIndepSets.indepSets` asserts that for any types `α`, `Ω`, and `ι`, any measurable spaces of types `α` and `Ω`, any function `s` from `ι` to a set of sets of `Ω`, any kernel `κ` from `α` to `Ω`, and any measure `μ` of `α`, if the function `s` is independent with respect to the kernel `κ` and the measure `μ` (as defined by `ProbabilityTheory.kernel.iIndepSets`), then for any distinct indices `i` and `j` of `ι`, the sets `s i` and `s j` are also independent with respect to the kernel `κ` and the measure `μ` (as defined by `ProbabilityTheory.kernel.IndepSets`).

In terms of probability theory, this theorem means that if a collection of sets is mutually independent (each set is independent of any intersection of other sets), then any pair of these sets is also independent. Independence here means that for almost all elements in the underlying space (with respect to the given measure), the value of the kernel for the intersection of the two sets equals the product of the kernel values for each set.

If a collection of sets is mutually independent with respect to a kernel and measure, then any pair of sets in the collection is also independently in the same sense with respect to the same kernel and measure.


theorem Ordinal.typein_one_out : ∀ (x : (Quotient.out 1).α), Ordinal.typein (fun x x_1 => x < x_1) x = 0 := by sorry

The theorem `Ordinal.typein_one_out` states that for every element `x` belonging to the set of equivalence classes represented by the number `1` under the operation `Quotient.out`, the order type of `x` with respect to the strict less than relation (`<`) is `0`. In other words, within the well-order defined by the less-than relation, `x` would be the first element (having an order type of `0`), for any `x` in the equivalence class of `1`.

For every equivalence class represented by the number 1 under Quotient.out in the order type of well-founded relation <, the class's representative has order type 0.


PartialEquiv.rightInvOn

theorem PartialEquiv.rightInvOn :
    ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), Set.RightInvOn (↑(PartialEquiv.symm e)) (↑e) e.target := by
  sorry

The theorem `PartialEquiv.rightInvOn` states that for any partial equivalence `e` from type `α` to type `β`, the inverse function of `e` (obtained via `PartialEquiv.symm e`) is a right inverse to `e` on the target set of `e`. In other words, for all elements in the target set of `e`, if we apply `e` to the result of applying the inverse function of `e`, we get back the original element.

For any partial equivalence relation `e` from type `α` to type `β`, the right inverse of `e` (obtained from `e.symm`) equals `e` on the target set of `e`.


theorem Polynomial.natDegree_X_pow_add_C :
    ∀ {R : Type u} [inst : Nontrivial R] [inst : Semiring R] {n : ℕ} {r : R},
      Polynomial.natDegree (Polynomial.X ^ n + Polynomial.C r) = n :=
  by sorry

The theorem `Polynomial.natDegree_X_pow_add_C` states that for any non-trivial semiring `R`, for any natural number `n` and any element `r` from `R`, the natural degree of the polynomial that is the sum of the polynomial `X` raised to the power `n` and the constant polynomial `r` is equal to `n`. In other words, the degree of a polynomial formed by adding a constant to a monomial is determined solely by the degree of the monomial.

The natural degree of a polynomial equal to `X^n + constant` in a semiring is `n`, where `n` is a natural number and `constant` is an element from the semiring.


Array.ext

theorem Array.ext :
    ∀ {α : Type u_1} (a b : Array α),
      Array.size a = Array.size b →
        (∀ (i : ℕ) (hi₁ : i < Array.size a) (hi₂ : i < Array.size b), a[i] = b[i]) → a = b :=
  by sorry

This theorem, `Array.ext`, states that for all arrays `a` and `b` of some type `α`, if `a` and `b` have the same size and all corresponding elements of `a` and `b` are equal (i.e., for all natural number indices `i` less than the size of `a` and `b`, the `i`-th element of `a` is equal to the `i`-th element of `b`), then `a` and `b` are equal. Essentially, this theorem formalizes the intuitive notion that two arrays are equal if and only if they have the same size and all their corresponding elements are equal.

If two arrays of the same size and type have equal elements at corresponding indices, then they are equal.


theorem YoungDiagram.exists_not_mem_col : ∀ (μ : YoungDiagram) (j : ℕ), ∃ i, (i, j) ∉ μ.cells := by sorry

This theorem states that for any given Young Diagram `μ` and any natural number `j`, there exists a natural number `i` such that the cell `(i, j)` is not a member of the set of cells of `μ`. In other words, no matter what column `j` we choose, we can always find a row `i` where there isn't a cell at the position `(i, j)` in the Young Diagram `μ`.

For any Young Diagram `μ` and natural number `j`, there exists a row index `i` such that `(i, j)` is not in `μ`.


theorem AddSubgroup.coe_map :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (K : AddSubgroup G),
      ↑(AddSubgroup.map f K) = ⇑f '' ↑K :=
  by sorry

The theorem `AddSubgroup.coe_map` asserts that for any given `AddGroup` G and `AddGroup` N, along with an additive homomorphism `f` from G to N and an `AddSubgroup` K of G, the image of the subgroup K under the map f is exactly the same as the image of the elements of K under the map f. In other words, the mapping of the subgroup K under the homomorphism f is equivalent to the set of elements obtained by mapping each element of K under f, represented in set-theoretic notation as `f(K)`.

For any additive homomorphism from an additive group to another group and any additive subgroup of the domain, the image of the subgroup under the homomorphism is equal to the set of images of its elements under the homomorphism.


/-- If a set `s` of semilinear functions is bounded and is closed in the weak-* topology, then its
image under coercion to functions `E → F` is a closed set. We don't have a name for `E →SL[σ] F`
with weak-* topology in `mathlib`, so we use an equivalent condition (see `isClosed_induced_iff'`).

TODO: reformulate this in terms of a type synonym with the right topology.  -/
theorem ContinuousLinearMap.isClosed_image_coe_of_bounded_of_weak_closed :
    ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {F : Type u_6} [inst : NormedAddCommGroup F] [inst_1 : NontriviallyNormedField 𝕜]
      [inst_2 : NontriviallyNormedField 𝕜₂] [inst_3 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} {E' : Type u_11}
      [inst_4 : SeminormedAddCommGroup E'] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : RingHomIsometric σ₁₂]
      {s : Set (E' →SL[σ₁₂] F)},
      Bornology.IsBounded s →
        (∀ (f : E' →SL[σ₁₂] F), ⇑f ∈ closure (DFunLike.coe '' s) → f ∈ s) → IsClosed (DFunLike.coe '' s) :=
  by sorry

This theorem states that given a set `s` of semilinear functions from `E'` to `F` (denoted as `E' →SL[σ₁₂] F`) over two nontrivially normed fields `𝕜` and `𝕜₂` with a ring homomorphism `σ₁₂` between them, if this set is bounded according to some bornology and is closed under the weak-* topology (that is, any limit point of the set under the weak-* topology is already in the set), then the image of `s` under the coercion to functions `E' → F` is a closed set. Here, a set is closed if its complement is open, and the weak-* topology is a particular kind of topology often used in functional analysis. The condition of closure in the weak-* topology is expressed in Lean as "every function `f` whose coerced function is in the closure of the coerced set `s` is itself in `s`".

Given a set of semilinear functions from a nontrivially normed vector space over two fields with a ring homomorphism, if the set is bounded and closed under the weak-* topology, then its image under coercion is a closed set.


theorem MvPolynomial.eval₂Hom_zero_apply :
    ∀ {R : Type u} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₂] (f : R →+* S₂)
      (p : MvPolynomial σ R), (MvPolynomial.eval₂Hom f 0) p = f (MvPolynomial.constantCoeff p) :=
  by sorry

This theorem states that for any commutative semiring `R` and `S₂`, and for any index set `σ`, if `f` is a ring homomorphism from `R` to `S₂` and `p` is a multivariate polynomial with variables indexed by `σ` and coefficients in `R`, then evaluating `p` at `0` using `eval₂Hom` with `f` and `0` as arguments is equal to applying `f` to the constant coefficient of `p`. In other words, the theorem describes a property of the evaluation of a polynomial at zero.

For any commutative semiring `R`, index set `σ`, ring homomorphism `f` from `R` to `S₂`, and multivariate polynomial `p` with coefficients in `R` indexed by `σ`, we have `eval₂Hom f 0 p = f (const_num p)`, where `const_num p` denotes the constant coefficient of `p`.


theorem measurableSet_eq_fun :
    ∀ {α : Type u_3} {m : MeasurableSpace α} {E : Type u_4} [inst : MeasurableSpace E] [inst_1 : AddGroup E]
      [inst_2 : MeasurableSingletonClass E] [inst_3 : MeasurableSub₂ E] {f g : α → E},
      Measurable f → Measurable g → MeasurableSet {x | f x = g x} :=
  by sorry

The theorem `measurableSet_eq_fun` states that for any measurable spaces `α` and `E`, wherein `E` is an additive group and has measurable singleton and subtraction operations, if `f` and `g` are two measurable functions from `α` to `E`, then the set of all points `x` in `α` where `f x` equals `g x` is also a measurable set. In other words, the preimage of any measurable set under the equality function of `f` and `g` is measurable.

If `α` is a measurable space, `E` is a measurable additive group, and `f, g : α → E` are measurable functions, then the set `{x : α | f x = g x}` is measurable.


theorem Units.inv_mul_eq_one : ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, ↑u⁻¹ * a = 1 ↔ ↑u = a := by sorry

This theorem states that for any type `α` that forms a Monoid (a set equipped with an associative binary operation and an identity element) and any element `u` of the multiplicative group of non-zero elements of `α` represented as `αˣ`, and for any `a` belonging to `α`, the product of the inverse of `u` and `a` equals the identity element (1 in this case) if and only if `u` equals `a`. This is a property of units in a Monoid.

For any monoid `α` and its multiplicative group `αˣ`, if `u` is a unit in `α` and `a` is an element of `α` such that `u * a = 1` in `αˣ`, then `u = a`.


theorem Mathlib.Order.Filter.CountableInter._auxLemma.2 :
    ∀ {α : Type u_2} {l : Set (Set α)} {hunion : ∀ (S : Set (Set α)), Set.Countable S → (∀ s ∈ S, s ∈ l) → ⋃₀ S ∈ l}
      {hmono : ∀ t ∈ l, ∀ s ⊆ t, s ∈ l} {s : Set α}, (s ∈ Filter.ofCountableUnion l hunion hmono) = l sᶜ :=
  by sorry

The theorem `Mathlib.Order.Filter.CountableInter._auxLemma.2` states that for any type `α`, any set `l` of sets of `α`, any set `s` of `α`, given that for any countable set `S` of sets of `α` where each element of `S` is in `l`, the union of `S` is in `l`, and for any set `t` in `l`, any set `s` that is a subset of `t` is in `l`, the statement that `s` is in the filter generated by countable unions from `l` is equivalent to the statement that the complement of `s` is in `l`.

For any type `α` and countable set `S` of subsets of `α` in a filter `l`, if every subset of a set in `S` is in `l` and the complement of any set in `l` is also in `l`, then a set is in the filter if and only if its complement is in the filter.


theorem Commute.self_pow : ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), Commute a (a ^ n) := by sorry

This theorem states that for any monoid `M` and any element `a` in `M`, `a` commutes with its own power `a^n`, for any natural number `n`. In other words, in the context of a given monoid, the multiplication of any element with its own power is commutative, i.e., `a * a^n = a^n * a`.

For any monoid `M` and its element `a`, the power `a^n` commutes with `a`, i.e., `a * a^n = a^n * a` for all natural numbers `n`.


theorem FiniteField.X_pow_card_sub_X_natDegree_eq :
    ∀ (K' : Type u_3) [inst : Field K'] {p : ℕ}, 1 < p → Polynomial.natDegree (Polynomial.X ^ p - Polynomial.X) = p :=
  by sorry

This theorem states that for any given type `K'` that forms a field and any natural number `p` greater than 1, the natural degree (which is a non-negative integer representation of the degree) of the polynomial obtained by raising the polynomial variable `X` to the power `p` and then subtracting `X` itself is equal to `p`. This essentially states that the highest power of `X` in the polynomial `X^p - X` is `p`.

For any field `K` and natural number `p > 1`, the degree of the polynomial `X^p - X` over `K` is equal to `p`.


theorem irreducibleComponent_property :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X),
      IsPreirreducible (irreducibleComponent x) ∧
        {x} ⊆ irreducibleComponent x ∧
          ∀ (u : Set X), IsPreirreducible u → irreducibleComponent x ⊆ u → u = irreducibleComponent x :=
  by sorry

The theorem `irreducibleComponent_property` asserts that for every topological space `X` and any point `x` in `X`, the irreducible component containing `x` has three properties. First, it is a pre-irreducible set. In other words, if we take any two open sets `u` and `v` that both have a non-empty intersection with the irreducible component, then the intersection of the irreducible component with the intersection of `u` and `v` is also non-empty. Second, the singleton set containing `x` is a subset of the irreducible component. Finally, the irreducible component is maximal among the pre-irreducible sets containing `x`: if `u` is any pre-irreducible set that contains the irreducible component, then `u` must in fact be equal to the irreducible component.

For every point `x` in a topological space `X`, the irreducible component containing `x` is a maximal pre-irreducible set that contains `x` and is a subset of every pre-irreducible set that contains it.


theorem gcd_zero_left :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α),
      gcd 0 a = normalize a :=
  by sorry

The theorem `gcd_zero_left` states that for any type `α` that has an instance of the `CancelCommMonoidWithZero` and `NormalizedGCDMonoid` structures, for any element `a` of type `α`, the greatest common divisor (gcd) of 0 and `a` is equal to the normalized form of `a`. In other words, in the context of a cancel commutative monoid with zero and normalized GCD monoid structure, the gcd of zero and any element is just the normalized version of the element itself.

In a cancel commutative monoid with zero and normalized GCD monoid structures, the greatest common divisor of 0 and any element is equal to the normalized form of that element.


theorem contMDiffAt_id :
    ∀ {𝕜 : 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] {x : M} {n : ℕ∞},
      ContMDiffAt I I n id x :=
  by sorry

This theorem, `contMDiffAt_id`, states that the identity function is continuously differentiable at any point `x` in a charted space `M` that is modeled on a normed space `E` over a nontrivially normed field `𝕜`, with the model being provided by a model with corners `I`. This holds for all degrees of differentiability `n`, where `n` is a natural number or infinity (`ℕ∞`).

The identity function is continuously differentiable up to order `n` at any point `x` in the charted space `M` modeled on the normed space `E` over the nontrivially normed field `𝕜`, for all natural numbers `n` or infinity.


theorem NNReal.tendsto_pow_atTop_nhds_zero_of_lt_one :
    ∀ {r : NNReal}, r < 1 → Filter.Tendsto (fun n => r ^ n) Filter.atTop (nhds 0) := by sorry

This theorem states that for any nonnegative real number `r` less than one, the sequence `r^n` tends to zero as `n` tends to infinity. In other words, as `n` increases without bound, the values of `r^n` get arbitrarily close to zero. This is a formalization of the mathematical result that a geometric sequence with a common ratio in the open interval `(0, 1)` converges to zero.

For any non-negative real number `r` with `0 < r < 1`, the sequence `[r^n | n : ℕ]` converges to 0 as `n` approaches infinity.


theorem MvPolynomial.aeval_bind₁ :
    ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] (f : τ → S) (g : σ → MvPolynomial τ R) (φ : MvPolynomial σ R),
      (MvPolynomial.aeval f) ((MvPolynomial.bind₁ g) φ) =
        (MvPolynomial.aeval fun i => (MvPolynomial.aeval f) (g i)) φ :=
  by sorry

The theorem `MvPolynomial.aeval_bind₁` establishes a relationship between the evaluation of a multivariate polynomial and variable substitution in multivariate polynomials over an algebra.

More specifically, for any commutative semirings `R` and `S`, where `S` is an algebra over `R`, and for any types `σ` and `τ`, this theorem states that for any function `f: τ → S`, function `g: σ → MvPolynomial τ R`, and multivariate polynomial `φ: MvPolynomial σ R`, the evaluation of the result of substituting each variable in `φ` with the associated polynomial from `g` using the function `f` is equal to the evaluation of `φ` where each variable is substituted by the evaluation of the associated polynomial from `g` using `f`.

In other words, the order of performing variable substitution and evaluation in a multivariate polynomial does not matter. This property can be helpful while manipulating multivariate polynomials in algebraic structures.

For any commutative semirings R and S, where S is an algebra over R, and for any functions f : τ -> S and g : σ -> MvPolynomial τ R, the evaluation of φ[g(x)] using x in σ, where φ is a multivariate polynomial in MvPolynomial σ R, is equal to the evaluation of φ evaluated at x, where each x in σ is substituted by g(x).


MeasureTheory.IntegrableAtFilter.neg

theorem MeasureTheory.IntegrableAtFilter.neg :
    ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
      {μ : MeasureTheory.Measure α} {l : Filter α} {f : α → E},
      MeasureTheory.IntegrableAtFilter f l μ → MeasureTheory.IntegrableAtFilter (-f) l μ :=
  by sorry

The theorem `MeasureTheory.IntegrableAtFilter.neg` states that for any measurable space `α`, normed additive commutative group `E`, measure `μ` on `α`, filter `l` on `α`, and function `f` from `α` to `E`, if `f` is integrable at the filter `l`, then the negation of `f`, denoted by `-f`, is also integrable at the same filter `l`. Essentially, it implies that the integrability property at a particular filter is preserved under the operation of function negation.

If a measurable function $f : \alpha \to E$ is integrable at the filter $l$ on the measurable space $(\alpha, \Sigma, \mu)$, then the negation of $f$, $-f$, is also integrable at the filter $l$.


theorem CategoryTheory.Subgroupoid.id_mem_of_nonempty_isotropy :
    ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C),
      ∀ c ∈ CategoryTheory.Subgroupoid.objs S, CategoryTheory.CategoryStruct.id c ∈ S.arrows c c :=
  by sorry

This theorem states that for any given type `C` that forms a groupoid (as indicated by the presence of an instance of `CategoryTheory.Groupoid C`), and any subgroupoid `S` of this groupoid, if an object `c` is part of the set of vertices of the subgroupoid `S` on which `S` has non-trivial isotropy (meaning that there exists at least one morphism in `S` that starts and ends at `c`), then the identity morphism on `c` (which is a morphism from `c` to itself) is also in this set of morphisms in `S` that start and end at `c`.

In mathematical terms, it says that if a vertex has non-trivial isotropy in a subgroupoid (i.e., there is at least one morphism in the subgroupoid that loops back to the vertex), then the identity morphism on that vertex belongs to the set of morphisms of the subgroupoid from the vertex to itself.

If a vertex `c` in a groupoid `C` has non-trivial isotropy in a subgroupoid `S`, then the identity morphism on `c` is in `S`.


theorem IsLocalization.map_eq :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {g : R →+* P}
      {T : Submonoid P} {Q : Type u_4} [inst_5 : CommSemiring Q] (hy : M ≤ Submonoid.comap g T) [inst_6 : Algebra P Q]
      [inst_7 : IsLocalization T Q] (x : R),
      (IsLocalization.map Q g hy) ((algebraMap R S) x) = (algebraMap P Q) (g x) :=
  by sorry

The theorem `IsLocalization.map_eq` states that for any commutative semiring `R`, a submonoid `M` of `R`, a commutative semiring `S` such that `S` is a localization of `R` at `M`, a monoid homomorphism `g` from `R` to a commutative semiring `P`, a submonoid `T` of `P`, and a commutative semiring `Q` such that `Q` is a localization of `P` at `T`, if `M` is a subset of the preimage of `T` under `g`, then for any element `x` of `R`, the result of first applying the algebra map from `R` to `S` to `x`, then applying the map from `S` to `Q` induced by `g`, is the same as the result of first applying `g` to `x`, then applying the algebra map from `P` to `Q`.

In mathematical terms, this theorem states that the following diagram commutes:
```
R --(algebraMap R S)--> S --(IsLocalization.map Q g hy)--> Q
 |                                                  |
 |                                                  |
 V                                                  V
P --(algebraMap P Q)--> Q
```
where the vertical arrows are the map `g` and the horizontal arrows are the algebra maps.

For commutative semirings R, S (a localization of R at a submonoid M), P, and Q (a localization of P at a submonoid T), and a monoid homomorphism g from R to P with M a subset of g^-1(T), the diagram commutes, i.e., algebraMap R S (x) = IsLocalization.map Q g (algebraMap P Q (g x)) for all x in R.


theorem Set.IccExtend_of_right_le :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α} (f : ↑(Set.Icc a b) → β),
      b ≤ x → Set.IccExtend h f x = f { val := b, property := ⋯ } :=
  by sorry

This theorem states that for any types `α` and `β` with `α` having a linear order, given two values `a` and `b` in `α` such that `a` is less than or equal to `b`, a function `f` from the closed interval `[a, b]` to `β`, and a value `x` in `α`, if `b` is less than or equal to `x`, then the extension of the function `f` to the entire set `α`, when evaluated at `x`, equals the evaluation of `f` at `b`. This implies that the extension of the function `f` is constant for all `x` greater than `b`.

For any function `f` from a linearly ordered type `α` to a type `β`, and any `a ≤ b` in `α` with `x ≥ b`, the extension of `f` to `α` evaluates `f x = f b`.


theorem List.map_join :
    ∀ {α : Type u} {β : Type v} (f : α → β) (L : List (List α)),
      List.map f (List.join L) = List.join (List.map (List.map f) L) :=
  by sorry

The theorem `List.map_join` states that for any type α and β, and any function `f` from α to β, if `L` is a list of lists of type α, then mapping `f` over the joined list `L` is the same as first mapping `f` over each individual list in `L`, and then joining the resulting lists. In essence, this theorem captures the property that the order of joining the lists and applying the function does not matter - the result will be the same. This is a property of the `map` and `join` functions in functional programming, similar to the distributive law in algebra.

For any type α and β, and any function f from α to β, the mapping of f over the joined list of lists L of type α is equal to the joined lists of the mappings of f over each individual list in L.


/-- If `M / S / R` is a scalar tower, and `M / R` is Noetherian, then `M / S` is
also noetherian.  -/
theorem isNoetherian_of_tower :
    ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
      [inst_3 : SMul R S] [inst_4 : Module S M] [inst_5 : Module R M] [inst_6 : IsScalarTower R S M],
      IsNoetherian R M → IsNoetherian S M :=
  by sorry

This theorem states that if we have a scalar tower `M / S / R`, where `M`, `S`, and `R` are types, and if `M / R` is Noetherian (a property of rings and modules that loosely means they cannot be broken down into infinitely many smaller non-trivial submodules), then `M / S` is also Noetherian. This holds under the conditions that `R` is a semiring, `S` is a semiring, `M` is an additive commutative monoid, `R` can be multiplied by `S`, `M` is a module over `S`, `M` is a module over `R`, and `R`, `S`, and `M` form a scalar tower.

If `M / S` is a scalar tower over semirings `R`, `S`, where `M` is an additive commutative monoid that is a module over both `R` and `S`, and `M / R` is Noetherian, then `M / S` is also Noetherian.


theorem IsUpperSet.add_right :
    ∀ {α : Type u_1} [inst : OrderedAddCommGroup α] {s t : Set α}, IsUpperSet s → IsUpperSet (s + t) := by sorry

This theorem states that for any ordered additive commutative group `α` and any two sets `s` and `t` of `α`, if `s` is an upper set (that is, every element of `s` is less than or equal to every other element of `s`), then the set `s + t` (which consists of the sums of all possible pairs of elements, one from `s` and the other from `t`) is also an upper set.

If `s` is an upper set in an ordered additive commutative group `α`, then `s + t` is an upper set for any set `t` in `α`.


theorem Polynomial.degree_X_pow_add_C :
    ∀ {R : Type u} [inst : Nontrivial R] [inst : Semiring R] {n : ℕ},
      0 < n → ∀ (a : R), Polynomial.degree (Polynomial.X ^ n + Polynomial.C a) = ↑n :=
  by sorry

The theorem `Polynomial.degree_X_pow_add_C` states that for any non-trivial semiring `R` and any positive integer `n`, the degree of the polynomial that results from adding a constant `a` (from `R`) to the `n`th power of the polynomial variable `X` is `n`. In other words, if we have a polynomial formed by adding a constant to `X` raised to a positive power, the degree of that polynomial will be equal to the power to which `X` was raised, irrespective of the constant added. This is expressed mathematically as $\text{degree}(X^n + a) = n$ for $n > 0$ and $a \in R$.

The degree of a polynomial of the form `X^n + a`, where `X` is a polynomial variable, `n` is a positive integer, and `a` is a constant from a non-trivial semiring, is equal to `n`.


theorem PrimeSpectrum.isClosed_zeroLocus :
    ∀ {R : Type u} [inst : CommSemiring R] (s : Set R), IsClosed (PrimeSpectrum.zeroLocus s) := by sorry

This theorem states that for any set `s` of elements from a commutative semiring `R`, the zero locus of `s` in the prime spectrum of `R` is a closed set. Here, the zero locus of a set in the prime spectrum is the set of all prime ideals in which all elements of the set become zero when mapped under the ring homomorphism. The notion of "closed" is in the sense of the Zariski topology, a topology commonly used in algebraic geometry.

The zero locus of any set in the prime spectrum of a commutative semiring is a closed set under the Zariski topology.


theorem Polynomial.hasseDeriv_monomial :
    ∀ {R : Type u_1} [inst : Semiring R] (k n : ℕ) (r : R),
      (Polynomial.hasseDeriv k) ((Polynomial.monomial n) r) = (Polynomial.monomial (n - k)) (↑(Nat.choose n k) * r) :=
  by sorry

This theorem states that for any semiring `R`, and any natural numbers `k` and `n`, and any element `r` of `R`, the `k`th Hasse derivative of the polynomial `a * X^n`, where `a` is `r`, is equal to the polynomial `b * X^(n-k)`, where `b` is the product of `r` and the binomial coefficient "n choose k". The Hasse derivative of a polynomial is a polynomial where the coefficient of `X^i` in the original polynomial is multiplied by the binomial coefficient "i choose k" and the power of `X` is reduced by `k`. The binomial coefficient "n choose k" is the number of ways to choose `k` elements from a set of `n` elements.

For any semiring `R`, natural numbers `k` and `n`, and element `r` of `R`, the `k`th Hasse derivative of `r * X^n` is equal to `(r * binomialCoef n k) * X^(n-k)`.


/-- Given a pushout square assembled from a pushout square on the left and
a commuting square on the right, the right square is a pushout square.  -/
theorem CategoryTheory.IsPushout.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.IsPushout (CategoryTheory.CategoryStruct.comp h₁₁ h₁₂) v₁₁ v₁₃
          (CategoryTheory.CategoryStruct.comp h₂₁ h₂₂) →
        CategoryTheory.CategoryStruct.comp h₁₂ v₁₃ = CategoryTheory.CategoryStruct.comp v₁₂ h₂₂ →
          CategoryTheory.IsPushout h₁₁ v₁₁ v₁₂ h₂₁ → CategoryTheory.IsPushout h₁₂ v₁₂ v₁₃ h₂₂ :=
  by sorry

In a category `C` with objects `X₁₁`, `X₁₂`, `X₁₃`, `X₂₁`, `X₂₂`, and `X₂₃`, and morphisms `h₁₁`, `h₁₂`, `h₂₁`, `h₂₂`, `v₁₁`, `v₁₂`, and `v₁₃`, the theorem `CategoryTheory.IsPushout.of_right` states that if we have a pushout square composed of a left pushout square and a right commuting square, then the right square is also a pushout square. This is under the condition that the composite of `h₁₂` and `v₁₃` is equal to the composite of `v₁₂` and `h₂₂`, and `h₁₁`, `v₁₁`, `v₁₂`, and `h₂₁` form a pushout square. In other words, given a commutative cube where the front and back faces are pushouts, if the left face and the top, bottom and right faces commute, then the right face is also a pushout.

Given a commutative cube in a category with front and back faces being pushout squares, if the left face and the top, bottom, and right faces commute, then the right face is also a pushout square.


theorem TrivSqZeroExt.continuous_snd :
    ∀ {R : Type u_3} {M : Type u_4} [inst : TopologicalSpace R] [inst_1 : TopologicalSpace M],
      Continuous TrivSqZeroExt.snd :=
  by sorry

The theorem `TrivSqZeroExt.continuous_snd` states that for any two types `R` and `M` - where `R` and `M` have topological space structures - the canonical projection `TrivSqZeroExt.snd`, which maps an element of `TrivSqZeroExt R M` to `M`, is a continuous function. In mathematical terms, this function preserves the topological structure of the space `TrivSqZeroExt R M` when mapping to `M`.

The canonical projection `TrivSqZeroExt.snd` from `TrivSqZeroExt R M` to `M` is a continuous function between the topological spaces `TrivSqZeroExt R M` and `M`.


Set.Countable.biUnion

/-- **Alias** of the reverse direction of `Set.Countable.biUnion_iff`. -/
theorem Set.Countable.biUnion :
    ∀ {α : Type u} {β : Type v} {s : Set α} {t : (a : α) → a ∈ s → Set β},
      Set.Countable s → (∀ (a : α) (ha : a ∈ s), Set.Countable (t a ha)) → Set.Countable (⋃ a, ⋃ (h : a ∈ s), t a h) :=
  by sorry

The theorem `Set.Countable.biUnion` states that for any two types `α` and `β`, and any set `s` of type `α`, if `s` is countable, and for any element `a` of `s`, the set `t a ha` (where `t` is a function that takes an element of `s` and a proof that it belongs to `s` to a set of type `β`, and `ha` is a proof that `a` belongs to `s`) is countable, then the union of all such sets `t a ha` for each `a` in `s` is also countable. In mathematical terms, this is stating that a countable union of countable sets is countable.

If `α` and `β` are types, `s` is a countable set of type `α`, and for each `a` in `s`, the set `t a ha` (where `t : α → Set β` and `ha : a ∈ s`) is countable, then the union of all `t a ha` is countable (i.e., countable union of countable sets is countable).


theorem Filter.mem_iInf_of_iInter :
    ∀ {α : Type u} {ι : Type u_2} {s : ι → Filter α} {U : Set α} {I : Set ι},
      Set.Finite I → ∀ {V : ↑I → Set α}, (∀ (i : ↑I), V i ∈ s ↑i) → ⋂ i, V i ⊆ U → U ∈ ⨅ i, s i :=
  by sorry

The theorem `Filter.mem_iInf_of_iInter` states that for any two types `α` and `ι`, a function from `ι` to `Filter α`, a set `U` of type `α`, and a finite set `I` of type `ι`, if for each element `i` in `I`, the set `V i` is an element of the filter corresponding to `i`, and the intersection of all the sets `V i` is a subset of `U`, then `U` is an element of the infimum of the filters corresponding to each `i` in `I`. In simpler words, if every set in a collection is in the corresponding filter, and their intersection is contained in a set, then that set is in the intersection of the filters.

If for each `i` in a finite set `I`, `V i` is an element of the filter `F i` on `α`, and `∩_{i ∈ I} V i ⊆ U`, then `U` is an element of `∏_{i ∈ I} F i`. (Here, `∏_{i ∈ I} F i` denotes the infimum or meet of the filters `F i`.)


theorem Fintype.card_pi :
    ∀ {α : Type u_1} {β : α → Type u_4} [inst : DecidableEq α] [inst_1 : Fintype α] [inst_2 : (a : α) → Fintype (β a)],
      Fintype.card ((a : α) → β a) = Finset.prod Finset.univ fun a => Fintype.card (β a) :=
  by sorry

The theorem `Fintype.card_pi` states that for any type `α` with decidable equality and is a finite type, and a function `β : α → Type u_4` where each `β a` is also a finite type, the cardinality of the function type `(a : α) → β a` (i.e., the number of all possible functions from `α` to `β a` for every `a` in `α`) is equal to the product of the cardinalities of `β a` for all `a` in the universal finite set of type `α`. In other words, the number of all possible functions from `α` to `β a` is the product of the number of elements in each `β a` over all `a` in `α`.

For a finite type `α` with decidable equality and a function `β : α → Type u_4` where each `β a` is finite, the number of functions from `α` to `β` is the product of the cardinalities of `β a` for all `a` in `α`.


theorem List.reduceOption_cons_of_some :
    ∀ {α : Type u_1} (x : α) (l : List (Option α)), List.reduceOption (some x :: l) = x :: List.reduceOption l := by
  sorry

The theorem `List.reduceOption_cons_of_some` states that for any type `α`, any element `x` of type `α` and any list `l` of optional `α`, when the `reduceOption` function is applied to a list that starts with `some x` and followed by `l`, it results in a list that starts with `x` and followed by the list obtained by applying the `reduceOption` function to `l`. Essentially, it says that the `reduceOption` function removes the `some` wrapper from the head of the list and operates independently on the rest of the list.

For any type `α` and any `x : α` and optional list `ls : option list α`, `List.reduceOption x (some x :: ls) = x :: List.reduceOption ls`.


theorem SimpleGraph.ConnectedComponent.ind₂ :
    ∀ {V : Type u} {G : SimpleGraph V} {β : SimpleGraph.ConnectedComponent G → SimpleGraph.ConnectedComponent G → Prop},
      (∀ (v w : V), β (SimpleGraph.connectedComponentMk G v) (SimpleGraph.connectedComponentMk G w)) →
        ∀ (c d : SimpleGraph.ConnectedComponent G), β c d :=
  by sorry

The theorem `SimpleGraph.ConnectedComponent.ind₂` states that for any type `V` and any simple graph `G` on `V`, if for a property `β`, which is a relation between connected components of `G`, we have that this property holds for all pairs of vertices `v` and `w` in `V` when considered as their respective connected components via `SimpleGraph.connectedComponentMk`, then this property `β` also holds for any two arbitrary connected components `c` and `d` of `G`. In other words, if a property holds for all pairs of vertices considered as connected components, then it holds for all pairs of connected components.

If a property holds between connected components of a simple graph, given that it holds between any pair of vertices in their respective connected components, then the property holds between any two connected components.


theorem Projectivization.mk_eq_mk_iff :
    ∀ (K : Type u_1) {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (v w : V)
      (hv : v ≠ 0) (hw : w ≠ 0), Projectivization.mk K v hv = Projectivization.mk K w hw ↔ ∃ a, a • w = v :=
  by sorry

This theorem states that for any division ring `K` and additive commutative group `V` that is also a `K`-module, and any two non-zero vectors `v` and `w` in `V`, the projective coordinates of `v` and `w` (constructed using `Projectivization.mk`) are equal if and only if there exists a scalar `a` from the ring `K` such that `v` is a scalar multiple of `w`, that is `v` equals `a` scaled by `w`, denoted as `a • w = v` in mathematical notation. This theorem essentially captures the idea of equivalence in projective coordinates, where two non-zero vectors are considered equivalent if they are scalar multiples of each other.

For any division ring `K`, additive commutative group `V` being a `K`-module, and non-zero vectors `v` and `w` in `V`, the projective coordinates of `v` and `w` are equal if and only if there exists `a` in `K` such that `v = a • w`.


theorem AddSubgroup.map_equiv_eq_comap_symm :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G ≃+ N) (K : AddSubgroup G),
      AddSubgroup.map (↑f) K = AddSubgroup.comap (↑(AddEquiv.symm f)) K :=
  by sorry

This theorem states that for any additive group isomorphism `f` from `G` to `N` and any additive subgroup `K` of `G`, the image of `K` under the isomorphism `f` is the same as the preimage of `K` under the inverse of the isomorphism `f`. This holds for any types `G` and `N` which have `AddGroup` instances. In other words, it establishes a correspondence between the subgroup `K` of the original group and the mapped group under the isomorphism and its inverse.

For any additive group isomorphism `f` and subgroup `K` of a group `G` with `AddGroup` instances, `f(K) = {f(x) | x ∈ K} = {y | ∃x. y = f(x) ∧ x ∈ K} = f⁻¹⁻¹(K)`.


/-- For any function `f` from a normed vector space to a Banach space, the set of points `x` such
that `f` is analytic at `x` is open.  -/
theorem isOpen_analyticAt :
    ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [inst_5 : CompleteSpace F]
      (f : E → F), IsOpen {x | AnalyticAt 𝕜 f x} :=
  by sorry

This theorem states that, for any function `f` from a normed vector space to a Banach space, the set of points `x` at which `f` is analytic is an open set in the topological space. Here, a function `f` is considered analytic at a point `x` if it can be represented by a convergent power series around `x`. The underlying field for the spaces is denoted by 𝕜, which is assumed to be a Nontrivially normed field. This theorem hence establishes the topological property of the set of all points where a function is analytic.

The set of points in a normed vector space where a function from the space to a Banach space is analytic is an open set.


theorem Finset.mem_diag :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α × α}, x ∈ Finset.diag s ↔ x.1 ∈ s ∧ x.1 = x.2 := by
  sorry

This theorem states that for any type `α` with a decidable equality and any finite set `s` of type `α`, a pair `x` (of type `α × α`) is a member of the diagonal of `s` if and only if the first element of `x` is a member of `s` and the first and second elements of `x` are equal. In other words, the diagonal of a finite set `s` contains precisely those pairs whose elements are both in `s` and are equal.

For any finite set `s` of type `α` with decidable equality, the diagonal of `s` equals the set of pairs `(x, x)` where `x` is in `s`.


theorem Isometry.preimage_sphere :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
      Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.sphere (f x) r = Metric.sphere x r :=
  by sorry

This theorem states that for any types `α` and `β` which have a pseudo-metric space structure, any function `f` from `α` to `β`, if `f` is an isometry (meaning it preserves the distance between any two elements in `α`), then the preimage of the sphere centered at `f(x)` with radius `r` under `f` is equal to the sphere centered at `x` with radius `r` in `α`. In other words, the isometrically transformed points from the sphere in the domain space `α` form a sphere with the same radius in the codomain space `β`.

For any isometric function `f` between pseudo-metric spaces `(α, dα)` and `(β, dβ)`, the preimage of the sphere `{y ∈ β : dβ(y, f(x)) = r}` centered at `f(x)` with radius `r` is equal to the sphere `{x ∈ α : dα(x, x') = r}`, where `x'` is any point in `α` with `dα(x, x') = r`.


theorem Real.deriv_mul_log : ∀ {x : ℝ}, x ≠ 0 → deriv (fun x => x * Real.log x) x = Real.log x + 1 := by sorry

The theorem, `Real.deriv_mul_log`, states that for all real numbers `x`, given that `x` is not equal to zero, the derivative of the function `x * log(x)` at point `x` is equal to `log(x) + 1`. In essence, it's showing a formula for the derivative of the function which multiplies a real number `x` by its logarithm, under the condition that `x` is nonzero.

For any nonzero real number `x`, the derivative of the function `x => x * log x` is equal to `log x + 1`.


/-- A variant of `of_isLimit` that is more useful with `apply`.  -/
theorem CategoryTheory.IsPullback.of_isLimit' :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z}
      {g : Y ⟶ Z} (w : CategoryTheory.CommSq fst snd f g),
      CategoryTheory.Limits.IsLimit (CategoryTheory.CommSq.cone w) → CategoryTheory.IsPullback fst snd f g :=
  by sorry

The theorem `CategoryTheory.IsPullback.of_isLimit'` states that for any category `C`, and objects `P`, `X`, `Y`, `Z` in `C`, with morphisms `fst : P ⟶ X`, `snd : P ⟶ Y`, `f : X ⟶ Z`, `g : Y ⟶ Z` that form a commutative square `w` (i.e., a diagram where both paths from `P` to `Z` via `X` or `Y` are the same), if the cone formed by this commutative square is a limit, then we can say that the pullback of `f` and `g` along `fst` and `snd` exists. In categorical terms, this theorem provides a condition under which a pullback can be formed.

If in a commutative square in a category with a limit cone, the cone is a limit, then the pullback of the two morphisms forming the square exists.


theorem ConjClasses.forall_isConj :
    ∀ {α : Type u} [inst : Monoid α] {p : ConjClasses α → Prop},
      (∀ (a : ConjClasses α), p a) ↔ ∀ (a : α), p (ConjClasses.mk a) :=
  by sorry

The theorem `ConjClasses.forall_isConj` expresses an equivalence between two predicates in the context of the conjugacy classes of a group. It states that for any type `α` equipped with a monoid structure, a property `p` holding for every conjugacy class of `α` is equivalent to the property `p` holding for every element of `α` when considered as a member of its conjugacy class through the canonical quotient map `ConjClasses.mk`. In other words, we can test a property over all conjugacy classes by testing it simply over all elements of the group.

For any monoid `α` and property `p`, `p` holds for all conjugacy classes of `α` if and only if it holds for all elements of `α` viewed as representatives of their conjugacy classes.


theorem Prod.swap_leftInverse : ∀ {α : Type u_1} {β : Type u_2}, Function.LeftInverse Prod.swap Prod.swap := by sorry

The theorem `Prod.swap_leftInverse` states that for any two types `α` and `β`, the `Prod.swap` operation (which swaps the elements in a pair) is its own left inverse. This means that performing `Prod.swap` twice on any pair will return the original pair. In formal terms, given any pair `(a, b)` of elements from `α` and `β` respectively, applying `Prod.swap` twice results in `(a, b)`. This can be expressed concisely as `Prod.swap ∘ Prod.swap = id` where `id` is the identity function.

For all types `α` and `β`, the `Prod.swap` operation on pairs of elements from `α` and `β` is idempotent, i.e., `Prod.swap ∘ Prod.swap = id`.


theorem AddSubgroup.range_mem_leftTransversals :
    ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {f : G ⧸ H → G},
      (∀ (q : G ⧸ H), ↑(f q) = q) → Set.range f ∈ AddSubgroup.leftTransversals ↑H :=
  by sorry

This theorem states that for any type `G` which forms an additive group (`AddGroup G`), for any subgroup `H` of `G`, and for any function `f` mapping from the quotient group `G ⧸ H` to `G`, if for all elements `q : G ⧸ H`, `f(q)` equals `q` when lifted to `G` (i.e., `↑(f q) = q`), then the range of `f` is a left transversal of subgroup `H`. In other words, the range of `f` complements `H` on the left side in the group `G`, which means that every element in `G` can be written uniquely as an element from the range of `f` plus an element of `H`.

For any additive group `G`, subgroup `H`, and function `f` from the quotient `G / H` to `G` such that `↑(f (q + H)) = q + H` for all `q : G / H`, the range of `f` is a left transversal of `H` in `G`.


theorem eq_max :
    ∀ {α : Type u} [inst : LinearOrder α] {a b c : α},
      a ≤ c → b ≤ c → (∀ {d : α}, a ≤ d → b ≤ d → c ≤ d) → c = max a b :=
  by sorry

This theorem states that for any linearly ordered type `α`, and for any three elements `a`, `b`, `c` of this type, if `a` and `b` are both less than or equal to `c`, and `c` is less than or equal to any `d` such that `a` and `b` are both less than or equal to `d`, then `c` is equal to the maximum of `a` and `b`. In simple terms, it asserts that `c` is the maximum of `a` and `b` if `c` is greater than or equal to both of them and there is no other element greater than `c` to which both `a` and `b` are less than or equal to.

If `α` is linearly ordered and `a`, `b`, `c` are in `α` such that `a` and `b` are less than or equal to `c`, and for all `d` in `α` with `a` and `b` less than or equal to `d`, we have `c` = max {`a`, `b`}, then `c` is the maximum of `a` and `b`.


/-- Properties of division with remainder for a / b.   -/
theorem PNat.XgcdType.rq_eq : ∀ (u : PNat.XgcdType), PNat.XgcdType.r u + (u.bp + 1) * PNat.XgcdType.q u = u.ap + 1 := by
  sorry

This theorem states that for all positive natural numbers u represented by the type `PNat.XgcdType`, the sum of the remainder (`r = a % b`) and the product of `u.bp + 1` and the quotient (`q = ap / bp`) equals `u.ap + 1`. This essentially captures the properties of Euclidean division, where the dividend is equal to the divisor times the quotient plus the remainder.

For all positive natural numbers u represented by `PNat.XgcdType`, the theorem asserts that `u.ap + 1 = u.bp * q + r`, where `q` is the quotient, `r` is the remainder, and `a = u.ap * b` and `b = u.bp`.


theorem Finset.ssubset_insert :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α}, a ∉ s → s ⊂ insert a s := by sorry

This theorem, `Finset.ssubset_insert`, states that for any type `α` with decidable equality, given a finite set `s` of type `α` and an element `a` of type `α`, if `a` is not in `s`, then `s` is a proper subset of the set obtained by inserting `a` into `s`. In other words, adding a new, previously not present element to a finite set results in a larger set that properly contains the original one.

For any finite type `α` with decidable equality, if `a` is not in `finset α s`, then `finset.insert a s` is a strictly larger set than `s`.


IsRightRegular.pow

/-- Any power of a right-regular element is right-regular.  -/
theorem IsRightRegular.pow :
    ∀ {R : Type u_1} {a : R} [inst : Monoid R] (n : ℕ), IsRightRegular a → IsRightRegular (a ^ n) := by sorry

This theorem states that for any type `R` that forms a monoid under multiplication, if an element `a` of `R` is right-regular, then any power of `a` is also right-regular. In other words, if multiplication on the right by `a` is injective (it maps distinct inputs to distinct outputs), then multiplication on the right by `a` raised to any natural number power is also injective.

If `R` is a monoid and `a` in `R` is right-regular, then for all natural numbers `n`, `a` right-multiplied by `a` `n` times is injective.


theorem ModularForm.is_invariant_const :
    ∀ (A : Matrix.SpecialLinearGroup (Fin 2) ℤ) (x : ℂ),
      SlashAction.map ℂ 0 A (Function.const UpperHalfPlane x) = Function.const UpperHalfPlane x :=
  by sorry

The theorem `ModularForm.is_invariant_const` states that for any 2x2 matrix `A` with integer entries from the Special Linear Group (i.e., matrices with determinant equals to 1) and for any complex number `x`, the application of the action `SlashAction.map` with `ℂ` and 0 as arguments on the constant function with value `x` over the Upper Half Plane, equals to the constant function itself. In other words, the `SlashAction.map` action leaves the constant function invariant, irrespective of the matrix and the complex number chosen.

For any 2x2 integer matrix A from the Special Linear Group and complex number x, the SlashAction.map operation with ℂ and 0 as arguments applied to the constant function equal to x over the Upper Half Plane results in the same constant function.


theorem le_iff_forall_pos_lt_add :
    ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LinearOrder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α},
      a ≤ b ↔ ∀ (ε : α), 0 < ε → a < b + ε :=
  by sorry

This theorem states that for any type `α` which has an additive group structure and a linear order, and which satisfies the covariant class condition (i.e., for all `x` and `x_1`, `x + x_1` implies `x ≤ x_1`), a given element `a` is less than or equal to another element `b` if and only if for any positive `ε`, `a` is less than the sum of `b` and `ε`. This theorem essentially characterizes the "less than or equal to" relation in terms of the ability to add a small positive quantity to the larger element to exceed the smaller one.

For any additive group `α` with a linear order and covariant class condition, `a ≤ b` if and only if for any positive `ε`, `a + ε ≤ b`.


theorem MeasureTheory.Measure.restrict_biUnion_congr :
    ∀ {α : Type u_2} {ι : Type u_6} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set ι}
      {t : ι → Set α},
      Set.Countable s →
        (μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔ ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i)) :=
  by sorry

This theorem, `MeasureTheory.Measure.restrict_biUnion_congr`, states that for any given type `α` and `ι`, a measurable space `m0` of type `α`, two measures `μ` and `ν` on this measurable space, a countable set `s` of type `ι`, and a function `t` from `ι` to a set of type `α`, the restriction of measures `μ` and `ν` to the union of sets `t i` for each `i` in set `s` are equal if and only if the restriction of measures `μ` and `ν` to each set `t i` for all `i` in set `s` are equal.

In other words, it says that the equality of measure restriction over the union of a countable collection of sets is equivalent to the pointwise equality of measure restriction over each set in that collection.

For any measurable spaces `(α, ι, m0)`, measures `μ` and `ν` on `m0`, a countable set `s ι`, and a function `t : ι → α`, the measures `μ` and `ν` restricted to the union of sets `{t i | i ∈ s}` are equal if and only if they are equal on each set `{t i}` for all `i ∈ s`.


theorem Real.rpow_le_one : ∀ {x z : ℝ}, 0 ≤ x → x ≤ 1 → 0 ≤ z → x ^ z ≤ 1 := by sorry

The theorem `Real.rpow_le_one` states that for any real numbers `x` and `z`, if `x` is non-negative and less than or equal to 1, and `z` is also non-negative, then `x` raised to the power of `z` will always be less than or equal to 1. This is a property about exponentiation in the set of real numbers.

For all real numbers `x` and `z` with `0 ≤ x ≤ 1` and `z ≥ 0`, `x^z ≤ 1`.


theorem Nat.Prime.minFac_eq : ∀ {p : ℕ}, Nat.Prime p → Nat.minFac p = p := by sorry

This theorem states that for any natural number `p`, if `p` is a prime number, then the smallest prime factor of `p` is `p` itself. In mathematical terms, this is saying that if `p` is a prime number (meaning it has no divisors other than `p` and `1`), then the smallest factor of `p` that is also a prime number is `p`.

For any prime number p, p is its own smallest prime factor.


theorem IsBezout.gcd_dvd_right :
    ∀ {R : Type u} [inst : CommRing R] (x y : R) [inst_1 : Submodule.IsPrincipal (Ideal.span {x, y})],
      IsBezout.gcd x y ∣ y :=
  by sorry

The theorem `IsBezout.gcd_dvd_right` states that for any commutative ring `R` and any two elements `x` and `y` of `R`, if the ideal generated by `x` and `y` is principal (i.e., it can be generated by a single element), then the `gcd` of `x` and `y` (as defined in a Bézout domain) divides `y`. The Bézout domain is a particular kind of integral domain where every finitely generated ideal is principal, and a `gcd` in such a domain is not uniquely determined.

In a commutative ring where every ideal is principal (a Bézout domain), the `gcd` of two elements `x` and `y` divides `y`.


theorem Set.Ioo_insert_right :
    ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a < b → insert b (Set.Ioo a b) = Set.Ioc a b := by sorry

This theorem states that for any partially ordered set, given two elements `a` and `b` where `a` is less than `b`, the set obtained by inserting `b` into the open interval from `a` to `b` (denoted as `(a, b)`, exclusive of `a` and `b`) is equivalent to the interval from `a` to `b` including `b` (denoted as `(a, b]`). In other words, adding the right endpoint to a left-open right-open interval transforms it into a left-open right-closed interval.

For any partially ordered set, the set obtained by inserting an element into a left-open interval is equal to the corresponding left-open right-closed interval.


theorem Ordinal.nfp_add_zero : ∀ (a : Ordinal.{u_1}), Ordinal.nfp (fun x => a + x) 0 = a * Ordinal.omega := by sorry

The theorem `Ordinal.nfp_add_zero` states that for any ordinal `a`, the least fixed point of the function `f(x) = a + x`, starting at 0, is equal to `a` times the first infinite ordinal `ω`. In other words, when you repeatedly apply the function `f(x) = a + x` starting at 0 until reaching a fixed point, you will arrive at the product of `a` and `ω`, where `ω` is the order type of the set of natural numbers.

The least fixed point of the function `a +` is equal to `a * ω`, where `a` is an ordinal and `ω` is the first infinite ordinal.


theorem Set.zero_nonempty : ∀ {α : Type u_2} [inst : Zero α], Set.Nonempty 0 := by sorry

The theorem `Set.zero_nonempty` states that for every type `α` that has an instance of the `Zero` typeclass, the set containing the zero element is nonempty. In other words, no matter what type `α` we are working with, if it has a zero element then the singleton set containing just this zero element is not empty. This is expressed in Lean 4 by saying that `Set.Nonempty 0` holds for these types `α`.

For every type `α` with a zero element, the singleton set `{0 : α}` is nonempty.


theorem Polynomial.support_erase :
    ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R) (n : ℕ),
      Polynomial.support (Polynomial.erase n p) = Finset.erase (Polynomial.support p) n :=
  by sorry

This theorem states that for any semiring `R`, any polynomial `p` from `R`, and any natural number `n`, the support (i.e., the set of all powers `n` for which the `X^n` term of the polynomial has a non-zero coefficient) of the polynomial obtained by erasing the `X^n` term from `p` is equal to the set obtained by erasing `n` from the support of `p`. In other words, removing the `X^n` term from a polynomial precisely removes `n` from the set of powers with non-zero coefficients in the polynomial.

For any semiring `R`, polynomial `p` from `R` in the indeterminate `X`, and natural number `n`, the support of the polynomial `p` without the `X^n` term equals the support of `p` without `n`.


localCohomology.hasColimitDiagram

theorem localCohomology.hasColimitDiagram :
    ∀ {R : Type (max u v)} [inst : CommRing R] {D : Type v} [inst_1 : CategoryTheory.SmallCategory D]
      (I : CategoryTheory.Functor D (Ideal R)) (i : ℕ),
      CategoryTheory.Limits.HasColimit (localCohomology.diagram I i) :=
  by sorry

The theorem `localCohomology.hasColimitDiagram` states that for any commutative ring `R`, any small category `D`, any functor `I` from `D` to the ideals of `R`, and any natural number `i`, the functor `localCohomology.diagram I i` has a colimit in the category of functors from the opposite of `D` to the category of functors from the module category over `R` to itself. In other words, the directed system of ring module ideals determined by the functor `I` and indexed by the natural number `i` always has a colimit.

For any commutative ring R, small category D, and functor I from D to the ideals of R, the functor localCohomology.diagram I i from the opposite of D to the category of R-module functors has a colimit.