theorem LinearIndependent.cardinal_mk_le_finrank :
    ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      [inst_3 : StrongRankCondition R] [inst_4 : Module.Finite R M] {ι : Type w} {b : ι → M},
      LinearIndependent R b → Cardinal.mk ι ≤ ↑(FiniteDimensional.finrank R M) :=
  by sorry

This theorem states that for any Ring `R`, Additive Commutative Group `M`, where `M` is also a module over `R`, with `R` having the strong rank condition and `M` being a finite module, and any type `ι` with a function `b` from `ι` to `M` such that `b` defines a linearly independent set, the cardinality of type `ι` (i.e., the size of the set of linearly independent vectors) is less than or equal to the rank (i.e., the dimension) of the module `M` over `R`. In other words, the size of any linearly independent set in a vector space cannot exceed the dimension of that space.

For any ring `R` with the strong rank condition, finite module `M` over `R`, and a linearly independent set `b : ι → M` from a type `ι`, the cardinality of `ι` is bounded by the rank of `M` as a module over `R`.


/-- A sequential limit of measurable functions valued in a (pseudo) metrizable space is
measurable.  -/
theorem measurable_of_tendsto_metrizable :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace β]
      [inst_2 : TopologicalSpace.PseudoMetrizableSpace β] [inst_3 : MeasurableSpace β] [inst_4 : BorelSpace β]
      {f : ℕ → α → β} {g : α → β},
      (∀ (i : ℕ), Measurable (f i)) → Filter.Tendsto f Filter.atTop (nhds g) → Measurable g :=
  by sorry

The theorem `measurable_of_tendsto_metrizable` states that if we have a sequence of measurable functions `f : ℕ → α → β` converging to a function `g : α → β`, in a pseudo-metrizable topological space `β`, then the limit function `g` is also measurable. Here, convergence is defined in terms of the `Filter.Tendsto` function, which states that for every neighborhood of `g`, the pre-image of this neighborhood under the function `f` is eventually in the filter `Filter.atTop`, signifying that as we go to the limit (in this case as `ℕ` goes to infinity), `f` gets arbitrarily close to `g`. The `Measurable` property of a function is defined as the preimage of every measurable set being measurable. Thus, in effect, the theorem guarantees that the limit of measurable functions in a pseudo-metrizable space retains the measurability property.

If `f : ℕ → α → β` is a sequence of measurable functions converging to a measurable function `g : α → β` in a pseudo-metrizable topological space `β`, then `g` is also measurable.


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

This theorem states that for any two elements `x` and `y` of a module `M₁` over a semiring `R₁`, and a continuous linear map `f` from `M₁` to another module `M₂` over a semiring `R₂` with respect to a ring homomorphism `σ₁₂` from `R₁` to `R₂`, the result of applying `f` to the sum of `x` and `y` (`f (x + y)`) is equal to the sum of the results of applying `f` to `x` and `y` separately (`f x + f y`). In other words, the continuous linear map `f` preserves addition.

For any semirings R₁, R₂, modules M₁ over R₁ and M₂ over R₂, and continuous linear map f from M₁ to M₂ over R₂ via a ring homomorphism σ₁₂, we have f (x + y) = f x + f y for all x, y in M₁.


theorem List.argmax_mem :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [inst_1 : DecidableRel fun x x_1 => x < x_1] {f : α → β}
      {l : List α} {m : α}, m ∈ List.argmax f l → m ∈ l :=
  by sorry

The theorem `List.argmax_mem` states that for any types `α` and `β`, provided `β` has a preorder (a binary relation indicating one element is less than or equal to another) and a decidable relation for less than, and given a function `f` from `α` to `β` and a list of elements of type `α`, if an element `m` of type `α` is the result of the function `List.argmax` applied to `f` and the list, then `m` must be an element of the original list. In other words, `List.argmax` always returns an element from the original list.

For any type `α`, function `f` from `α` to a type `β` with a decidable less-than relation, and list `xs` of elements from `α`, if `m` is the argmax value of `f` over `xs`, then `m` is an element of `xs`.


theorem StarSubalgebra.toSubalgebra_injective :
    ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
      [inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A],
      Function.Injective StarSubalgebra.toSubalgebra :=
  by sorry

The theorem `StarSubalgebra.toSubalgebra_injective` asserts that for any types `R` and `A`, given that `R` is a commutative semiring, a star ring, and an algebra, and `A` is a semiring, a star ring, and a star module over `R`, the function `StarSubalgebra.toSubalgebra` is injective. In other words, if two star subalgebras are mapped to the same subalgebra under the function `StarSubalgebra.toSubalgebra`, then these two star subalgebras were indeed the same to begin with. This is an injectivity property specific to the structure of a star subalgebra within the context of *-ring theory.

Given a commutative semiring `R` that is a star ring and an algebra, and a semiring `A` that is a star ring and a star module over `R`, the function `StarSubalgebras.toSubalgebra` mapping star subalgebras of `A` to subalgebras of `R` is injective.


theorem CategoryTheory.Limits.IsColimit.fac_assoc :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
      {t : CategoryTheory.Limits.Cocone F} (self : CategoryTheory.Limits.IsColimit t)
      (s : CategoryTheory.Limits.Cocone F) (j : J) {Z : C} (h : s.pt ⟶ Z),
      CategoryTheory.CategoryStruct.comp (t.ι.app j) (CategoryTheory.CategoryStruct.comp (self.desc s) h) =
        CategoryTheory.CategoryStruct.comp (s.ι.app j) h :=
  by sorry

The theorem `CategoryTheory.Limits.IsColimit.fac_assoc` states that for any type `J` that is a Category, a Category `C`, a functor `F` from `J` to `C`, a cocone `t` over `F`, and a proof `self` that `t` is a colimit, given another cocone `s` over `F`, an object `j` of `J`, and a morphism `h` from the apex of `s` to some other object `Z` in `C`, the composition of the morphism from `j` in the diagram of `t` and the composition of the unique morphism from `t` to `s` (given by `self.desc s`) with `h`, is equal to the composition of the morphism from `j` in the diagram of `s` with `h`. In other words, this theorem is expressing associativity in the triangle commutative diagram involving two cocones and a morphism in a category.

Given a Category `J`, a Category `C`, a functor `F` from `J` to `C`, a colimit cocone `t` over `F` with proof `self` of colimiteness, and another cocone `s` over `F`, for any object `j` in `J` and morphism `h` from the apex of `s` to an object in `C`, the composition of the morphisms from `j` in the diagrams of `t` and `s`, followed by `h`, is equal to the composition of the morphisms from `j` in the diagrams of `s` and `t`, followed by `h`.


/-- Fundamental theorem of calculus: if `f : ℝ → E` is integrable on `a..b` and `f x` has a finite
limit `c` almost surely as `x` tends to `b` from the right or from the left,
then `u ↦ ∫ x in a..u, f x` has right (resp., left) derivative `c` at `b`.  -/
theorem intervalIntegral.integral_hasDerivWithinAt_of_tendsto_ae_right :
    ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E] {f : ℝ → E}
      {c : E} {a b : ℝ},
      IntervalIntegrable f MeasureTheory.volume a b →
        ∀ {s t : Set ℝ} [inst_3 : intervalIntegral.FTCFilter b (nhdsWithin b s) (nhdsWithin b t)],
          StronglyMeasurableAtFilter f (nhdsWithin b t) MeasureTheory.volume →
            Filter.Tendsto f (nhdsWithin b t ⊓ MeasureTheory.Measure.ae MeasureTheory.volume) (nhds c) →
              HasDerivWithinAt (fun u => ∫ (x : ℝ) in a..u, f x) c s b :=
  by sorry

The Fundamental Theorem of Calculus is stated as follows: given a function `f : ℝ → E` which is interval integrable on `a..b`, and the limit of `f x` as `x` approaches `b` from either the right or the left is finite and equals some `c` (almost surely), then the function `u ↦ ∫ x in a..u, f x` has a right (or left) derivative at `b` which is `c`. The theorem is specific in the sense that it requires the function `f` to be strongly measurable at a chosen filter and to also have a limit that tends to `c` at that filter, almost everywhere with respect to the Lebesgue measure.

If a strongly measurable function `f : ℝ → E` on the real numbers `ℝ` with values in a Banach space `E` is interval integrable on `a..b` and has right-left limiting value `c` at `b`, then the function `u ↦ ∫ x in a..u, f x` has a right (or left) derivative at `b` equal to `c`.


/-- An antitone function on a downwards-directed type is directed.  -/
theorem directed_of_isDirected_ge :
    ∀ {α : Type u} {β : Type v} [inst : LE α] [inst_1 : IsDirected α fun x x_1 => x ≥ x_1] {r : β → β → Prop}
      {f : α → β}, (∀ (a₁ a₂ : α), a₁ ≤ a₂ → r (f a₂) (f a₁)) → Directed r f :=
  by sorry

The theorem `directed_of_isDirected_ge` states that for any types `α` and `β`, given an order (`LE`) on `α` and assuming `α` is downward-directed (meaning for any two elements there exists another element that is greater than or equal to them), along with a relation `r` on `β` and a function `f` from `α` to `β` which is antitone (its values decrease or stay the same as its inputs increase), then the function `f` is directed with respect to the relation `r`. In other words, for any two inputs of `f`, there exists another input such that its value under `f` is related by `r` to the values of the original pair.

If `α` is downward-directed, `LE` being the order on `α`, `r` is a relation on `β`, and `f` is an antitone function from `α` to `β`, then `f` is a directed function with respect to `r`.


theorem inf_covBy_of_covBy_sup_of_covBy_sup_left :
    ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : IsWeakLowerModularLattice α] {a b : α},
      a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ a :=
  by sorry

This theorem states that for any type `α` that forms a weak lower modular lattice, given any two elements `a` and `b` of this type, if `a` is covered by the join (supremum) of `a` and `b`, and `b` is also covered by the join of `a` and `b`, then the meet (infimum) of `a` and `b` is covered by `a`. In simpler terms, in certain types of orders (like a weak lower modular lattice), if both `a` and `b` are immediately below their join `a ⊔ b`, then their meet `a ⊓ b` is immediately below `a`.

In a weak lower modular lattice, if elements `a` and `b` are each covered by their join `a ⊔ b`, then the meet `a ⊓ b` is covered by `a`.


IsOpen.sdiff

theorem IsOpen.sdiff :
    ∀ {X : Type u} {s t : Set X} [inst : TopologicalSpace X], IsOpen s → IsClosed t → IsOpen (s \ t) := by sorry

The theorem `IsOpen.sdiff` states that for any type `X` and any two sets `s` and `t` of type `X` in a given topological space, if `s` is an open set and `t` is a closed set, then the set difference `s \ t` is an open set. In other words, the result of subtracting a closed set from an open set in a topological space is always an open set.

If `s` is an open set and `t` is a closed set in a topological space, then their set difference `s \ t` is an open set.


theorem Finset.powersetCard.proof_1 :
    ∀ {α : Type u_1} (n : ℕ) (s : Finset α), ∀ _t ∈ Multiset.powersetCard n s.val, Multiset.Nodup _t := by sorry

The theorem `Finset.powersetCard.proof_1` states that for any type `α`, any natural number `n`, and any Finset `s` of this type, any element `_t` in the multiset of all submultisets of `s` of length `n` (as obtained from the `Multiset.powersetCard` function) has no duplicates. In other words, the multiplicity of any element in `_t` is at most 1, as defined by `Multiset.Nodup`.

For any type `α`, natural number `n`, and Finset `s` of type `α`, the multiset of all submultisets of `s` of length `n` as obtained from `Multiset.powersetCard` has no duplicate elements.


theorem Nat.log_of_lt : ∀ {b n : ℕ}, n < b → Nat.log b n = 0 := by sorry

The theorem `Nat.log_of_lt` states that for any two natural numbers `b` and `n`, if `n` is less than `b`, then the logarithm of `n` with base `b` (`Nat.log b n`) is equal to zero. This result is intuitive since logarithms measure how many times we need to multiply the base `b` to obtain `n`, and if `n` is less than `b`, we don't need to multiply `b` at all. Therefore, the logarithm is zero.

For all natural numbers `b` and `n`, if `n` < `b`, then `Nat.log b n` equals zero.


theorem PFunctor.M.dest_mk : ∀ {F : PFunctor.{u}} (x : ↑F (PFunctor.M F)), PFunctor.M.dest (PFunctor.M.mk x) = x := by
  sorry

The theorem `PFunctor.M.dest_mk` states that for any polynomial functor `F` and any value `x` of type `F` indexed by `M F` (the final coalgebra of `F`), when we create an `M F` type element using the constructor `PFunctor.M.mk` with `x` as an argument, and then apply the `PFunctor.M.dest` function to it, we get back the original value `x`. Essentially, this theorem provides a property of the `M` type's constructor and deconstructor: the deconstruction of any constructed value returns the original value.

For any polynomial functor `F` and its final coalgebra element `x` of type `M F`, applying the `PFunctor.M.dest` function to the element `PFunctor.M.mk x` returns the original value `x`.


theorem Finset.sum_nsmul :
    ∀ {α : Type u_3} {β : Type u_4} [inst : AddCommMonoid β] (s : Finset α) (n : ℕ) (f : α → β),
      (Finset.sum s fun x => n • f x) = n • Finset.sum s fun x => f x :=
  by sorry

This theorem, named `Finset.sum_nsmul`, states that for any finite set `s` of elements of an arbitrary type `α`, any natural number `n`, and any function `f` from `α` to a type `β` that forms an additive commutative monoid, the sum over `s` where each element is multiplied by `n` after being mapped by `f` (`Finset.sum s fun x => n • f x`) is equal to `n` times the sum over `s` of the elements mapped by `f` (`n • Finset.sum s fun x => f x`). This theorem essentially expresses a property of distributivity of scalar multiplication over a finite sum in the context of additive commutative monoids.

For any finite set `s`, natural number `n`, and additive commutative monoid homomorphism `f` from a type `α` to a type `β`, we have `Finset.sum s fun x => n • f x = n * Finset.sum s fun x => f x`.


CategoryTheory.Aut.ext

theorem CategoryTheory.Aut.ext :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {φ₁ φ₂ : CategoryTheory.Aut X},
      φ₁.hom = φ₂.hom → φ₁ = φ₂ :=
  by sorry

This theorem states that for any given category `C` and object `X` in `C`, and any two automorphisms `φ₁` and `φ₂` of `X`, if the morphisms from `X` to itself induced by `φ₁` and `φ₂` are equal, then the automorphisms `φ₁` and `φ₂` themselves are equal. In essence, it establishes that two automorphisms of an object in a category are identical if their corresponding morphisms are identical.

If `φ₁` and `φ₂` are automorphisms of an object `X` in a category `C` such that the morphisms `X  X` induced by `φ₁` and `φ₂` are equal, then `φ₁` and `φ₂` are equal as automorphisms.


theorem nonneg_le_nonneg_of_sq_le_sq :
    ∀ {α : Type u} [inst : LinearOrderedSemiring α] {a b : α}, 0 ≤ b → a * a ≤ b * b → a ≤ b := by sorry

This theorem, `nonneg_le_nonneg_of_sq_le_sq`, states that for any type `α` that is a linear ordered semiring, given two elements `a` and `b` from `α` where `b` is non-negative (i.e., `0 ≤ b`), if the square of `a` is less than or equal to the square of `b` (i.e., `a * a ≤ b * b`), then `a` is less than or equal to `b`. In mathematical terms, $\forall a, b \in \alpha, 0 \leq b \land a^2 \leq b^2 \rightarrow a \leq b$.

If `α` is a linear ordered semiring, `b` is non-negative in `α`, and `a^2 ≤ b^2` holds, then `a ≤ b`.


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

The theorem `Submonoid.mem_closure` states that for any type `M` that has a multiplication and one (`MulOneClass`), any set `s` of `M`, and any element `x` of `M`, the element `x` is in the submonoid generated by the set `s` if and only if for every submonoid `S` of `M`, if `s` is a subset of the carrier of `S` (`↑S`), then `x` is an element of `S`. In simpler terms, it means that an element is in the smallest submonoid containing a set if and only if it is in every submonoid that contains the set.

An element is in the smallest submonoid generated by a set if and only if it belongs to every submonoid containing that set.


theorem Monoid.fg_iff_submonoid_fg :
    ∀ {M : Type u_1} [inst : Monoid M] (N : Submonoid M), Monoid.FG ↥N ↔ Submonoid.FG N := by sorry

This theorem states that for any monoid `M` and any submonoid `N` of `M`, `N` is finitely generated as a monoid if and only if `N` is finitely generated as a submonoid of `M`. In other words, the property of being finitely generated is preserved whether we consider `N` as a monoid in its own right or as a submonoid of `M`.

For any monoid `M` and its submonoid `N`, `N` is finitely generated as a monoid if and only if it is finitely generated as a submonoid of `M`.


theorem Finset.toList_eq_nil : ∀ {α : Type u_1} {s : Finset α}, Finset.toList s = [] ↔ s = ∅ := by sorry

This theorem states that for any type `α` and for any finite set `s` of type `α`, the list produced from the finite set `s` using the function `Finset.toList` is empty if and only if the set `s` is empty. In other words, `Finset.toList` returning an empty list is equivalent to the finite set being empty.

For any type `α`, the list obtained from a finite set `s` of type `α` using `Finset.toList` is empty if and only if `s` is empty.


theorem Nat.factorial_mul_pow_le_factorial : ∀ {m n : ℕ}, Nat.factorial m * (m + 1) ^ n ≤ Nat.factorial (m + n) := by
  sorry

This theorem, `Nat.factorial_mul_pow_le_factorial`, asserts that for all natural numbers `m` and `n`, the factorial of `m` times `(m + 1)` raised to the power of `n` is less than or equal to the factorial of `(m + n)`. In other words, it states that for any two natural numbers, the factorial of the first number times the increment of the first number raised to the power of the second number will never exceed the factorial of the sum of these two numbers.

For all natural numbers m and n, m!*(m + 1)^n ≤ (m + n)!.


theorem CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_hom_naturality :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.ShortComplex.HasHomology S₁]
      [inst_3 : CategoryTheory.ShortComplex.HasHomology S₂] (φ : S₁ ⟶ S₂)
      (h₁ : CategoryTheory.ShortComplex.RightHomologyData S₁) (h₂ : CategoryTheory.ShortComplex.RightHomologyData S₂),
      CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.homologyIso h₁).hom
          (CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂) =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ)
          (CategoryTheory.ShortComplex.RightHomologyData.homologyIso h₂).hom :=
  by sorry

This theorem, `CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_hom_naturality`, specifies the naturality condition for the homology of short complexes in a category. Given any category `C` that has zero morphisms, and two short complexes `S₁` and `S₂` in `C` that have homology, this theorem states that for any morphism `φ` from `S₁` to `S₂`, and homology data `h₁` and `h₂` for `S₁` and `S₂` respectively, the composition of the homology isomorphism of `h₁` and the right homology map of `φ`, `h₁` and `h₂` is equal to the composition of the homology map of `φ` and the homology isomorphism of `h₂`. This essentially states that the process of mapping the short complexes and then applying the homology isomorphism is the same as first applying the homology map and then the homology isomorphism, which is the characteristic property of natural transformations in category theory.

Given any category with zero morphisms and two short complexes with homology, the homology isomorphism of one complex and the right homology map of a morphism between them is equal to the composition of the right homology map of the morphism and the homology isomorphism of the other complex.


theorem algebra_compatible_smul :
    ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A] {M : Type u_3}
      [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (r : R)
      (m : M), r • m = (algebraMap R A) r • m :=
  by sorry

The theorem `algebra_compatible_smul` states that for any types `R` and `A` where `R` is a commutative semiring and `A` is a semiring with an algebra structure over `R`, and for any type `M` which is an additive commutative monoid and also a module over `A` and `R` with a scalar tower structure, the action of scalar multiplication by an element `r` from `R` on an element `m` from `M` is the same as the action of scalar multiplication by the image of `r` under the algebra map from `R` to `A` on `m`. In other words, the scalar multiplication operation is compatible with the algebra map.

For any commutative semiring `R`, semiring `A` with an algebra structure over `R`, additive commutative monoid `M` that is an `A`-module and `R`-module with scalar tower structure, the scalar multiplication of an `A`-element `r` and an `M`-element `m` equals the scalar multiplication of `m` by `r`'s image under the algebra map.


theorem Nat.sInf_upward_closed_eq_succ_iff :
    ∀ {s : Set ℕ}, (∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s) → ∀ (k : ℕ), sInf s = k + 1 ↔ k + 1 ∈ s ∧ k ∉ s := by
  sorry

This theorem, `Nat.sInf_upward_closed_eq_succ_iff`, states that for any set `s` of natural numbers, if `s` is upward closed (meaning that for any two natural numbers `k₁` and `k₂`, if `k₁` is less than or equal to `k₂` and `k₁` is in `s`, then `k₂` is also in `s`), then for any natural number `k`, the least upper bound (infimum) of the set `s` equals `k + 1` if and only if `k + 1` is in `s` and `k` is not in `s`.

This theorem connects the concept of upper bounds and specific elements' membership in a set, specifically with respect to the condition of the set being upward closed. This is useful in understanding the structure and properties of sets of natural numbers.

Given an upward closed set of natural numbers `s`, the least upper bound of `s` equals `k + 1` if and only if `k + 1` is in `s` and `k` is not.


theorem Set.Finite.absorbs_sUnion :
    ∀ {M : Type u_1} {α : Type u_2} [inst : Bornology M] [inst_1 : SMul M α] {s : Set α} {T : Set (Set α)},
      Set.Finite T → (Absorbs M s (⋃₀ T) ↔ ∀ t ∈ T, Absorbs M s t) :=
  by sorry

The theorem `Set.Finite.absorbs_sUnion` states that for any types `M` and `α`, given a bornology on `M`, a scalar multiplication on `α`, a set `s` of `α`, and a set `T` of sets of `α`, if `T` is finite, then the set `s` absorbs the union of all sets in `T` if and only if `s` absorbs every set in `T`. Here, a set `s` absorbs another set `t` if every scaling of `s` by any but a bounded set of elements contains `t`, and a set is finite if it is equivalent to a set of natural numbers less than some natural number.

For any bornology on a type `M`, scalar multiplication on a type `α`, finite set `T` of subsets of `α`, and set `s` of `α`, `s` absorbs the union of `T` if and only if it absorbs every set in `T`.


theorem PiNat.firstDiff_comm : ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n), PiNat.firstDiff x y = PiNat.firstDiff y x :=
  by sorry

The theorem `PiNat.firstDiff_comm` states that for any function `E` from natural numbers to some type, and any two elements `x` and `y` in the product space generated by `E`, the function `PiNat.firstDiff` commutes. In other words, the first index at which `x` and `y` differ is the same as the first index at which `y` and `x` differ. This means the order in which you compare `x` and `y` does not affect the outcome of `PiNat.firstDiff`.

For any function from natural numbers to some type and any two elements of its product space, the indices at which they first differ are equal.


/-- A more general version of `finprod_mem_union` that requires `s ∩ mulSupport f` and
`t ∩ mulSupport f` rather than `s` and `t` to be finite.  -/
theorem finprod_mem_union' :
    ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s t : Set α},
      Disjoint s t →
        Set.Finite (s ∩ Function.mulSupport f) →
          Set.Finite (t ∩ Function.mulSupport f) →
            (finprod fun i => finprod fun h => f i) =
              (finprod fun i => finprod fun h => f i) * finprod fun i => finprod fun h => f i :=
  by sorry

This theorem, `finprod_mem_union'`, states a more generalized version of the `finprod_mem_union` theorem. It states that for any two disjoint sets `s` and `t` of a type `α`, and any function `f` from `α` to a commutative monoid `M`, if the intersection of `s` and the multiplicative support of `f`, and the intersection of `t` and the multiplicative support of `f` are both finite, then the finite product (denoted by `finprod`) over all elements considering both `s` and `t` is equal to the product of the finite product over elements of `s` and the finite product over elements of `t`. Here, the multiplicative support of `f` is the set of points `x` such that `f(x) ≠ 1`.

For disjoint sets `s` and `t` of a type `α` and a function `f` from `α` to a commutative monoid `M` with finite intersections of `s` and `f`'s multiplicative support, and `t` and `f`'s multiplicative support, `finprod (s ∪ t) f = finprod s f ⊓ finprod t f`, where `⊓` denotes the finite product.


theorem Function.injective_of_subsingleton :
    ∀ {α : Sort u_1} {β : Sort u_2} [inst : Subsingleton α] (f : α → β), Function.Injective f := by sorry

The theorem `Function.injective_of_subsingleton` states that for any two types `α` and `β`, and any function `f` from `α` to `β`, if `α` is a subsingleton type (meaning it has at most one element), then the function `f` is injective. In other words, if the elements of `α` are identical or there is only one element, then each element of `β` is mapped by `f` from at most one element of `α`.

If `α` is a subsingleton type, then any function `f` from `α` to `β` is injective.


/-- If `μ` has finite spanning sets in the collection of measurable sets `C`, then `μ` is σ-finite.
 -/
theorem MeasureTheory.Measure.FiniteSpanningSetsIn.sigmaFinite :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {C : Set (Set α)},
      MeasureTheory.Measure.FiniteSpanningSetsIn μ C → MeasureTheory.SigmaFinite μ :=
  by sorry

This theorem states that if a measure `μ`, defined on a measurable space `α`, has finite spanning sets in a collection of measurable sets `C`, then `μ` is `σ`-finite. This means that it can be decomposed into a countable union of sets with finite measure. The theorem is a property in the field of measure theory, which is a branch of mathematics that studies concepts such as length, area, and volume in a more general and abstract way than traditional geometry and calculus.

If a measure μ on a measurable space α has finite spanning sets for every countable collection of measurable sets, then μ is σ-finite.


theorem sup_himp_distrib :
    ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b c : α), a ⊔ b ⇨ c = (a ⇨ c) ⊓ (b ⇨ c) := by sorry

This theorem states that in the context of a Generalized Heyting Algebra (a specific type of algebraic structure) over any type α, for any three elements a, b, and c of α, the sup-implication distribution law holds. This law indicates that the sup-implication (a join operation followed by implication) of a and b towards c is equal to the intersection of the implications from a to c and from b to c. In LaTeX, it can be written as `a ∨ b → c = (a → c) ∧ (b → c)`.

In a Generalized Heyting Algebra, the sup-implication of a and b is equal to the intersection of their implications: a ∨ b → c = a → c ∧ b → c.


theorem Set.Ici_injective : ∀ {α : Type u_1} [inst : PartialOrder α], Function.Injective Set.Ici := by sorry

This theorem states that for all types `α` that have a `PartialOrder` instance, the function `Set.Ici` is injective. In other words, if we have two elements `a` and `b` of type `α`, and the left-closed right-infinite interval starting from `a` is the same as the one starting from `b` (i.e., all elements greater than or equal to `a` are the same as those greater than or equal to `b`), then `a` must be equal to `b`. This is essentially saying that each distinct point defines a unique left-closed right-infinite interval in a partially ordered set.

If `α` is a type with a `PartialOrder` instance, then the function `Set.Ici` mapping an element `x` to the left-closed right-infinite interval `{ y | y ≥ x }` is an injection.


/-- Left-multiplying a permutation with `swap i j` twice gives the original permutation.

This specialization of `swap_mul_self` is useful when using cosets of permutations.
 -/
theorem Equiv.swap_mul_self_mul :
    ∀ {α : Type u} [inst : DecidableEq α] (i j : α) (σ : Equiv.Perm α), Equiv.swap i j * (Equiv.swap i j * σ) = σ := by
  sorry

The theorem `Equiv.swap_mul_self_mul` states that for any type `α` with decidable equality and any elements `i`, `j` of `α`, along with a permutation `σ` of `α`, the operation of left-multiplying the permutation `σ` with the swap function `swap i j` twice yields the original permutation `σ`. In other words, applying the swap operation twice, which swaps the positions of `i` and `j`, is equivalent to not making any changes to the permutation. This property is especially useful when working with cosets of permutations.

For any permutation σ of type α with decidable equality, σ * swap i j * σ = swap i j.


theorem mem_upperBounds_image2 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
      {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
      (∀ (b : β), Monotone (Function.swap f b)) →
        (∀ (a : α), Monotone (f a)) → a ∈ upperBounds s → b ∈ upperBounds t → f a b ∈ upperBounds (Set.image2 f s t) :=
  by sorry

The theorem `mem_upperBounds_image2` states that for all types `α`, `β`, `γ`, which are ordered by preorders, and given a binary function `f: α → β → γ` and sets `s: Set α` and `t: Set β`, if the function `f` is monotone in both of its arguments (the function `f` with one argument fixed is monotone), then for all elements `a` in the upper bounds of `s` and `b` in the upper bounds of `t`, the value `f a b` is in the upper bounds of the image of function `f` over the cartesian product of sets `s` and `t`.

This essentially means that if `a` and `b` are upper bounds of sets `s` and `t` respectively, and if `f` is monotone, then `f a b` is an upper bound of the values of `f` taken over all pairs from `s` and `t`.

If `α`, `β`, `γ` are ordered types, `f: α → β → γ` is a monotone function, `s ⊆ α` and `t ⊆ β`, and `a ∈ upperBound s` and `b ∈ upperBound t`, then `f a b ∈ upperBound (image f (s × t))`.


theorem Filter.blimsup_sup_not :
    ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteDistribLattice α] {f : Filter β} {p : β → Prop} {u : β → α},
      (Filter.blimsup u f p ⊔ Filter.blimsup u f fun x => ¬p x) = Filter.limsup u f :=
  by sorry

The theorem `Filter.blimsup_sup_not` states that for any complete distributive lattice `α`, filter `f` on type `β`, predicate `p` on `β` and function `u` from `β` to `α`, the supremum (join operation) of the `blimsup` of `u` with respect to `f` and `p` and the `blimsup` of `u` with respect to `f` and the negation of `p`, is equal to the `limsup` of `u` along the filter `f`. In other words, the `limsup` of function `u` along a filter `f` is the supremum of the `blimsup` for the function `u` where predicate `p` holds, and the `blimsup` for the function `u` where the negation of predicate `p` holds.

For any complete distributive lattice α, filter f on β, predicate p on β, and function u from β to α, the limit supremum of u along f is equal to the join of the blimsup of u with respect to f and p, and the blimsup of u with respect to f and the negation of p.


theorem CauSeq.cauchy₃ :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] (f : CauSeq β abv) {ε : α}, 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (↑f k - ↑f j) < ε :=
  by sorry

This theorem, named `CauSeq.cauchy₃`, states that for any types `α` and `β` where `α` is a linearly ordered field and `β` is a ring, and for any function `abv : β → α` that is an absolute value, any Cauchy sequence `f : CauSeq β abv` satisfies the following property: given any positive ε (`0 < ε`), there exists an index `i` such that for all indices `j` and `k` where `k` is greater than or equal to `j` and `j` is greater than or equal to `i`, the absolute value of the difference between the `k`-th term and the `j`-th term of the sequence (`abv (↑f k - ↑f j)`) is less than ε.

In other words, beyond a certain point in the sequence, the absolute difference between any two terms is less than any given positive number, which is a key characteristic of Cauchy sequences in mathematical analysis.

For any Cauchy sequence `f` in a linearly ordered field `α` with absolute value function `abv : β → α`, where `β` is a ring, there exists an index `i` such that for all `j` and `k` with `k ≥ j ≥ i`, `|abv(f(k) - f(j))| < ε`.


theorem Subgroup.mem_comap :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {K : Subgroup N} {f : G →* N} {x : G},
      x ∈ Subgroup.comap f K ↔ f x ∈ K :=
  by sorry

This theorem states that for any groups `G` and `N`, any subgroup `K` of `N`, any group homomorphism `f` from `G` to `N`, and any element `x` of `G`, the element `x` belongs to the preimage of subgroup `K` along the homomorphism `f` if and only if the image of `x` under `f` belongs to `K`. Here, the preimage of a subgroup along a homomorphism is defined as the subgroup of `G` consisting of all elements which map to `K` under `f`.

For any group homomorphism $f$ from group $G$ to group $N$, subgroup $K$ of $N$, and element $x$ in $G$, $x$ is in the preimage of $K$ under $f$ if and only if $f(x) \in K$.


theorem Mathlib.Combinatorics.SimpleGraph.Operations._auxLemma.1 :
    ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s] {a : α}, (a ∈ Set.toFinset s) = (a ∈ s) := by sorry

This theorem asserts that for any type `α`, any set `s` of type `α`, and any element `a` of type `α`, `a` is a member of the finset equivalent of `s` if and only if `a` is a member of the set `s`. In other words, conversion of a set `s` to its finset form via `Set.toFinset` preserves the membership of elements.

For any type `α`, any set `s` of type `α`, and any element `a` of type `α`, `a` is in the finset `Set.toFinset s` if and only if `a` is in the set `s`.


theorem CliffordAlgebraRing.ι_eq_zero : ∀ {R : Type u_1} [inst : CommRing R], CliffordAlgebra.ι 0 = 0 := by sorry

The theorem `CliffordAlgebraRing.ι_eq_zero` states that for any type `R` that is a commutative ring, the canonical linear map from `R` to the Clifford Algebra with respect to the zero quadratic form is the zero map. In other words, this theorem says that when the quadratic form is zero, every element of `R` is mapped to zero by the canonical linear map to the Clifford Algebra.

For any commutative ring R and the Clifford Algebra over R with respect to the zero quadratic form, the canonical linear map from R to the Clifford Algebra is the zero map.


CategoryTheory.EffectiveEpiFamily.fac

theorem CategoryTheory.EffectiveEpiFamily.fac :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {B W : C} {α : Type u_2} (X : α → C)
      (π : (a : α) → X a ⟶ B) [inst_1 : CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W)
      (h :
        ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
          CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
            CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂))
      (a : α), CategoryTheory.CategoryStruct.comp (π a) (CategoryTheory.EffectiveEpiFamily.desc X π e ⋯) = e a :=
  by sorry

This theorem, named `CategoryTheory.EffectiveEpiFamily.fac`, is from the field of category theory. Given a category `C`, with objects `B` and `W` and a type `α`, it considers a family of morphisms `X : α → C` and `π : (a : α) → X a ⟶ B` that forms an effective epimorphism family. It also takes a morphism `e : (a : α) → X a ⟶ W` that satisfies a property denoted by `h`. This property ensures that, for all objects `Z` in `C` and all elements `a₁, a₂` of `α`, if the composition of two morphisms `g₁ : Z ⟶ X a₁` and `g₂ : Z ⟶ X a₂` with `π a₁` and `π a₂` respectively are equal, then the compositions of `g₁` and `g₂` with `e a₁` and `e a₂` respectively are also equal. The theorem then states that for any `a : α`, the composition of `π a` with the morphism given by the `desc` operation of the effective epimorphism family `X π` applied to `e` is equal to `e a`.

Given a category `C`, a family `X : α → C` and morphism `π : α → X �Circ B` forming an effective epimorphism family, and a morphism `e : α → X �Circ W` satisfying a certain condition, for all objects `Z` in `C` and all `a` in `α`, the composition of `π a` with the `desc` morphism of `X π` applied to `e` at `a` equals `e a`.


theorem CategoryTheory.Presieve.isAmalgamation_restrict :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
      {R₁ R₂ : CategoryTheory.Presieve X} (h : R₁ ≤ R₂) (x : CategoryTheory.Presieve.FamilyOfElements P R₂)
      (t : P.obj (Opposite.op X)),
      CategoryTheory.Presieve.FamilyOfElements.IsAmalgamation x t →
        CategoryTheory.Presieve.FamilyOfElements.IsAmalgamation (CategoryTheory.Presieve.FamilyOfElements.restrict h x)
          t :=
  by sorry

The theorem `CategoryTheory.Presieve.isAmalgamation_restrict` states that in a category 'C', for any presheaf 'P' and for any two presieves 'R₁' and 'R₂' on an object 'X' such that 'R₁' is included in 'R₂', if a family of elements 'x' of the presheaf 'P' over the presieve 'R₂' amalgamates to an element 't' of 'P', then the family of elements obtained by restricting 'x' to 'R₁' also amalgamates to 't'. In other words, the process of amalgamation is stable under restriction of presieves.

If presheaf 'P' over category 'C', presieves 'R₁' and 'R₂' on object 'X' with 'R₁' included in 'R₂', and a family of elements 'x' in 'P' over 'R₂' amalgamates to an element 't' in 'P', then the family of elements 'x' restricted to 'R₁' also amalgamates to 't'.


theorem Polynomial.eval_C_mul :
    ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R} {x : R},
      Polynomial.eval x (Polynomial.C a * p) = a * Polynomial.eval x p :=
  by sorry

The theorem `Polynomial.eval_C_mul` states that for any type `R` equipped with a semiring structure, a given element `a` of `R`, a polynomial `p` over `R`, and a value `x` from `R`, the evaluation of the multiplication of the constant polynomial `a` and `p` at `x` is the same as the product of `a` and the evaluation of `p` at `x`. In other words, if we multiply a polynomial by a constant and then evaluate it at a point, it's the same as if we evaluated the polynomial first and then multiplied the result by the constant. This is denoted in mathematical terms as `Polynomial.eval x (Polynomial.C a * p) = a * Polynomial.eval x p`.

For any semiring `R`, polynomial `p` over `R`, constant `a` in `R`, and `x` in `R`, `Polynomial.eval x (Polynomial.C a * p) = a * Polynomial.eval x p`.


theorem Set.addCentralizer_univ :
    ∀ (M : Type u_1) [inst : AddSemigroup M], Set.addCentralizer Set.univ = Set.addCenter M := by sorry

This theorem states that for any type `M` equipped with an addition operation (i.e., forming an additive semigroup), the centralizer of the universal set is equal to the center of `M`. In other words, the set of all elements in `M` that commute with every element in the universal set (i.e., satisfy `m + c = c + m` for all `m` in the universal set) is precisely the set of all elements in `M` that commute with every other element in `M`. This is essentially a statement about the commutativity of the addition operation in the entire `M`.

The center of an additive semigroup equals its universal centralizer.


/-- The basic open sets for the topology on ultrafilters are also closed.  -/
theorem ultrafilter_isClosed_basic : ∀ {α : Type u} (s : Set α), IsClosed {u | s ∈ u} := by sorry

The theorem states that for any type `α` and any set `s` of elements of type `α`, the collection of ultrafilters `u` for which `s` is a member of `u` is a closed set in the topological space of ultrafilters. In other words, the basic open sets in the topology on ultrafilters are also closed sets.

The collection of ultrafilters containing a given set is a closed set in the topology of ultrafilters.


/-- The cardinality of the interval (a, b).  -/
theorem Cardinal.mk_Ioo_real : ∀ {a b : ℝ}, a < b → Cardinal.mk ↑(Set.Ioo a b) = Cardinal.continuum := by sorry

This theorem establishes that the cardinality of the open interval (a, b) in real numbers is equal to the cardinality of the continuum. In other words, for any pair of real numbers a and b where a is less than b, the set of real numbers strictly between a and b (denoted (a, b)) has the same size (cardinality) as the continuum. The continuum is defined as the set of all real numbers, represented by the cardinal number 2 raised to the power of the cardinality of the set of natural numbers (also known as aleph null).

The cardinality of the open real interval (a, b) is equal to that of the continuum.


theorem MeasureTheory.OuterMeasure.ofFunction_eq :
    ∀ {α : Type u_1} {m : Set α → ENNReal} {m_empty : m ∅ = 0} (s : Set α),
      (∀ ⦃t : Set α⦄, s ⊆ t → m s ≤ m t) →
        (∀ (s : ℕ → Set α), m (⋃ i, s i) ≤ ∑' (i : ℕ), m (s i)) →
          ↑(MeasureTheory.OuterMeasure.ofFunction m m_empty) s = m s :=
  by sorry

This theorem states that for any type `α`, given a function `m` that assigns measures to sets (with the property that `m` of the empty set is zero) and a set `s` of type `α`, if two conditions are satisfied: first, for any set `t` that contains `s`, the measure of `s` is less than or equal to the measure of `t`; and second, the measure of the union of a sequence of sets is less than or equal to the sum of the measures of the individual sets in the sequence, then the measure of `s` under the maximal outer measure `μ` constructed by `MeasureTheory.OuterMeasure.ofFunction` is equal to `m s`. In other words, the maximal outer measure `μ` is consistent with the original measure assigning function `m` under these conditions.

If `m` is a measure function on type `α` with `m ∅ = 0`, and for any set `s` and any set `t` containing `s`, `m s ≤ m t`, and the measure of any countable union equals the sum of the measures of its elements, then `m s = μ s`, where `μ` is the maximal outer measure constructed from `m`.


theorem PartialHomeomorph.map_extend_nhds :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
      [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H]
      [inst_4 : TopologicalSpace M] (f : PartialHomeomorph M H) (I : ModelWithCorners 𝕜 E H) {x : M},
      x ∈ f.source →
        Filter.map (↑(PartialHomeomorph.extend f I)) (nhds x) =
          nhdsWithin (↑(PartialHomeomorph.extend f I) x) (Set.range ↑I) :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed add commutative group `E`, normed space over `𝕜` and `E`, and topological spaces `H` and `M`, given a partial homeomorphism `f` between `M` and `H`, and a model with corners `I` (which is a structure used in the definition of manifolds), for any point `x` in the source of `f`, the forward map of the neighborhood filter at `x` under the extension of `f` by `I` is equal to the neighborhood within the range of `I` at the image of `x` under the extension of `f` by `I`. In simpler terms, this theorem is about how the neighborhood of a point is transformed under a partial homeomorphism when it is extended using a model with corners.

For any partial homeomorphism `f` between topological spaces `M` and `H`, and given a non-trivially normed field `𝕜`, normed add commutative group `E` over `𝕜` and `E`, and a model with corners `I`, the forward neighborhood filters of `x` in `M` and `f(x)` in `H`, under the extension of `f` by `I`, are equal.


theorem Asymptotics.isBigO_zero_right_iff :
    ∀ {α : Type u_1} {F' : Type u_7} {E'' : Type u_9} [inst : SeminormedAddCommGroup F']
      [inst_1 : NormedAddCommGroup E''] {f'' : α → E''} {l : Filter α}, (f'' =O[l] fun _x => 0) ↔ f'' =ᶠ[l] 0 :=
  by sorry

The theorem `Asymptotics.isBigO_zero_right_iff` states that for any types `α`, `F'`, and `E''`, where `F'` is a seminormed commutative additive group and `E''` is a normed commutative additive group, and for any function `f''` from `α` to `E''` and any filter `l` on `α`, it is the case that `f''` is Big O of zero with respect to `l` if and only if `f''` equals zero almost everywhere with respect to `l`. In mathematical terms, it means that a function is asymptotically negligible (i.e., it becomes arbitrarily small as its argument approaches some limit) if and only if it is essentially zero around that limit.

A function from a type to a normed commutative additive group is Big O of zero with respect to a filter on the domain if and only if it equals zero almost everywhere with respect to that filter.


theorem Set.Countable.isLindelof_biUnion :
    ∀ {X : Type u} {ι : Type u_1} [inst : TopologicalSpace X] {s : Set ι} {f : ι → Set X},
      Set.Countable s → (∀ i ∈ s, IsLindelof (f i)) → IsLindelof (⋃ i ∈ s, f i) :=
  by sorry

The theorem `Set.Countable.isLindelof_biUnion` states that, given a topological space `X`, a countable set `s` of indices of type `ι`, and a function `f` mapping indices to subsets of `X`, if each of the subsets `f i` for `i` in `s` is a Lindelöf space, then the union of these subsets (i.e., ⋃ {i ∈ s, f i}) is also a Lindelöf space. In other words, a countable union of Lindelöf spaces is itself a Lindelöf space. A Lindelöf space, as defined here, is a topological space in which every nontrivial filter with the countable intersection property that contains the set has a cluster point in the set.

A countable union of Lindelöf spaces is a Lindelöf space.


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

The theorem `ContMDiff.of_le` states that given any nontrivially normed field `𝕜`, normed additive commutative groups `E` and `E'`, normed spaces 𝕜 `E` and 𝕜 `E'`, topological spaces `H`, `M`, `H'`, `M'`, models with corners `I` (for the manifold `M` with values in `E`) and `I'` (for the manifold `M'` with values in `E'`), charts for these manifolds `M` and `M'`, and a function `f` from `M` to `M'`, if `f` is `n` times continuously differentiable (`ContMDiff`), then `f` is also `m` times continuously differentiable for any `m` less than or equal to `n`.

If `f` is `n` times continuously differentiable from `M` to `M'` between normed spaces, then `f` is also `m` times continuously differentiable for any `m` less than or equal to `n`.


theorem Filter.iInf_principal_finset :
    ∀ {α : Type u} {ι : Type w} (s : Finset ι) (f : ι → Set α),
      ⨅ i ∈ s, Filter.principal (f i) = Filter.principal (⋂ i ∈ s, f i) :=
  by sorry

This theorem states that for every finite set `s` of elements of some type `ι` and a function `f` from `ι` to sets of elements of type `α`, the infimum (greatest lower bound) of the principal filters of the images of the elements in `s` under `f` is equal to the principal filter of the intersection of the images of the elements in `s` under `f`. In other words, the principal filter of the intersection of a collection of sets is equal to the infimum of the principal filters of the sets in the collection, when the collection is a finite set.

For every finite set `s` and function `f` from a type `ι` to sets of type `α`, the infimum of the principal filters of `f` applied to elements in `s` equals the principal filter of the intersection of `f`'s images on `s`.


LTSeries.strictMono

theorem LTSeries.strictMono : ∀ {α : Type u_1} [inst : Preorder α] (x : LTSeries α), StrictMono x.toFun := by sorry

The theorem `LTSeries.strictMono` states that for any type `α` that has a preorder structure, if `x` is a `LTSeries` over `α`, then the function associated with `x` (accessed by `x.toFun`) is strictly monotonic. In other words, for any two elements `a` and `b` in `α` such that `a < b`, the value of the function at `a` is strictly less than the value of the function at `b`.

For any preordered type `α` and `LTSeries` `x` over `α`, the function `x.toFun` is strictly monotonic: `x.toFun a < x.toFun b` for all `a, b ∈ α` with `a < b`.


theorem AddSubsemigroup.not_mem_bot : ∀ {M : Type u_1} [inst : Add M] {x : M}, x ∉ ⊥ := by sorry

This theorem states that for any type `M` that supports addition operation (denoted by `[inst : Add M]`), no element `x` from `M` belongs to the bottom element (denoted by `⊥`). In simple terms, it's stating that no element of an additive semigroup can be the bottom element.

There exists no element in an additive semigroup that satisfies the property of being the additive identity and the bottom element at the same time.


theorem OrthonormalBasis.toBasis_adjustToOrientation :
    ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {ι : Type u_2} [inst_2 : Fintype ι]
      [inst_3 : DecidableEq ι] [ne : Nonempty ι] (e : OrthonormalBasis ι ℝ E) (x : Orientation ℝ E ι),
      OrthonormalBasis.toBasis (OrthonormalBasis.adjustToOrientation e x) =
        Basis.adjustToOrientation (OrthonormalBasis.toBasis e) x :=
  by sorry

The theorem `OrthonormalBasis.toBasis_adjustToOrientation` asserts that for any normed commutative group `E` with an inner-product space structure over the real numbers, and an indexed type `ι` that is a finite type with decidable equality and is not empty, given an orthonormal basis `e` of `E` over `ι`, and an orientation `x` of `E` with respect to `ι`, the basis corresponding to the adjusted orthonormal basis according to the orientation `x` is the same as the adjusted basis of the original orthonormal basis according to the same orientation `x`. In other words, adjusting the orientation of an orthonormal basis and then converting to a basis yields the same result as converting to a basis first and then adjusting the orientation.

Given a finite, non-empty indexed type `ι`, a real inner-product space `E`, an orthonormal basis `e` of `E` over `ι`, and an orientation `x` of `E`, the basis obtained by adjusting the orthonormal basis `e` according to `x` is equal to the adjusted orthonormal basis of `e` according to `x`.


/-- The symbol `J(1 | b)` has the value `1`.  -/
theorem jacobiSym.one_left : ∀ (b : ℕ), jacobiSym 1 b = 1 := by sorry

This theorem states that, for any natural number `b`, the Jacobi symbol `J(1 | b)` is equal to `1`. In other words, when the first argument of the Jacobi symbol function (`jacobiSym`) is `1`, the resulting value of the function is always `1`, regardless of the value of `b`.

For all natural numbers b, the Jacobi symbol J(1 | b) equals 1.


theorem BoxIntegral.Box.mem_coe : ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) {x : ι → ℝ}, x ∈ ↑I ↔ x ∈ I := by sorry

This theorem states that for any BoxIntegral (denoted by `I`), and for any function `x` from `ι` to the set of real numbers (ℝ), `x` is an element of the coerced BoxIntegral (i.e., `↑I`) if and only if `x` is an element of `I`. In other words, a point is in the BoxIntegral whether you consider it as a box or as a coerced box.

For any BoxIntegral `I` and any function `x` from an index set `ι` to the real numbers, `x` is in the coerced BoxIntegral `↑I` if and only if `x` is in `I`.


theorem ContinuousLinearMap.coe_smul :
    ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
      [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
      [inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {S₂ : Type u_9} [inst_8 : Monoid S₂]
      [inst_9 : DistribMulAction S₂ M₂] [inst_10 : SMulCommClass R₂ S₂ M₂] [inst_11 : ContinuousConstSMul S₂ M₂]
      (c : S₂) (f : M₁ →SL[σ₁₂] M₂), ↑(c • f) = c • ↑f :=
  by sorry

The theorem `ContinuousLinearMap.coe_smul` states that for any semirings `R₁` and `R₂`, a continuous semilinear map `f` from topological space `M₁` to `M₂` (both of which are commutative monoids), and scalar `c` from a monoid `S₂` that acts distributively on `M₂` and commutes with `R₂` under scalar multiplication, the coercion of the product of `c` and `f` (`c • f`) is equal to the scalar multiplication of `c` and the coercion of `f` (`c • ↑f`). This theory assumes `S₂` continuously acts on `M₂` by scalar multiplication.

For any commutative monoids M₁ and M₂, semirings R₁ and R₂, a continuous semilinear map f from M₁ to M₂, and a scalar c from a monoid S₂ that distributes over M₂ and commutes with R₂ under scalar multiplication, the coercion of the product of c and f is equal to the scalar multiplication of c by the coercion of f: c • f = c • ↑f.


theorem Equiv.removeNone_some :
    ∀ {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α},
      (∃ x', e (some x) = some x') → some ((Equiv.removeNone e) x) = e (some x) :=
  by sorry

This theorem, `Equiv.removeNone_some`, states that for any two types `α` and `β`, given an equivalence `e` between the `Option` types of `α` and `β`, and for any element `x` of type `α`, if there exists an `x'` such that applying the equivalence `e` to `some x` results in `some x'`, then applying the function `some` to the result of `Equiv.removeNone e` of `x` is equivalent to applying `e` to `some x`. In other words, the equation `some ((Equiv.removeNone e) x) = e (some x)` holds under the given conditions. This theorem essentially shows that we can safely remove `none` from the equivalence between the `Option` types without changing the results for elements that are not `none`.

For any equivalence between `Option` types `e` and any `x` in type `α`, if `e (some x) = some y` for some `y`, then `some (Equiv.removeNone e x) ≡ e (some x)`.


theorem CompleteLattice.sSup_continuous :
    ∀ {α : Type u} {β : Type v} [inst : OmegaCompletePartialOrder α] [inst_1 : CompleteLattice β] (s : Set (α →o β)),
      (∀ f ∈ s, OmegaCompletePartialOrder.Continuous f) → OmegaCompletePartialOrder.Continuous (sSup s) :=
  by sorry

This theorem, named `CompleteLattice.sSup_continuous`, establishes that given two types, `α` and `β`, where `α` is an omega-complete partial order, and `β` is a complete lattice, for any set `s` of order-preserving maps from `α` to `β`, if every function `f` in `s` is continuous, then the supremum (or least upper bound) of the set `s`, denoted as `sSup s`, is also continuous. The continuity here is defined in the sense of the omega-complete partial order. Therefore, this theorem essentially states the preservation of continuity under the taking of suprema in the context of complete lattices and omega-complete partial orders.

If `α` is an omega-complete partial order and `β` is a complete lattice, then the supremum of a set of order-preserving, continuous functions from `α` to `β` is itself continuous.


QuotientAddGroup.eq'

theorem QuotientAddGroup.eq' :
    ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {a b : α}, ↑a = ↑b ↔ -a + b ∈ s := by sorry

This theorem, named "QuotientAddGroup.eq'", states that for all elements `a` and `b` of an additive group `α`, and for a given additive subgroup `s` of `α`, the equivalence class of `a` is equal to the equivalence class of `b` if and only if the element obtained by adding the additive inverse of `a` to `b` belongs to the subgroup `s`. In other words, `a` and `b` are equivalent under the quotient group's equivalence relation precisely when their difference belongs to the subgroup `s`.

For all additive groups α, subgroups s of α, and elements a, b in α, a ≡ b (mod s) if and only if a - b ∈ s.


theorem Padic.const_equiv :
    ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {q r : ℚ},
      CauSeq.const (padicNorm p) q ≈ CauSeq.const (padicNorm p) r ↔ q = r :=
  by sorry

The theorem `Padic.const_equiv` states that for any natural number `p` that is prime, and any two rational numbers `q` and `r`, the Cauchy sequence constants determined by the `p`-adic norm of `q` and `r` are equivalent if and only if `q` equals `r`. In other words, two rational numbers are identical if their `p`-adic norm-based Cauchy sequence constants are equivalent. The `p`-adic norm of a rational number `q` is calculated as `p` to the power of negative `p`-adic valuation of `q` if `q` is not equal to zero, otherwise it is zero.

For any prime number p and rational numbers q and r, the equivalence of their p-adic Cauchy sequence constants implies q = r.


theorem List.Nodup.not_mem : ∀ {α : Type u} {l : List α} {a : α}, List.Nodup (a :: l) → a ∉ l := by sorry

The theorem `List.Nodup.not_mem` states that for any type `α`, any list `l` of type `α`, and any element `a` of type `α`, if the list that is formed by appending `a` to the front of `l` has no duplicates (i.e., `List.Nodup (a :: l)`), then `a` is not a member of `l` (i.e., `a ∉ l`). This means that the condition of having no duplicates in the extended list ensures that the added element `a` is not already present in the original list `l`.

If `a` is not a duplicate in the list `a :: l`, then `a` is not an element of `l`.


/-- The main theorem of this file: Given a coverage `K` on `C`,
a `Type*`-valued presheaf on `C` is a sheaf for `K` if and only if it is a sheaf for
the associated Grothendieck topology.
 -/
theorem CategoryTheory.Presieve.isSheaf_coverage :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (K : CategoryTheory.Coverage C)
      (P : CategoryTheory.Functor Cᵒᵖ (Type w)),
      CategoryTheory.Presieve.IsSheaf (CategoryTheory.Coverage.toGrothendieck C K) P ↔
        ∀ {X : C}, ∀ R ∈ K.covering X, CategoryTheory.Presieve.IsSheafFor P R :=
  by sorry

The main theorem states that, given a coverage `K` on a category `C`, a presheaf valued in the category of types (`Type*`) on `C` is a sheaf for `K` if and only if it is a sheaf for the associated Grothendieck topology. This means that the sheaf condition applies not only to all sieves in the Grothendieck topology generated by `K`, but equivalently to all coverings in `K` itself. This establishes a strong connection between the notions of a sheaf for a coverage and a sheaf for a Grothendieck topology.

A presheaf is a sheaf for a coverage in a category if and only if it is a sheaf for the Grothendieck topology generated by that coverage.


theorem div_add_div :
    ∀ {α : Type u_1} [inst : Semifield α] {b d : α} (a c : α),
      b ≠ 0 → d ≠ 0 → a / b + c / d = (a * d + b * c) / (b * d) :=
  by sorry

This theorem states that for any type `α` that forms a Semifield, given non-zero elements `b` and `d` of this type and any elements `a` and `c`, the sum of the division of `a` by `b` and the division of `c` by `d` is equal to the division of the sum of `a` multiplied by `d` and `b` multiplied by `c` by the product of `b` and `d`. In mathematical terms, it's saying that for all `a`, `b`, `c`, `d` in a Semifield where `b` and `d` are not zero, the equation $\frac{a}{b} + \frac{c}{d} = \frac{a \cdot d + b \cdot c}{b \cdot d}$ holds.

For any semifield `α` with non-zero elements `b` and `d`, the sum of the quotients of `a` by `b` and `c` by `d` equals the quotient of the product of `a` multiplied by `d` and `b` multiplied by `c` by the product of `b` and `d`. In symbols: $\frac{a}{b} + \frac{c}{d} = \frac{a \cdot d + b \cdot c}{b \cdot d}$.


theorem List.get_of_mem : ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → ∃ n, List.get l n = a := by sorry

This theorem, `List.get_of_mem`, states that for any type `α`, any element `a` of this type, and any list `l` of elements of this type, if `a` is an element of `l` (denoted by `a ∈ l`), then there exists an index `n` such that the element at the `n`th index of `l` (denoted by `List.get l n`) is `a`. Essentially, it asserts that if an element is in a list, then we can find its position within the list.

For any type `α`, list `l` of length `n` over `α`, and element `a` in `l`, there exists an index `i` in `{0, 1, ..., n-1}` such that `a = List.get l i`.


theorem Nat.add_mod_add_ite : ∀ (a b c : ℕ), ((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c := by
  sorry

This theorem states that for any three natural numbers a, b, and c, the sum of the modulus of the sum of a and b by c and an additional term - which is c if c is less than or equal to the modulus of the sum of a and b, or 0 otherwise - is equal to the sum of the modulus of a and c and the modulus of b and c. In mathematical terms, this can be written as: `((a + b) mod c) + (c if c ≤ (a mod c + b mod c) else 0) = (a mod c + b mod c)`.

For natural numbers a, b, and c, the expression ((a + b) mod c + c if c <= a % c + b % c else 0) equals (a % c + b % c).


theorem CategoryTheory.Subgroupoid.mem_objs_of_src :
    ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : C} {f : c ⟶ d},
      f ∈ S.arrows c d → c ∈ CategoryTheory.Subgroupoid.objs S :=
  by sorry

This theorem states that for any category `C` that is also a groupoid, any subgroupoid `S` of `C`, and any arrows `f` from `c` to `d` in `C`, if `f` is an element of the arrows of `S` from `c` to `d`, then `c` is an element of the set of objects in `S` that have nontrivial isotropy. Here, isotropy refers to the symmetry of an object - in this case, the object `c` has nontrivial isotropy if there is at least one arrow (or morphism) in `S` that begins and ends at `c`.

In a groupoid `C`, if `S` is a subgroupoid and `f` is an arrow from object `c` to `d` in `S`, then `c` belongs to the set of objects in `S` having nontrivial isotropy.


theorem Bornology.forall_isBounded_image_eval_iff :
    ∀ {ι : Type u_3} {π : ι → Type u_4} [inst : (i : ι) → Bornology (π i)] {s : Set ((i : ι) → π i)},
      (∀ (i : ι), Bornology.IsBounded (Function.eval i '' s)) ↔ Bornology.IsBounded s :=
  by sorry

This theorem states that for any type `ι`, any function `π` from `ι` to some type, and for every set `s` of functions from `ι` to `π i` (where we have a bornology on each `π i`), the set `s` is bounded if and only if the image of each function `Function.eval i` (which takes each function in `s` and applies it to `i`) is bounded with regard to the bornology on `π i`. In simpler terms, it tells us that a set of functions is bounded if and only if, when we apply each function to each possible input, we always get a bounded set.

For any type `ι`, a set `s` of functions from `ι` to some type `π` is bounded (with respect to the bornology on each `π i`) if and only if the image under `Function.eval` of every function in `s` is a bounded set (with respect to the bornology on `π i`).


theorem Real.lt_sqrt : ∀ {x y : ℝ}, 0 ≤ x → (x < Real.sqrt y ↔ x ^ 2 < y) := by sorry

This theorem states that for any two real numbers `x` and `y`, given that `x` is non-negative, then `x` is less than the square root of `y` if and only if the square of `x` is less than `y`. In mathematical notation, this is saying: for all real numbers `x` and `y` with `x` being greater than or equal to 0, `x` is less than `sqrt{y}` is equivalent to `x^2` being less than `y`.

For any non-negative real numbers x and y, x < sqrt(y) if and only if x^2 < y.


theorem Infinite.of_not_fintype : ∀ {α : Type u_1}, (Fintype α → False) → Infinite α := by sorry

This theorem states that for any type `α`, if the type `α` is not finite (meaning that it cannot be represented by a `Fintype` structure), then `α` is infinite. This is a fundamental result in set theory which essentially says that a type is infinite if and only if it is not finite. In mathematical notation, this could be written as: for every type `α`, if `α` is not a finite type, then `α` is an infinite type.

If a type `α` is not finite (has no `Fintype` structure), then `α` is infinite.


theorem Fin.bot_eq_zero : ∀ (n : ℕ), ⊥ = 0 := by sorry

This theorem states that for any natural number `n`, the bottom element of the finite set `Fin n` is equal to zero. This is a fundamental property of the `Fin` data type in Lean, which is a type used to represent a finite set of natural numbers less than some fixed natural number `n`.

For any natural number $n$, the bottom element of the finite set $Fin(n)$ is equal to $0$.


theorem SetTheory.PGame.zero_lt_one : 0 < 1 := by sorry

The theorem `SetTheory.PGame.zero_lt_one` in Lean 4 asserts that zero is less than one. In the context of set theory and game theory, this compares the game numbers 0 and 1, and states that 0 is less than 1. This theorem is fundamental in mathematics and is used as a basis for many other mathematical concepts and theories.

The theorem `SetTheory.PGame.zero_lt_one` in Lean 4 asserts that 0 < 1.


theorem CategoryTheory.Limits.cokernel.condition_apply :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
      {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] [inst_3 : CategoryTheory.ConcreteCategory C]
      (x : (CategoryTheory.forget C).obj X), (CategoryTheory.Limits.cokernel.π f) (f x) = 0 x :=
  by sorry

The theorem `CategoryTheory.Limits.cokernel.condition_apply` states the following:

For any categories `C`, `X`, `Y`, morphism `f` from `X` to `Y`, given that `C` has zero morphisms, `f` has a cokernel and `C` is a concrete category, then for any object `x` in the category `C` (when considered as an object of type via the forgetful functor), the composition of the map `f` followed by the cokernel map `π f` applied to `x` equals to the zero morphism applied to `x`. In other words, applying the cokernel map to the image of `x` under `f` gives us the zero object, reflecting the universal property of the cokernel in category theory.

For any morphism `f` in a concrete category `C` with zero morphisms, if `f` has a cokernel, then for any object `x` in `C`, the composition of `f` and the cokernel map of `f` equals the zero morphism on `x`.


theorem MeasureTheory.OuterMeasure.comap_iInf :
    ∀ {α : Type u_1} {ι : Sort u_2} {β : Type u_3} (f : α → β) (m : ι → MeasureTheory.OuterMeasure β),
      (MeasureTheory.OuterMeasure.comap f) (⨅ i, m i) = ⨅ i, (MeasureTheory.OuterMeasure.comap f) (m i) :=
  by sorry

The theorem `MeasureTheory.OuterMeasure.comap_iInf` states that for any function `f` mapping from a type `α` to a type `β`, and a sequence `m` of outer measures on `β` indexed by `ι`, the pullback of the infimum (greatest lower bound) of `m` through `f` is the same as the infimum of the pullbacks of the individual measures in `m` through `f`. In other words, pulling back 'commutes' with taking the infimum of a sequence of outer measures.

Given a function `f: α → β` and a sequence `(m_i : MeasurableSpace β)_(i: ι)` of outer measures on `β`, we have `∫(f ∫(x: α) f(x) ∥d(m_i)_x∥) = ∫(x: α) ∥f(x)∥d(∫(i: ι) m_i)`.


theorem Int.neg_succ : ∀ (a : ℤ), -Int.succ a = Int.pred (-a) := by sorry

The theorem `Int.neg_succ` states that for any integer `a`, the negation of the immediate successor of `a` is equal to the immediate predecessor of the negation of `a`. In mathematical terms, it says that for all integers $a$, $- (a + 1) = (-a) - 1$.

The theorem `Int.neg_succ` asserts that for all integers $a$, $-(a + 1) = (-a) - 1$.


theorem Real.hasDerivAt_arcsin : ∀ {x : ℝ}, x ≠ -1 → x ≠ 1 → HasDerivAt Real.arcsin (1 / Real.sqrt (1 - x ^ 2)) x := by
  sorry

The theorem `Real.hasDerivAt_arcsin` states that for all real numbers `x` that are not equal to `-1` or `1`, the function `Real.arcsin` has a derivative at `x`. The derivative is given by the function `1 / Real.sqrt (1 - x ^ 2)`. In other words, except at the points `-1` and `1`, the rate of change of the `arcsin` function at a point `x` is equal to `1` divided by the square root of `(1 - x ^ 2)`.

For all real numbers `x` distinct from `-1` and `1`, the derivative of `Real.arcsin` at `x` exists and equals `1 / √(1 - x²)`.


theorem mdifferentiableAt_id :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : SmoothManifoldWithCorners I M]
      {x : M}, MDifferentiableAt I I id x :=
  by sorry

This theorem states that the identity function is smooth at any point in a smooth manifold. More specifically, for any non-trivially normed field `𝕜`, normed additive commutative group `E`, topological space `H`, and `M` which is a smooth manifold with corners with respect to model with corners `I`, the identity function `id` is continuously differentiable at any point `x` in `M`.

The identity function on a smooth manifold is smooth (continuously differentiable).


theorem neg_add_cancel_comm : ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + b + a = b := by sorry

This theorem, `neg_add_cancel_comm`, states that for any type `G` equipped with the structure of an additive commutative group, for any two elements `a` and `b` of this group, the sum of the negation of `a`, `b`, and `a` is equal to `b`. In mathematical terms, for any `a` and `b` in some additive commutative group `G`, we have that `-a + b + a = b`. This result is a reflection of the property of additive inverses in a commutative group.

For any additive commutative group `G` and elements `a, b` in `G`, we have `-a + b + a = b`.


theorem MeasureTheory.ProgMeasurable.stoppedProcess :
    ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι]
      [inst_1 : MeasurableSpace ι] [inst_2 : TopologicalSpace ι] [inst_3 : OrderTopology ι]
      [inst_4 : SecondCountableTopology ι] [inst_5 : BorelSpace ι] [inst_6 : TopologicalSpace β] {u : ι → Ω → β}
      {τ : Ω → ι} {f : MeasureTheory.Filtration ι m} [inst_7 : TopologicalSpace.MetrizableSpace ι],
      MeasureTheory.ProgMeasurable f u →
        MeasureTheory.IsStoppingTime f τ → MeasureTheory.ProgMeasurable f (MeasureTheory.stoppedProcess u τ) :=
  by sorry

The theorem `MeasureTheory.ProgMeasurable.stoppedProcess` states that for any types `Ω`, `β`, and `ι`, for a given measurable space `m` on `Ω`, a linear order on `ι`, measurable space on `ι`, topological space on `ι`, order topology on `ι`, second countable topology on `ι`, Borel space on `ι`, topological space on `β`, a function `u` mapping `ι` and `Ω` to `β`, a function `τ` mapping `Ω` to `ι`, and a filtration `f` on `m` with `ι` as the index set, and assuming `ι` is a metrizable space, if the function `u` is progressively measurable with respect to the filtration `f`, and if the function `τ` is a stopping time with respect to the same filtration `f`, then the stopped process of `u` with respect to `τ` is also progressively measurable with respect to the filtration `f`. In other words, stopping a progressively measurable process at a stopping time yields another progressively measurable process.

Given a measurable space, a linear order on a metrizable index set, a filtration, a progressively measurable function, and a stopping time, the stopped process of the function at the stopping time is also progressively measurable with respect to the filtration.


theorem Computation.exists_of_mem_parallel :
    ∀ {α : Type u} {S : Stream'.WSeq (Computation α)} {a : α}, a ∈ Computation.parallel S → ∃ c ∈ S, a ∈ c := by sorry

This theorem states that for any type `α`, any infinite stream `S` of computations of type `α`, and any value `a` of type `α`, if `a` is in the result of the parallel computation of `S`, then there exists a computation `c` in `S` such that `a` is in `c`. In other words, if a value is produced by running multiple computations in parallel, then there must be at least one individual computation that produces that value.

For any type `α`, infinite stream `S` of computations of type `α`, and value `a` of type `α`, if `a` is in the result of the parallel computation of `S`, then there exists some computation `c` in `S` such that `a` is in the result of `c`.


FirstOrder.Language.Substructure.FG.cg

theorem FirstOrder.Language.Substructure.FG.cg :
    ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : FirstOrder.Language.Structure L M]
      {N : FirstOrder.Language.Substructure L M},
      FirstOrder.Language.Substructure.FG N → FirstOrder.Language.Substructure.CG N :=
  by sorry

The theorem `FirstOrder.Language.Substructure.FG.cg` states that for any first-order language `L` and a type `M` that is a structure of `L`, if a substructure `N` of `M` is finitely generated (i.e., it is the closure of a finite subset of `M`), then `N` is also countably generated (i.e., it is the closure of a countable subset of `M`). This is a universal property that holds for all such `L`, `M`, and `N`.

If `L` is a first-order language, `M` is an `L`-structure, and `N` is a finitely generated substructure of `M`, then `N` is countably generated.


theorem Filter.IsBoundedUnder.bddAbove_range_of_cofinite :
    ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [inst_1 : IsDirected β fun x x_1 => x ≤ x_1] {f : α → β},
      Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) Filter.cofinite f → BddAbove (Set.range f) :=
  by sorry

This theorem states that for any types `α` and `β`, where `β` has an order and is directed, and any function `f` mapping from `α` to `β`, if the function `f` is bounded under the cofinite filter with respect to the preorder relation (i.e., every element from the cofinite filter applied to `f` is less than or equal to some fixed value eventually), then the set of all values that `f` can take (the range of `f`) is bounded above. In other words, there exists an upper bound for all possible outputs of `f`.

If `α` is any type, `β` is a type with an order and directed, and `f` is a function from `α` to `β` that is bounded under the cofinite filter of `β`, then the range of `f` has an upper bound.


theorem HasMFDerivWithinAt.mdifferentiableWithinAt :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H}
      {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5}
      [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H']
      {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M']
      {f : M → M'} {x : M} {s : Set M} [Is : SmoothManifoldWithCorners I M] [I's : SmoothManifoldWithCorners I' M']
      {f' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)},
      HasMFDerivWithinAt I I' f s x f' → MDifferentiableWithinAt I I' f s x :=
  by sorry

This theorem states that for any non-trivially normed field `𝕜`, normed additive commutative groups `E` and `E'`, normed spaces `𝕜 E` and `𝕜 E'`, topological spaces `H`, `M`, `H'`, and `M'`, models with corners `I`, `I'`, charted spaces `H M`, `H' M'`, function `f` from `M` to `M'`, point `x` in `M`, a set `s` of `M`, and smooth manifolds with corners `I M` and `I' M'`, if a function `f` has a manifold derivative within a set `s` at point `x` (as captured by `HasMFDerivWithinAt I I' f s x f'`), then the function `f` is manifold differentiable within the set `s` at the point `x` (as captured by `MDifferentiableWithinAt I I' f s x`). This theorem thus establishes a relationship between having a manifold derivative and being manifold differentiable at a given point within a set in the context of differential geometry.

If a function between smooth manifolds with corners has a manifold derivative within a set at a point, then it is manifold differentiable within that set at the point.


theorem Profinite.NobelingProof.ProjRestricts.proof_1 :
    ∀ {I : Type u_1} (C : Set (I → Bool)) {J K : I → Prop} [inst : (i : I) → Decidable (J i)]
      [inst_1 : (i : I) → Decidable (K i)],
      (∀ (i : I), J i → K i) →
        Profinite.NobelingProof.π (Profinite.NobelingProof.π C K) J = Profinite.NobelingProof.π C J :=
  by sorry

The theorem `Profinite.NobelingProof.ProjRestricts.proof_1` states that for any type `I`, given a set `C` of boolean-valued functions on `I`, and two properties `J` and `K` defined on `I` (with `J` implying `K`), the image of the set "image of `C` under the projection `K`" under the projection `J` is equal to the image of `C` under the projection `J`. In simpler terms, this theorem suggests that projecting `C` twice with `J` and `K` (given that `J` implies `K`) does not change the result as compared to directly projecting `C` with `J`.

For any set `C` of boolean-valued functions on a type `I`, and properties `J` and `K` on `I` with `J` implying `K`, the image of `C` under `K` and then `J` is equal to the image of `C` under `J`.


theorem Finset.prod_dvd_of_coprime :
    ∀ {R : Type u} {I : Type v} [inst : CommSemiring R] {z : R} {s : I → R} {t : Finset I},
      Set.Pairwise (↑t) (IsCoprime on s) → (∀ i ∈ t, s i ∣ z) → (Finset.prod t fun x => s x) ∣ z :=
  by sorry

The theorem `Finset.prod_dvd_of_coprime` states that for any type `R` with a commutative semiring structure, any type `I`, any `z` of type `R`, any function `s` from `I` to `R`, and any finite set `t` of type `I`, if the function `s` induces pairwise coprime elements on the set `t` and each element of `s i` for `i` in `t` divides `z`, then the product of `s x` for `x` in `t` also divides `z`. This means, if we have a finite set of elements which are pairwise coprime (i.e., any two distinct elements have no common divisors other than 1) and each of these elements divides a given number, then their product also divides that number.

Let `R` be a commutative semiring, `I` a type, `z` an element of `R`, `s : I -> R`, and `t` a finite set of pairwise coprime elements of `I` such that `s i` divides `z` for all `i` in `t`, then `∏(s x for x in t)` divides `z`.


theorem List.nil_union : ∀ {α : Type u_1} [inst : BEq α] (l : List α), [] ∪ l = l := by sorry

This theorem, `List.nil_union`, states that for all types `α`, given a list `l` of type `α`, the union of an empty list and `l` is equal to `l` itself. This is under the condition that the type `α` has a binary equality instance. In terms of set theory, it means that the union of an empty set with any set is the set itself.

For all types `α` with equality, the union of an empty list of type `α` and a list `l` of type `α` is equal to `l`.


theorem FirstOrder.Language.BoundedFormula.realize_rel :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {v : α → M} {xs : Fin l → M} {k : ℕ} {R : L.Relations k} {ts : Fin k → FirstOrder.Language.Term L (α ⊕ Fin l)},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Relations.boundedFormula R ts) v xs ↔
        FirstOrder.Language.Structure.RelMap R fun i => FirstOrder.Language.Term.realize (Sum.elim v xs) (ts i) :=
  by sorry

The theorem `FirstOrder.Language.BoundedFormula.realize_rel` states that for any first-order language `L`, any `L`-structure `M`, any function `v` from type `α` to `M`, any function `xs` from `Fin l` to `M` (where `l` is a natural number), any natural number `k`, any `k`-ary relation `R` in `L`, and any function `ts` from `Fin k` to the set of terms in `L` over `α ⊕ Fin l`, the realization of the bounded formula obtained by applying `R` to `ts` using `v` and `xs` is equivalent to the application of the relation map of `R` to the function which maps each element `i` of `Fin k` to the realization of the term `ts i` using the function `Sum.elim v xs`. In simpler terms, this theorem connects the realization of a bounded formula with the realization of terms under a relation in a first-order language structure.

For any first-order language L, structure M, function v : α -> M, function xs : Fin l -> M, natural number k, k-ary relation R in L, and function ts : Fin k -> terms(L) over α ⊕ Fin l, the realization of the bounded formula obtained by applying R to ts using v and xs is equivalent to applying the relation map of R to the function that maps i in Fin k to the realization of ts i using Sum.elim v xs.


theorem MeasureTheory.lintegral_coe_eq_integral :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → NNReal),
      MeasureTheory.Integrable (fun x => ↑(f x)) μ → ∫⁻ (a : α), ↑(f a) ∂μ = ENNReal.ofReal (∫ (a : α), ↑(f a) ∂μ) :=
  by sorry

This theorem, `MeasureTheory.lintegral_coe_eq_integral`, states that for any type `α`, a measurable space `m` of type `α`, a measure `μ` on this measurable space, and a function `f` from `α` to nonnegative real numbers, if the function obtained by taking the nonnegative real number output of `f` and considering it as a real number is integrable (i.e., it is measurable and has a finite integral), then the Lebesgue integral of the function `f` (after considering its output as a real number) with respect to the measure `μ` equals to the extended nonnegative real number obtained by considering the real number integral of the function `f` (after considering its output as a real number) with respect to the measure `μ`. If the real number integral is negative, it will be considered as zero.

For any measurable function `f` from a measurable space `(α, m)` to nonnegative real numbers, if the real number integral of `|f|` with respect to the measure `μ` is finite, then `∫(f dμ) = ‛{∫(x dμ) : x ∈ ℝ | x = ∥f(x)∥}‛`, where `∥f(x)∥` denotes the nonnegative real number output of `f` at `x`.


theorem Mathlib.ModelTheory.Order._auxLemma.12 :
    ∀ {L : FirstOrder.Language} {α : Type w} {M : Type w'} {n : ℕ} [inst : FirstOrder.Language.IsOrdered L]
      [inst_1 : FirstOrder.Language.Structure L M] [inst_2 : LE M] [inst_3 : FirstOrder.Language.OrderedStructure L M]
      {t₁ t₂ : FirstOrder.Language.Term L (α ⊕ Fin n)} {v : α → M} {xs : Fin n → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Term.le t₁ t₂) v xs =
        (FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ ≤ FirstOrder.Language.Term.realize (Sum.elim v xs) t₂) :=
  by sorry

The theorem `Mathlib.ModelTheory.Order._auxLemma.12` in Lean 4 states that for any first-order language `L` that is ordered, with a structure `M` that is also ordered, and for any terms `t₁` and `t₂` of this language, we can realize a formula that asserts `t₁ ≤ t₂` based on variables `α` (interpreted by `v : α → M`) and `xs : Fin n → M`. This realization is equivalent to saying that the realization of the term `t₁` with the same variable interpretation is less than or equal to the realization of the term `t₂` with the same variable interpretation. In other words, this theorem certifies that the semantic interpretation of the symbolic `≤` in terms of the structure `M` is consistent with the interpretation of the `≤` symbol in the language `L`.

For any ordered first-order language `L` and ordered structure `M`, the realization of a formula `t₁ ≤ t₂` in `M` is equivalent to the relationship between the realizations of terms `t₁` and `t₂` in `M`.


theorem Set.Ioo_eq_empty_iff :
    ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [inst_1 : DenselyOrdered α], Set.Ioo a b = ∅ ↔ ¬a < b := by sorry

This theorem states that for any type `α` with a preorder and any two elements `a` and `b` of `α`, under the condition that `α` is densely ordered, the open interval from `a` to `b` (denoted by `Set.Ioo a b`, which includes all elements `x` such that `a < x < b`) is empty if and only if `a` is not less than `b`. In other words, if `a` is not less than `b`, there are no elements `x` between `a` and `b`, hence the open interval is empty. Conversely, if the open interval is empty, this implies that there are no elements between `a` and `b`, hence `a` cannot be less than `b`.

For a densely ordered type `α` and elements `a` and `b` of `α`, the open interval `Set.Ioo a b` is empty if and only if `a` is not less than `b`.


theorem IsLocalization.mk'_self :
    ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
      [inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x : R} (hx : x ∈ M),
      IsLocalization.mk' S x { val := x, property := hx } = 1 :=
  by sorry

The theorem `IsLocalization.mk'_self` states that for any commutative semiring `R` and any submonoid `M` of `R`, if `S` is a localization of `R` at `M`, then for any element `x` in `M`, the value of `IsLocalization.mk' S x` applied to `x` is `1`. In other words, it states that when the function `IsLocalization.mk'` is applied to `a` of `M` and `{ val := a, property := hx }` (which is just `a` again packaged with a proof that it is in `M`), the result is always `1`. This is an important property in the theory of localization of rings.

For any commutative semiring `R`, submonoid `M` of `R`, and localization `S` of `R` at `M`, the application of `IsLocalization.mk' S` to any element `x` in `M` results in `1`.


theorem Mathlib.ModelTheory.Order._auxLemma.15 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {θ : FirstOrder.Language.BoundedFormula L α (Nat.succ l)} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.all θ) v xs =
        ∀ (a : M), FirstOrder.Language.BoundedFormula.Realize θ v (Fin.snoc xs a) :=
  by sorry

This theorem, `Mathlib.ModelTheory.Order._auxLemma.15`, states that for any first-order language `L`, a type `M` under the structure of `L`, another type `α`, a natural number `l`, a bounded formula `θ` in `L` with `α` and `l+1` as parameters, a function `v` mapping `α` to `M`, and a function `xs` mapping `Fin l` to `M`, the realization of the universal quantification of `θ` with respect to `v` and `xs` is equivalent to the statement that for all `a` in `M`, `θ` is realized with respect to `v` and the `l`-tuple `xs` extended by `a`. In other words, a universal statement in our language is true if and only if the statement is true for every element of `M` when it is added to the end of our `l`-tuple.

For any first-order language L, type M, formula θ, functions v from α to M and xs from Fin l to M, the realization of the universal quantification of θ with respect to v and xs is equivalent to θ being true for all a in M when appended to the tuple xs.


theorem Mathlib.ModelTheory.Order._auxLemma.16 :
    ∀ {L : FirstOrder.Language} {M : Type w} [inst : FirstOrder.Language.Structure L M] {α : Type u'} {l : ℕ}
      {θ : FirstOrder.Language.BoundedFormula L α (Nat.succ l)} {v : α → M} {xs : Fin l → M},
      FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.BoundedFormula.ex θ) v xs =
        ∃ a, FirstOrder.Language.BoundedFormula.Realize θ v (Fin.snoc xs a) :=
  by sorry

This theorem states that for any first order language `L`, type `M` that is a structure for `L`, another type `α`, a natural number `l`, a bounded formula `θ` in `L` with `α` and `l+1` parameters, a function from `α` to `M`, and a function from the finite ordinal number `l` to `M`, the realization of the bounded formula obtained by prefixing an existential quantifier to `θ` with respect to the given functions is equivalent to the existence of an element `a` such that the realization of `θ` with respect to the given functions and an `l+1`-tuple obtained by appending `a` to the `l`-tuple defined by the last given function holds. In other words, adding an existential quantifier to a bounded formula `θ` corresponds to the existence of an additional parameter in the realizing environment that satisfies `θ`.

For any first order language L, structure M for L, type α, natural number l, bounded formula θ(x₁, ..., xₖ) in L with parameters α and l+1, functions f : α -> M and g : Nat -> M (l), the existence of an element a such that ∃x.(θ(a, x₁, ..., xₖ) ∧ g(l) = f(a)) is equivalent to the realization of ∃x.(θ(x, x₁, ..., xₖ) & ∧ₙi=0.l.(g(i) = f(xₖ₋i))) by f and g.


theorem HasDerivAt.congr_of_eventuallyEq :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {f' : F} {x : 𝕜},
      HasDerivAt f f' x → f₁ =ᶠ[nhds x] f → HasDerivAt f₁ f' x :=
  by sorry

This theorem, `HasDerivAt.congr_of_eventuallyEq`, states that for any nontrivially normed field `𝕜`, normed additive commutative group `F`, and normed space over `𝕜` and `F`, if a function `f` has a derivative `f'` at a point `x`, and another function `f₁` equals `f` in a neighborhood of `x` (more precisely, `f₁` equals `f` eventually at `x`), then `f₁` also has the derivative `f'` at the point `x`. In other words, the existence of the derivative at a point is stable under small perturbations of the function in a neighborhood of that point.

If `f` has a derivative `f'` at `x` and `f₁` equals `f` eventually at `x`, then `f₁` also has derivative `f'` at `x` in a nontrivially normed field.


theorem Commute.sub_dvd_pow_sub_pow :
    ∀ {α : Type u} [inst : Ring α] {x y : α}, Commute x y → ∀ (n : ℕ), x - y ∣ x ^ n - y ^ n := by sorry

The theorem `Commute.sub_dvd_pow_sub_pow` states that for any type `α` that forms a ring, given two elements `x` and `y` of this type that commute (meaning `x * y = y * x`), and given any natural number `n`, the difference `x - y` evenly divides the difference `x^n - y^n`. In other words, there exists some element in the ring such that multiplying it by `x - y` yields `x^n - y^n`.

For any commuting elements $x, y$ in a ring and natural number $n$, $x^n - y^n$ is divisible by $x - y$.


/-- The composition of left adjoint mates is the adjoint mate of the composition.  -/
theorem CategoryTheory.comp_leftAdjointMate :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
      [inst_2 : CategoryTheory.HasLeftDual X] [inst_3 : CategoryTheory.HasLeftDual Y]
      [inst_4 : CategoryTheory.HasLeftDual Z] {f : X ⟶ Y} {g : Y ⟶ Z},
      (ᘁCategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp (ᘁg) (ᘁf) :=
  by sorry

This theorem, in the Category Theory, states that for any type `C` which is a category and also a monoidal category, with objects `X`, `Y`, and `Z` where each object has a left dual, the composition of left adjoint mates of morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, is equivalent to the composition of the left adjoint of `g` and the left adjoint of `f`. Here, `ᘁCategoryTheory.CategoryStruct.comp f g` denotes the left adjoint mate of the composition of `f` and `g`, and `CategoryTheory.CategoryStruct.comp (ᘁg) (ᘁf)` denotes the composition of the left adjoints of `g` and `f`. Therefore, we can say that the process of taking left adjoint mates commutes with composition in the category.

For any category `C` with objects `X`, `Y`, `Z` having left duals, the left adjoint mates of morphisms `f: X ↔ Y` and `g: Y ↔ Z` commute, i.e., `ᘁCategoryTheory.CategoryStruct.comp f g ≈ ᘁCategoryTheory.CategoryStruct.comp (ᘁg) (ᘁf)`.


theorem map_finset_inf :
    ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} {ι : Type u_5} [inst : SemilatticeInf α] [inst_1 : OrderTop α]
      [inst_2 : SemilatticeInf β] [inst_3 : OrderTop β] [inst_4 : FunLike F α β] [inst_5 : InfTopHomClass F α β] (f : F)
      (s : Finset ι) (g : ι → α), f (Finset.inf s g) = Finset.inf s (⇑f ∘ g) :=
  by sorry

The theorem `map_finset_inf` states that for all types `F`, `α`, `β`, and `ι`, with `α` and `β` being semilattice infima and ordered tops, and type `F` being a function-like object from `α` to `β` which also satisfies the `InfTopHomClass` typeclass, and given a function `f` of type `F`, a finite set `s` of type `Finset ι`, and a function `g` from `ι` to `α`, the function `f` applied to the infimum of the set `s` under function `g` equals to the infimum of the set `s` under the composition of `f` and `g`. In simpler terms, this theorem is about the commutativity of the function `f` with the operation of taking the infimum over a finite set.

For any semilattice infima and ordered tops types `α` and `β`, function-like object `F` from `α` to `β` belonging to `InfTopHomClass`, and finite set `s` of index type `ι`, the function `f : F` applied to the infimum of `s` under `g : ι → α` is equal to the infimum of `s` under the composition `f ∘ g`.


theorem Polynomial.degree_add_divByMonic :
    ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R},
      Polynomial.Monic q →
        Polynomial.degree q ≤ Polynomial.degree p →
          Polynomial.degree q + Polynomial.degree (p /ₘ q) = Polynomial.degree p :=
  by sorry

The theorem `Polynomial.degree_add_divByMonic` states that for any ring `R` and any polynomials `p` and `q` over `R`, if `q` is monic (its leading coefficient is 1) and the degree of `q` is less than or equal to the degree of `p`, then the sum of the degree of `q` and the degree of the quotient of `p` divided by `q` (`p /ₘ q`) equals the degree of `p`. Essentially, this theorem captures the relationship between the degrees of two polynomials and their quotient in certain conditions.

For any ring R and monic polynomial q of degree less than or equal to that of polynomial p over R, the degree of p equals the degree of q plus the degree of the quotient p /ₘ q.


theorem PartENat.add_one_le_of_lt : ∀ {x y : PartENat}, x < y → x + 1 ≤ y := by sorry

This theorem states that for any two elements `x` and `y` of the type `PartENat`, which consists of natural numbers along with an infinite element (`⊤`), if `x` is strictly less than `y`, then `x + 1` is less than or equal to `y`. This corresponds to the intuitive idea that adding one to a number does not exceed the next number, unless the next number is infinity.

For all `x` and `y` in `PartENat`, if `x < y`, then `x + 1 ≤ y`.


theorem Submodule.isOrtho_bot_left :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {V : Submodule 𝕜 E}, ⊥ ⟂ V :=
  by sorry

This theorem states that for any type `𝕜` and `E`, where `𝕜` is a ring-like structure, `E` is a normed additive commutative group, and an inner product space is defined over `𝕜` and `E`, the zero submodule (denoted as `⊥`) is orthogonal to any given submodule `V` of the inner product space. In other words, in a given inner product space, every element of the zero submodule has an inner product of zero with every element of any other submodule `V`.

In an inner product space over a ring-like structure and an additive commutative group, the zero submodule is orthogonal to any given submodule.


theorem IsometryEquiv.image_sphere :
    ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x : α)
      (r : ℝ), ⇑h '' Metric.sphere x r = Metric.sphere (h x) r :=
  by sorry

The theorem `IsometryEquiv.image_sphere` states that for any two types `α` and `β` that have the structure of a pseudometric space, and for any isometry `h` from `α` to `β`, the image under `h` of the sphere of radius `r` centered at a point `x` in `α` is precisely the sphere of the same radius `r` centered at the image of `x` under `h` in `β`. In other words, an isometry maps spheres to spheres of the same radius, preserving their geometric structure.

For any isometry between pseudometric spaces and any point and radius, the image of a sphere is a sphere of the same radius with the same center in the target space.


theorem Part.mem_some : ∀ {α : Type u_1} (a : α), a ∈ Part.some a := by sorry

The theorem `Part.mem_some` states that for all types `α` and any element `a` of type `α`, `a` is an element of `Part.some a`. In other words, any element `a` belongs to the partial function represented by `Part.some a`, which is defined to have a `True` domain and always returns `a`.

For any type `α` and element `a` of type `α`, `a` is a member of the image of the constant partial function `Part.some a`.


theorem antitone_const_tsub :
    ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α] {c : α}
      [inst_4 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1], Antitone fun x => c - x :=
  by sorry

The theorem `antitone_const_tsub` states that for any type `α` that has a preorder structure, an additive commutative semigroup structure, a subtraction operation, and an ordered subtraction, and for any constant `c` of type `α`, the function `f(x) = c - x` is antitone. In other words, if `a ≤ b` for any `a` and `b` of type `α`, then `f(b) = c - b ≤ c - a = f(a)`. This theorem requires that addition on `α` is covariant, meaning that `x + y ≤ x + z` whenever `y ≤ z`.

For any type `α` endowed with a preorder, an additive commutative semigroup structure, subtraction, and ordered subtraction, the function `f(x) = c - x` is antitone, i.e., `f(a) ≤ f(b)` whenever `a ≤ b`. Under this setup, `α`'s addition is covariant.