theorem Filter.Tendsto.const_sub :
    ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Sub G] [inst_2 : ContinuousSub G] (b : G) {c : G}
      {f : α → G} {l : Filter α}, Filter.Tendsto f l (nhds c) → Filter.Tendsto (fun k => b - f k) l (nhds (b - c)) :=
  by sorry

This theorem, `Filter.Tendsto.const_sub`, states that for any types `G` and `α` where `G` is a topological space and subtraction is defined and continuous on `G`, and any elements `b` and `c` of `G`, if a function `f` from `α` to `G` tends to `c` with respect to some filter `l`, then the function which subtracts the value of `f` from the constant `b` also tends to `b - c` with respect to the same filter `l`. In other words, if the limit of function `f` as it approaches the filter `l` is `c`, then the limit of the function `(b - f)` as it approaches `l` is `(b - c)`.

If `f: α → G` tends to `c` in the topological space `G` with respect to filter `l`, then the function `(b → b - f(x))` tends to `(b - c)` in `G` with respect to `l`, where `b` is a constant element of `G`.


theorem Quaternion.coe_mul : ∀ {R : Type u_3} [inst : CommRing R] (x y : R), ↑(x * y) = ↑x * ↑y := by sorry

This theorem states that for any commutative ring `R` and any two elements `x` and `y` from `R`, the quaternionic representation of the product `x * y` is equal to the product of the quaternionic representations of `x` and `y`. In other words, multiplication in the ring `R` is compatible with the quaternionic representation.

For any commutative ring R and all its elements x, y, the quaternionic representation of x * y equals the product of the quaternionic representations of x and y.


theorem CategoryTheory.Bicategory.whiskerLeft_rightUnitor :
    ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
      CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.rightUnitor g).hom =
        CategoryTheory.CategoryStruct.comp
          (CategoryTheory.Bicategory.associator f g (CategoryTheory.CategoryStruct.id c)).inv
          (CategoryTheory.Bicategory.rightUnitor (CategoryTheory.CategoryStruct.comp f g)).hom :=
  by sorry

This theorem, `CategoryTheory.Bicategory.whiskerLeft_rightUnitor`, states that for any bicategory `B` with objects `a`, `b`, and `c`, and morphisms `f : a ⟶ b` and `g : b ⟶ c`, the homomorphism associated with the left whiskering of `f` with the right unitor of `g` is equal to the composition of the inverse of the associator of `f`, `g`, and the identity on `c` with the homomorphism of the right unitor of the composition of `f` and `g`. This equality follows from the coherence conditions in the definition of bicategories, and the whiskering and unitors are specific isomorphisms that exist in any bicategory.

For any bicategory B and morphisms f : a ⟶ b, g : b ⟶ c, the homomorphism of the left whiskering of f with the right unitor of g equals the composition of the inverse of the associator of f, g, and the identity on c, with the homomorphism of the right unitor of the composition of f and g.


theorem toIocDiv_add_zsmul :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α) (m : ℤ),
      toIocDiv hp a (b + m • p) = toIocDiv hp a b + m :=
  by sorry

The theorem `toIocDiv_add_zsmul` states that for any type `α` that is a linear ordered additive commutative group and Archimedean, for any positive `p` of type `α`, and for any `a`, `b` of type `α` and integer `m`, the unique integer obtained by applying the `toIocDiv` function to the input `a` and `b + m * p` is equal to the sum of the unique integer obtained by applying the `toIocDiv` function to `a` and `b`, and `m`. In other words, adding `m` multiples of `p` to `b` before applying the `toIocDiv` function is the same as adding `m` to the result of applying the `toIocDiv` function to `a` and `b` without `m * p`.

For any Archimedean linear ordered additive commutative group type `α` with positive element `p`, and integers `m` and `a`, `b` of type `α`, the result of applying `toIocDiv` to `a` and `b + m * p` is equal to the sum of the result of applying `toIocDiv` to `a` and `b`, and the integer `m`.


theorem List.zip_append :
    ∀ {α : Type u_1} {β : Type u_2} {l₁ r₁ : List α} {l₂ r₂ : List β},
      List.length l₁ = List.length l₂ → List.zip (l₁ ++ r₁) (l₂ ++ r₂) = List.zip l₁ l₂ ++ List.zip r₁ r₂ :=
  by sorry

This theorem, `List.zip_append`, states that for any types `α` and `β`, and any lists `l₁`, `r₁` of type `α`, and `l₂`, `r₂` of type `β`, if the lengths of `l₁` and `l₂` are equal, then the result of zipping the concatenation of `l₁` and `r₁` with the concatenation of `l₂` and `r₂` is equivalent to the concatenation of the zip of `l₁` and `l₂` with the zip of `r₁` and `r₂`. Zipping, in this context, refers to combining two lists into a list of pairs, with one element from each list. The longer list is truncated to match the shorter list.

For any types `α` and `β` and lists `l₁ : List α`, `l₂ : List β`, `r₁ : List α`, and `r₂ : List β` of equal lengths, `List.zip (l₁ ++ r₁) (l₂ ++ r₂) = List.append (List.zip l₁ l₂) (List.zip r₁ r₂)`.


ClosedEmbedding.noncompactSpace

theorem ClosedEmbedding.noncompactSpace :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : NoncompactSpace X]
      {f : X → Y}, ClosedEmbedding f → NoncompactSpace Y :=
  by sorry

This theorem states that if we have two types `X` and `Y` which are equipped with topological space structures and `X` is a noncompact space, then for any function `f` from `X` to `Y`, if `f` is a closed embedding, it follows that `Y` is also a noncompact space. This essentially implies that a closed embedding from a noncompact space to another space preserves the noncompactness of the domain.

If `X` is a noncompact topological space and `f : X → Y` is a closed embedding, then `Y` is also a noncompact topological space.


theorem Module.algebraMap_end_apply :
    ∀ (R : Type u) (S : Type v) (M : Type w) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
      [inst_3 : Module R M] [inst_4 : Module S M] [inst_5 : SMulCommClass S R M] [inst_6 : SMul R S]
      [inst_7 : IsScalarTower R S M] (a : R) (m : M), ((algebraMap R (Module.End S M)) a) m = a • m :=
  by sorry

This theorem states that for any commutative semiring `R`, semiring `S`, and an additive commutative monoid `M` that is also a module over both `R` and `S`, and assuming `R` and `S` action on `M` commute (`SMulCommClass S R M`) and `S` acts on `R` (`SMul R S`), forming a scalar tower (`IsScalarTower R S M`), the application of the algebra map from `R` to the endomorphisms of the `S`-module `M` to an element `a` from `R` and `m` from `M` is equivalent to the scalar multiplication of `m` by `a`. In LaTeX notation, for any `a` in `R` and `m` in `M`, it is true that `(algebraMap R (Module.End S M)) a m = a • m`.

Given a commutative semiring `R`, semiring `S`, and an additive commutative `R-S`-module `M` with commuting actions and scalar tower property, the application of the algebra map from `R` to the endomorphisms of `M` to an element `a` from `R` and `m` from `M` equals the scalar multiplication of `m` by `a`, i.e., `(algebraMap R (Module.End S M)) a m = a • m`.


theorem finrank_eq_zero_of_basis_imp_false :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : Module.Free R M], (∀ (s : Finset M), Basis (↑↑s) R M → False) → FiniteDimensional.finrank R M = 0 :=
  by sorry

The theorem `finrank_eq_zero_of_basis_imp_false` states that for any type `R` serving as a Ring, and any type `M` forming an Additive Commutative Group and a Module over `R`, with `M` being a free module over `R`, if it is impossible for any finite set `s` of elements of `M` to form a basis for the module `M` over `R`, then the rank (as a natural number) of the module `M` over `R`, which is defined as `0` for infinite rank, must be `0`. In mathematical terms, if a vector space has no finite basis, it must be of dimension `0`.

If a free module over a ring has no finite basis, then its rank is 0.


/-- **Alias** of `sbtw_cyclic_left`. -/
theorem SBtw.sbtw.cyclic_left : ∀ {α : Type u_1} [inst : CircularPreorder α] {a b c : α}, sbtw a b c → sbtw b c a := by
  sorry

This is a theorem in Lean 4 which states that for any type `α` that has a circular preorder, if `a`, `b`, and `c` are instances of this type and `a` is strictly between `b` and `c` (`sbtw a b c`), then `b` is strictly between `c` and `a` (`sbtw b c a`). This theorem essentially shows the cyclic property of a circular preorder.

In a circular preorder, if `a` is strictly between `b` and `c`, then `b` is strictly between `c` and `a`.


theorem Set.inter_left_comm : ∀ {α : Type u} (s₁ s₂ s₃ : Set α), s₁ ∩ (s₂ ∩ s₃) = s₂ ∩ (s₁ ∩ s₃) := by sorry

The theorem `Set.inter_left_comm` states that for any type `α` and any three sets of type `α`, namely `s₁`, `s₂`, and `s₃`, the intersection of `s₁` with the intersection of `s₂` and `s₃` is equal to the intersection of `s₂` with the intersection of `s₁` and `s₃`. This can be viewed as a form of the commutative property for set intersections, but with the intersection operation being applied to three sets, not just two. In other words, the order in which we take the intersection of three sets does not matter.

For any sets `s₁`, `s₂`, and `s₃` of type `α`, `s₁ ∩ (s₂ ∩ s₃) = s₂ ∩ (s₁ ∩ s₃)`.


theorem Stream'.WSeq.join_cons :
    ∀ {α : Type u} (s : Stream'.WSeq α) (S : Stream'.WSeq (Stream'.WSeq α)),
      Stream'.WSeq.join (Stream'.WSeq.cons s S) = Stream'.WSeq.think (Stream'.WSeq.append s (Stream'.WSeq.join S)) :=
  by sorry

The theorem `Stream'.WSeq.join_cons` states that for any type `α`, any weak sequence `s` of type `α` and any weak sequence `S` of weak sequences of type `α`, joining a weak sequence consisting of `s` and `S` is equivalent to appending `s` to the result of joining `S` after one computational step. In other words, prepending `s` to `S` before joining is the same as first thinking (computing for one step without producing any elements), then appending `s` to the joined `S`.

For any type `α`, the join of a weak sequence `s` with the join of a weak sequence of weak sequences `S` is equivalent to appending `s` to the result of joining `S`, up to the next computation step.


theorem Computation.map_pure' :
    ∀ {α β : Type u_1} (f : α → β) (a : α), f <$> Computation.pure a = Computation.pure (f a) := by sorry

The theorem `Computation.map_pure'` states that for any two types `α` and `β` and a function `f` from `α` to `β`, applying `f` to the result of the computation that immediately terminates with a result `a` (represented by `Computation.pure a`) is equivalent to the computation that immediately terminates with the result of applying `f` to `a` (represented by `Computation.pure (f a)`). In other words, it asserts that the `map` operation preserves the `pure` operation under function application in the context of computations.

For all types `α` and `β` and functions `f` from `α` to `β`, `Computation.map_pure f (Computation.pure a) = Computation.pure (f a)`.


/-- If `(p : ι → Prop, s : ι → Set α)` is a basis of a filter `f`, `g` is a monotone function
`Set α → Filter γ`, and for each `i`, `(pg : β i → Prop, sg : β i → Set α)` is a basis
of the filter `g (s i)`, then
`(fun (i : ι) (x : β i) ↦ p i ∧ pg i x, fun (i : ι) (x : β i) ↦ sg i x)` is a basis
of the filter `f.lift g`.

This basis is parametrized by `i : ι` and `x : β i`, so in order to formulate this fact using
`Filter.HasBasis` one has to use `Σ i, β i` as the index type, see `Filter.HasBasis.lift`.
This lemma states the corresponding `mem_iff` statement without using a sigma type.  -/
theorem Filter.HasBasis.mem_lift_iff :
    ∀ {α : Type u_1} {γ : Type u_3} {ι : Sort u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α},
      Filter.HasBasis f p s →
        ∀ {β : ι → Type u_5} {pg : (i : ι) → β i → Prop} {sg : (i : ι) → β i → Set γ} {g : Set α → Filter γ},
          (∀ (i : ι), Filter.HasBasis (g (s i)) (pg i) (sg i)) →
            Monotone g → ∀ {s : Set γ}, s ∈ Filter.lift f g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s :=
  by sorry

The theorem `Filter.HasBasis.mem_lift_iff` states that given a filter `f` with a basis `(p : ι → Prop, s : ι → Set α)`, a monotone function `g` from `Set α` to `Filter γ`, and for each `i`, a basis `(pg : β i → Prop, sg : β i → Set α)` of the filter `g (s i)`, then the tuple `(fun (i : ι) (x : β i) ↦ p i ∧ pg i x, fun (i : ι) (x : β i) ↦ sg i x)` is a basis of the filter `f.lift g`. This basis is parameterized by `i : ι` and `x : β i`. In particular, a set `s` belongs to the filter `f.lift g` if and only if there exists an `i` such that `p i` holds and there exists an `x` such that `pg i x` holds and `sg i x` is a subset of `s`. This theorem provides a characterization of membership in the filter `f.lift g` without requiring the use of a sigma type.

Given a filter `f` with basis `(p : ι → Prop, s : ι → Set α)`, a monotone function `g : Set α -> Filter γ`, and basis `(pg : β i → Prop, sg : β i → Set α)` for each `i` of the filters `g (s i)`, the tuple `(p i ∧ pg i x, sg i x)` is a basis for `f.lift g`, and a set `s` belongs to `f.lift g` if and only if there exists an `i` and an `x` such that `p i` holds, `pg i x` holds, and `sg i x` is a subset of `s`.


theorem dist_pos : ∀ {γ : Type w} [inst : MetricSpace γ] {x y : γ}, 0 < dist x y ↔ x ≠ y := by sorry

This theorem, `dist_pos`, states that for any type `γ` in a metric space, the distance between two points `x` and `y` of type `γ` is greater than 0 if and only if `x` and `y` are not equal. In other words, in any metric space, two points have positive distance between them if and only if they are distinct.

In a metric space, the distance between two points is positive if and only if they are distinct.


theorem Polynomial.natDegree_C_mul_le :
    ∀ {R : Type u} [inst : Semiring R] (a : R) (f : Polynomial R),
      Polynomial.natDegree (Polynomial.C a * f) ≤ Polynomial.natDegree f :=
  by sorry

This theorem states that for any semiring `R`, any element `a` from `R`, and any polynomial `f` over `R`, the natural degree of the polynomial obtained by multiplying the constant polynomial `a` and `f` is less than or equal to the natural degree of `f`. In mathematical terms, if we denote the natural degree of a polynomial `p` as `deg(p)`, then for any constant `a` and any polynomial `f`, we have `deg(a*f) ≤ deg(f)`.

For any constant `a` and polynomial `f` in a semiring, the degree of their product `a * f` is less than or equal to the degree of `f`.


theorem Submodule.IsPrincipal.generator_mem :
    ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Ring R] [inst_2 : Module R M] (S : Submodule R M)
      [inst_3 : Submodule.IsPrincipal S], Submodule.IsPrincipal.generator S ∈ S :=
  by sorry

The theorem `Submodule.IsPrincipal.generator_mem` asserts that, for any given type `R` which is a ring and type `M` which is an additive commutative group and a module over `R`, if you have a submodule `S` of `M` which is a principal submodule, then the generator of `S` (that is, an element `x` in `M` such that `S` is the span of `{x}`) is itself an element of the submodule `S`. This theorem is essentially stating that the generator of a principal submodule is always a member of that submodule.

If `S` is a principal submodule of the `R`-module `M`, then the generator of `S` is an element of `S`.


theorem PartialEquiv.IsImage.leftInvOn_piecewise :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β} {e' : PartialEquiv α β}
      [inst : (i : α) → Decidable (i ∈ s)] [inst_1 : (i : β) → Decidable (i ∈ t)],
      PartialEquiv.IsImage e s t →
        PartialEquiv.IsImage e' s t →
          Set.LeftInvOn (Set.piecewise t ↑(PartialEquiv.symm e) ↑(PartialEquiv.symm e')) (Set.piecewise s ↑e ↑e')
            (Set.ite s e.source e'.source) :=
  by sorry

This theorem, `PartialEquiv.IsImage.leftInvOn_piecewise`, states the property of the function `Set.piecewise` with respect to two partial equivalences and two sets. More specifically, given two types `α` and `β`, two partial equivalences `e` and `e'` from `α` to `β`, and two sets `s` of type `α` and `t` of type `β`, if `t` is an image of `s` under both `e` and `e'`, then the function `Set.piecewise t` applied to the inverse of `e` and the inverse of `e'` is a left inverse to `Set.piecewise s` applied to `e` and `e'` on the set that is the intersection of `s` with the source of `e` and the union of the complement of `s` with the source of `e'`. This property essentially captures the connection between the image of a set under a partial equivalence and the operation of piecewise-defined functions.

Given sets `s` and `t`, partial equivalences `e` and `e'`, if `t` is the image of `s` under both `e` and `e'`, then `Set.piecewise t` applied to the inverses of `e` and `e'` is a left inverse to `Set.piecewise s` applied to `e` and `e'` on `s ∩ Dom e ∩ Dom e'` and `(Dom e \ s) ∪ (Dom e' \ s)`.


theorem Multiset.le_cons_self : ∀ {α : Type u_1} (s : Multiset α) (a : α), s ≤ a ::ₘ s := by sorry

This theorem states that for any type `α` and a multiset `s` of `α`, along with any element `a` of `α`, the multiset `s` is less than or equal to the multiset obtained by prepending `a` to `s`. In other words, adding an element to the multiset does not decrease its size, in the sense of the multiset size order relation.

For any type `α` and multisets `s` and `t` of `α` where `t` is obtained by adding an element `a` to `s`, we have `s ≤ t` in the multiset order relation.


theorem Set.finite_subset_iUnion :
    ∀ {α : Type u} {s : Set α},
      Set.Finite s → ∀ {ι : Type u_1} {t : ι → Set α}, s ⊆ ⋃ i, t i → ∃ I, Set.Finite I ∧ s ⊆ ⋃ i ∈ I, t i :=
  by sorry

The theorem `Set.finite_subset_iUnion` states that for any type `α`, given a finite set `s` of type `α`, for any index set `ι` and any indexed family `t` of sets of `α`, if `s` is a subset of the union of the sets `t i` for all `i`, then there exists a finite subset `I` of `ι` such that `s` is a subset of the union of the sets `t i` for `i` in `I`. In other words, if a finite set is included in the union of an indexed family of sets, then the finite set is actually included in the union of a finite subfamily of sets.

Given a finite set `s` and an indexed family `t` of sets, if `s` is a subset of the union of the `t i` for all `i`, then there exists a finite subset `I` of the index set such that `s` is a subset of the union of the `t i` for `i` in `I`.


/-- If a point in an R₁ space has a compact neighborhood,
then it has a basis of compact closed neighborhoods.  -/
theorem IsCompact.isCompact_isClosed_basis_nhds :
    ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : R1Space X] {x : X} {L : Set X},
      IsCompact L → L ∈ nhds x → Filter.HasBasis (nhds x) (fun K => K ∈ nhds x ∧ IsCompact K ∧ IsClosed K) fun x => x :=
  by sorry

This theorem states that for any point in an R₁ space, if it has a compact neighborhood, then it has a basis of compact closed neighborhoods. Here, an R₁ space is a type of topological space with certain properties. The theorem takes as input a topological space `X`, a point `x` in `X`, and a set `L` in `X`. If `L` is a compact set and a neighborhood of `x`, then the neighborhood filter at `x` has a basis consisting of sets that are also neighborhoods of `x`, and are additionally both compact and closed. A basis of a filter is a collection of sets that suffice to generate the filter by taking intersections and supersets. This theorem plays a significant role in the study of the topological properties of points and sets within a space.

In an R₁ space, if a point has a compact neighborhood, then it has a basis of compact and closed neighborhoods.


theorem integral_inv : ∀ {a b : ℝ}, 0 ∉ Set.uIcc a b → ∫ (x : ℝ) in a..b, x⁻¹ = Real.log (b / a) := by sorry

This theorem, `integral_inv`, states that for any two real numbers `a` and `b`, if zero does not lie in the set of elements between `a` and `b` (inclusive), then the integral of the function `x⁻¹` (the reciprocal of `x`) from `a` to `b` is equal to the logarithm of `b` divided by `a`. In mathematical terms, it says that if 0 is not in the closed interval [a, b], then the definite integral from `a` to `b` of `1/x` dx equals to the natural logarithm of `b / a`.

If the interval [a, b] in the real numbers excludes zero, then ∫(1/x dx) = ln(b/a).


theorem Int.le_ediv_of_mul_le : ∀ {a b c : ℤ}, 0 < c → a * c ≤ b → a ≤ b / c := by sorry

This theorem states that for any three integers `a`, `b`, and `c`, if `c` is greater than 0 and the product of `a` and `c` is less than or equal to `b`, then `a` is less than or equal to the integral division of `b` by `c`. In mathematical terms, if $c > 0$, $a \cdot c \leq b$, then $a \leq \lfloor \frac{b}{c} \rfloor$.

If `c` is a positive integer and `a * c` is less than or equal to `b`, then `a` is less than or equal to the integer quotient of `b` by `c`. (Or, mathematically: If $c > 0$ and $a \cdot c \leq b$, then $a \leq \lfloor \frac{b}{c} \rfloor$.)


theorem LieSubmodule.lie_le_left :
    ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I J : LieIdeal R L),
      ⁅I, J⁆ ≤ I :=
  by sorry

This theorem states that for any commutative ring `R` and any Lie ring `L` over `R`, given any two Lie ideals `I` and `J` of `L`, the Lie bracket of `I` and `J` (denoted `[I, J]`) is a substructure of `I`. In terms of Lie algebra, this theorem expresses a key characteristic of the Lie ideal, which is closed under the Lie bracket operation with any other Lie ideal.

For any commutative ring R and Lie ring L over R, the Lie bracket of two Lie ideals I and J of L is a sub-Lie ideal of I.


/-- **Alias** of `Left.mul_le_one`.

---

Assumes left covariance.
The lemma assuming right covariance is `Right.mul_le_one`.  -/
theorem mul_le_one' :
    ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α]
      [inst_2 : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α}, a ≤ 1 → b ≤ 1 → a * b ≤ 1 :=
  by sorry

This theorem, named `mul_le_one'`, states that for any type `α` that is a multiplication one class and has a preorder, and is also covariant in a particular way, if `a` and `b` are two elements of `α` such that both `a` and `b` are less than or equal to 1, then the product of `a` and `b` is also less than or equal to 1. This theorem assumes left covariance. There is a corresponding lemma assuming right covariance, named `Right.mul_le_one`.

If `α` is a multiplication one class with a preorder that is covariant in the left argument, then for all `a, b ∈ α` with `a ≤ 1` and `b ≤ 1`, we have `a * b ≤ 1`.


theorem CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s.proof_4 :
    ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
      [inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
      (S : CategoryTheory.SplitEpi f.hom) (n : ℕ)
      (i : Fin (SimplexCategory.len (Opposite.op (SimplexCategory.mk (n + 1))).unop + 1)),
      CategoryTheory.CategoryStruct.comp
          ((fun i =>
              if x : i = 0 then
                CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePullback.base fun x => f.hom) S.section_
              else CategoryTheory.Limits.WidePullback.π (fun x => f.hom) (Fin.pred i x))
            i)
          f.hom =
        CategoryTheory.Limits.WidePullback.base fun x => f.hom :=
  by sorry

The theorem `CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s.proof_4` states that for any category `C` and any morphism (or "arrow") `f` in `C`, where for any natural number `n`, `f` has a wide pullback with `f.right` as the base and `f.left` as the objects linked to the base by the morphism `f.hom`. Also, `f.hom` is a split epimorphism. For any natural number `n` and any element `i` drawn from the `n+1`-dimensional simplex, if `i` is not the zero element, the composition of `WidePullback.π (fun x => f.hom) (Fin.pred i x)` (which is the projection from the wide pullback to the `i-1`th object) and `f.hom` is equal to `WidePullback.base fun x => f.hom` (which is the morphism from the limit of the wide pullback to the base). If `i` is the zero element, then the composition of `WidePullback.base fun x => f.hom` and the section of `f.hom` (which is a right inverse of `f.hom`) is also equal to `WidePullback.base fun x => f.hom`.

For any morphism `f` in a category `C` with split epimorphic `f.hom`, if `n` is a natural number and `i` is an `(n+1)`-dimensional simplex non-zero element, then the composition of the projection from the wide pullback of `f` to the `i-1`th object and `f.hom` equals `f.hom`; if `i` is the zero element, then the composition of `f.hom` and its section equals `f.hom` from the wide pullback to the base.


theorem bernoulli'_zero : bernoulli' 0 = 1 := by sorry

The theorem `bernoulli'_zero` states that the zeroth Bernoulli number, which is denoted as $B_0$ in mathematical notation, is equal to 1. In line with the recursive definition of the Bernoulli numbers, this theorem provides the base case where n equals zero.

The zeroth Bernoulli number $B\_0$ equals 1.


theorem riemannZeta_def :
    riemannZeta =
      Function.update (fun s => ↑Real.pi ^ (s / 2) * riemannCompletedZeta s / Complex.Gamma (s / 2)) 0 (-1 / 2) :=
  by sorry

This theorem defines the Riemann zeta function, `riemannZeta`, in terms of the completed Riemann zeta function `riemannCompletedZeta` and the complex Gamma function `Complex.Gamma`. Specifically, for any complex number `s` other than `0`, `riemannZeta(s)` is equal to `π^(s/2) * riemannCompletedZeta(s) / Γ(s/2)`, where `Γ` denotes the complex Gamma function. However, at `s = 0`, `riemannZeta` is specifically defined to be `-1/2`.

For complex numbers `s` other than 0, the Riemann zeta function `riemannZeta(s)` equals `π^(s/2) * riemannCompletedZeta(s) / Γ(s/2)`, while `riemannZeta(0)` is defined as `-1/2`.


theorem nhds_bot_basis :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderBot α] [inst_3 : OrderTopology α]
      [inst_4 : Nontrivial α], Filter.HasBasis (nhds ⊥) (fun a => ⊥ < a) fun a => Set.Iio a :=
  by sorry

This theorem states that, for any type `α` which has a topological space, linear ordering, a least element (`OrderBot`), an order topology and is nontrivial, the neighborhood filter at the least element (`nhds ⊥`) has a basis given by sets of the form `Set.Iio a`, where `a` is any element greater than the least element. In other words, the basis sets for the neighborhood filter at the bottom element are all left-infinite, right-open intervals that start from the least element and end just before `a`, for all `a` in `α` that are greater than the least element.

For any nontrivial type `α` with a topological space structure, a linear ordering, a least element, and an order topology, the basis for the neighborhood filter at the least element is given by sets of the form `(a -- ε)`, where `a` is any element strictly greater than the least element.


theorem Finset.range_orderEmbOfFin :
    ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k),
      Set.range ⇑(Finset.orderEmbOfFin s h) = ↑s :=
  by sorry

The theorem `Finset.range_orderEmbOfFin` states that for any given type `α` under a linear order, and any finite set `s` of type `α`, if `k` is the cardinality of `s`, then the range of the function obtained by applying the `Finset.orderEmbOfFin` function to `s` and `k` equals the finite set `s` itself. In other words, every element in the finite set `s` is an output of the function `Finset.orderEmbOfFin s h`, where `h` is a proof that `s` has `k` elements.

For any linear order type `α` and finite set `s` of size `k` in `α`, `Finset.orderEmbOfFin s h` equals `s`, where `h` is the proof of `s` having size `k`.


theorem uniformEmbedding_comap :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [u : UniformSpace β], Function.Injective f → UniformEmbedding f := by
  sorry

The theorem `uniformEmbedding_comap` states that for any types `α` and `β` and any function `f` from `α` to `β`, if `β` comes with a UniformSpace structure and the function `f` is injective, then `f` is a Uniform Embedding. In layman's terms, this theorem is saying if you have an injective function from one set to another, and the second set has a certain kind of mathematical structure called a Uniform Space, then that function preserves the structure in a certain way that qualifies it as a Uniform Embedding.

If `α` is any type, `β` is a UniformSpace, and `f : α → β` is injective, then `f` is a Uniform Embedding.


theorem CategoryTheory.Adjunction.map_projective :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
      {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C},
      (F ⊣ G) →
        ∀ [inst_2 : CategoryTheory.Functor.PreservesEpimorphisms G] (P : C),
          CategoryTheory.Projective P → CategoryTheory.Projective (F.obj P) :=
  by sorry

This theorem states that for any categories `C` and `D`, and any functors `F` from `C` to `D` and `G` from `D` to `C`, if `F` is a left adjoint to `G` and `G` preserves epimorphisms, then for any object `P` in `C` that is projective, the object `F.obj P` in `D` is also projective. Here, an object is said to be projective if every morphism from it to an epimorphism can be factored through the epimorphism.

Given categories `C`, `D`, functors `F: C -> D` left adjoint to `G: D -> C`, and `G` preserving epimorphisms, if `P` is a projective object in `C`, then `F.obj P` is a projective object in `D`.


theorem MvPolynomial.coeff_mul :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq σ] (p q : MvPolynomial σ R)
      (n : σ →₀ ℕ),
      MvPolynomial.coeff n (p * q) =
        Finset.sum (Finset.antidiagonal n) fun x => MvPolynomial.coeff x.1 p * MvPolynomial.coeff x.2 q :=
  by sorry

This theorem, `MvPolynomial.coeff_mul`, states that for any commutative semiring `R` and any type `σ` with decidable equality, given two multi-variable polynomials `p` and `q` over `R` and `σ`, and any monomial `n`, the coefficient of the monomial `n` in the product of polynomials `p` and `q` is equal to the sum, over all pairs of monomials `(x.1, x.2)` such that they add up to `n`, of the product of the coefficient of `x.1` in `p` and the coefficient of `x.2` in `q`. In mathematical notation, this can be written as $(p*q)_n = \sum_{(i,j) \in S} p_i * q_j$, where $S = \{(i,j) | i+j=n\}$ and $(p*q)_n$ denotes the coefficient of monomial `n` in the product of `p` and `q`.

The coefficient of a monomial in the product of two multi-variable polynomials is the sum of the products of the coefficients of corresponding monomials in the factors, for all monomials that sum up to the target monomial.


theorem Nat.div_eq_of_eq_mul_left : ∀ {n m k : ℕ}, 0 < n → m = k * n → m / n = k := by sorry

This theorem states that for any positive natural numbers `n`, `m`, and `k`, if `m` equals `k` multiplied by `n`, then the result of dividing `m` by `n` equals `k`. In other words, it captures the property of integers where division is the inverse operation of multiplication, provided the divisor is nonzero.

For any natural numbers `n`, `m`, and `k`, if `m = k * n`, then `m / n = k`.


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

This theorem states that for any type `α` that is a metric space, and for any nonnegative real number `K` and function `f` from `α` to `α`, if `f` is a contracting map with constant `K` (meaning `K` is less than `1` and `f` is `K`-Lipschitz), then the value `1 - K` is always positive. In other words, the difference between `1` and the Lipschitz constant of a contracting map is always greater than `0`.

For any metric space `α` and contracting map `f:` `α` `->` `α` with Lipschitz constant `K` < 1, `1 - K` is positive.


/-- A function `ψ` on a `SuccOrder` is strictly monotone before some `n` if for all `m` such that
`m < n`, we have `ψ m < ψ (succ m)`.  -/
theorem strictMonoOn_Iic_of_lt_succ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : Preorder β] {ψ : α → β} [inst_2 : SuccOrder α]
      [inst_3 : IsSuccArchimedean α] {n : α}, (∀ m < n, ψ m < ψ (Order.succ m)) → StrictMonoOn ψ (Set.Iic n) :=
  by sorry

The theorem `strictMonoOn_Iic_of_lt_succ` asserts that for any `SuccOrder` (an order where every element has a successor) on an arbitrary type `α`, and a function `ψ` from `α` to another arbitrary type `β`, if for all `m` less than a given `n`, the value of `ψ` at `m` is less than the value of `ψ` at the successor of `m`, then `ψ` is strictly monotone on the interval of `α` that includes all elements less than or equal to `n`. In other words, `ψ` increases as you move up in the order from any point to its successor, up to the point `n`.

If `ψ : α → β` is a function on a type `α` with a `SuccOrder`, and `ψ` is decreasing on all intervals `[m, succ m]` for all `m` less than some `n`, then `ψ` is strictly increasing on the interval `[min α, n]`.


theorem Directed.finite_le :
    ∀ {α : Type u_1} {r : α → α → Prop} [inst : IsTrans α r] {β : Type u_2} {γ : Type u_3} [inst : Nonempty γ]
      {f : γ → α} [inst : Finite β], Directed r f → ∀ (g : β → γ), ∃ z, ∀ (i : β), r (f (g i)) (f z) :=
  by sorry

This theorem states that for any types `α`, `β`, and `γ`, and a relation `r` on `α` that is transitive, if `γ` is nonempty and `β` is finite, and if there is a function `f : γ → α` such that for every pair of elements in `γ`, there exists an element in `γ` larger than both of them with respect to `r`, then for any function `g : β → γ`, there exists an element `z` in `γ` such that for all elements `i` in `β`, `f(g(i))` is less than or equal to `f(z)` with respect to `r`. In simpler terms, this theorem states that for every element in the finite set `β`, there exists a "upper bound" in `γ` with respect to the relation `r`.

Given types `α`, `β`, and `γ`, a transitive relation `r` on `α`, a nonempty and finite set `β`, and a function `f : γ → α` such that for every pair of elements in `γ`, there exists an element in `γ` larger than both with respect to `r`, then for every function `g : β → γ`, there exists an element `z` in `γ` such that for all `i` in `β`, `f(g(i)) ≤ f(z)` holds in `α` with respect to `r`.


theorem Mathlib.Algebra.Parity._auxLemma.2 : ∀ {α : Type u_2} [inst : Add α] (m : α), Even (m + m) = True := by sorry

This theorem states that for any type `α` that supports addition, and for any element `m` of type `α`, the statement "`m + m` is Even" is always true. Here, an element `a` of a type `α` is said to be Even if it can be expressed as `r + r` for some `r` of type `α`.

For any type `α` with additive structure and any `α` element `m`, `m + m` is an even element.


theorem PiLp.edist_eq_sum :
    ∀ {ι : Type u_2} {β : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → EDist (β i)] {p : ENNReal},
      0 < p.toReal →
        ∀ (f g : PiLp p β),
          edist f g = (Finset.sum Finset.univ fun i => edist (f i) (g i) ^ p.toReal) ^ (1 / p.toReal) :=
  by sorry

The theorem `PiLp.edist_eq_sum` states that for any type `ι`, any function `β` from `ι` to some other type, given we have a finite number of `ι` and each `ι` has a defined 'extended' distance (`EDist`), and a nonnegative real number `p` that is greater than 0. Then for any two functions `f` and `g` of type `PiLp p β` (a type synonym defined to hold the `L^p` distance on a Pi type), the 'extended' distance between `f` and `g` is equal to the p-th root of the sum over all elements in the universal set (`Finset.univ`) of the p-th power of the 'extended' distance between `f i` and `g i`. In mathematical terms, given `0 < p`, we have `edist(f, g) = \left(\sum_{i \in \text{univ}} (edist(f(i), g(i)))^p\right)^{1/p}`.

For any type `ι`, function `β`, finite `ι`, nonnegative real `p > 0`, and functions `f` and `g` of type `PiLp p β`, the extended distance `edist(f, g)` is equal to the `p`-th root of the sum over all `i ∈ Finset.univ` of the `p`-th power of the extended distance between `f i` and `g i`.


theorem Mathlib.Algebra.Parity._auxLemma.8 : ∀ {α : Type u_2} [inst : AddZeroClass α], Even 0 = True := by sorry

The theorem `Mathlib.Algebra.Parity._auxLemma.8` asserts that for any type `α` which has an addition operation with a zero element (`AddZeroClass α`), the number zero (`0`) is considered to be an even number. This is based on the definition of evenness in this context, which specifies that a number is even if it can be expressed as the sum of two identical numbers (say `r + r`). Here, `0` can be seen as `0 + 0`, thus meeting the criterion to be classified as even.

The theorem `Mathlib.Algebra.Parity._auxLemma.8` states that in any type `α` with an additive zero, the additive zero `0` is even, i.e., it can be expressed as the sum of two identical elements.


theorem Array.appendList_data : ∀ {α : Type u_1} (arr : Array α) (l : List α), (arr ++ l).data = arr.data ++ l := by
  sorry

This theorem, `Array.appendList_data`, states that for any type `α` and for all arrays `arr` of type `α` and lists `l` of type `α`, the data of the array formed by appending the list `l` to the array `arr` is equal to the list formed by appending the list `l` to the data of the array `arr`. In other words, appending a list to an array in Lean 4 and then fetching the data is the same as appending the list to the array's data directly.

For any type `α`, the data of the array obtained by appending list `l` to array `arr` in Lean 4 is equal to the list obtained by appending `l` to the data of `arr`.


/-- Nonzero divisors have nonzero valuation.  -/
theorem IsDedekindDomain.HeightOneSpectrum.int_valuation_ne_zero' :
    ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R)
      (x : ↥(nonZeroDivisors R)), IsDedekindDomain.HeightOneSpectrum.intValuationDef v ↑x ≠ 0 :=
  by sorry

The theorem `IsDedekindDomain.HeightOneSpectrum.int_valuation_ne_zero'` states that for any commutative ring `R` that is a Dedekind domain, and for any element `x` in the submonoid of non-zero-divisors of `R`, the integer valuation of `x` in the height one spectrum of `R` is non-zero. In more mathematical terms, it asserts that if `v` is a valuation in the height one spectrum of a Dedekind domain `R`, and `x` is a non-zero divisor in `R`, then the integer value assigned by `v` to `x` is non-zero.

In a Dedekind domain, every non-zero divisor has non-zero valuation in the height one spectrum.


theorem leftCoset_eq_iff :
    ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) {x y : α}, x • ↑s = y • ↑s ↔ x⁻¹ * y ∈ s := by sorry

This theorem states that for any given type `α` that forms a group and for any subgroup `s` of `α`, the left coset of `s` under `x` equals the left coset of `s` under `y` if and only if the element represented by the inverse of `x` times `y` is in `s`. In terms of group theory, it links the condition of two left cosets being equal to the existence of a certain element in the subgroup.

For any group `α` and subgroup `s`, the left cosets `xs` and `ys` of `s` are equal if and only if `x⁻¹y ∈ s`.


theorem List.inits_eq_tails :
    ∀ {α : Type u_1} (l : List α), List.inits l = List.reverse (List.map List.reverse (List.tails (List.reverse l))) :=
  by sorry

This theorem states that for any given list `l` of a particular type `α`, the list of initial segments of `l` (as given by `List.inits l`) is the same as the list of reversed terminal segments of the reversed `l` (as given by `List.reverse (List.map List.reverse (List.tails (List.reverse l)))`). In simpler terms, it tells that if you reverse the list and take its terminal segments and then reverse those segments and the whole list again, you will get the initial segments of the original list.

For any list `l` of type `α`, the list of initial segments `List.inits l` is equal to the list of reversed terminal segments of the reversed list `List.reverse l`, i.e., `List.reverse (List.map List.reverse (List.tails (List.reverse l)))`.


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

This theorem states that for any additve group `G` and sets `S` and `T` within that group, `S` and `T` are complements if and only if for every element `g` in the group, there exists a unique pair of elements `(x.1, x.2)`, one from each set, such that the sum of these elements equals `g`. In other words, every element in the group can be expressed uniquely as the sum of an element from `S` and an element from `T`. This concept of complementarity involves a bijection between the pairs from `S` and `T` and the group `G`.

For any additive group `G` and sets `S` and `T` within it, `S` and `T` are complements if and only if for each group element `g`, there exists a unique pair `(x.1, x.2)` with `x.1 ∈ S` and `x.2 ∈ T` such that `g = x.1 + x.2`.


theorem differentiable_fst :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F],
      Differentiable 𝕜 Prod.fst :=
  by sorry

The theorem `differentiable_fst` states that for any non-trivially normed field `𝕜`, and any types `E` and `F` that form normed additive commutative groups and normed spaces over `𝕜`, the projection function `Prod.fst` is differentiable at all points. In other words, if we consider pairs of elements from `E` and `F`, the function that takes a pair and returns its first element is differentiable with respect to the field `𝕜`.

For any non-trivially normed field `𝕜` and normed additive commutative groups and normed spaces `E` and `F` over `𝕜`, the projection function `Prod.fst` from `E × F` to `E` is differentiable.


theorem MeasureTheory.IsAddFundamentalDomain.lintegral_eq_tsum_of_ac :
    ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
      {s : Set α} {μ : MeasureTheory.Measure α} [inst_3 : MeasurableSpace G] [inst_4 : MeasurableVAdd G α]
      [inst_5 : MeasureTheory.VAddInvariantMeasure G α μ] [inst_6 : Countable G] {ν : MeasureTheory.Measure α},
      MeasureTheory.IsAddFundamentalDomain G s μ →
        MeasureTheory.Measure.AbsolutelyContinuous ν μ →
          ∀ (f : α → ENNReal), ∫⁻ (x : α), f x ∂ν = ∑' (g : G), ∫⁻ (x : α) in g +ᵥ s, f x ∂ν :=
  by sorry

The theorem `MeasureTheory.IsAddFundamentalDomain.lintegral_eq_tsum_of_ac` states the following: Given a type `G` with an additive group structure, a type `α` with a measurable space structure, an `AddAction` of `G` on `α`, a measurable addition operation (`MeasurableVAdd`) between `G` and `α`, a measure `μ` on `α` that is invariant under the action of `G` (`MeasureTheory.VAddInvariantMeasure`), a countable set `G`, a set `s` of `α`, and another measure `ν` on `α`, if `s` is an additive fundamental domain for `G` under the measure `μ` and the measure `ν` is absolutely continuous with respect to `μ`, then for any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), the integral of `f` with respect to `ν` equals the sum over all `g` in `G` of the integral of `f` over the set `g + s` with respect to `ν`. In mathematical terms, $\int f d\nu = \sum_{g \in G} \int_{g + s} f d\nu$.

Given a measurable space `(α, Σ, μ)`, a group `G` acting measurably on `α` with invariant measure `μ`, an absolutely continuous measure `ν` on `α` with respect to `μ`, and an additive fundamental domain `s` for `G` under `μ`, for any measurable function `f` from `α` to the extended nonnegative real numbers, the integral of `f` with respect to `ν` equals the sum of the integrals of `f` over `g+s` for all `g` in `G` with respect to `ν`. In symbols, $\int f d\nu = \sum\_{g \in G} \int\_{g+s} f d\nu$.


theorem zpow_bit0_pos : ∀ {α : Type u_1} [inst : LinearOrderedField α] {a : α}, a ≠ 0 → ∀ (n : ℤ), 0 < a ^ bit0 n := by
  sorry

This theorem, `zpow_bit0_pos`, states that for any type `α` that has a structure of a linearly ordered field, given any non-zero element `a` of `α` and any integer `n`, the value of `a` raised to the power of `bit0 n` (meaning `2n`, as `bit0` function doubles its input) is always positive. Essentially, it's stating that for non-zero values, raising them to an even power will always yield a positive result, which aligns with the mathematical fact that the square of any non-zero real number is always positive.

For any non-zero element in a linearly ordered field, raising it to an even power results in a positive value.


theorem Set.IsWF.min_le_min_of_subset :
    ∀ {α : Type u_2} [inst : LinearOrder α] {s t : Set α} {hs : Set.IsWF s} {hsn : Set.Nonempty s} {ht : Set.IsWF t}
      {htn : Set.Nonempty t}, s ⊆ t → Set.IsWF.min ht htn ≤ Set.IsWF.min hs hsn :=
  by sorry

This theorem, `Set.IsWF.min_le_min_of_subset`, states that for any two sets `s` and `t` of a type `α` which is equipped with a linear order, if both sets are well-founded (meaning the less-than operation is well-founded when restricted to these sets) and nonempty, then if `s` is a subset of `t`, the minimum element of `t` is less than or equal to the minimum element of `s`. In this context, the minimum element of a well-founded, nonempty set is defined with respect to the given order on `α`.

If `s` is a nonempty, well-founded subset of a well-founded, nonempty set `t` with respect to a linear order on their common type `α`, then the minimum element of `s` is less than or equal to the minimum element of `t`.


theorem le_partialSups_of_le :
    ∀ {α : Type u_1} [inst : SemilatticeSup α] (f : ℕ → α) {m n : ℕ}, m ≤ n → f m ≤ (partialSups f) n := by sorry

This theorem states that for any type `α` that forms a semilattice with a supremum operation, and for any function `f` from the natural numbers to `α`, if `m` is less than or equal to `n`, then the value of `f` at `m` is less than or equal to the value of the monotone sequence `partialSups f` at `n`. The `partialSups` function generates a sequence whose value at any natural number `n` is the supremum of the values of `f m` for all `m` less than or equal to `n`.

For any semilattice `α` with supremum operation and any function `f` from the natural numbers to `α`, if `m ≤ n`, then `f m ≤ sup {f x | x ≤ n}`.


theorem contDiffAt_norm :
    ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst : InnerProductSpace 𝕜 E]
      [inst : NormedSpace ℝ E] {n : ℕ∞} {x : E}, x ≠ 0 → ContDiffAt ℝ n norm x :=
  by sorry

The theorem `contDiffAt_norm` states that for any real or complex field 𝕜, a normed add commutative group E, an inner product space over E, a normed space over E, and any natural number or infinity n, if vector x in E is not the zero vector, then the norm function is continuously differentiable at x of order n.

For any normed add commutative group E over a real or complex field, inner product space, and normed space over E, if $x \in E$ is nonzero, then the norm function is continuously differentiable of order $n$ at $x$.


theorem PosNum.minFac_to_nat : ∀ (n : PosNum), ↑(PosNum.minFac n) = Nat.minFac ↑n := by sorry

This theorem states that for every positive number `n`, the smallest prime factor of `n` when considered as a positive number, is equal to the smallest prime factor of `n` when considered as a natural number. In other words, the function `PosNum.minFac` applied to `n` and then coerced to a natural number, is the same as the function `Nat.minFac` applied to `n` coerced to a natural number. This theorem connects the prime factorization of positive numbers and natural numbers.

For every positive integer `n`, the smallest prime factor of `n` as a positive number equals the smallest prime factor of `n` as a natural number. Alternatively, `PosNum.minFac  n = Nat.minFac  (n : nat)`.


theorem Finset.filter_eq_empty_iff :
    ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α},
      Finset.filter p s = ∅ ↔ ∀ ⦃x : α⦄, x ∈ s → ¬p x :=
  by sorry

This theorem, `Finset.filter_eq_empty_iff`, states that for any type `α`, any decidable predicate `p` on `α`, and any finite set `s` of elements from `α`, the condition that the filter of `s` with respect to `p` returning an empty set is equivalent to the condition that for all elements `x` in `s`, `p` does not hold for `x`. In other words, the set resulting from filtering `s` with `p` is empty if and only if there is no element in `s` for which the predicate `p` is true.

For any type `α`, decidable predicate `p` on `α`, and finite set `s` from `α`, the filter of `s` with respect to `p` is empty if and only if no element in `s` satisfies `p`.


DifferentiableAt.mdifferentiableAt

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

---

For maps between vector spaces, `MDifferentiableAt` and `DifferentiableAt` coincide  -/
theorem DifferentiableAt.mdifferentiableAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
      {f : E → E'} {x : E},
      DifferentiableAt 𝕜 f x → MDifferentiableAt (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') f x :=
  by sorry

The theorem `DifferentiableAt.mdifferentiableAt` states that for maps between vector spaces, if a function `f` is differentiable at a point `x` under the field `𝕜` (the field can be considered as a set which contains elements and these elements follow certain mathematical laws like addition, multiplication, etc.), then `f` is also `MDifferentiable` at point `x`. Here, `MDifferentiable` refers to differentiability in the manifold sense with respect to the model with corners, which in this case are the vector spaces themselves. This is essentially stating that the concepts of differentiability in the context of vector spaces and manifolds coincide.

If a function between vector spaces is differentiable at a point, then it is MDifferentiable at that point.


theorem Equiv.Perm.one_lt_card_support_of_ne_one :
    ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α},
      f ≠ 1 → 1 < (Equiv.Perm.support f).card :=
  by sorry

This theorem, `Equiv.Perm.one_lt_card_support_of_ne_one`, states that for any type `α` with decidable equality and finite number of elements, if a permutation `f` on `α` is not the identity permutation (represented by `1`), then the number of non-fixed points (`support`) of this permutation `f` is greater than one. Here, a non-fixed point of a permutation is an element that the permutation maps to a different element.

For any finite type `α` with decidable equality, a non-identity permutation on `α` has at least 2 non-fixed points.


theorem Finset.disjoint_Ioi_Iio :
    ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrderBot α] (a : α),
      Disjoint (Finset.Ioi a) (Finset.Iio a) :=
  by sorry

The theorem `Finset.disjoint_Ioi_Iio` states that, for any type `α` with a preorder structure and where `α` is both a locally finite order from the top and a locally finite order from the bottom, for any element `a` of `α`, the set of elements greater than `a` (`Finset.Ioi a`) is disjoint from the set of elements less than `a` (`Finset.Iio a`). In other words, there is no element `x` in `α` that can be both strictly greater than `a` and strictly less than `a` at the same time. This embodies the intuitive notion of the ordering in a set: if a number is greater than `a`, it cannot be less than `a` and vice versa.

For any locally finite preorder type `α` with elements `a`, the sets `Finset.Ioi a` and `Finset.Iio a` are disjoint.


theorem Set.Ici_add_bij :
    ∀ {M : Type u_1} [inst : OrderedCancelAddCommMonoid M] [inst_1 : ExistsAddOfLE M] (a d : M),
      Set.BijOn (fun x => x + d) (Set.Ici a) (Set.Ici (a + d)) :=
  by sorry

This theorem, `Set.Ici_add_bij`, states that for any type `M` that is an ordered, cancelable, and commutative monoid with an existing additive order (i.e., for every pair of elements in `M`, there exists a third element such that adding it to the lesser element yields the greater element), and for any two elements `a` and `d` of `M`, the function that adds `d` to an input is a bijective function from the set of elements that are greater than or equal to `a` (`Set.Ici a`) to the set of elements that are greater than or equal to `a + d` (`Set.Ici (a + d)`). In other words, if we add `d` to each element in the left-closed right-infinite interval starting at `a`, we get a one-to-one correspondence with the left-closed right-infinite interval starting at `a + d`.

For any ordered, cancelable, and commutative monoid `M` with an additive order, the function that adds a fixed element `d` is a bijection from the set of elements greater than or equal to `a` to the set of elements greater than or equal to `a + d`.


theorem Finset.union_sdiff_of_subset :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ⊆ t → s ∪ t \ s = t := by sorry

The theorem `Finset.union_sdiff_of_subset` states that for any type `α` with decidable equality, given any two finite sets `s` and `t` of type `α`, if `s` is a subset of `t`, then the union of `s` and the set difference of `t` and `s` is `t`. This can be viewed as a property of set operations where union with a set difference, under the condition that the first set is a subset of the second one, results in the original second set.

For any type `α` with decidable equality, if `s` is a subset of `finite set t` in `α`, then `s ∪ (t \ s) = t`.


theorem AddCommute.addOrderOf_add_dvd_lcm :
    ∀ {G : Type u_1} [inst : AddMonoid G] {x y : G},
      AddCommute x y → addOrderOf (x + y) ∣ Nat.lcm (addOrderOf x) (addOrderOf y) :=
  by sorry

The theorem `AddCommute.addOrderOf_add_dvd_lcm` states that for any type `G` that has an additive monoid structure, given any two elements `x` and `y` of `G` that commute additively (that is, `x + y = y + x`), the additive order of `x + y` is a divisor of the least common multiple of the additive orders of `x` and `y`. In other words, if we denote by `n • a` the result of adding `a` to itself `n` times, the smallest number `n` such that `n • (x + y) = 0` divides the least common multiple of the smallest numbers `m` and `l` such that `m • x = 0` and `l • y = 0`, respectively.

For any commuting additive monoid elements x and y, the additive order of x + y divides the least common multiple of the additive orders of x and y.


theorem mul_lt_one_of_nonneg_of_lt_one_right :
    ∀ {α : Type u} [inst : OrderedSemiring α] {a b : α}, a ≤ 1 → 0 ≤ b → b < 1 → a * b < 1 := by sorry

This theorem states that for any ordered semiring `α`, given two elements `a` and `b` from `α`, if `a` is less than or equal to 1, `b` is non-negative (greater than or equal to 0), and `b` is less than 1, then the product of `a` and `b` is less than 1. This theorem essentially captures the property that in an ordered semiring, the product of a number less than or equal to 1 and a positive number less than 1 is itself less than 1.

In an ordered semiring, if `0 ≤ a ≤ 1` and `0 ≤ b < 1`, then `a * b < 1`.


theorem CategoryTheory.Subgroupoid.le_iff :
    ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S T : CategoryTheory.Subgroupoid C),
      S ≤ T ↔ ∀ {c d : C}, S.arrows c d ⊆ T.arrows c d :=
  by sorry

This theorem is about the relation between two sub-groupoids in category theory. Given two sub-groupoids `S` and `T` of a groupoid `C`, this theorem states that `S` is less than or equal to `T` if and only if for all objects `c` and `d` in `C`, the set of arrows (or morphisms) in `S` from `c` to `d` is a subset of the set of arrows in `T` from `c` to `d`.

Given sub-groupoids `S` and `T` of a groupoid `C`, `S` is included in `T` if and only if for all objects `c` and `d` in `C`, the set of arrows from `c` to `d` in `S` is a subset of the set of arrows from `c` to `d` in `T`.


theorem one_sub_div : ∀ {K : Type u_3} [inst : DivisionRing K] {a b : K}, b ≠ 0 → 1 - a / b = (b - a) / b := by sorry

This theorem, named `one_sub_div`, applies to any division ring `K` and two elements `a` and `b` in `K`. It states that, assuming `b` is not equal to zero, subtracting `a / b` from `1` is equivalent to dividing the difference of `b` and `a` by `b`. In mathematical terms, it asserts that:

1 - (a / b) = (b - a) / b, given that b ≠ 0.

Given a division ring `K` and elements `a, b` in `K` with `b ≠ 0`, the equality `1 - (a / b) = (b - a) / b` holds.


theorem Array.get_push_eq : ∀ {α : Type u_1} (a : Array α) (x : α), (Array.push a x)[Array.size a] = x := by sorry

The theorem `Array.get_push_eq` states that for any type `α`, any array `a` of type `α`, and any element `x` of type `α`, if we push the element `x` onto the end of the array `a` to create a new array, then the element at the index corresponding to the original size of the array `a` in the new array is `x`. In other words, if you append an element to the end of an array, you can retrieve it using the original array's size as the index.

For any type `α`, array `a` of length `n` over `α`, and `x ∈ α`, the element at position `n` in the array obtained by appending `x` to `a` is `x`.


theorem iSup_split :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α) (p : β → Prop),
      ⨆ i, f i = (⨆ i, ⨆ (_ : p i), f i) ⊔ ⨆ i, ⨆ (_ : ¬p i), f i :=
  by sorry

This theorem states that for any type `α` that forms a complete lattice and a function `f` from another type `β` to `α`, and a given predicate `p` on `β`, the supremum of `f` over all `β` is equal to the join (supremum) of two other suprema: the supremum of `f` over all `β` that satisfy the predicate `p`, and the supremum of `f` over all `β` that do not satisfy the predicate `p`. Essentially, it's splitting the set of all `β` into two based on whether they satisfy a condition `p`, and relating the overall supremum to the suprema of these two subsets.

Given a complete lattice `α`, a function `f` from type `β` to `α`, and a predicate `p` on `β`, the supremum of `f` over `β` equals the join of the suprema of `f` over `β` satisfying `p` and those over `β` not satisfying `p`.


theorem Complex.arg_le_pi_div_two_iff : ∀ {z : ℂ}, Complex.arg z ≤ Real.pi / 2 ↔ 0 ≤ z.re ∨ z.im < 0 := by sorry

The theorem `Complex.arg_le_pi_div_two_iff` states that for any complex number `z`, the argument of `z` (as defined by `Complex.arg`) is less than or equal to pi divided by 2 if and only if the real part of `z` is non-negative or the imaginary part of `z` is negative. In other words, it provides a characterization of the complex numbers whose argument is less than or equal to $\frac{\pi}{2}$ in terms of the signs of their real and imaginary parts.

The complex argument is less than or equal to pi/2 if and only if the real part is non-negative or the imaginary part is negative.


theorem Equiv.Perm.SameCycle.cycleOf_eq :
    ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x y : α},
      Equiv.Perm.SameCycle f x y → Equiv.Perm.cycleOf f x = Equiv.Perm.cycleOf f y :=
  by sorry

This theorem states that for any type `α` that has a decidable equality and is a finite type, given a permutation `f` of `α` and any two elements `x` and `y` of `α`, if `x` and `y` are in the same cycle of the permutation `f` (as denoted by `Equiv.Perm.SameCycle f x y`), then the cycles of `x` and `y` in the permutation `f` (as denoted by `Equiv.Perm.cycleOf f x` and `Equiv.Perm.cycleOf f y`, respectively) are equal. In other words, if two elements are in the same cycle of a permutation, they share the same cycle.

For any finite type `α` with decidable equality, if `x` and `y` are in the same cycle of a permutation `f` on `α`, then `Equiv.Perm.cycleOf f x` equals `Equiv.Perm.cycleOf f y`.


theorem Complex.arg_of_im_neg : ∀ {z : ℂ}, z.im < 0 → Complex.arg z = -Real.arccos (z.re / Complex.abs z) := by sorry

The theorem `Complex.arg_of_im_neg` states that for any complex number `z`, if the imaginary part of `z` is less than 0, then the argument of `z` (the angle in polar coordinates) is equal to the negative of the arccosine of the ratio of the real part of `z` to the absolute value of `z`. Here, the arccosine function returns values in the range [0, π], and the argument of a complex number is defined to be in the range (-π, π].

If the imaginary part of a complex number `z` is negative, then the argument of `z` equals the negative of the arccosine of the real part of `z` divided by the absolute value of `z`. (Arguments are in the range [-π, π]).


BoxIntegral.HasIntegral.neg

theorem BoxIntegral.HasIntegral.neg :
    ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
      {l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤} {y : F},
      BoxIntegral.HasIntegral I l f vol y → BoxIntegral.HasIntegral I l (-f) vol (-y) :=
  by sorry

The theorem `BoxIntegral.HasIntegral.neg` states that for any given type `ι`, a normed add commutative group `E` and a normed space over `ℝ` for `E`, a normed add commutative group `F` and another normed space over `ℝ` for `F`, along with a box integral `I` over `ι`, a finite type over `ι`, an integration parameter `l`, a function `f` from `ι → ℝ` to `E`, a volume form `vol` as an additive map from the box integral to the top element of the continuous linear map from `E` to `F`, and a value `y` in `F`. If the box integral `I` integrates `f` with respect to `vol` to `y`, then the box integral `I` also integrates the negation of `f` with respect to `vol` to the negation of `y`.

If a box integral over a type `ι` integrates a function `f` from `ι` to a normed space `E` over `ℝ` with respect to a volume form `vol` to a value `y` in another normed space `F`, then it also integrates the negation of `f` with respect to `vol` to the negation of `y`.


theorem CategoryTheory.ShiftMkCore.shiftFunctorAdd_eq :
    ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
      (h : CategoryTheory.ShiftMkCore C A) (a b : A), CategoryTheory.shiftFunctorAdd C a b = h.add a b :=
  by sorry

This theorem, `CategoryTheory.ShiftMkCore.shiftFunctorAdd_eq`, states that for any two elements `a` and `b` from an additive monoid `A`, and given a shift-making core structure `h` in a category `C`, the result of applying the shift functor addition operation `shiftFunctorAdd` on `C`, `a`, and `b` is equal to the result of applying the `add` operation of `h` on `a` and `b`. Essentially, it provides an equivalence between the shift functor addition operation and the addition operation defined in the shift-making core structure in the context of category theory.

For any additive monoid `A` and shift-making core structure `h` in a category `C`, the shift functor addition `shiftFunctorAdd h a b` is equal to the `add` operation applied to `a` and `b` in `h`.


theorem multiplicity.isUnit_right :
    ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : DecidableRel fun x x_1 => x ∣ x_1] {a b : α},
      ¬IsUnit a → IsUnit b → multiplicity a b = 0 :=
  by sorry

The theorem `multiplicity.isUnit_right` states that for any type `α` that has the structure of a commutative monoid and a decidable relation for divisibility, given any two elements `a` and `b` of this type, if `a` is not a unit and `b` is a unit, then the multiplicity of `a` in `b` is zero. Here, a unit is an element that has a two-sided inverse (like 1 in the natural numbers), and the multiplicity of `a` in `b` is the largest natural number `n` such that `a^n` divides `b`. In other words, a non-unit element does not divide a unit element.

For any commutative monoid with decidable divisibility relation, a non-unit element does not divide a unit element.


theorem List.foldl_cons :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : β → α → β} (l : List α) (b : β),
      List.foldl f b (a :: l) = List.foldl f (f b a) l :=
  by sorry

The theorem `List.foldl_cons` states that for any types `α` and `β`, any value `a` of type `α`, any function `f` of type `β → α → β`, any list `l` of elements of type `α`, and any value `b` of type `β`, the result of folding the function `f` over the list obtained by prepending `a` to `l`, starting with `b`, is equal to the result of folding the function `f` over the list `l`, starting with `f b a`. This essentially means that the first operation in the fold of the extended list is applying `f` to `b` and `a`.

For any types `α` and `β`, the result of appending an element `a` of type `α` to a list `l` of length `n` and folding a function `f : β → α → β` over the extended list starting with `b` of type `β`, is equal to the result of folding `f` over the original list `l` starting with `f(b, a)`.


theorem Set.ssubset_iff_insert : ∀ {α : Type u} {s t : Set α}, s ⊂ t ↔ ∃ a ∉ s, insert a s ⊆ t := by sorry

This theorem states that for any arbitrary type `α`, and any two sets `s` and `t` of type `α`, `s` is a proper subset of `t` if and only if there exists an element `a` not in `s` such that inserting `a` into `s` results in a set that is a subset of `t`. In other words, `s` is a proper subset of `t` precisely when `t` contains `s` and at least one additional element not in `s`.

A set `s` is a proper subset of `t` if and only if `t` contains `s` and there exists an element not in `s` that belongs to `t`.


theorem Filter.mem_top : ∀ {α : Type u} {s : Set α}, s ∈ ⊤ ↔ s = Set.univ := by sorry

The theorem `Filter.mem_top` states that for any type `α` and any set `s` of type `α`, `s` is a member of the top filter if and only if `s` is the universal set of `α`. In other words, within the context of filters, the top filter only contains the universal set that includes all elements of a given type `α`.

The top filter of a set `s` in type `α` contains exactly the universal set of `α`.


/-- **Alias** of the reverse direction of `Asymptotics.isLittleO_iff_tendsto`. -/
theorem Asymptotics.isLittleO_of_tendsto :
    ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {l : Filter α} {f g : α → 𝕜},
      (∀ (x : α), g x = 0 → f x = 0) → Filter.Tendsto (fun x => f x / g x) l (nhds 0) → f =o[l] g :=
  by sorry

This theorem, referred to as the alias of the reverse direction of `Asymptotics.isLittleO_iff_tendsto`, states that for any types `α` and `𝕜`, where `𝕜` is a normed division ring, and for any filter `l` and two functions `f` and `g` from `α` to `𝕜`, if for every `x` in `α`, `g` of `x` is zero implies that `f` of `x` is also zero, and if the limit of the function `f/g` as `x` approaches any value in the domain `α` (according to filter `l`) is zero, then `f` is little-o of `g` (denoted by `f =o[l] g`). That is, the function `f` is asymptotically smaller than `g` at all points determined by the filter `l`.

If a function `f` from type `α` to a normed division ring `𝕜` satisfies `g(x) = 0 implies f(x) = 0` and `lim (f/g)ₗl = 0`, then `f = o[l] g`. (Here, `lim (f/g)ₗl` denotes the limit of the quotient `f/g` as `x` approaches any value in `α` according to filter `l`.)


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

The theorem `Basis.toBasis_toOrthonormalBasis` states that for any finite-dimensional inner product space `E` over a ring `𝕜` that behaves like real or complex numbers, if we have a basis `v` for `E` and this basis is orthonormal (meaning each basis vector has norm 1 and any pair of different basis vectors are orthogonal), then the basis obtained by converting this orthonormal basis back to a regular basis is the same as the original basis `v`. In other words, the process of converting a basis to an orthonormal basis and then back to a regular basis is an identity operation on the set of orthonormal bases.

For any finite-dimensional inner product space over a ring behaving like the real or complex numbers, if a basis is orthonormal, then converting it to a regular basis and back yields the original basis.


theorem Nat.evenOddRec.proof_1 : ∀ (i : ℕ), 2 * i = bit0 i := by sorry

This theorem states that for any natural number `i`, multiplying `i` by 2 is the same as applying the `bit0` function to `i`. The `bit0` function takes a number and adds it to itself, which is the definition of multiplication by two. Therefore, it is true for all natural numbers `i` that `2 * i` is equivalent to `bit0 i`.

For all natural numbers `i`, `2 * i` is equivalent to `bit0 i`. In other words, multiplying a natural number by 2 is the same as applying the `bit0` function.


theorem Nat.evenOddRec.proof_2 : ∀ (i : ℕ), 2 * i + 1 = bit1 i := by sorry

This theorem states that for every natural number `i`, the result of multiplying `i` by 2 and then adding 1 is equal to the application of the `bit1` function to `i`. In other words, the value of `2*i + 1` and `bit1 i` are the same for any natural number `i`. The `bit1` function in this context effectively doubles its input and then adds one, which mirrors the operation on the left side of the equation.

For all natural numbers `i`, `2 * i + 1` equals `bit1 i`.


theorem Equiv.Perm.IsCycle.exists_zpow_eq :
    ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, Equiv.Perm.IsCycle f → f x ≠ x → f y ≠ y → ∃ i, (f ^ i) x = y := by
  sorry

This theorem states that for any type `α`, given a permutation `f` on `α` which is a cycle (as defined by `Equiv.Perm.IsCycle`), and any two elements `x` and `y` of `α` such that `f` applied to `x` and `y` does not yield `x` and `y` respectively (`f x ≠ x` and `f y ≠ y`), there exists an integer `i` such that applying `f` to `x`, `i` times (`(f ^ i) x`), yields `y`. In other words, for a cycle permutation and two non-fixed points, you can find a number of times to apply the permutation to one point to reach the other point.

For any cycle permutation `f` on a type `α` and distinct elements `x` and `y` in `α` with `f(x) ≠ x` and `f(y) ≠ y`, there exists an integer `i` such that `(f ^ i) x = y`.


theorem CategoryTheory.Limits.prodComparison_snd :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{w, u₂} D]
      (F : CategoryTheory.Functor C D) (A B : C) [inst_2 : CategoryTheory.Limits.HasBinaryProduct A B]
      [inst_3 : CategoryTheory.Limits.HasBinaryProduct (F.obj A) (F.obj B)],
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prodComparison F A B) CategoryTheory.Limits.prod.snd =
        F.map CategoryTheory.Limits.prod.snd :=
  by sorry

This theorem, `CategoryTheory.Limits.prodComparison_snd`, states that for any categories `C` and `D`, and any functor `F` from `C` to `D`, and for any objects `A` and `B` of `C`, given that both `A` and `B` have binary products in `C` and their images under `F` have binary products in `D`, the composition of the product comparison morphism `CategoryTheory.Limits.prodComparison F A B` and the projection to the second factor `CategoryTheory.Limits.prod.snd` is equal to the image under `F` of the projection to the second factor. In other words, it shows that the functor `F` preserves the second projection of the binary product up to an isomorphism.

For any functor F between categories with binary products, the diagram commutes up to isomorphism: F(π₂(A, B)) = π₂(F(A), F(B)).


theorem lowerSemicontinuousAt_ciSup :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {ι : Sort u_3} {δ' : Type u_5}
      [inst_1 : ConditionallyCompleteLinearOrder δ'] {f : ι → α → δ'},
      (∀ᶠ (y : α) in nhds x, BddAbove (Set.range fun i => f i y)) →
        (∀ (i : ι), LowerSemicontinuousAt (f i) x) → LowerSemicontinuousAt (fun x' => ⨆ i, f i x') x :=
  by sorry

The theorem `lowerSemicontinuousAt_ciSup` states that for a topological space `α`, a point `x` from that space, and a conditionally complete linear order `δ'`, if a function `f` mapping from some index set `ι` to `α` to `δ'` satisfies two conditions: (1) for all points `y` in a neighborhood of `x`, the range of function values is bounded above, and (2) the function `f` is lower semicontinuous at `x` for each index `i`, then the supremum function which takes `x'` to the supremum of `f i x'` over all `i`, is also lower semicontinuous at `x`.

In other words, if each function in a family of functions is lower semicontinuous at a point and the family is bounded above in a neighborhood of that point, then the function that gives the supremum of the family at each point is also lower semicontinuous at the given point.

If a family of lower semicontinuous functions from a topological space to a conditionally complete linear order, each bounded above in a neighborhood of a point, has a supremum function that is also defined and bounded at that point, then the supremum function is lower semicontinuous at the point.


theorem Mathlib.Data.Setoid.Basic._auxLemma.2 :
    ∀ {α : Type u_1} {r s : Setoid α}, (r ≤ s) = ∀ {x y : α}, Setoid.Rel r x y → Setoid.Rel s x y := by sorry

This theorem states that for any types `α` and any two Setoids `r` and `s` on `α`, the statement that `r` is a subset of `s` (denoted by `r ≤ s`) is equivalent to the statement that for all `x` and `y` of type `α`, if `x` and `y` are related by the relation `r` (denoted by `Setoid.Rel r x y`), then `x` and `y` are also related by the relation `s` (denoted by `Setoid.Rel s x y`). In mathematical terms, this is stating that one equivalence relation is a subset of another if and only if every pair of elements that are equivalent under the first relation are also equivalent under the second relation.

For any Setoids `r` and `s` on a type `α`, `r ≤ s` if and only if for all `x` and `y` of type `α`, `Setoid.Rel r x y` implies `Setoid.Rel s x y`.


theorem Matrix.StdBasisMatrix.mul_right_apply_same :
    ∀ {n : Type u_3} {α : Type u_5} [inst : DecidableEq n] [inst_1 : Semiring α] (i j : n) (c : α) [inst_2 : Fintype n]
      (a : n) (M : Matrix n n α), (M * Matrix.stdBasisMatrix i j c) a j = M a i * c :=
  by sorry

The theorem `Matrix.StdBasisMatrix.mul_right_apply_same` states that for any type `n` with decidable equality and any semiring `α`, given indices `i`, `j` of type `n`, a scalar `c` of type `α`, a matrix `M` of type `Matrix n n α`, and an index `a` of type `n`, the result of multiplying matrix `M` with the standard basis matrix at indices `i`, `j` with value `c` and then applying the resulting matrix at indices `a`, `j` is equal to the product of the element at indices `a`, `i` of the matrix `M` and scalar `c`. This theorem essentially describes a property of matrix multiplication with respect to standard basis matrices.

For any semiring α and type n with decidable equality, the product of matrix M with the standard basis matrix at indices i, j multiplied by scalar c, and then applying the resulting matrix at indices a, j, equals the product of the element at indices a, i of matrix M and scalar c.


theorem PowerSeries.X_pow_eq :
    ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), PowerSeries.X ^ n = (PowerSeries.monomial R n) 1 := by sorry

This theorem states that for any semiring `R` and any natural number `n`, raising `X` of the formal power series ring to the `n`th power is equal to the `n`th monomial with coefficient 1 in `R`. In other words, $(X^n)$ in the formal power series ring is the same as the `n`th monomial where the coefficient is 1.

For any semiring `R` and natural number `n`, the `n`th power of `X` in the formal power series ring equals the `n`th monomial with coefficient 1 in `R`.


/-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
a monotone sequence.  -/
theorem Monotone.monotone_iterate_of_le_map :
    ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, Monotone f → x ≤ f x → Monotone fun n => f^[n] x := by
  sorry

This theorem states that if `f` is a monotone function over a set with a pre-order structure and there exists a point `x` such that `x ≤ f x`, then the sequence formed by repeatedly applying `f` to `x` (`f^[n] x`) is also monotone. In other words, for a monotone function, whenever `x` is less than or equal to its image under `f`, the sequence obtained by iterating `f` on `x` preserves the order.

If `f` is a monotone function on a pre-ordered set and `x` is an element such that `x ≤ f x`, then the sequence `(f^[n] x)` is monotone.


theorem ENNReal.openEmbedding_coe : OpenEmbedding ENNReal.ofNNReal := by sorry

This theorem states that the function `ENNReal.ofNNReal`, which maps from the set of non-negative real numbers (`NNReal`) to the extended non-negative real numbers (`ENNReal`), is an open embedding. In topology, an open embedding is a function between topological spaces which is both an embedding (injective and homeomorphic to its image) and open (the image of an open set is open). Therefore, the 'openness' property of this function ensures that it preserves the topology, i.e., the open set structures of `NNReal` and `ENNReal`.

The function `ENNReal.ofNNReal` is an open embedding from the non-negative real numbers to the extended non-negative real numbers.


theorem CochainComplex.HomComplex.Cochain.ofHom_zero :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
      (F G : CochainComplex C ℤ), CochainComplex.HomComplex.Cochain.ofHom 0 = 0 :=
  by sorry

This theorem states that for any given category `C` (where `C` is preadditive) and any two cochain complexes `F` and `G` over `C` with integer indexing, the `0`-cochain attached to the zero morphism between these cochain complexes is also a zero morphism. This reflects the property in homological algebra that applying a zero morphism in a chain complex yields a zero morphism.

In a preadditive category `C`, the 0-cochain of the zero morphism between two cochain complexes `F` and `G` over `C` with integer indexing is the identity morphism. (This is equivalent to stating that the application of a zero morphism in a cochain complex results in a cochain of zeros.)


theorem Function.Surjective.preimage_injective :
    ∀ {α : Type u_2} {β : Type u_3} {f : α → β}, Function.Surjective f → Function.Injective (Set.preimage f) := by sorry

The theorem `Function.Surjective.preimage_injective` states that for any types `α` and `β` and any function `f` from `α` to `β`, if `f` is surjective (meaning that for each element `b` in `β` there exists an element `a` in `α` such that `f(a) = b`), then the function that gets the preimage of a set under `f` is injective. In other words, if `f` is surjective, then for any two sets `s1` and `s2` of `β`, if `f` maps the same set of `α` to `s1` and `s2` (`f`'s preimage of `s1` and `s2` are the same), then `s1` and `s2` must be the same set.

If `f` is a surjective function from type `α` to type `β`, then for any sets `s1` and `s2` in `β`, `f⁁¹(s1) = f⁁¹(s2)` implies `s1 = s2`.


theorem LinearMap.toFun_eq_coe :
    ∀ {R : Type u_1} {S : Type u_6} {M : Type u_9} {M₃ : Type u_12} [inst : Semiring R] [inst_1 : Semiring S]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
      {f : M →ₛₗ[σ] M₃}, f.toFun = ⇑f :=
  by sorry

This theorem states that for any semirings `R` and `S`, additive commutative monoids `M` and `M₃`, modules `M` over `R` and `M₃` over `S`, and a ring homomorphism `σ` from `R` to `S`, the `toFun` function of a linear map `f` from `M` to `M₃` under `σ` is equal to `f` when considered as a function (i.e., `f.toFun = ⇑f`). Essentially, this reconfirms the identification of a linear map `f` with its underlying function.

For any semirings R and S, additive commutative monoids M and M₃, modules M over R and M₃ over S, and a ring homomorphism σ from R to S, the toFun function of a linear map f from M to M₃ under σ equals f as functions.


theorem Multiset.revzip_powersetAux :
    ∀ {α : Type u_1} {l : List α} ⦃x : Multiset α × Multiset α⦄,
      x ∈ List.revzip (Multiset.powersetAux l) → x.1 + x.2 = ↑l :=
  by sorry

The theorem `Multiset.revzip_powersetAux` states that for any type `α`, any list `l` of that type, and any pair of multisets `x`, if `x` is an element of the list obtained by applying the function `List.revzip` to the powerset of `l`, then the sum of the two multisets in the pair `x` is equal to the multiset associated with the list `l`. In simpler terms, it states that each pair of subsets in the reverse-zipped powerset of a list sums up to the original list when considered as multisets, allowing for reordering and repetition of elements.

For any type `α` and list `l` of length `n` over `α`, if multisets `x` and `y` are paired in the reverse-zipped powerset of `l`, then `x ⊎ y = ∫i=0<n x(i) ⊎ y(n-i) dι`, where `⊎` denotes multiset union and `∫` denotes summation.


theorem inf_sdiff_distrib_left :
    ∀ {α : Type u} [inst : GeneralizedBooleanAlgebra α] (a b c : α), a ⊓ b \ c = (a ⊓ b) \ (a ⊓ c) := by sorry

This theorem states that for any generalized Boolean algebra, the operation of finding the infimum (greatest lower bound) of `a` and `b` and then subtracting `c` is equivalent to finding the infimum of `a` and `b` first, and then subtracting the infimum of `a` and `c`. In essence, it's expressing a property of distributivity of the `sdiff` (set difference) and `inf` (infimum or greatest lower bound) operations over the elements of the algebra.

In a generalized Boolean algebra, the operation of taking the infimum of two elements and then subtracting a third element is equivalent to first taking the infimum of the first two elements and then subtracting their infimum with the third element.


theorem CategoryTheory.MorphismProperty.StableUnderBaseChange.fst :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C},
      CategoryTheory.MorphismProperty.StableUnderBaseChange P →
        ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [inst_1 : CategoryTheory.Limits.HasPullback f g],
          P g → P CategoryTheory.Limits.pullback.fst :=
  by sorry

This theorem states that for any category `C`, if a property `P` of morphisms in `C` is stable under base change, then for any objects `X`, `Y`, and `S` in `C`, and morphisms `f : X ⟶ S` and `g : Y ⟶ S` that have a pullback, if `P` holds for the morphism `g`, then it also holds for the first projection of the pullback of `f` and `g`. In terms of category theory, this means that the property of morphisms being examined is preserved under the operation of forming pullbacks and projecting onto the first factor.

If a property of morphisms in a category is stable under base change, then for any morphisms with a pullback and having the property, the first projection of their pullback also possesses the property.


theorem deriv_inv : ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜}, deriv (fun x => x⁻¹) x = -(x ^ 2)⁻¹ := by
  sorry

This theorem states that for any non-trivially normed field `𝕜` and any value `x` in this field, the derivative of the function `f(x) = x⁻¹` (the reciprocal of `x`) at the point `x` is equal to `-(x ^ 2)⁻¹` (the negative reciprocal of the square of `x`). In mathematical terms, if `f(x) = 1/x`, then `f'(x) = -1/x²`. This is a basic result in calculus.

The derivative of the reciprocal function `f(x) = 1/x` is `-1/x²`.


theorem AddMonoidAlgebra.single_zero_mul_apply :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : AddZeroClass G] (f : AddMonoidAlgebra k G) (r : k)
      (x : G), (AddMonoidAlgebra.single 0 r * f) x = r * f x :=
  by sorry

The theorem `AddMonoidAlgebra.single_zero_mul_apply` states that for any semiring `k`, any `AddZeroClass` `G` (i.e., a type endowed with an addition operation and a zero element), any `AddMonoidAlgebra` `f` over `k` and `G`, and any element `r` of `k` and `x` of `G`, the convolution product of the `AddMonoidAlgebra` generated by the zero element of `G` and the element `r` of `k`, with `f`, evaluated at `x`, is equal to `r` times the value of `f` at `x`. Essentially, this theorem is capturing the distributive property of multiplication over addition in the context of monoid algebras.

For any semiring `k`, AddMonoidAlgebra over `k` and AddZeroClass `G`, element `r` of `k`, and `x` of `G`, the convolution product of the AddMonoidAlgebra generated by the zero element of `G` and `r` with `f` equals `r` times `f(x)`.


Inseparable.refl

theorem Inseparable.refl : ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X), Inseparable x x := by sorry

This theorem, `Inseparable.refl`, states that for any given point 'x' in a topological space 'X', the point 'x' is inseparable from itself. In other words, in any topological space, a point is always inseparable from itself, which means the neighbourhoods of the point 'x' are always the same as the neighbourhoods of the same point 'x'.

For any point x in a topological space, the singleton sets {x} and {x} have non-empty intersection. In Lean 4, this is expressed as the theorem `Inseparable.refl x : ∃ (U : set X), x ∈ U ∧ x ∈ U.^op`.


theorem natAbs_nsmul_eq_zero : ∀ {G : Type u_3} [inst : AddGroup G] {a : G} {n : ℤ}, Int.natAbs n • a = 0 ↔ n • a = 0 :=
  by sorry

The theorem `natAbs_nsmul_eq_zero` states that for any type `G` which is an add group, and for any element `a` of `G` and integer `n`, the `n`-fold addition of `a` (defined by `n • a`) is zero if and only if the `n`-fold addition of `a` where `n` is the absolute value of an integer is zero. In other words, the repetition of addition operation (`n • a`) results in zero both when `n` is an integer and when `n` is the absolute value of that integer.

For any add group `G` and element `a` in `G`, the repeated addition of `a` (`n • a`) is equal to zero if and only if the absolute value of the integer `n` equals zero. (In Lean, this theorem is named `natAbs_nsmul_eq_zero`.)


theorem upperBounds_union :
    ∀ {α : Type u} [inst : Preorder α] {s t : Set α}, upperBounds (s ∪ t) = upperBounds s ∩ upperBounds t := by sorry

This theorem states that for any two sets `s` and `t` of some type `α` which has a preorder (a binary relation that is reflexive and transitive), the set of upper bounds of the union of `s` and `t` is equal to the intersection of the set of upper bounds of `s` and the set of upper bounds of `t`. In more mathematical terms, this theorem is saying that $\operatorname{upperBounds}(s \cup t) = \operatorname{upperBounds}(s) \cap \operatorname{upperBounds}(t)$. An upper bound of a set is an element that is greater than or equal to every element in the set.

For sets `s` and `t` in type `α` with a preorder, the set of upper bounds of their union equals the intersection of the upper bounds of `s` and `t`. In mathematical notation, $\operatorname{upperBounds}(s \cup t) = \operatorname{upperBounds}(s) \cap \operatorname{upperBounds}(t)$.


ConvexBody.convex

theorem ConvexBody.convex :
    ∀ {V : Type u_1} [inst : TopologicalSpace V] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V] (K : ConvexBody V),
      Convex ℝ ↑K :=
  by sorry

The theorem `ConvexBody.convex` states that for any convex body `K` in a topological space `V` (which is also an additive commutative group and a real number `ℝ` module), the convex body `K` is a convex set in `V` with respect to `ℝ`. In other words, for any two points within this convex body, the entire line segment that joins these two points also lies within the convex body.

For any convex body K in a topological vector space V with real scalars, every line segment contained in K is also a subset of K.


/-- Change of variable formula for differentiable functions: if a function `f` is
injective and differentiable on a measurable set `s`, then the Bochner integral of a function
`g : E → F` on `f '' s` coincides with the integral of `|(f' x).det| • g ∘ f` on `s`.  -/
theorem MeasureTheory.integral_image_eq_integral_abs_det_fderiv_smul :
    ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
      [inst_2 : FiniteDimensional ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] {s : Set E}
      {f : E → E} {f' : E → E →L[ℝ] E} [inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E]
      (μ : MeasureTheory.Measure E) [inst_7 : MeasureTheory.Measure.IsAddHaarMeasure μ],
      MeasurableSet s →
        (∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) →
          Set.InjOn f s →
            ∀ (g : E → F),
              ∫ (x : E) in f '' s, g x ∂μ = ∫ (x : E) in s, |ContinuousLinearMap.det (f' x)| • g (f x) ∂μ :=
  by sorry

This is a theorem about the change of variables in integration for differentiable functions. It states that if you have a function `f` which is injective and differentiable on a measurable set `s`, then the integral of any function `g : E → F` over the image of `s` under `f` is equal to the integral of the absolute value of the determinant of the derivative of `f` scaled by `g ∘ f` over `s`. This theorem is essentially a generalization of the substitution rule from single-variable calculus to the context of functions between finite-dimensional real normed spaces.

If `f : E → F` is injective and differentiable on a measurable set `s ⊆ E`, then ∫g(f(x)) d(m\_E)(x) = |∥DF(x)∥⁻¹∫|g(y)∥∥DF(x)∥⁴ d(m\_F)(y), where `m_E` and `m_F` are Lebesgue measures on `E` and `F` respectively, and `DF(x)` is the Jacobian matrix of `f` at `x`.


theorem Finset.ext_iff : ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁ = s₂ ↔ ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ := by sorry

This theorem states that for any two finite sets `s₁` and `s₂` of a certain type `α`, `s₁` is equal to `s₂` if and only if for every element `a` of type `α`, `a` is an element of `s₁` if and only if `a` is an element of `s₂`. In other words, two finite sets are equal if they contain exactly the same elements.

Two finite sets `s₁` and `s₂` of type `α` are equal if and only if they have the same elements.


theorem Metric.cthickening_eq_iInter_thickening :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ},
      0 ≤ δ → ∀ (E : Set α), Metric.cthickening δ E = ⋂ ε, ⋂ (_ : δ < ε), Metric.thickening ε E :=
  by sorry

This theorem states that for any type `α` that has a pseudo emetric space structure, any non-negative real number `δ`, and any set `E` of the type `α`, the closed δ-thickening of `E` is equal to the intersection over all `ε` of the open ε-thickening of `E` for all `ε` larger than `δ`. In other words, the set of all points that are at a distance of at most `δ` from the set `E` is exactly the same as the set of all points that are at a distance less than `ε` from `E` for all `ε` larger than `δ`. This is a statement about how we can construct a closed "thickening" of a set in a pseudo emetric space from open "thickenings".

For any pseudo metric space `α` and set `E` in `α`, the closed `δ`-ball around `E` equals the intersection of all open `ε`-balls around `E` with `ε > δ`.


theorem Continuous.Prod.mk_left :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (y : Y),
      Continuous fun x => (x, y) :=
  by sorry

This theorem, `Continuous.Prod.mk_left`, states that for any two types `X` and `Y` with `TopologicalSpace` instances, and any fixed element `y` of type `Y`, the function that takes an element `x` of type `X` and pairs it with the fixed `y` to form a pair `(x, y)` is a continuous function. This is stated in the context of topology, where continuity has a specific mathematical meaning related to the preservation of nearness.

For any topological spaces X and Y, and any fixed y in Y, the function x ═> (x, y) from X to X xico Y is continuous.


theorem Module.eval_ker :
    ∀ (K : Type uK) (V : Type uV) [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
      [inst_3 : Module.Free K V], LinearMap.ker (Module.Dual.eval K V) = ⊥ :=
  by sorry

This theorem states that for any commutative ring `K` and any module `V` over `K` that is free, the kernel of the evaluation linear map, which maps the module `V` to the dual of the dual of `V`, is trivial (i.e., it consists only of the zero vector). This means that the evaluation map is injective, or equivalently, it does not map any non-zero vector in `V` to the zero vector in the dual of the dual of `V`. Hence, in the context of module theory, this theorem is asserting the reflexivity of finite-dimensional vector spaces.

For any commutative ring `K` and free `K`-module `V`, the evaluation map from `V` to `(V^*)^*` is injective.


MeasureTheory.Measure.Regular.map

theorem MeasureTheory.Measure.Regular.map :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α]
      {μ : MeasureTheory.Measure α} [inst_2 : BorelSpace α] [inst_3 : MeasurableSpace β] [inst_4 : TopologicalSpace β]
      [inst_5 : BorelSpace β] [inst_6 : MeasureTheory.Measure.Regular μ] (f : α ≃ₜ β),
      MeasureTheory.Measure.Regular (MeasureTheory.Measure.map (⇑f) μ) :=
  by sorry

This theorem states that for any two types `α` and `β` with `α` having a measurable space structure, a topological space structure, a borel space structure and a regular measure `μ`, and `β` having a measurable space structure, a topological space structure, and a borel space structure, if there exists a homeomorphism `f` from `α` to `β`, then the measure obtained by pushing forward `μ` via `f` is also a regular measure. This essentially means that under these conditions, the property of being a regular measure is preserved under the operation of pushing forward by a homeomorphism.

If `α` and `β` are measurable spaces with topological spaces and borel structures, `μ` is a regular measure on `α`, `f` is a homeomorphism from `α` to `β`, then the pushforward measure `f_*\mu` on `β` is also a regular measure.


theorem Set.Ico_subset_Ico_union_Ico :
    ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a c ⊆ Set.Ico a b ∪ Set.Ico b c := by sorry

The theorem `Set.Ico_subset_Ico_union_Ico` states that for any linearly ordered type `α` and any three elements `a`, `b`, and `c` of this type, the left-closed right-open interval from `a` to `c` (denoted `Set.Ico a c`) is a subset of the union of the left-closed right-open interval from `a` to `b` and the left-closed right-open interval from `b` to `c` (denoted `Set.Ico a b ∪ Set.Ico b c`). In mathematical terms, we are saying if `x` is in the interval `[a, c)`, then `x` is necessarily in the interval `[a, b)` or in the interval `[b, c)`.

For any linearly ordered type `α` and elements `a < b < c` in `α`, `Set.Ico a c` is a subset of `Set.Ico a b ∪ Set.Ico b c`. In other words, every element in the left-closed right-open interval from `a` to `c` belongs to either the interval from `a` to `b` or the interval from `b` to `c`.


theorem NonUnitalRingHom.ext_iff :
    ∀ {α : Type u_2} {β : Type u_3} [inst : NonUnitalNonAssocSemiring α] [inst_1 : NonUnitalNonAssocSemiring β]
      {f g : α →ₙ+* β}, f = g ↔ ∀ (x : α), f x = g x :=
  by sorry

This theorem states that for any two non-unital ring homomorphisms `f` and `g` from a type `α` to a type `β`, where both `α` and `β` are non-unital, non-associative semirings, `f` is equal to `g` if and only if `f` and `g` map every element `x` in `α` to the same element in `β`. In other words, two such ring homomorphisms are equal if they behave the same way on every element of `α`.

Two non-unital ring homomorphisms from a non-unital, non-associative semiring `α` to a non-unital semiring `β` are equal if and only if they map every element of `α` to the same image in `β`.


theorem Pi.uniformContinuous_postcomp' :
    ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] {β : ι → Type u_4}
      [inst : (i : ι) → UniformSpace (β i)] {g : (i : ι) → α i → β i},
      (∀ (i : ι), UniformContinuous (g i)) → UniformContinuous fun f i => g i (f i) :=
  by sorry

The theorem `Pi.uniformContinuous_postcomp'` states that if for every index `ι` in a given set, a function `g` mapping from a uniform space `α` to another uniform space `β` is uniformly continuous, then the function composition of `g` and another function `f`, where `f` takes an index `i` and returns an element in `α` at that index, is also uniformly continuous. In other words, for any index `i`, if `g(i)` is uniformly continuous, then the composite function `(g(i) ∘ f(i))` is also uniformly continuous. This theorem is a statement about the preservation of uniform continuity under function composition in the context of indexed sets of uniform spaces.

If, for each index `ι`, a uniformly continuous function `g(ι) : α → β` is composed with a function `f : ℛ → α` that maps indices to elements in `α`, the resulting composite function `g(f(ι)) : ℛ → β` is also uniformly continuous.


theorem Int.natAbs_one : Int.natAbs 1 = 1 := by sorry

The theorem `Int.natAbs_one` states that the absolute value of 1, when considered as an integer, is equal to 1. This is intuitive as the absolute value of any number, which is defined as its distance from zero along the number line, is always non-negative. In particular, the absolute value of 1 is 1 itself.

The theorem `Int.natAbs_one` asserts that |1| = 1 in the context of integers.


theorem Real.arctan_eq_arcsin : ∀ (x : ℝ), Real.arctan x = Real.arcsin (x / Real.sqrt (1 + x ^ 2)) := by sorry

The theorem `Real.arctan_eq_arcsin` states that for all real numbers `x`, the arctangent of `x` is equal to the arcsine of the expression `x / sqrt(1 + x^2)`. Here, `sqrt` refers to the square root of a real number. This theorem provides a relationship between the arctangent and arcsine functions, revealing them to be related through a particular expression involving the input `x`.

For all real numbers x, arctan x = arcsin (x / √(1 + x²)).


theorem TopologicalSpace.ext_iff :
    ∀ {X : Type u} {t t' : TopologicalSpace X}, t = t' ↔ ∀ (s : Set X), IsOpen s ↔ IsOpen s := by sorry

The theorem `TopologicalSpace.ext_iff` states that for any given type `X` and any two topological spaces `t` and `t'` over `X`, `t` is equal to `t'` if and only if for every set `s` in `X`, `s` is open in `t` if and only if `s` is open in `t'`. In other words, two topological spaces on the same set are identical if they have the same open sets.

Two topological spaces over the same set are equal if and only if they have identical open sets.