theorem uniformEmbedding_iff' :
    ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
      UniformEmbedding f ↔
        Function.Injective f ∧ UniformContinuous f ∧ Filter.comap (Prod.map f f) (uniformity β) ≤ uniformity α :=
  by sorry

The theorem `uniformEmbedding_iff'` states that for any two types `α` and `β` having uniform space structures, and any function `f` from `α` to `β`, the function `f` is a uniform embedding if and only if it satisfies the following three conditions:

1) `f` is an injective function, meaning that `f x = f y` implies `x = y`.

2) `f` is uniformly continuous, which means that if `x` is sufficiently close to `y`, then `f x` is close to `f y` regardless of `x` and `y`'s location in `α`.

3) The filter obtained by applying the function `f` twice to the input (in other words, taking the product map of `f` and `f`) and then applying the preimage operation (comap) to the uniformity of `β` is less than or equal to the uniformity of `α`. In mathematical terms, `Filter.comap (Prod.map f f) (uniformity β) ≤ uniformity α`.

A function between uniform spaces is a uniform embedding if and only if it is injective, uniformly continuous, and the image of their uniformities under the product map and preimage operation satisfies the inequality.


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

The theorem `IsMax.eq_of_ge` states that for any type `α` equipped with a partial order, if an element `a` is a maximal element and another element `b` satisfies the condition `a ≤ b`, then `b` must be equal to `a`. In other words, no element in the set can be strictly greater than a maximal element; if it's not less than the maximal element, then it must be equal.

If `α` is a type equipped with a partial order, and `a` is a maximal element of `α` and `a ≤ b`, then `b = a`.


theorem Set.singleton_pi' :
    ∀ {ι : Type u_1} {α : ι → Type u_2} (i : ι) (t : (i : ι) → Set (α i)), Set.pi {i} t = {x | x i ∈ t i} := by sorry

The theorem `Set.singleton_pi'` states that for any type `ι`, any function `α : ι → Type u_2`, any element `i : ι`, and any family of sets `t : (i : ι) → Set (α i)`, the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a` whenever `a` is in the singleton set `{i}`, is the same as the set of functions `x` where `x i` belongs to `t i`. In other words, when considering only the functions defined at a single point `i`, the condition for a function to be in the set of functions is simply that its value at `i` is in the corresponding set `t i`.

For any type `ι`, function `α : ι → Type u_2`, element `i : ι`, and set family `t : (i : ι) → Set (α i)`, the dependent functions in `Πa, π a` with `f a ∈ t a` for `a` in the singleton set `{i}` are identical to the functions `x` with `x i ∈ t i`.


theorem MonoidAlgebra.single_zero :
    ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] (a : G), MonoidAlgebra.single a 0 = 0 := by sorry

The theorem `MonoidAlgebra.single_zero` states that for any type `k` under the semiring structure, and any type `G`, if we apply the `MonoidAlgebra.single` function to any element 'a' of `G` and the zero of `k`, it yields the zero of the `MonoidAlgebra`. In other words, in the context of monoid algebras, "singling out" an element with a zero coefficient results in the zero element of the corresponding monoid algebra.

For any semiring `k` and monoid `G`, applying `MonoidAlgebra.single` to an element `a` in `G` and the zero of `k` results in the zero of the monoid algebra `MonoidAlgebra k G`.


theorem Mathlib.Order.Filter.Basic._auxLemma.176 :
    ∀ {α : Type u} {β : Type v} {ι : Sort x} {f : α → β} {x : ι → Filter α} {y : Filter β},
      Filter.Tendsto f (⨆ i, x i) y = ∀ (i : ι), Filter.Tendsto f (x i) y :=
  by sorry

The theorem `Mathlib.Order.Filter.Basic._auxLemma.176` states that for any types `α` and `β`, any sort `ι`, any function `f` from `α` to `β`, any function `x` from `ι` to the set of filters on `α`, and any filter `y` on `β`, the function `f` tends to the filter `y` under the join (supremum) of the filters `x i` (for each `i` in `ι`) if and only if for each `i` in `ι`, the function `f` tends to the filter `y` under the filter `x i`. In other words, the limit of `f` at the supremum of the filters is the same as the limit of `f` at each of the individual filters.

For any types α and β, functions f from α to β, filters x on α indexed by an index set ι, and a filter y on β, the function f tends to the filter y under the join of x i (for each i in ι) if and only if for all i in ι, the function f tends to the filter y under the filter x i.


theorem Mathlib.Order.Filter.Basic._auxLemma.181 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
      Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ :=
  by sorry

This theorem states that for any two types `α` and `β`, a function `f` from `α` to `β`, and two filters `l₁` and `l₂` on `α` and `β` respectively, the function `f` tends to the filter `l₂` from `l₁` if and only if for every set `s` in `l₂`, the preimage of `s` under the function `f` is in `l₁`. In other words, a function `f` has a limit at a point if every neighborhood of the limit point in the codomain has a preimage that is a neighborhood of the point in the domain.

A function between two types has a limit from one filter to another if and only if the preimage of every set in the target filter is in the domain filter.


theorem isSimpleOrder_iff_isAtom_top :
    ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α], IsSimpleOrder α ↔ IsAtom ⊤ := by sorry

The theorem `isSimpleOrder_iff_isAtom_top` states that for any type `α` that has a partial order and a bounded order, `α` is a simple order if and only if the top element (denoted as `⊤`) is an atom.

In this context, an atom of a bounded order is an element with no other element between it and the bottom element (denoted as `⊥`). Also, the atom is not equal to the bottom element. And a simple order is a special type of partial order where every non-top element is below some other element.

A bounded partial order `α` is simple if and only if its top element `⊤` is an atom that is strictly above the bottom element `⊥`.


theorem Set.singleton_add_singleton : ∀ {α : Type u_2} [inst : Add α] {a b : α}, {a} + {b} = {a + b} := by sorry

This theorem states that for any two elements `a` and `b` of a type `α` that is equipped with an addition operation, the sum of the sets containing `a` and `b` individually equals the set containing the sum of `a` and `b`. Symbolically, this is expressed as `{a} + {b} = {a + b}`. This theorem is valid for any type that supports addition, not just the usual numbers.

For any type `α` with an addition operation, the set of an element `a` is equal to the set containing the sum of `a` and another element `b`, i.e., {a} = {a + b}.


theorem Mathlib.Order.Filter.Basic._auxLemma.147 :
    ∀ {α : Sort u_3} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) := by sorry

This theorem states that for any types `α` and `β` and any function `f` from `α` to `β`, the property that there exists a value `b` of type `β` such that `b` is the image of some value `a` of type `α` under `f` and `b` satisfies a property `p`, is equivalent to the property that there exists a value `a` of type `α` such that `f(a)` satisfies the property `p`. In other words, it's expressing that the existence of an element in the codomain satisfying a property can be traced back to the existence of an element in the domain such that its image under the function satisfies that property.

For any functions between types and properties, the existence of an image satisfying a property is equivalent to the existence of a preimage with that property.


theorem Submodule.map_mono :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} [inst_6 : RingHomSurjective σ₁₂] {F : Type u_9} [inst_7 : FunLike F M M₂]
      [inst_8 : SemilinearMapClass F σ₁₂ M M₂] {f : F} {p p' : Submodule R M},
      p ≤ p' → Submodule.map f p ≤ Submodule.map f p' :=
  by sorry

The theorem `Submodule.map_mono` states that for any semirings `R` and `R₂`, additively commutative monoids `M` and `M₂`, `R`-module structure on `M`, `R₂`-module structure on `M₂`, a surjective ring homomorphism `σ₁₂ : R →+* R₂`, a function `f : F` that behaves like a function from `M` to `M₂`, semilinear map `F` with respect to `σ₁₂`, if we have two submodules `p` and `p'` of `M` such that `p` is a subset of `p'` (`p ≤ p'`), then the image of `p` under the function `f` is a subset of the image of `p'` under `f` (`Submodule.map f p ≤ Submodule.map f p'`). In other words, the mapping of submodules by a function respects the inclusion relation between submodules.

If `σ₁₂ : R → R₂` is a surjective ring homomorphism, `f : M → M₂` is a semilinear map respecting `σ₁₂`, `p ≤ p'` are submodules of an `R`-module `M`, then `Submodule.map f p ≤ Submodule.map f p'`.


theorem Mathlib.Order.Filter.Basic._auxLemma.153 :
    ∀ {ι : Type u_2} {α : ι → Type u_3} [inst : ∀ (j : ι), Nonempty (α j)] {i : ι} {f : Filter (α i)},
      Filter.NeBot (Filter.comap (Function.eval i) f) = Filter.NeBot f :=
  by sorry

This theorem states that for any index type `ι`, any function `α` from `ι` to some type, and any index `i` of type `ι`, given a filter `f` on the type `α i`, the filter obtained by precomposing `f` with the evaluation function at `i` is nontrivial if and only if `f` itself is nontrivial. Here, a nontrivial filter is one that does not collapse to contain only a single element. This theorem essentially says that the process of precomposing with the evaluation function preserves the nontriviality of a filter.

For any index type `ι`, function `α : ι → Type`, index `i : ι`, and filter `f` on `α i`, the filter `f.map (eval i)` is nontrivial if and only if `f` is nontrivial.


theorem isOpenMap_inr :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsOpenMap Sum.inr := by sorry

The theorem `isOpenMap_inr` states that for any two types `X` and `Y`, each equipped with a topological space structure, the injective function `Sum.inr`, which maps an element of `Y` into the right component of the sum type `X + Y`, is an open map. In other words, the image of any open set in `Y` under `Sum.inr` is an open set in the sum type `X + Y`.

The injective function `Sum.inr` from a topological space `Y` to the sum type `X + Y` preserves open sets, that is, the image of any open set in `Y` is an open set in `X + Y`.


theorem isOpenMap_inl :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsOpenMap Sum.inl := by sorry

The theorem `isOpenMap_inl` states that for any types `X` and `Y`, given that `X` and `Y` both have topological space structures, the left injection function `Sum.inl` from `X` into the sum type `X + Y` (written as `Sum X Y` in Lean), is an open map. In other words, for any open set in `X`, its image under the `Sum.inl` function is an open set in the sum space `X + Y`.

The left injection map from a topological space `X` into the sum `X + Y` preserves open sets.


theorem HasStrictFDerivAt.map_nhds_eq_of_equiv :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
      [inst_5 : CompleteSpace E] {f : E → F} {f' : E ≃L[𝕜] F} {a : E},
      HasStrictFDerivAt f (↑f') a → Filter.map f (nhds a) = nhds (f a) :=
  by sorry

This theorem states that for a given strict Frechet derivative at a point `a` in a complete normed additive commutative group `E` over a nontrivially normed field `𝕜`, mapped to another normed additive commutative group `F` under a continuous linear equivalence `f'`, if the function `f` has a strict Frechet derivative `f'` at `a`, then the forward map of the neighborhood filter at `a` under `f` is equal to the neighborhood filter at `f(a)`. In simpler terms, this theorem provides a condition under which the derivative of a function at a point determines the local behavior of the function around that point in the sense of filters.

If `f : E → F` is a continuous linear map between complete normed additive commutative groups with `f'` its strict Frechet derivative at `a ∈ E`, then the forward neighborhood filter of `a` under `f` equals the neighborhood filter of `f(a)`.


theorem Mathlib.Order.Filter.Basic._auxLemma.168 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {l : Filter α}, Filter.Tendsto f l ⊤ = True := by sorry

This theorem states that for any types `α` and `β`, any function `f` from `α` to `β`, and any filter `l` on `α`, the condition that `f` tends to `l` at the top filter (denoted as `⊤`) is always true. In other words, for any function and any filter, the image of the filter under the function is always a subset of the top filter. The top filter is a special filter that contains all sets, so this theorem is saying that the image of any filter under any function is always a valid filter.

For any function between types and any filter, the image of the filter under the function is a subset of the top filter.


theorem Mathlib.Order.Filter.Basic._auxLemma.169 :
    ∀ {α : Type u} {β : Type v} {γ : Type w} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
      Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y :=
  by sorry

This theorem asserts that for all types `α`, `β`, and `γ`, and for all functions `f : β → γ`, `g : α → β`, and given two filters `x : Filter α` and `y : Filter γ`, the statement that `f` tends to `y` under the filter that arises from mapping `g` over `x` (expressed as `Filter.Tendsto f (Filter.map g x) y`) is equivalent to the statement that the composition of `f` and `g` tends to `y` under the filter `x` (expressed as `Filter.Tendsto (f ∘ g) x y`). In other words, the "limit" behavior of the composed function `(f ∘ g)` under a filter is the same as applying `f` to the "limit" of `g` under the same filter. This theorem is a formal statement of the limit of a composition of functions in the context of filters.

The theorem states that for all types `α`, `β`, `γ`, functions `f : β → γ`, `g : α → β`, and filters `x : Filter α` and `y : Filter γ`, the filter convergence `Filter.Tendsto f (Filter.map g x) y` is equivalent to `Filter.Tendsto (f ∘ g) x y`.


theorem Mathlib.Data.Multiset.Range._auxLemma.1 : ∀ {m n : ℕ}, (m ∈ Multiset.range n) = (m < n) := by sorry

This theorem states that for all natural numbers `m` and `n`, `m` is an element of the multiset `Multiset.range n` if and only if `m` is less than `n`. This multiset is defined as the set of natural numbers from `0` to `n-1`. In other words, it establishes a relationship between the membership of a natural number in a particular multiset and its comparison with the size of that multiset.

For all natural numbers `m` and `n`, `m` is an element of the multiset `Multiset.range n` if and only if `m < n`.


theorem IsRelPrime.mul_left :
    ∀ {α : Type u_1} [inst : CommMonoid α] {x y z : α} [inst_1 : DecompositionMonoid α],
      IsRelPrime x z → IsRelPrime y z → IsRelPrime (x * y) z :=
  by sorry

The theorem `IsRelPrime.mul_left` states that for any commutative monoid `α` that also has a decomposition monoid structure, and for any elements `x`, `y`, and `z` of `α`, if `x` and `z` are relatively prime and `y` and `z` are relatively prime, then the product of `x` and `y` is also relatively prime to `z`. In mathematical terms, if $\gcd(x, z) = 1$ and $\gcd(y, z) = 1$, then $\gcd(xy, z) = 1$. Here, 'relatively prime' means that the greatest common divisor is a unit (in integers, it's 1).

If `α` is a commutative monoid with a decomposition monoid structure, and `x`, `y`, and `z` are elements of `α` such that `x` is relatively prime to `z` and `y` is relatively prime to `z`, then `x * y` is relatively prime to `z`. (Here, "relatively prime" means that the greatest common divisor of `x` and `z`, as well as `y` and `z`, is a unit.)


theorem Mathlib.Order.Filter.Basic._auxLemma.117 :
    ∀ {α : Type u} {s t : Set α} {l : Filter α}, (s ≤ᶠ[l] t) = (l ⊓ Filter.principal s ≤ l ⊓ Filter.principal t) := by
  sorry

This theorem states that for any type `α`, any two sets `s` and `t` of this type, and any filter `l` on this type, the condition that set `s` is lesser than or equal to set `t` in the filter order of `l` is equivalent to the condition that the infimum (or greatest lower bound) of the filter `l` and the principal filter of `s` is lesser than or equal to the infimum of the filter `l` and the principal filter of `t`. Here, the principal filter of a set is the collection of all supersets of that set. The filter order `≤ᶠ[l]` refers to the order of sets in the context of the filter `l`, where one set is considered less than or equal to another if it contains the other.

For any type `α`, filter `l` on `α`, sets `s` and `t` of `α`, the condition `s ≤ᶠ[l] t` if and only if `inf(l, filter.principal s) ≤ inf(l, filter.principal t)`.


theorem CategoryTheory.ShortComplex.Exact.epi_toCycles :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
      {S : CategoryTheory.ShortComplex C},
      CategoryTheory.ShortComplex.Exact S →
        ∀ [inst_2 : CategoryTheory.ShortComplex.HasLeftHomology S],
          CategoryTheory.Epi (CategoryTheory.ShortComplex.toCycles S) :=
  by sorry

This theorem states that for any category `C` that has a preadditive structure (meaning that the category has an addition operation that satisfies some properties analogous to the addition of numbers), and for any short complex `S` in this category, if `S` is exact (which is a property of sequences of morphisms in category theory), then given that `S` has left homology, the morphism from `S` to its cycles is an epimorphism. In category theory, an epimorphism is a type of morphism that satisfies a certain property related to the factorization of morphisms.

In any preadditive category with exact sequences and left homology, the morphism from a complex to its cycles is an epimorphism.


theorem FractionalIdeal.coeIdeal_ne_zero :
    ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_3} [inst_1 : Field K] [inst_2 : Algebra R K]
      [inst_3 : IsFractionRing R K] {I : Ideal R}, ↑I ≠ 0 ↔ I ≠ ⊥ :=
  by sorry

The theorem `FractionalIdeal.coeIdeal_ne_zero` states the following: For any commutative ring `R`, any field `K` that is the field of fractions of `R` (i.e., `K` is the field extension of `R` where elements of `R` can be viewed as fractions), and any left ideal `I` in `R`, the coercion of `I` to a fractional ideal in `K` is not zero if and only if `I` is not the zero ideal in `R`. In other words, a non-zero ideal in the ring `R` remains non-zero when considered as a fractional ideal in its field of fractions `K`.

For any commutative ring R, field K extending it, and non-zero left ideal I in R, the coercion of I to a fractional ideal in K is a non-zero fractional ideal.


theorem sup_eq_iSup : ∀ {α : Type u_1} [inst : CompleteLattice α] (x y : α), x ⊔ y = ⨆ b, bif b then x else y := by
  sorry

This theorem, `sup_eq_iSup`, states that for any complete lattice `α` and any two elements `x` and `y` in `α`, the supremum (`⊔`) of `x` and `y` is equal to the indexed supremum (`⨆`) over a boolean `b`, where if `b` is true then we choose `x`, else we choose `y`. In other words, the supremum of `x` and `y` is the greatest element that is less than or equal to both `x` and `y`, and this can also be expressed as the greatest element among all elements that are either `x` or `y`, depending on the truthfulness of `b`.

 For any complete lattice `α` and elements `x`, `y` in `α`, `⊔`{x, y} = `⨆`{b : Bool | (b = true) → x ≤ y ∧ y ≤ x}

or equivalently,

The supremum of `x` and `y` equals the greatest element that is less than or equal to both `x` and `y`, and is also in the set {x, y}.


/-- If `K / E / F` is a field extension tower, `L` is an intermediate field of `K / F`, such that
either `E / F` or `L / F` is algebraic, then `E(L) = E[L]`.  -/
theorem IntermediateField.adjoin_toSubalgebra_of_isAlgebraic :
    ∀ {F : Type u_1} [inst : Field F] (E : Type u_2) [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type u_3}
      [inst_3 : Field K] [inst_4 : Algebra F K] [inst_5 : Algebra E K] [inst_6 : IsScalarTower F E K]
      (L : IntermediateField F K),
      Algebra.IsAlgebraic F E ∨ Algebra.IsAlgebraic F ↥L →
        (IntermediateField.adjoin E ↑L).toSubalgebra = Algebra.adjoin E ↑L :=
  by sorry

The theorem `IntermediateField.adjoin_toSubalgebra_of_isAlgebraic` states that given a tower of field extensions `K / E / F`, and an intermediate field `L` of `K / F`, if either the extension `E / F` or `L / F` is algebraic (i.e., every element is a root of a non-zero polynomial with coefficients in `F`), then the field obtained by adjoining `E` and `L` is the same as the subalgebra generated by adjoining `E` and `L`.

If fields `K/F`, `E/F`, and `L/F` are such that either `E/F` or `L/F` is algebraic, then `K = F[E] ⊥ F[L]`. (Here, `F[E]` and `F[L]` denote the subfields generated by `E` and `L` over `F`, and `⊥` denotes the subalgebra generated by their union.)


AnalyticAt.continuousAt

theorem AnalyticAt.continuousAt :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E},
      AnalyticAt 𝕜 f x → ContinuousAt f x :=
  by sorry

The theorem `AnalyticAt.continuousAt` states that, for any non-trivial normed field `𝕜`, any normed additive groups `E` and `F` over `𝕜` which are also normed spaces, any function `f` from `E` to `F`, and any point `x` in `E`, if the function `f` is analytic at the point `x` (meaning `f` admits a convergent power series expansion around `x`), then `f` is also continuous at the point `x`. In other words, the value of `f` at `x` tends to the limit of `f` at `x` as points in `E` approach `x`.

If a function between two normed spaces is analytic at a point, then it is continuous at that point.


theorem CharP.ringChar_ne_one : ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : Nontrivial R], ringChar R ≠ 1 :=
  by sorry

The theorem `CharP.ringChar_ne_one` asserts that for any type `R`, if `R` has a non-associative semiring structure and `R` is nontrivial (i.e., there exist two distinct elements in `R`), then the unique characteristic of the semiring `R` (denoted as `ringChar R`) is not equal to 1. This means that in a nontrivial, non-associative semiring, the unique characteristic cannot be 1.

In a nontrivial, non-associative semiring, the unique characteristic is not equal to 1.


theorem BoxIntegral.Box.disjoint_coe : ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, Disjoint ↑I ↑J ↔ Disjoint ↑I ↑J := by
  sorry

The theorem `BoxIntegral.Box.disjoint_coe` states that for any type `ι` and any two box integrals `I` and `J` of this type, the proposition `Disjoint ↑I ↑J` is equivalent to itself. In other words, if two elements of a lattice (the box integrals `I` and `J`) are disjoint, meaning their infimum is the bottom element, then that fact remains true if we restate it; the disjointness of the two elements is invariant under restatement. This theorem might be a tautology used for some specific purpose in the context of the `BoxIntegral.Box` namespace.

The theorem `BoxIntegral.Box.disjoint_coe` asserts that the disjointness of two box integrals is a reflexive property.


theorem Matrix.mul_nonsing_inv_cancel_left :
    ∀ {m : Type u} {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
      (A : Matrix n n α) (B : Matrix n m α), IsUnit (Matrix.det A) → A * (A⁻¹ * B) = B :=
  by sorry

This theorem states that for any two matrices `A` and `B` of types `Matrix n n α` and `Matrix n m α` respectively, where `n` is any finite type with decidable equality and `α` is a commutative ring, if the determinant of matrix `A` is a unit in the ring `α` (i.e., it has a multiplicative inverse), then multiplying `A` with the result of multiplying the inverse of `A` with `B` gives us back matrix `B`. In other words, if `A` is invertible (its determinant is non-zero), then the equation `A * (A⁻¹ * B) = B` holds. This is a mathematical formulation of the property of matrix multiplication that the product of a matrix and its inverse is always the identity matrix, hence cancelling each other out.

If `A` is an invertible `n x n` matrix over a commutative ring `α`, then `A * (A⁻¹ * B) = B` for any `n x m` matrix `B` over `α`.


ZFSet.sound

theorem ZFSet.sound : ∀ {x y : PSet}, PSet.Equiv x y → ZFSet.mk x = ZFSet.mk y := by sorry

This theorem, `ZFSet.sound`, states that for any two pre-sets, `x` and `y`, if these two pre-sets are extensionally equivalent (as defined by `PSet.Equiv`, i.e., every element of the first pre-set is extensionally equivalent to some element of the second pre-set and vice versa), then the ZFC set representation (obtained via `ZFSet.mk`) of `x` and `y` are equal. In other words, it ensures the soundness of the function that constructs a ZFC set from a pre-set, in that extensionally equivalent pre-sets yield the same ZFC set.

If two pre-sets are extensionally equivalent, then their corresponding ZFC sets are equal.


/-- If the second of three points is weakly between the other two, and not equal to the first,
the angle at the first point (reversed) is zero.  -/
theorem Wbtw.angle₃₁₂_eq_zero_of_ne :
    ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
      [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P},
      Wbtw ℝ p₁ p₂ p₃ → p₂ ≠ p₁ → EuclideanGeometry.angle p₃ p₁ p₂ = 0 :=
  by sorry

This theorem states that given three points wherein the second point is weakly between the first and the third, and the second point is not equal to the first, then the angle at the first point when considering the line segments to the second and third points (in reverse order) is zero. In other words, if we have points `p₁`, `p₂`, and `p₃`, with `p₂` weakly between `p₁` and `p₃` and distinct from `p₁`, then the angle formed at point `p₁` by the segments `p₃p₁` and `p₁p₂` is zero degrees. This essentially means that the three points lie on the same straight line with `p₂` in between `p₁` and `p₃`.

Given distinct points `p₁`, `p₂`, and `p₃` with `p₂` weakly between `p₁` and `p₃`, the angle at `p₁` formed by the line segments `p₁p₂` and `p₂p₃` is zero degrees.


theorem MeasureTheory.integral_mono_of_nonneg :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ℝ},
      0 ≤ᶠ[MeasureTheory.Measure.ae μ] f →
        MeasureTheory.Integrable g μ → f ≤ᶠ[MeasureTheory.Measure.ae μ] g → ∫ (a : α), f a ∂μ ≤ ∫ (a : α), g a ∂μ :=
  by sorry

The theorem `MeasureTheory.integral_mono_of_nonneg` states that for any measurable space `α` with a measure `μ`, and any two functions `f` and `g` from `α` to the real numbers such that `f` is almost everywhere nonnegative with respect to `μ` and `g` is integrable with respect to `μ`, if `f` is almost everywhere less than or equal to `g` with respect to `μ`, then the integral of `f` with respect to `μ` is less than or equal to the integral of `g` with respect to `μ`. In simpler terms, this theorem is about the monotonicity of the integral for almost everywhere nonnegative functions.

If `f` is a measurable, almost everywhere nonnegative function and integrable with respect to measure `μ` on measurable space `α`, and `f ≤ g` almost everywhere with respect to `μ` for another integrable function `g`, then `∫(f dμ) ≤ ∫(g dμ)`.


theorem Ordinal.isNormal_iff_strictMono_limit :
    ∀ (f : Ordinal.{u_4} → Ordinal.{u_5}),
      Ordinal.IsNormal f ↔
        StrictMono f ∧ ∀ (o : Ordinal.{u_4}), Ordinal.IsLimit o → ∀ (a : Ordinal.{u_5}), (∀ b < o, f b ≤ a) → f o ≤ a :=
  by sorry

The theorem `Ordinal.isNormal_iff_strictMono_limit` states that for any function `f` mapping from an ordinal to another ordinal, `f` is a normal ordinal function if and only if `f` is strictly monotone (in other words, `f(a) < f(b)` whenever `a < b`), and furthermore if `o` is a limit ordinal, for any ordinal `a`, if all values `f(b)` for `b < o` are less than or equal to `a`, then `f(o)` must be less than or equal to `a`. This captures the defining property of a normal ordinal function: it is strictly increasing and its value at a limit ordinal is the least upper bound of its values at smaller ordinals.

A function between ordinals is normal if and only if it is strictly monotone and preserves limit ordinals' least upper bounds.


/-- The set of points which are isolated on the right is countable when the space is
second-countable.  -/
theorem countable_setOf_covBy_right :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α]
      [inst : SecondCountableTopology α], Set.Countable {x | ∃ y, x ⋖ y} :=
  by sorry

The theorem `countable_setOf_covBy_right` states that for any type `α`, given a topological space, a linear order, an order topology, and a second countable topology, the set of points in `α` that are strictly less than some other points (i.e., the set of points which are isolated on the right) is countable.

The set of points in a type `α` that are isolated on the right under an order topology in a second countable topological space is countable.


theorem Rat.normalize_self : ∀ (r : ℚ), Rat.normalize r.num r.den ⋯ = r := by sorry

The theorem `Rat.normalize_self` states that for any rational number `r`, if we normalize `r` by taking its numerator and denominator and use them as arguments for the `Rat.normalize` function, the output is equal to the original rational number `r` itself. In other words, normalizing a rational number using its own numerator and denominator results in the same rational number.

For any rational number r, normalizing r using its numerator and denominator yields the same rational number (i.e., Rat.normalize (numerator r) (denominator r) = r).


theorem intentClosure_extentClosure_intentClosure :
    ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Set α),
      intentClosure r (extentClosure r (intentClosure r s)) = intentClosure r s :=
  by sorry

The theorem `intentClosure_extentClosure_intentClosure` states that for any relation `r` from a type `α` to a type `β`, and for any set `s` of type `α`, the intent closure of the extent closure of the intent closure of `s` under `r` is equal to the intent closure of `s` under `r`. In other words, applying the operations of extent closure and intent closure in succession on `s` under `r` doesn't change the original intent closure of `s` under `r`. This theorem provides a form of closure property for the operation of intent closure under the interplay of the relation `r` and the set `s`.

For any relation $r$ from type $\alpha$ to type $\beta$ and set $s$ of type $\alpha$, the intent closure of the set $s$ under $r$ is equal to the intent closure of the extent closure of $s$ under $r$.


theorem PartialHomeomorph.map_extend_symm_nhdsWithin :
    ∀ {𝕜 : 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) {s : Set M} {y : M},
      y ∈ f.source →
        Filter.map (↑(PartialEquiv.symm (PartialHomeomorph.extend f I)))
            (nhdsWithin (↑(PartialHomeomorph.extend f I) y)
              (↑(PartialEquiv.symm (PartialHomeomorph.extend f I)) ⁻¹' s ∩ Set.range ↑I)) =
          nhdsWithin y s :=
  by sorry

The theorem `PartialHomeomorph.map_extend_symm_nhdsWithin` states that for any non-trivially normed field `𝕜`, normed add commutative group `E`, normed space `E` over `𝕜`, topological spaces `H` and `M`, a partial homeomorphism `f` from `M` to `H`, a model with corners `I` from `𝕜` to `E` to `H`, a set `s` in `M`, and a point `y` in `M` that is in the source of `f`, the forward map of the neighborhood within filter of `(↑(PartialHomeomorph.extend f I) y)` in the set `((↑(PartialEquiv.symm (PartialHomeomorph.extend f I)) ⁻¹' s) ∩ Set.range ↑I)` under the inverse of the partial equivalence of the extension of `f` using `I` is equal to the neighborhood within filter of `y` in `s`.

In simple terms, this theorem involves the mapping from one local neighbourhood to another in the context of partial homeomorphisms and topological spaces.

For a non-trivially normed field `𝕜`, normed add commutative group `E`, normed space `E` over `𝕜`, topological spaces `H` and `M`, a partial homeomorphism `f` from `M` to `H`, a model with corners `I` from `𝕜` to `E` to `H`, and a set `s` in `M` with `y` in `s` being in the domain of `f`, the neighborhood filter of `(f(y))` in `(f(s))` is equal to the neighborhood filter of `y` in `s`, under the inverse of the partial equivalence of the extension of `f` using `I`.


theorem WCovBy.Icc_eq : ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, a ⩿ b → Set.Icc a b = {a, b} := by sorry

This theorem states that for any given type `α` which has a partial order, and for any two elements `a` and `b` of this type, if `a` is incomparable to `b` (denoted by `a ⩿ b`), then the closed interval from `a` to `b` (represented by `Set.Icc a b`) is equal to the set containing just `a` and `b` (denoted by `{a, b}`). Here, a closed interval from `a` to `b` is defined as the set of all elements `x` such that `a ≤ x` and `x ≤ b`. An element is said to be incomparable to another if it is neither less than nor greater than the other.

For any type `α` with a partial order and any incomparable elements `a` and `b` in `α`, the set of elements between `a` and `b` (inclusive) is equal to the set containing only `a` and `b`. In Lean notation, `Set.Icc a b = {a, b}`.


theorem CategoryTheory.Limits.inr_comp_pushoutSymmetry_hom :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
      [inst_1 : CategoryTheory.Limits.HasPushout f g],
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inr
          (CategoryTheory.Limits.pushoutSymmetry f g).hom =
        CategoryTheory.Limits.pushout.inl :=
  by sorry

This theorem states that in any category `C`, for any objects `X`, `Y`, and `Z` and morphisms `f : X ⟶ Y` and `g : X ⟶ Z` such that the pushout of `f` and `g` exists, the composition of the second inclusion into the pushout after the pushout symmetry homomorphism is equal to the first inclusion into the pushout. In other words, if we travel along the second inclusion into the pushout and then use the pushout symmetry homomorphism, it is the same as taking the first inclusion into the pushout directly. This is a specific property of the "pushout" construction in category theory, which is a kind of colimit.

In any category with pushouts, the second inclusion into the pushout of two morphisms is equal to the composition of the first inclusion, pushout symmetry homomorphism.


theorem Equiv.trans_toPartialEquiv :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (e' : β ≃ γ),
      Equiv.toPartialEquiv (e.trans e') = PartialEquiv.trans (Equiv.toPartialEquiv e) (Equiv.toPartialEquiv e') :=
  by sorry

The theorem `Equiv.trans_toPartialEquiv` states that for any three types `α`, `β`, and `γ`, and any two equivalences `e` from `α` to `β` and `e'` from `β` to `γ`, the partial equivalence corresponding to the composition of `e` and `e'` (obtained using `Equiv.toPartialEquiv` on `e.trans e'`) is the same as the composition of the partial equivalences corresponding to `e` and `e'` (obtained by calling `PartialEquiv.trans` on `Equiv.toPartialEquiv e` and `Equiv.toPartialEquiv e'`). In other words, converting a composition of equivalences to a partial equivalence preserves the property of composition.

For any equivalences e : α ≡ β and e' : β ≡ γ, Equiv.toPartialEquiv (e.trans e') = PartialEquiv.trans (Equiv.toPartialEquiv e) (Equiv.toPartialEquiv e').


/-- See also `Complex.cpow_int_mul'`.  -/
theorem Complex.cpow_int_mul : ∀ (x : ℂ) (n : ℤ) (y : ℂ), x ^ (↑n * y) = (x ^ y) ^ n := by sorry

This theorem, `Complex.cpow_int_mul`, states that for any three complex numbers `x`, `n`, and `y`, where `n` is actually an integer cast to a complex number, the exponentiation `x` raised to the power of (`n` multiplied by `y`) is equal to `x` raised to the power of `y` and the result again raised to the power of `n`. In mathematical terms, it states that \(x^{(n \cdot y)} = (x^y)^n\).

The theorem asserts that for any complex number x and integers n and y, x^(ny) = (x^y)^n.


theorem Profinite.NobelingProof.Products.evalFacProp :
    ∀ {I : Type u} [inst : LinearOrder I] (C : Set (I → Bool)) {l : Profinite.NobelingProof.Products I} (J : I → Prop),
      (∀ a ∈ ↑l, J a) →
        ∀ [inst_1 : (j : I) → Decidable (J j)],
          ⇑(Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C J) l) ∘
              Profinite.NobelingProof.ProjRestrict C J =
            ⇑(Profinite.NobelingProof.Products.eval C l) :=
  by sorry

This theorem, which is a part of Profinite's NobelingProof, asserts the following: for any type `I` equipped with a linear order, a set `C` of Boolean-valued functions on `I`, a product `l` of elements from `I`, and a predicate `J` on `I`, if every element `a` in the product `l` satisfies the predicate `J`, then for any `j` in `I` that can be decided by `J`, the composition of the evaluation of `l` under the image of `Proj π J` with the restriction of `Proj π J` to `C`, is equal to the evaluation of `l` under `C`.

In simple terms, this theorem shows a relationship between the evaluation of a product under a set of functions and its projection restricted to a subset, assuming that all elements of the product satisfy a certain property. The mathematical operations involved are function composition and evaluation.

Given a linear ordered type `I`, a set `C` of Boolean-valued functions on `I`, a product `l` of elements from `I`, and a predicate `J` on `I`, if every `a` in `l` satisfies `J`, then for any `j` in `I` decidable by `J`, the composition of `l`'s evaluation under `Proj π J` and `Proj π J`'s restriction to `C` equals `l`'s evaluation under `C`.


theorem Set.le_iff_subset : ∀ {α : Type u} {s t : Set α}, s ≤ t ↔ s ⊆ t := by sorry

This theorem states that for any given type `α` and any two sets `s` and `t` of this type, `s` is less than or equal to `t` if and only if `s` is a subset of `t`. In the context of set theory, the "less than or equal to" relation becomes the subset relation. This means that every element of set `s` is also an element of set `t`.

For any type `α`, sets `s` and `t` of type `α`, the relation `s ⊆ t` holds if and only if `s ≤ t` holds. (In the context of set theory, `s ≤ t` denotes `s` is a subset of `t`. )


/-- The quadratic character is `1` or `-1` on nonzero arguments.  -/
theorem quadraticChar_dichotomy :
    ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {a : F},
      a ≠ 0 → (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1 :=
  by sorry

This theorem states that for any field `F` with a finite number of elements and a decidable equality, the quadratic character of any non-zero element `a` from `F` is either `1` or `-1`. In mathematical terms, given a field `F` that is finite and for which equality is decidable, if `a` is any non-zero element in `F`, then the quadratic character of `a` is either `1` or `-1`.

In a finite field `F` with decidable equality, the quadratic character of any non-zero element `a` is either 1 or -1.


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

This theorem states that for any ordered semiring (a type of algebraic structure that includes operations of addition and multiplication and obeys certain axioms), if both 'a' and 'b' are elements of this semiring such that they are both greater than or equal to 1, then their product 'a * b' is also greater than or equal to 1.

In any ordered semiring, if both a and b are elements greater than or equal to 1, then their product a * b is also greater than or equal to 1.


Inducing.injective

/-- A topology `Inducing` map from a T₀ space is injective.  -/
theorem Inducing.injective :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T0Space X]
      {f : X → Y}, Inducing f → Function.Injective f :=
  by sorry

The theorem `Inducing.injective` states that for all types `X` and `Y`, if `X` is equipped with a `TopologicalSpace` structure and `T0Space` (also known as a Kolmogorov space, where any two distinct points in the space are topologically distinguishable) structure, and `Y` is equipped with a `TopologicalSpace` structure, then for any function `f` from `X` to `Y` that induces the topology on `X` from `Y`, this function `f` is injective. In other words, if `f` preserves the topological structure and `X` is a `T0Space`, then `f` is such that if `f x = f y` then `x = y`.

If X is a T0 space and has the topology induced from a topological space Y via a function f, then f is injective.


theorem lcm_comm :
    ∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a b : α),
      lcm a b = lcm b a :=
  by sorry

This theorem, `lcm_comm`, asserts that the least common multiple (LCM) operation in a cancellation commutative monoid with zero and a normalized GCD monoid is commutative. In other words, for any two elements `a` and `b` of a given type `α` that satisfies these algebraic structures, the LCM of `a` and `b` is the same as the LCM of `b` and `a`.

In a cancellation commutative monoid with zero and a normalized GCD monoid, the least common multiple of elements `a` and `b` equals the least common multiple of `b` and `a`.


theorem bind₁_wittPolynomial_xInTermsOfW :
    ∀ (p : ℕ) (R : Type u_1) [inst : CommRing R] [inst_1 : Invertible ↑p] (n : ℕ),
      (MvPolynomial.bind₁ (wittPolynomial p R)) (xInTermsOfW p R n) = MvPolynomial.X n :=
  by sorry

The theorem `bind₁_wittPolynomial_xInTermsOfW` states that for any natural number `p`, any type `R` where `R` is a commutative ring, and for any natural number `n`, the binding of the `n`-th `xInTermsOfW` polynomial in the Witt polynomial basis with respect to `p` and `R`, is equivalent to the `n`-th degree `1` monomial (denoted as `MvPolynomial.X n`). In mathematical terms, this theorem asserts that applying the Witt polynomial transformation to the `xInTermsOfW` basis recovers the original monomial basis.

For any commutative ring R and natural number n, the n-th Witt polynomial in the basis of xInTermsOfW with respect to a prime p is equivalent to the n-th degree monomial X^n in R.


theorem Filter.eventually_atBot :
    ∀ {α : Type u_3} [inst : SemilatticeInf α] [inst_1 : Nonempty α] {p : α → Prop},
      (∀ᶠ (x : α) in Filter.atBot, p x) ↔ ∃ a, ∀ b ≤ a, p b :=
  by sorry

This theorem states that for any type `α` that is a semilattice with respect to the infimum operation and is nonempty, and for any proposition `p` that applies to elements of `α`, the proposition `p` holds eventually at negative infinity (as represented by `Filter.atBot`) if and only if there exists an element `a` in `α` such that `p` holds for all elements `b` that are less than or equal to `a`. In simpler terms, the proposition `p` is true for all sufficiently small values in the semilattice.

For any semilattice `α` with nonempty infimum `⊥` and proposition `p` over `α`, `Filter.atBot p` holds if and only if there exists an element `a` such that `p` holds for all `b ≤ a`.


theorem Filter.limsSup_le_limsSup_of_le :
    ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {f g : Filter α},
      f ≤ g →
        autoParam (Filter.IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝ →
          autoParam (Filter.IsBounded (fun x x_1 => x ≤ x_1) g) _auto✝¹ → Filter.limsSup f ≤ Filter.limsSup g :=
  by sorry

The theorem `Filter.limsSup_le_limsSup_of_le` states that for any two filters `f` and `g` over a conditionally complete lattice `α`, if `f` is less than or equal to `g`, and assuming that `f` is eventually bounded above and `g` is eventually bounded below, then the `limsSup` (infimum of upper bounds) of `f` is less than or equal to the `limsSup` of `g`. This is a formal way to say that if one filter is "smaller" than another, then the smallest value that is greater than or equal to all elements of the first filter is less than or equal to the smallest value that is greater than or equal to all elements of the second filter.

If `f` is a filter on a conditionally complete lattice `α` that is less than or equal to filter `g`, and both `f` and `g` are eventually bounded, then `limsSup(f) ≤ limsSup(g)`.


theorem IsCoprime.isUnit_of_dvd' :
    ∀ {R : Type u} [inst : CommSemiring R] {a b x : R}, IsCoprime a b → x ∣ a → x ∣ b → IsUnit x := by sorry

This theorem states that for any type `R` that is a commutative semiring, and any elements `a`, `b`, and `x` of this type, if `a` and `b` are coprime (that is, there exist two elements whose multiplication with `a` and `b` respectively, when added, equal 1), and `x` divides both `a` and `b`, then `x` is a unit. In the context of a monoid, an element is a unit if it has a two-sided inverse. Consequently, this theorem essentially claims that any number that divides two coprime numbers must have a multiplicative inverse.

In a commutative semiring, if two coprime elements have a common divisor, then each of them is a unit of the semiring.


/-- If a monotone function is continuous at the supremum of a nonempty bounded above set `s`,
then it sends this supremum to the supremum of the image of `s`.  -/
theorem Monotone.map_csSup_of_continuousAt :
    ∀ {α : Type u} {β : Type v} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
      [inst_2 : OrderTopology α] [inst_3 : ConditionallyCompleteLinearOrder β] [inst_4 : TopologicalSpace β]
      [inst_5 : OrderClosedTopology β] {f : α → β} {s : Set α},
      ContinuousAt f (sSup s) → Monotone f → Set.Nonempty s → BddAbove s → f (sSup s) = sSup (f '' s) :=
  by sorry

The theorem `Monotone.map_csSup_of_continuousAt` states that for any nonempty set `s` which is bounded above, if a function `f` is both monotone and continuous at the supremum of `s`, then the value of `f` at the supremum of `s` is equal to the supremum of the image of `s` under `f`. In other words, the function `f` maps the supremum of `s` to the supremum of the image of `s`. This theorem applies under the conditions that `α` and `β` are conditionally complete linear orders (meaning every nonempty set bounded above has a supremum and every nonempty set bounded below has an infimum), `α` and `β` are topological spaces, the order topology is defined on `α`, and the order closed topology is defined on `β`.

If `s` is a nonempty, bounded above set in a conditionally complete linear order `α`, and `f` is a monotone and continuous function from `α` to another conditionally complete linear order `β` with order topology and order-closed topology, then `f` maps the supremum of `s` to the supremum of `f``(s)`.


theorem Finset.vadd_finset_inter :
    ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : AddGroup α] [inst_2 : AddAction α β]
      {s t : Finset β} {a : α}, a +ᵥ s ∩ t = (a +ᵥ s) ∩ (a +ᵥ t) :=
  by sorry

The theorem `Finset.vadd_finset_inter` states that for any types `α` and `β`, assuming `β` has decidable equality and `α` forms an additive group that acts on `β`, for any finsets `s` and `t` of type `β` and any element `a` of type `α`, the intersection of the translated finset `a +ᵥ s` with `t` is the same as the intersection of the translated finsets `a +ᵥ s` and `a +ᵥ t`. Here, `a +ᵥ s` denotes the translation (vector addition) of the finset `s` by the element `a`.

For any additive group `α` acting on a type `β` with decidable equality, and any finsets `s`, `t` of type `β` and element `a` of type `α`, the intersection of translated finsets `a + s` and `t` equals the intersection of translated finsets `a + s` and `a + t`.


theorem List.Mem.duplicate_cons_self : ∀ {α : Type u_1} {l : List α} {x : α}, x ∈ l → List.Duplicate x (x :: l) := by
  sorry

This theorem states that, for any type `α`, any list `l` of type `α`, and any element `x` of type `α`, if `x` belongs to the list `l`, then `x` is a duplicate in the list constructed by consing `x` onto `l`. In other words, if an element is in a list, then adding that element to the front of the list will always result in a list where that element is duplicated.

For any type `α`, if `x ∈ list α` then `x :: list α` contains a duplicate element.


theorem GaloisConnection.upperBounds_l_image :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
      GaloisConnection l u → ∀ (s : Set α), upperBounds (l '' s) = u ⁻¹' upperBounds s :=
  by sorry

This theorem states that for any two types `α` and `β` that have a preorder relation, and for any pair of functions `l : α → β` and `u : β → α` that form a Galois Connection, the set of upper bounds of the image of a set `s` under the function `l` equals the preimage of the set of upper bounds of `s` under the function `u`. In other words, if you apply `l` to each element of `s` and then find all upper bounds of the resulting set in `β`, you will get the same set as if you first find all upper bounds of `s` in `α` and then apply `u` to each of them.

For any preorder (α, ≤) and functions l : α → β and u : β → α forming a Galois connection, the upper bounds of the image of a set s under l equals the preimage of the set of upper bounds of s under u. In other words, (∃ x : β. ∀ y ∈ s. l y ≤ x) iff ∃ x' : α. ∀ y ∈ s. y ≤ u x'.


theorem CategoryTheory.ShiftMkCore.shiftFunctorZero_eq :
    ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
      (h : CategoryTheory.ShiftMkCore C A), CategoryTheory.shiftFunctorZero C A = h.zero :=
  by sorry

This theorem asserts that for any category `C` and any additive monoid `A`, given the structure `h` of "having shifts" (`CategoryTheory.ShiftMkCore`) on `C` with respect to `A`, the shift functor at zero (`CategoryTheory.shiftFunctorZero C A`) is equal to the zero morphism in the structure `h`. In other words, in the context of category theory, shifting by zero in a category that supports shift operations is the same as applying the zero morphism.

For any category with shifts `C` and additive monoid `A`, the shift functor at zero is equal to the zero morphism in the shifts structure.


theorem Sigma.isConnected_iff :
    ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (π i)] {s : Set ((i : ι) × π i)},
      IsConnected s ↔ ∃ i t, IsConnected t ∧ s = Sigma.mk i '' t :=
  by sorry

The theorem `Sigma.isConnected_iff` states that for any set `s` of pairs (also known as a sigma type), where the first element of the pair is of type `ι` and the second element is of a type `π i` that depends on `ι`, and each `π i` is equipped with a topological structure, the set `s` is connected if and only if there exists an index `i` and a set `t` such that `t` is connected and `s` is the image of `t` under the function `Sigma.mk i`. Here, the function `Sigma.mk i` creates pairs where the first element is `i` and the second element is from `t`. The connectedness of a set is defined as the set being nonempty and there is no non-trivial open partition.

A sigma type of pairs, where the first element is of type `ι` and the second element is of a connected type `π i`, is connected if and only if it is the image of a connected set under the function that maps each element to a pair with the first element being a fixed index and the second element from the set.


theorem Pell.isPell_norm : ∀ {d : ℤ} {b : ℤ√d}, Pell.IsPell b ↔ b * star b = 1 := by sorry

The theorem `Pell.isPell_norm` states that for any integer `d` and any element `b` of the integer extension of square root of `d` (denoted as `ℤ√d`), `b` satisfies the property of being a solution to the Pell equation if and only if the product of `b` and its conjugate is `1`. The Pell equation is defined as `x^2 - d * y^2 = 1` where `x` and `y` are the real and imaginary parts of the complex number respectively.

For an integer `d` and any element `b` in the integer extension of sqrt `d`, `b` is a solution to the Pell equation `x^2 - d * y^2 = 1` if and only if `b` and its conjugate have a product of 1.


theorem Module.injective_object_of_injective_module :
    ∀ (R : Type u) [inst : Ring R] (Q : Type v) [inst_1 : AddCommGroup Q] [inst_2 : Module R Q]
      [inj : Module.Injective R Q], CategoryTheory.Injective (ModuleCat.of R Q) :=
  by sorry

This theorem, referred to as `Module.injective_object_of_injective_module`, states that for any ring `R` and any `R-module` `Q` with the additive commutative group structure and the module structure, if `Q` is an injective `R-module`, then the object of the category of `R-modules` associated to `Q` is also injective. In other words, the association of `R-modules` to objects in the category of `R-modules` preserves the property of injectivity.

If `Q` is an injective `R-module` in the category of `R-modules`, then the object associated to `Q` in this category is also an injective object.


theorem Polynomial.map_natDegree_eq_sub :
    ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} {F : Type u_3} [inst_1 : Semiring S]
      [inst_2 : FunLike F (Polynomial R) (Polynomial S)] [inst_3 : AddMonoidHomClass F (Polynomial R) (Polynomial S)]
      {φ : F} {p : Polynomial R} {k : ℕ},
      (∀ (f : Polynomial R), Polynomial.natDegree f < k → φ f = 0) →
        (∀ (n : ℕ) (c : R), c ≠ 0 → Polynomial.natDegree (φ ((Polynomial.monomial n) c)) = n - k) →
          Polynomial.natDegree (φ p) = Polynomial.natDegree p - k :=
  by sorry

The theorem `Polynomial.map_natDegree_eq_sub` states that for any semirings `R` and `S`, a polymorphic function `F` that acts like a function from `Polynomial R` to `Polynomial S`, an additive monoid homomorphism class, a function `φ` of type `F`, a polynomial `p` in `R`, and a natural number `k`, if the function `φ` maps all polynomials of degree less than `k` to 0, and for all natural numbers `n` and coefficients `c` in `R` (that are not zero), the degree of the polynomial obtained by applying `φ` to the monomial `a * X^n` is `n - k`, then the degree of the polynomial obtained by applying `φ` to `p` is equal to the degree of `p` minus `k`. In mathematical notation, the theorem says that if $\phi$ is a function that zeros out all polynomials with degree less than $k$ and shifts the degree of all monomials by $k$, then the degree of $\phi(p)$ is the degree of $p$ minus $k$.

Given a semiring homomorphism φ that maps monomials of degree n to monomials of degree n-k and sets polynomials of degree < k to 0, the degree of φ(p) equals the degree of p - k for any polynomial p.


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

The theorem `bddAbove_Iio` states that for any type `α` with a pre-order relation, and for any element `a` of type `α`, the left-infinite right-open interval `(,a)` (denoted as `Set.Iio a` in Lean) is always bounded above. In other words, there exists an upper bound for all elements `x` such that `x < a`.

For any type `α` with a pre-order relation and any element `a` in `α`, the left-infinite right-open interval `(,a)` has an upper bound.


theorem Matrix.nondegenerate_toBilin'_iff :
    ∀ {R₃ : Type u_7} [inst : CommRing R₃] {ι : Type u_12} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
      {M : Matrix ι ι R₃}, BilinForm.Nondegenerate (Matrix.toBilin' M) ↔ Matrix.Nondegenerate M :=
  by sorry

This theorem states that for any commutative ring `R₃`, any type `ι` which has decidable equality and is finite, and any matrix `M` with indices and entries from these types, the bilinear form obtained from the matrix `M` using the linear equivalence `Matrix.toBilin'` is nondegenerate if and only if the matrix `M` is nondegenerate. Here, a matrix `M` is said to be nondegenerate if for any non-zero vector `v`, there exists a non-zero vector `w` such that the dot product of `v` with the result of multiplying `M` by `w` is non-zero. Similarly, a bilinear form is considered nondegenerate if it is non-zero for all non-zero pair of vectors.

For any commutative ring `R₃`, a matrix `M` with finite, decidably equal indices and entries from `R₃` is nondegenerate if and only if the bilinear form obtained from `M` is nondegenerate.


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

The theorem `Finset.union_eq_left` states that for any type `α` with decidable equality and for any two finite sets `s` and `t` of type `α`, the union of `s` and `t` is equal to `s` if and only if `t` is a subset of `s`. In other words, adding all elements of `t` to `s` doesn't change `s` if every element of `t` is already in `s`.

For any type `α` with decidable equality and for finite sets `s` and `t` of type `α`, `s ∪ t = s` if and only if `t ⊆ s`.


theorem Finsupp.mapDomain_id :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M}, Finsupp.mapDomain id v = v := by sorry

The theorem `Finsupp.mapDomain_id` states that for all types `α` and `M` where `M` is a type with an additive commutative monoid structure, and for all finitely supported functions `v` from `α` to `M`, mapping the identity function over the domain of `v` leaves `v` unchanged. In other words, if you map each element in the domain of `v` to itself (which is what the identity function does), the resulting finitely supported function is the same as the original function `v`.

For any type `α` and additive commutative monoid `M`, the function `Finsupp.mapDomain id v` equals `v`, where `id` is the identity function on the domain of `v` and `v` is a finitely supported function from `α` to `M`.


theorem Filter.tendsto_atTop_add_right_of_le' :
    ∀ {α : Type u_3} {β : Type u_4} [inst : OrderedAddCommGroup β] (l : Filter α) {f g : α → β} (C : β),
      Filter.Tendsto f l Filter.atTop →
        (∀ᶠ (x : α) in l, C ≤ g x) → Filter.Tendsto (fun x => f x + g x) l Filter.atTop :=
  by sorry

This theorem states that for any types `α` and `β` where `β` forms an ordered additive commutative group, given a filter `l` on `α` and two functions `f` and `g` from `α` to `β`, and a value `C` from `β`, if the function `f` tends to infinity under the filter `l`, and eventually for every `x` in `α`, `C` is less than or equal to `g(x)` under the filter `l`, then the function that maps `x` to the sum of `f(x)` and `g(x)` also tends to infinity under the filter `l`. In simpler terms, if `f` goes to infinity and `g` is eventually at least some constant `C`, then the sum of `f` and `g` also goes to infinity.

If `f` tends to infinity and `C ≤ g(x)` for all `x` eventually under filter `l`, then the function `x ↦ f(x) + g(x)` tends to infinity under filter `l`.


theorem IsCompl.le_left_iff :
    ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] {x y z : α},
      IsCompl x y → (z ≤ x ↔ Disjoint z y) :=
  by sorry

This theorem states that for any type `α` that has a distributive lattice structure and a bounded order, and for any elements `x`, `y`, and `z` of this type, if `x` and `y` are complements of each other (i.e., their greatest lower bound (infimum) is the bottom element of the lattice and their least upper bound (supremum) is the top element of the lattice), then `z` is less than or equal to `x` if and only if `z` and `y` are disjoint. Here, two elements `a` and `b` are said to be disjoint if for all elements `x` that are less than or equal to `a` and `b`, `x` is also less than or equal to the bottom element of the lattice.

For any distributive lattice with a bounded order, elements `x`, `y`, and `z` satisfy `x <= z` if and only if `y` and `z` are disjoint, meaning that for all `a` with `a <= x` and `a <= y`, `a` is the bottom element of the lattice.


theorem Set.preimage_mul_const_Iio_of_neg :
    ∀ {α : Type u_1} [inst : LinearOrderedField α] (a : α) {c : α},
      c < 0 → (fun x => x * c) ⁻¹' Set.Iio a = Set.Ioi (a / c) :=
  by sorry

The theorem `Set.preimage_mul_const_Iio_of_neg` states that for any linearly ordered field `α`, given an element `a` of `α` and another element `c` of `α` which is less than zero, the preimage of the set of all elements less than `a` under multiplication with `c` is equivalent to the set of all elements greater than `a / c`. This essentially describes a transformation property of left-infinite right-open intervals under multiplication with a negative constant.

For any linearly ordered field `α` and elements `a` and `c` of `α` with `c < 0`, the preimage of the set of elements less than `a` under multiplication by `c` is equal to the set of elements greater than `a / c`.


theorem EuclideanDomain.mod_zero : ∀ {R : Type u} [inst : EuclideanDomain R] (a : R), a % 0 = a := by sorry

This theorem states that for any type `R` that forms a Euclidean Domain, the modulus of any element `a` of type `R` and `0` is `a`. In other words, if you take any element from a Euclidean Domain and compute the remainder of its division by zero, you will always get the original element back. This is expressed in the language of the Lean Theorem Prover.

In a Euclidean Domain, for all elements `a`, `a % 0 = a`. (Here, `%` denotes modulo operation.)


theorem Fintype.subtype.proof_1 :
    ∀ {α : Type u_1} {p : α → Prop} (s : Finset α), (∀ (x : α), x ∈ s ↔ p x) → ∀ x ∈ s, p x := by sorry

This theorem states that for any type `α`, and any property `p` defined on `α`, and for any finite set `s` of elements of type `α`, if every element `x` of `α` is in `s` if and only if it satisfies the property `p`, then for any element `x` in `s`, `x` satisfies the property `p`. In simpler terms, it asserts that if membership in the finite set `s` is equivalent to satisfying the property `p`, then all members of `s` have the property `p`.

If a finite set `s` of elements from a type `α` contains exactly those elements satisfying a property `p`, then every element in `s` has property `p`.


theorem Filter.lift_assoc :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {h : Set β → Filter γ},
      Monotone g → Filter.lift (Filter.lift f g) h = Filter.lift f fun s => Filter.lift (g s) h :=
  by sorry

The theorem `Filter.lift_assoc` states that for any types `α`, `β`, and `γ`, any filter `f` of type `α`, and any two functions `g` and `h` that map from a set of `α` and `β` to filters of `β` and `γ` respectively, if `g` is a monotone function, then the operation of lifting the filter `f` twice, first by `g` and then by `h`, is equivalent to lifting `f` once by a function which first applies `g` to `s` and then lifts the result by `h`. This can be thought of as a form of associativity for the filter lift operation when the intermediate function is monotone.

For any monotone functions `g : Filter α -> Filter β` and `h : Filter β -> Filter γ`, if `f : Filter α`, then `(h ∘ g) ( Filter.map g f ) = Filter.map (g ∘ h) f`.


theorem Multiset.eq_zero_iff_forall_not_mem : ∀ {α : Type u_1} {s : Multiset α}, s = 0 ↔ ∀ (a : α), a ∉ s := by sorry

This theorem states that for any type `α` and any multiset `s` of type `α`, `s` is equivalent to zero if and only if for all elements `a` of type `α`, `a` does not belong to `s`. In other words, a multiset is empty if and only if no element of the underlying type is a member of the multiset.

A multiset of type `α` is equivalent to the empty multiset if and only if no element of type `α` is in the multiset.


/-- Characterization the map `descSet hc`: the image of an element in a vertex of the original
diagram in the cocone point lies in `descSet hc ls` if and only if the image of the corresponding
element in the lifted diagram lie in `ls`.  -/
theorem CategoryTheory.Limits.Types.descSet_spec :
    ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)}
      {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c)
      {lc : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.comp K CategoryTheory.uliftFunctor.{v, u})}
      (s : Set c.pt) (ls : Set lc.pt),
      CategoryTheory.Limits.Types.descSet hc ls = s ↔
        ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s :=
  by sorry

This theorem, `CategoryTheory.Limits.Types.descSet_spec`, describes a property of the map, `descSet hc`, in the context of category theory and cocones. It states that for any category `J`, a functor from `J` to `Type u` denoted by `K`, a cocone `c` over `K` that is a colimit, another cocone `lc` over the functor composition of `K` and the `uliftFunctor`, and sets `s` and `ls` of points of `c` and `lc` respectively, the set `descSet hc ls` equals `s` if and only if the following condition holds: for all objects `j` in `J` and all elements `x` in the functor `K` applied to `j`, the element `{ down := x }` under the natural transformation of `lc` applied to `j` lies in `ls` if and only if the element `x` under the natural transformation of `c` applied to `j` lies in `s`. Here, `descSet hc ls` is a mapping that associates to each element in a vertex of the original diagram its image in the cocone point. It captures the idea of mapping elements from the original diagram to the cocone point and then assessing their membership in different sets.

For any category J, functor K : J -> Type u, colimit cocone c over K, another cocone lc over the composition of K and uliftFunctor, and sets s of points in c and ls of points in lc, the sets s and descSet hc ls are equal if and only if, for all j in J and all x in K j, the element x under the natural transformation of lc applied to j is in ls if and only if the element x under the natural transformation of c applied to j is in s.


theorem Subtype.fintype.proof_1 :
    ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : Fintype α] (a : α),
      a ∈ Finset.filter p Finset.univ ↔ p a :=
  by sorry

This theorem states that for any type `α`, any property `p` of elements of `α` that is a decidable predicate, and any instance of `α`, if `α` is a finite type, then an element `a` of `α` is in the set of all elements of `α` that satisfy the property `p` if and only if `a` itself satisfies the property `p`. In other words, it verifies that the finite set of elements in `α` that satisfy `p` correctly filters out those elements that do not satisfy `p`.

For any finite type `α` and decidable predicate `p` on `α`, an element `a` lies in the set of elements of `α` satisfying `p` if and only if `a` itself satisfies `p`.


theorem Set.indicator_zero :
    ∀ {α : Type u_1} (M : Type u_4) [inst : Zero M] (s : Set α), (Set.indicator s fun x => 0) = fun x => 0 := by sorry

This theorem states that for any type `α` and any set `s` of type `Set α`, if we apply the `Set.indicator` function to `s` using a function that maps every element of `α` to '0' (i.e., the zero element of `M`), then we'll always get a function that maps every element of `α` to '0'. In other words, regardless of whether an element is in the set `s` or not, using `Set.indicator` with a constant zero function will always yield a constant zero function.

For any set `s` of type `α`, the application of `Set.indicator` to `s` using the constant zero function results in a function equal to the constant zero function.


theorem LinearIsometryEquiv.trans_refl :
    ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
      {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
      [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
      [inst_7 : Module R₂ E₂] (e : E ≃ₛₗᵢ[σ₁₂] E₂), LinearIsometryEquiv.trans e (LinearIsometryEquiv.refl R₂ E₂) = e :=
  by sorry

The theorem `LinearIsometryEquiv.trans_refl` states that for any semiring R, another semiring R₂, any types E and E₂, two ring homomorphisms σ₁₂ (from R to R₂) and σ₂₁ (from R₂ to R) which form a pair of inverse ring homomorphisms, any seminormed additive commutative groups E and E₂, and any modules E over R and E₂ over R₂; if we have a linear isometry equivalence (which is also a semilinear map) from E to E₂, then applying the transformation of this equivalence followed by the identity map on E₂ (which is also considered as a linear isometry equivalence) is the same as applying the original equivalence itself. In other words, applying a transformation followed by the identity transformation has no effect, it is equivalent to applying the original transformation.

For any seminormed additive commutative groups E and E₂, and linear isometry equivalences between them that are also semilinear maps, the composition of the equivalence with the identity map on E₂ is equal to the original equivalence.


/-- If `f x = g x` for all `x ∈ s` and `f`, `g` are continuous on `t`, `s ⊆ t ⊆ closure s`, then
`f x = g x` for all `x ∈ t`. See also `Set.EqOn.closure`.  -/
theorem Set.EqOn.of_subset_closure :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : T2Space Y]
      {s t : Set X} {f g : X → Y},
      Set.EqOn f g s → ContinuousOn f t → ContinuousOn g t → s ⊆ t → t ⊆ closure s → Set.EqOn f g t :=
  by sorry

The theorem, `Set.EqOn.of_subset_closure`, states that for a given pair of functions `f` and `g` mapping from a topological space `X` to a `T2` space `Y`, if `f` and `g` are equal on a subset `s` and both functions are continuous on a subset `t` such that `s` is a subset of `t` and `t` is a subset of the closure of `s`, then `f` and `g` are also equal on the subset `t`. This theorem is related to the concept of closure in topology and function equality on sets.

If `f` and `g` are continuous functions mapping a topological space `X` to a T2 space `Y`, `f(s) = g(s)` for all `s` in a subset `s` of `X`, `s` is a subset of `t`, and `t` is a subset of the closure of `s`, then `f(t) = g(t)`.


theorem Cardinal.lt_aleph0_iff_fintype : ∀ {α : Type u}, Cardinal.mk α < Cardinal.aleph0 ↔ Nonempty (Fintype α) := by
  sorry

The theorem `Cardinal.lt_aleph0_iff_fintype` establishes an equivalence between two properties of a type `α`. On one hand, we have the property that the cardinality of `α` (i.e., the number of distinct elements in `α`) is strictly less than `ℵ₀` (the smallest infinite cardinal number, representing the size of the set of natural numbers). On the other hand, we have the property that `α` is a finite type (i.e., there are only finitely many distinct values of type `α`). The theorem states that these two properties are equivalent for any type `α`: `α` has fewer elements than the set of natural numbers if and only if `α` is a finite type.

A type `α` has fewer elements than `ℵ₀` if and only if it is a finite type.


theorem IsFractionRing.isFractionRing_of_isLocalization :
    ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_3) (T : Type u_4) [inst_1 : CommRing S]
      [inst_2 : CommRing T] [inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
      [inst_6 : IsScalarTower R S T] [inst_7 : IsLocalization M S] [inst_8 : IsFractionRing R T],
      M ≤ nonZeroDivisors R → IsFractionRing S T :=
  by sorry

This theorem states that if we have two commutative rings `R` and `S`, and a submonoid `M` of `R`, such that `S` is a localization of `R` at `M`, and we also have a third commutative ring `T` such that `T` is the field of fractions of `R`, with an algebra structure defined between `R`, `S`, and `T` and the additional condition that `R`, `S`, `T` form a scalar tower. If `M` is a subset of the non-zero divisors of `R`, then `T` is also the field of fractions of `S`. In simpler terms, we can carry the fraction field structure from `R` to `S` through localization, given that the localization does not introduce zero divisors.

If `R` and `S` are commutative rings with `S` being a localization of `R` at a submonoid `M` of non-zero divisors in `R`, and if `T` is the field of fractions of `R` with an algebra structure making `R`, `S`, and `T` a scalar tower, then `T` is the field of fractions of `S`.


/-- A presheaf on a category which is `FinitaryExtensive` is a sheaf iff it preserves finite products.
 -/
theorem CategoryTheory.isSheaf_iff_preservesFiniteProducts :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C]
      [inst_2 : CategoryTheory.FinitaryExtensive C] (F : CategoryTheory.Functor Cᵒᵖ (Type (max u v))),
      CategoryTheory.Presieve.IsSheaf (CategoryTheory.Coverage.toGrothendieck C (CategoryTheory.extensiveCoverage C))
          F ↔
        Nonempty (CategoryTheory.Limits.PreservesFiniteProducts F) :=
  by sorry

The theorem `CategoryTheory.isSheaf_iff_preservesFiniteProducts` states that for any category `C` which is `FinitaryExtensive`, a presheaf on `C` is a sheaf if and only if it preserves finite products. This means that a functor `F` from the opposite category of `C` to the category of Types is a sheaf with respect to the Grothendieck topology associated with the extensive coverage of `C` if and only if there exists a structure that shows `F` preserves finite products, i.e., the functor `F` maintains the property of product formation under the operation of taking the finite product of objects.

A presheaf on a finitary extensive category is a sheaf if and only if it preserves finite products.


theorem card_finset_fin_le : ∀ {n : ℕ} (s : Finset (Fin n)), s.card ≤ n := by sorry

This theorem states that for any natural number `n` and any finite set `s` of elements from the set of natural numbers less than `n` (`Fin n`), the cardinality or size of `s` (i.e., the number of elements in `s`) is always less than or equal to `n`. In terms of mathematical notation, for all natural numbers `n` and all finite sets `s` in `Fin n`, |s| ≤ n.

For all natural numbers `n` and finite sets `s` in `Fin n`, the cardinality of `s` is less than or equal to `n`. In mathematical notation, |s| ≤ n.


Monotone.Iio

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

The theorem `Monotone.Iio` states that for any two types `α` and `β` equipped with preorder structures, and any function `f` from `α` to `β`, if the function `f` is monotone, then the function that maps each `x` in `α` to the left-infinite right-open interval ending at `f(x)` is also monotone. In mathematical terms, if `f` is a function such that `a ≤ b` implies `f a ≤ f b` for all `a` and `b` in `α`, then for all `x` in `α`, the set of all `y` in `α` such that `y < f(x)` is a monotone function of `x`.

If `f` is a monotone function from preorder types `α` to `β`, then the function mapping each `x` in `α` to the left-open interval `(-\infty, f(x))` is also monotone.


theorem Submonoid.le_comap_of_map_le :
    ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (S : Submonoid M) {F : Type u_4}
      [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] {T : Submonoid N} {f : F},
      Submonoid.map f S ≤ T → S ≤ Submonoid.comap f T :=
  by sorry

The theorem `Submonoid.le_comap_of_map_le` states that for all types `M` and `N` with multiplication and identity (`MulOneClass M` and `MulOneClass N`), a submonoid `S` of `M`, a function `f` of type `F` that behaves like a function from `M` to `N` (`FunLike F M N`), and is a monoid homomorphism (`MonoidHomClass F M N`), and a submonoid `T` of `N`. If the image of submonoid `S` under the function `f` is a subset or equal to the submonoid `T`, then `S` is a subset or equal to the preimage of `T` under the function `f`.

If `f` is a monoid homomorphism from a submonoid `S` of `M` to a submonoid `T` of `N` such that `f(S) ⊆ T`, then `S ⊆ f⁻¹(T)`.


theorem NonemptyInterval.toDualProd_injective :
    ∀ {α : Type u_1} [inst : LE α], Function.Injective NonemptyInterval.toDualProd := by sorry

This theorem states that for any type `α` which has an order (`LE`), the function `NonemptyInterval.toDualProd` is injective. In other words, if we have two nonempty intervals in `α` and the function `NonemptyInterval.toDualProd` maps these two intervals to the same ordered pair of `α`, then these two intervals are the same. In simple terms, no two different nonempty intervals in `α` will give the same ordered pair when mapped by the function `NonemptyInterval.toDualProd`.

For any type `α` with an order, the function `NonemptyInterval.toDualProd` maps distinct nonempty intervals in `α` to distinct ordered pairs.


theorem map_int_cast_smul :
    ∀ {M : Type u_5} {M₂ : Type u_6} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] {F : Type u_9}
      [inst_2 : FunLike F M M₂] [inst_3 : AddMonoidHomClass F M M₂] (f : F) (R : Type u_10) (S : Type u_11)
      [inst_4 : Ring R] [inst_5 : Ring S] [inst_6 : Module R M] [inst_7 : Module S M₂] (x : ℤ) (a : M),
      f (↑x • a) = ↑x • f a :=
  by sorry

The theorem `map_int_cast_smul` states that for any types `M` and `M₂`, both instances of `AddCommGroup`, and any type `F` which is a `FunLike` from `M` to `M₂` and an `AddMonoidHomClass` from `M` to `M₂`, given a function `f : F`, types `R` and `S` which are instances of `Ring`, `M` being a `Module` over `R`, `M₂` being a `Module` over `S`, an integer `x` and an element `a : M`, the function `f` preserves the scalar multiplication of `a` by the integer `x`. In mathematical notation, this can be rendered as \(f(x \cdot a) = x \cdot f(a)\), where the multiplication on the left-hand side is in `M` and on the right-hand side in `M₂`.

For any AddMonoidHomClass `F` from an AddCommGroup `M` to an AddCommGroup `M₂`, and any `x ∈ ℤ`, `a ∈ M`, `f : F`, we have `f(x * a) = x * f(a)`.


theorem NormedSpace.unbounded_univ :
    ∀ (𝕜 : Type u_1) (E : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
      [inst : NormedSpace 𝕜 E] [inst : Nontrivial E], ¬Bornology.IsBounded Set.univ :=
  by sorry

This theorem, `NormedSpace.unbounded_univ`, states that for any nontrivially normed field `𝕜` and any normed additive commutative group `E` that forms a normed space over `𝕜` and is nontrivial itself, the universal set (or the set containing all elements) in this context is not bounded with respect to the ambient bornology on `E`. In other words, in such a normed space, there doesn't exist a finite set of balls of finite radius that can cover the entire space.

In any nontrivially normed field with a corresponding nontrivial normed additive commutative group, the universal set is unbounded in the bornology of the normed space.


theorem ADEInequality.sumInv_pqr : ∀ (p q r : ℕ+), ADEInequality.sumInv {p, q, r} = (↑↑p)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ := by
  sorry

The theorem `ADEInequality.sumInv_pqr` states that for any three positive natural numbers `p`, `q`, and `r`, the function `ADEInequality.sumInv` applied to the multiset `{p, q, r}` is equal to the sum of the inverses of `p`, `q`, and `r`, each treated as a rational number. This means that the function `sumInv` effectively computes the sum of the inverses of the elements in the multiset.

For any multiset {p, q, r} of positive natural numbers, ADEInequality.sumInv({p, q, r}) = p^(-1) + q^(-1) + r^(-1).


theorem Fin.insertNth_rev :
    ∀ {n : ℕ} {α : Type u_1} (i : Fin (n + 1)) (a : α) (f : Fin n → α) (j : Fin (n + 1)),
      Fin.insertNth i a f (Fin.rev j) = Fin.insertNth (Fin.rev i) a (f ∘ Fin.rev) j :=
  by sorry

This theorem, `Fin.insertNth_rev`, states that for any natural number `n`, a type `α`, an element `i` of the type `Fin (n + 1)`, an element `a` of type `α`, a function `f` mapping from `Fin n` to `α`, and an element `j` of the type `Fin (n + 1)`, inserting an element `a` at the position `i` in a tuple (with the help of function `f`) and then reversing the tuple (using `Fin.rev j`) is equivalent to reversing the position `i` (with `Fin.rev i`), inserting the same element `a` and then applying the function `f` composed with the reversal function `Fin.rev` to the tuple at position `j`. This theorem highlights the commutative property of the operation of insertion and reversal in the context of tuples.

For any natural number `n`, any `α`, `i ∈ Fin (n + 1)`, `a ∈ α`, `f : Fin n → α`, and `j ∈ Fin (n + 1)`, the tuples `(f (Fin.rev i) :: f <$> Fin.init (Fin.drop i (Fin.enumFromTo 0 (n + 1))) ++ [a] ++ Fin.drop i (Fin.enumFromTo 0 n) ++ [f (Fin.rev j)] ++ map f (Fin.init (Fin.drop (succ i) (Fin.enumFromTo 0 n))) ++ [f (Fin.last (Fin.drop (succ i) (Fin.enumFromTo 0 n)))] and `(Fin.rev j, a) ++ map f (Fin.init (Fin.drop (pred i) (Fin.enumFromTo 0 n))) ++ [f i] ++ reverse (Fin.drop i (Fin.enumFromTo 0 n)) ++ [f (Fin.last (Fin.drop (pred i) (Fin.enumFromTo 0 n)))]` are equal.


theorem IsCoprime.add_mul_right_left :
    ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → ∀ (z : R), IsCoprime (x + z * y) y := by sorry

This theorem states that for any commutative ring `R`, if `x` and `y` are coprime elements in `R`, then for any other element `z` in `R`, `x + z*y` and `y` are also coprime. Here, two elements `x` and `y` are coprime if there exist two other elements `a` and `b` in `R` such that `a * x + b * y = 1`.

If `x` and `y` are coprime elements in a commutative ring `R`, then `x` and `x + y * z` are coprime for any `z` in `R`.


theorem MeasureTheory.VectorMeasure.ennrealToMeasure_apply :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {v : MeasureTheory.VectorMeasure α ENNReal} {s : Set α},
      MeasurableSet s → ↑↑(MeasureTheory.VectorMeasure.ennrealToMeasure v) s = ↑v s :=
  by sorry

This theorem states that for any type `α`, given a measurable space `m` over `α`, a vector measure `v` over the extended nonnegative real numbers (`ENNReal`), and a set `s` of type `α`, if `s` is a measurable set, then the measure of `s` under the measure corresponding to the vector measure `v` is equal to the vector measure `v` of the set `s`. In mathematical terms, we could write this as: if `s` is a measurable set in a measurable space `M`, and `v` is a vector measure over `[0, ∞]`, then the measure under `v` of the set `s` is equal to `v(s)`.

For any measurable space `(α, M)`, measurable set `s` ∋ο M, and vector measure `v` over `[0, ∞]`, `v(s) = ∫x ∈ s d(v x)`.


/-- The `n`-th iterated derivative can be obtained by iterating `n` times the
differentiation operation.  -/
theorem iteratedDeriv_eq_iterate :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F}, iteratedDeriv n f = deriv^[n] f :=
  by sorry

The theorem `iteratedDeriv_eq_iterate` states that for any function `f` from some non-trivially normed field `𝕜` to a normed additive commutative group `F`, under the normed space structure of `𝕜` and `F`, the `n`-th iterated derivative of `f` is equivalent to applying the differentiation operation `n` times to `f`. In other words, for any natural number `n`, the `n`-th iterated derivative of `f` is the same as the `n`-th power of the `deriv` function applied to `f`. This connects the concept of iterated derivatives with repeated differentiation.

For any function `f` from a non-trivially normed field to a normed additive commutative group, the `n`-th iterated derivative of `f` equals the `n`-th power of the derivative function applied to `f`.


theorem tsum_comm' :
    ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
      [inst_2 : ContinuousAdd α] [inst_3 : T3Space α] {f : β → γ → α},
      Summable (Function.uncurry f) →
        (∀ (b : β), Summable (f b)) →
          (∀ (c : γ), Summable fun b => f b c) → ∑' (c : γ) (b : β), f b c = ∑' (b : β) (c : γ), f b c :=
  by sorry

This theorem, named `tsum_comm'`, states that under certain conditions, the order of summation can be interchanged for a double infinite series. These conditions are:

- The function `f` taking two inputs from sets of types `β` and `γ` respectively, and producing a value of type `α`, can be uncurried to become a function that takes a pair of values as an input.
- The function `f`, after being uncurried, is summable. This means that the infinite sum of the function `f` over its domain exists.
- For every value of `b` in type `β`, the series over `γ` is summable.
- For every value of `c` in type `γ`, the series over `β` is summable.

If these conditions hold, the theorem states that the double series can be summed in any order: summing first over `γ` and then over `β` produces the same result as summing first over `β` and then over `γ`. In mathematical terms, ∑' (c : γ) (b : β), f b c = ∑' (b : β) (c : γ), f b c.

If functions `f` meeting certain uncurriability and summability conditions are applied to double indices `(b : β, c : γ)`, then interchanging the order of summation over `β` and `γ` yields the same result: `∑' b ∑' c f b c = ∑' c ∑' b f b c`.


theorem ArithmeticFunction.coe_zeta_mul_coe_moebius :
    ∀ {R : Type u_1} [inst : Ring R], ↑ArithmeticFunction.zeta * ↑ArithmeticFunction.moebius = 1 := by sorry

This theorem states that for any ring R, the product of the Dirichlet series of the Riemann ζ function and the Möbius function equals 1. In more detail, it asserts that multiplying the function ζ, which is defined to be 0 when its argument is 0 and 1 otherwise, with the Möbius function μ, which takes on values of 1, -1 or 0 depending on whether its argument is squarefree with an even number of distinct prime factors, squarefree with an odd number of distinct prime factors or not squarefree, respectively, results in the multiplicative identity in the ring R.

For any ring R, the product of the Riemann ζ function and the Möbius function is the multiplicative identity in R.


Set.BijOn.symm

theorem Set.BijOn.symm :
    ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} {g : β → α},
      Set.InvOn f g t s → Set.BijOn f s t → Set.BijOn g t s :=
  by sorry

This theorem states that for any two sets `s` and `t` of types `α` and `β` respectively, with maps `f` from `α` to `β` and `g` from `β` to `α`, if `f` is an inverse of `g` on the range `t` and domain `s`, and `f` is a bijection from `s` to `t`, then `g` is a bijection from `t` to `s`. Here, a bijection is a function that is both injective (no two different inputs map to the same output) and surjective (every element of the target set is an output of the function).

If functions `f` from set `s` to `t` and `g` from `t` to `s` are mutually inverse bijections, then each is a bijection between `s` and `t`.


theorem mod_addOrderOf_zsmul :
    ∀ {G : Type u_1} [inst : AddGroup G] (x : G) (z : ℤ), (z % ↑(addOrderOf x)) • x = z • x := by sorry

The theorem `mod_addOrderOf_zsmul` states that for any additive group `G` and any element `x` of `G`, and for any integer `z`, the action of multiplying `x` by `z` modulo the additive order of `x` is the same as simply multiplying `x` by `z`. In mathematical terms, for any `z ∈ ℤ`, we have `(z mod addOrderOf(x)) • x = z • x`. This means that the cyclic behavior of `x` under addition is captured completely by its additive order, and any excess multiplication "wraps around" just like clock arithmetic.

For any additive group G, element x of G, and integer z, (z mod additiveOrderOf x) * x = z * x.


theorem MonoidHom.map_range :
    ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} {P : Type u_6} [inst_1 : Group N] [inst_2 : Group P] (g : N →* P)
      (f : G →* N), Subgroup.map g (MonoidHom.range f) = MonoidHom.range (MonoidHom.comp g f) :=
  by sorry

The theorem `MonoidHom.map_range` states that for any two groups `G`, `N` and `P`, and any two monoid homomorphisms `g: N -> P` and `f: G -> N`, the subgroup of `P` obtained by mapping the range of `f` under the homomorphism `g` is equal to the range of the composite homomorphism `g ∘ f`. In other words, applying a monoid homomorphism to the range of another homomorphism is the same as taking the range of the composition of those two homomorphisms.

For any groups G, N, and P, and monoid homomorphisms f : G -> N and g : N -> P, the image of f under g is equal to the image of the range of f under g.


theorem AddSubgroup.comap_map_eq :
    ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
      AddSubgroup.comap f (AddSubgroup.map f H) = H ⊔ AddMonoidHom.ker f :=
  by sorry

The theorem `AddSubgroup.comap_map_eq` states that for any additive group homomorphism `f` from an additive group `G` to another additive group `N`, and for any additive subgroup `H` of `G`, the preimage of the image of the subgroup `H` under the map `f` is equal to the join (i.e., smallest superset) of the subgroup `H` and the kernel of the homomorphism `f`. In mathematical notation, this translates to `f⁻¹(f(H)) = H ∪ ker(f)`. This essentially means that any element in the preimage of the image of `H` is either in `H` or gets mapped to the additive identity in `N` by `f`.

The preimage of the image of a subgroup under an additive group homomorphism equals the subgroup's join with the homomorphism's kernel.


theorem LinearMap.coeFn_sum :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
      [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
      {σ₁₂ : R →+* R₂} {ι : Type u_10} (t : Finset ι) (f : ι → M →ₛₗ[σ₁₂] M₂),
      ⇑(Finset.sum t fun i => f i) = Finset.sum t fun i => ⇑(f i) :=
  by sorry

The theorem `LinearMap.coeFn_sum` states that for any semirings `R` and `R₂`, additive commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `σ₁₂` from `R` to `R₂`, a finite set `t` of type `ι`, and a function `f` mapping each element of `t` to a linear map from `M` to `M₂`, the function application of the sum of the linear maps (obtained by summing over `t`) is equal to the sum of the function applications of the individual linear maps. In other words, the operation of taking a function application distributes over the operation of taking a sum of linear maps.

For any semirings R and R₂, additive commutative monoids M and M₂, modules M over R and M₂ over R₂, a ring homomorphism σ₁₂ from R to R₂, a finite set ι, and a function f from ι to the linear maps from M to M₂, the sum of the function applications of the linear maps in the set f is equal to the function application of the sum of these linear maps.


theorem Ideal.isJacobson_of_surjective :
    ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [H : Ideal.IsJacobson R],
      (∃ f, Function.Surjective ⇑f) → Ideal.IsJacobson S :=
  by sorry

The theorem `Ideal.isJacobson_of_surjective` states that for any two types `R` and `S` (representing rings), if `R` is a Jacobson ring (as indicated by `Ideal.IsJacobson R`), and if there exists a surjective function `f` from `R` to `S` (meaning that each element in `S` can be mapped from an element in `R` using the function `f`), then `S` is also a Jacobson ring. This theorem is defined in the context of two commutative rings `R` and `S` (`CommRing R` and `CommRing S`).

If `R` is a Jacobson ring and there exists a surjective homomorphism from `R` to a commutative ring `S`, then `S` is also a Jacobson ring.


theorem edist_triangle_right :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] (x y z : α), edist x y ≤ edist x z + edist y z := by sorry

The `edist_triangle_right` theorem, which is given for any type `α` in a pseudo e-metric space, states that for any three elements `x`, `y`, and `z` of this type, the e-distance (denoted as `edist`) from `x` to `y` is always less than or equal to the sum of the e-distance from `x` to `z` and the e-distance from `y` to `z`. This theorem is essentially the triangle inequality for e-metric spaces in Lean 4.

For any e-metric space type `α`, the e-distance `edist(x, y)` between elements `x` and `y` is less than or equal to `edist(x, z) + edist(z, y)` for all `x`, `y`, and `z` of type `α`.


/-- A version of `bot_lt_iff_ne_bot` for `WithBot` that only requires `LT α`, not
`PartialOrder α`.  -/
theorem WithBot.bot_lt_iff_ne_bot : ∀ {α : Type u_1} [inst : LT α] {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥ := by sorry

This theorem is a version of the `bot_lt_iff_ne_bot` for `WithBot`, which is a type that extends another type by adding a "bottom" element. The theorem states that for all types `α`, endowed with a less than (`LT`) operation, and for all values `x` of type `WithBot α`, `⊥` (the bottom element) is less than `x` if and only if `x` is not equal to `⊥`. The theorem does not require `α` to have a `PartialOrder` structure, only a `LT` (less than) operation.

For any type endowed with a less than operation, the bottom element is less than any non-bottom value in the type with bottom element.


theorem EReal.coe_pos : ∀ {x : ℝ}, 0 < ↑x ↔ 0 < x := by sorry

This theorem states that for any real number `x`, the property of the coersion of `x` being greater than 0 is equivalent to `x` itself being greater than 0. In mathematical terms, if `x` is a real number, then 0 being less than the coersion of `x` (notated as `↑x`) is equivalent to 0 being less than `x`.

The theorem asserts that for any real number `x`, `0 < x` is equivalent to `0 < ↑x`.


theorem Mathlib.Order.Heyting.Basic._auxLemma.4 :
    ∀ {α : Type u} [inst : SemilatticeInf α] {a b c : α}, (a ≤ b ⊓ c) = (a ≤ b ∧ a ≤ c) := by sorry

This theorem, named `_auxLemma.4` in the `Mathlib.Order.Heyting.Basic` module, states that for any type `α` that is a semilattice with respect to the operation "infimum" (denoted as `⊓`), and for any elements `a`, `b`, and `c` of this type, `a` is less than or equal to the infimum of `b` and `c` if and only if `a` is less than or equal to `b` and `a` is less than or equal to `c`. In other words, `a` being less than or equal to the "minimum" of `b` and `c` is equivalent to `a` being less than or equal to both `b` and `c`.

For any semilattic type α and elements a, b, c, a ≤ inf(b, c) if and only if a ≤ b and a ≤ c.


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

The theorem `toZ_of_lt` states that for any type `ι` that has a linear order, a successor order, satisfies the Archimedean property, and has a predecessor order, and for any two elements `i0` and `i` of this type such that `i` is less than `i0`, the function `toZ` applied to `i0` and `i` equals the negative of a certain natural number (found using `Nat.find`). In other words, if `i` is less than `i0`, `toZ` assigns it a negative integer value.

For any type with a linear order, successor, Archimedean property, and a predecessor order, the function `toZ` maps elements less than another element to the negative of a corresponding natural number.


theorem MeasureTheory.withDensity_apply_le :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) (s : Set α),
      ∫⁻ (a : α) in s, f a ∂μ ≤ ↑↑(μ.withDensity f) s :=
  by sorry

This theorem, `MeasureTheory.withDensity_apply_le`, in the field of Measure Theory, states that for any given type α, a measurable space `m0` on α, a measure `μ` on that measurable space, a function `f` from α to the extended nonnegative real numbers (usually denoted [0, ∞]), and a set `s` of type α, the Lebesgue integral (or the 'proper' integral) over the set `s` of the function `f` with respect to the measure `μ` is less than or equal to the measure of the set `s` with respect to the density of the measure `μ` as defined by the function `f`. In other words, the total 'amount of stuff' as measured by the function `f` over the set `s` is less than or equal to the total measure of the set `s` when we consider the measure `μ` to have been 'adjusted' by the function `f`.

For any measurable space (α, m0), measure μ, measurable function f : α → [0, ∞], and set s ∈ m0, we have ∫(s) (f) dμ ≤ μ(s).


theorem Submodule.map_comp :
    ∀ {R : Type u_1} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_5} {M₂ : Type u_7} {M₃ : Type u_8} [inst : Semiring R]
      [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M₂]
      [inst_5 : AddCommMonoid M₃] [inst_6 : Module R M] [inst_7 : Module R₂ M₂] [inst_8 : Module R₃ M₃] {σ₁₂ : R →+* R₂}
      {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R →+* R₃} [inst_9 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_10 : RingHomSurjective σ₁₂]
      [inst_11 : RingHomSurjective σ₂₃] [inst_12 : RingHomSurjective σ₁₃] (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₃] M₃)
      (p : Submodule R M), Submodule.map (LinearMap.comp g f) p = Submodule.map g (Submodule.map f p) :=
  by sorry

This theorem states that for three semirings R, R₂, R₃ and three modules M, M₂, M₃ over them, given three ring homomorphisms σ₁₂, σ₂₃, σ₁₃ (with σ₁₂ and σ₂₃ composing to σ₁₃), and two linear maps f : M → M₂ and g : M₂ → M₃ with respect to these homomorphisms, for any submodule p of M, mapping the submodule p through the composition of the linear maps g and f is the same as first mapping p through f, creating a new submodule, and then mapping this submodule through g. This theorem is essentially expressing the property that the map operation for submodules is compatible with the composition of linear maps.

For three semirings R, R₂, R₃ and modules M, M₂, M₃, if σ₁₂ and σ₂₃ are ring homomorphisms, σ₁₂σ₃ = σ₁₃ is their composition, and f : M → M₂ and g : M₂ → M₃ are linear maps, then the image of a submodule p of M under the composition gf is equal to the image of the submodule p under f followed by g.


theorem IsLocallyConstant.iff_eventually_eq :
    ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (f : X → Y),
      IsLocallyConstant f ↔ ∀ (x : X), ∀ᶠ (y : X) in nhds x, f y = f x :=
  by sorry

The theorem `IsLocallyConstant.iff_eventually_eq` asserts that for all types `X` and `Y` where `X` is a topological space and `f` is a function from `X` to `Y`, the function `f` is locally constant (the preimage of any set under `f` is an open set) if and only if for every `x` in `X`, eventually (meaning for all points `y` in the neighborhood of `x`), the value of `f` at `y` is equal to the value of `f` at `x`. In other words, a function is locally constant if the function's value remains the same in a neighborhood around each point.

A function between topological spaces is locally constant if and only if for each point in the domain, its image value is eventually constant in every neighborhood of that point.