theorem CategoryTheory.Limits.pushout.inr_desc :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
      [inst_1 : CategoryTheory.Limits.HasPushout f g] (h : Y ⟶ W) (k : Z ⟶ W)
      (w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
      CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.pushout.inr (CategoryTheory.Limits.pushout.desc h k w) =
        k :=
  by sorry

The theorem `CategoryTheory.Limits.pushout.inr_desc` states that in any category `C`, given objects `W`, `X`, `Y`, `Z` and morphisms `f` from `X` to `Y`, `g` from `X` to `Z`, `h` from `Y` to `W`, and `k` from `Z` to `W`, if the pushout of f and g exists (`CategoryTheory.Limits.HasPushout f g`), and the composition of `f` and `h` equals the composition of `g` and `k` (expressed as `CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k`), then the composition of the second inclusion into the pushout of `f` and `g` and the morphism `CategoryTheory.Limits.pushout.desc h k w` described by the universal property of the pushout equals `k`. In simpler terms, this theorem encapsulates one of the defining properties of a pushout in category theory.

In a category with pushouts, if the pushout of morphisms `f` and `g` exists and `f ∘ h = g ∘ k`, then the morphism `h` factors through the pushout via `k`.


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

This theorem states that for any type `α` that has a linear order, and any three elements `a`, `b`, and `c` in this type, if `a` is less than or equal to `b`, then `a` is also less than or equal to the maximum of `b` and `c`. In other words, in terms of general mathematics, if a ≤ b, then a is also less than or equal to max(b, c) for any linearly ordered set.

For any linearly ordered type `α` and elements `a`, `b`, `c` in `α`, if `a ≤ b`, then `a ≤ max b c`.


theorem Multiset.le_iff_subset : ∀ {α : Type u_1} {s t : Multiset α}, Multiset.Nodup s → (s ≤ t ↔ s ⊆ t) := by sorry

This theorem states that for any types `α` and multisets `s` and `t` of type `α`, if `s` has no duplicates (formally defined by `Multiset.Nodup s`), then `s` is less than or equal to `t` if and only if `s` is a subset of `t`. Here, the less than or equal relation (≤) for multisets is defined in terms of the multiplicity of elements in `s` not exceeding their multiplicity in `t`. The subset relation (⊆) means every element of `s` is also an element of `t`. In essence, the theorem is about an equivalence between these two relations when `s` doesn't contain duplicate elements.

For multisets `s` and `t` of type `α`, `s ≤ t` if and only if `s ⊆ t` when `s` has no duplicates.


IsOpen.isGδ

/-- An open set is a Gδ set.  -/
theorem IsOpen.isGδ : ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsOpen s → IsGδ s := by sorry

This theorem states that any open set in a given topological space is a Gδ set. In the context of topology, a Gδ set is a countable intersection of open sets. Therefore, the theorem is saying that if a set is open in a topological space, then there exists a countable collection of open sets such that their intersection equals to the original set.

In any topological space, every open set is a countable intersection of open sets (a Gδ set).


theorem star_comm_self' :
    ∀ {R : Type u_1} [inst : Mul R] [inst_1 : Star R] (x : R) [inst_2 : IsStarNormal x], star x * x = x * star x := by
  sorry

This theorem states that for any type `R` equipped with a multiplication operation (`Mul R`) and a `star` operation (`Star R`), and for any element `x` of `R` that is star-normal (`IsStarNormal x`), the product of `star x` and `x` is equal to the product of `x` and `star x`. In other words, the multiplication of `star x` and `x` commutes in the context of star-normal elements.

For any commutative ring `R` with a `star` operation, and for any star-normal element `x` in `R`, we have `(star x) * x = x * (star x)`.


/-- See note [partially-applied ext lemmas].  -/
theorem CliffordAlgebra.hom_ext :
    ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
      {Q : QuadraticForm R M} {A : Type u_4} [inst_3 : Semiring A] [inst_4 : Algebra R A]
      {f g : CliffordAlgebra Q →ₐ[R] A},
      AlgHom.toLinearMap f ∘ₗ CliffordAlgebra.ι Q = AlgHom.toLinearMap g ∘ₗ CliffordAlgebra.ι Q → f = g :=
  by sorry

This theorem, named `CliffordAlgebra.hom_ext`, states that for any commutative ring `R`, additive commutative group `M`, `R`-module `M`, quadratic form `Q` of `M` over `R`, semiring `A` and algebra `A` over `R`, if we have two algebra homomorphisms `f` and `g` from the Clifford Algebra of `Q` to `A`, such that the composition of `f` and `g` with the canonical linear map from `M` to the Clifford Algebra of `Q` are equal when considered as linear maps, then `f` and `g` themselves must be equal. This theorem captures an important property of homomorphisms in the context of algebraic structures, demonstrating that the equal compositions of the homomorphisms with a canonical linear map imply the equality of the homomorphisms themselves.

Given commutative rings R, additive commutative groups M as an R-module, quadratic forms Q over R, semirings A, and algebra homomorphisms f and g from the Clifford Algebra of Q to A such that their compositions with the canonical linear map from M to the Clifford Algebra of Q are equal, then f and g are equal.


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

The theorem "FirstOrder.Language.BoundedFormula.realize_rel₂" states that for every first-order language `L`, type `M`, structure instance `inst` for `L` and `M`, type `α`, natural number `l`, function `v` mapping `α` to `M`, function `xs` mapping a finite sequence of natural numbers to `M`, relation `R` of `L` with arity 2, and terms `t₁` and `t₂` of the language `L` with variables from either `α` or the finite sequence of `n` elements, the realisation of the bounded formula obtained by applying the relation `R` to the terms `t₁` and `t₂`, under the variable assignments `v` and `xs`, is equivalent to the interpretation of the relation `R` in the structure `M`, applied to the realised values of the terms `t₁` and `t₂` (which are obtained by realising the terms under the combined variable assignment given by the sum elimination of `v` and `xs`).

This essentially relates the semantics of a relation applied to two terms in a first-order language to the interpretation of that relation in a structure for that language.

For any first-order language L, type M, structure instance inst for L and M, relation R of arity 2, and terms t₁ and t₂ in L with variables from α or a finite sequence of natural numbers, the realization of the bounded formula obtained by applying R to t₁ and t₂ under variable assignments v and xs is equivalent to interpreting R in M on the realized values of t₁ and t₂.


theorem Quiver.Hom.op_unop : ∀ {C : Type u₁} [inst : Quiver C] {X Y : Cᵒᵖ} (f : X ⟶ Y), f.unop.op = f := by sorry

The theorem `Quiver.Hom.op_unop` states that for any type `C` with structure `Quiver`, and any two categories `X` and `Y` in the opposite category `Cᵒᵖ`, if there is a morphism `f` from `X` to `Y`, then the operation of first applying the `unop` operation to `f` and then the `op` operation, results in `f` itself. Essentially, the `unop` and `op` operations are inverses of each other for all morphisms in the opposite category `Cᵒᵖ`.

For any morphism $f$ in the opposite category of a quiver $C$, we have $(\op \circ \unop)(f) = (\unop \circ \op)(f) = f$.


HasFDerivAtFilter.comp

theorem HasFDerivAtFilter.comp :
    ∀ {𝕜 : 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]
      {G : Type u_4} [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {f' : E →L[𝕜] F} (x : E)
      {L : Filter E} {g : F → G} {g' : F →L[𝕜] G} {L' : Filter F},
      HasFDerivAtFilter g g' (f x) L' →
        HasFDerivAtFilter f f' x L →
          Filter.Tendsto f L L' → HasFDerivAtFilter (g ∘ f) (ContinuousLinearMap.comp g' f') x L :=
  by sorry

The `HasFDerivAtFilter.comp` theorem states that for two functions `f : E → F` and `g : F → G` defined over normed spaces `E`, `F`, and `G` over a nontrivially normed field `𝕜`, if `f` has a derivative `f'` at point `x` with respect to filter `L` and `g` has a derivative `g'` at `f(x)` with respect to filter `L'`, and if `f` tends to `L'` under filter `L`, then the composite function `g ∘ f` has a derivative `ContinuousLinearMap.comp g' f'` at point `x` with respect to filter `L`. This is a formal statement of the chain rule in the language of filters.

If functions `f : E → F` and `g : F → G` have derivatives at points `x` and `f(x)` with respect to filters `L` and `L'`, respectively, and `f(x)` tends to `L'` under `L`, then the composite function `g ∘ f` has a derivative `g' ∘ f'` at `x` with respect to `L`.


theorem Set.subsingleton_univ : ∀ {α : Type u} [inst : Subsingleton α], Set.Subsingleton Set.univ := by sorry

This theorem states that for any type `α`, given that `α` is a `Subsingleton` (meaning it can have at most one element), the universal set on `α` is also a `Subsingleton`. In other words, if a type `α` has at most one element, then the set of all elements of `α` also has at most one element.

If `α` is a subsingleton type, then the universe set `Set α` is also a subsingleton.


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

This theorem states that for any type `α`, given an `Array α` and a `List α`, the function `Array.toListAppend` that prepends the array onto the front of the list is equivalent to concatenating the array's data (converted to a list) with the list. In other words, applying `Array.toListAppend` with an array and a list as inputs produces the same result as appending the list representation of the array's data to the given list.

For any type `α`, the function `Array.toListAppend` applying to an `Array α` and a `List α` is equivalent to the concatenation of the list representation of the array's data with the given list.


theorem CauSeq.add_limZero :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrderedField α] [inst_1 : Ring β] {abv : β → α}
      [inst_2 : IsAbsoluteValue abv] {f g : CauSeq β abv},
      CauSeq.LimZero f → CauSeq.LimZero g → CauSeq.LimZero (f + g) :=
  by sorry

The theorem `CauSeq.add_limZero` states that for any ordered field `α`, any ring `β`, and any absolute value `abv` from `β` to `α`, if `f` and `g` are Cauchy sequences with respect to the absolute value `abv` and both `f` and `g` approach zero, then the sum of `f` and `g` also approaches zero. This is a property of limit arithmetic in the context of Cauchy sequences, which extends the idea that the limit of the sum of two sequences is the sum of their limits.

If `f` and `g` are Cauchy sequences over an ordered field `α` with respect to an absolute value `abv` and `abv(lim f) = abv(lim g) = 0`, then `abv(lim (f + g)) = 0`.


theorem Nat.pow_log_le_self : ∀ (b : ℕ) {x : ℕ}, x ≠ 0 → b ^ Nat.log b x ≤ x := by sorry

The theorem `Nat.pow_log_le_self` states that for any natural number `b` and any non-zero natural number `x`, the `b` raised to the power of the logarithm base `b` of `x` is less than or equal to `x`. In other words, it verifies the fundamental property of logarithms that the exponent to which one number must be raised to produce another number is less than or equal to the original number when the base of the logarithm is a natural number.

For all natural numbers x and b where b > 0, b^(log\_b x) ≤ x.


theorem List.filterMap_eq_map : ∀ {α : Type u_1} {β : Type u_2} (f : α → β), List.filterMap (some ∘ f) = List.map f :=
  by sorry

This theorem, `List.filterMap_eq_map`, states that for any types `α` and `β`, and any function `f` from `α` to `β`, the function `List.filterMap` applied to the composition of `some` and `f` is equivalent to the function `List.map` applied to `f`. In simple terms, it means that if we use `filterMap` to apply `f` to each element of a list and then wrap the result in an `Option` (using `some`), we end up with the same result as if we simply used `map` to apply `f` directly to each element of the list.

For any type `α`, type `β`, and function `f` from `α` to `β`, `List.filterMap (λx => some (f x)) l = List.map f l`.


theorem Ideal.mem_bot : ∀ {R : Type u} [inst : Semiring R] {x : R}, x ∈ ⊥ ↔ x = 0 := by sorry

This theorem states that for any semiring `R` and any element `x` of `R`, `x` is an element of the bottom ideal if and only if `x` is equal to zero. In other words, in any semiring, the bottom ideal only contains the zero element.

In any semiring, the bottom ideal is equivalent to the set of zero elements.


theorem Mathlib.Analysis.BoxIntegral.Partition.Basic._auxLemma.1 :
    ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I), (J ∈ π.boxes) = (J ∈ π) := by sorry

This theorem states that for any type `ι`, any given boxes `I` and `J`, and any prepartition `π` of `I`, the condition of `J` being in the set of boxes of `π` is equivalent to `J` being in `π`. In other words, for any box `J` and prepartition `π`, `J` is a part of `π` if and only if `J` is among the boxes that make up `π`.

For any type `ι`, prepartition `π` of `ι`, and box `J`, `J ∈ π` if and only if `J = some box in π`.


theorem antitone_smul_left :
    ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : OrderedRing α] [inst_1 : OrderedAddCommGroup β]
      [inst_2 : Module α β] [inst_3 : PosSMulMono α β], a ≤ 0 → Antitone fun x => a • x :=
  by sorry

The theorem `antitone_smul_left` states that for any ordered ring `α`, ordered additive commutative group `β`, module `α β`, and positive scalar multiplication monotonic structure `PosSMulMono α β`, if a given element `a` of `α` is less than or equal to zero, then scalar multiplication by `a` is an antitone (or decreasing) function. In other words, if `a ≤ b`, then `a • x ≤ b • x` for all `x` in `β`.

For any ordered ring `α`, ordered additive commutative group `β`, module `α β`, and positive scalar multiplication monotonic structure `PosSMulMono α β`, if `a ≤ 0` in `α`, then for all `x` in `β`, `a • x ≤ 0 • x` or equivalently, `a • x ≤ b • x` for all `b ≥ a` in `α`.


theorem QuotientGroup.induction_on' :
    ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x := by
  sorry

This theorem, `QuotientGroup.induction_on'`, is a principle of mathematical induction for quotient groups in the context of group theory. Specifically, for any type `α` equipped with a group structure, and any subgroup `s` of `α`, it states that if a property `C` holds for every element `z` of the original group when considered as an element of the quotient group (that is, `C ↑z`), then `C` holds for every element `x` in the quotient group `α ⧸ s`.

If `C` is a property that holds for every coset `[x]` of a subgroup `s` in a group `α`, then `C` holds for every element `x` in `α` (in the quotient group `α ⧸ s`).


theorem deriv_eqOn :
    ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
      [inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {s : Set 𝕜} {f' : 𝕜 → F},
      IsOpen s → (∀ x ∈ s, HasDerivWithinAt f (f' x) s x) → Set.EqOn (deriv f) f' s :=
  by sorry

The theorem `deriv_eqOn` states that for any nontrivially normed field `𝕜`, normed additively commutative group `F`, and normed space over `𝕜` with `F`, given a function `f` from `𝕜` to `F`, a set `s` of `𝕜`, and another function `f'` from `𝕜` to `F`, if the set `s` is open in the topological space on `𝕜` and for every element `x` in `s`, the function `f` has a derivative within `s` at the point `x` equal to `f'(x)`, then the derivative of the function `f` is equal to the function `f'` on the set `s`. This means that on the open set `s`, the derivative of `f` at any point `x` in `s` is the same as the function value of `f'` at `x`.

If a function between a nontrivially normed field and a normed additively commutative group has derivatives equal to a given function on an open set where the domain is a nontrivially normed field, then the functions are equal on that open set.


theorem ENNReal.toReal_pos_iff_ne_top : ∀ (p : ENNReal) [inst : Fact (1 ≤ p)], 0 < p.toReal ↔ p ≠ ⊤ := by sorry

This theorem states that for any extended nonnegative real number `p` such that `p` is greater than or equal to 1, `p` is greater than 0 when converted to a standard real number if and only if `p` is not equal to positive infinity. This essentially relates the positivity of the real number representation of `p` to the condition that `p` is not the "top" element (which represents positive infinity) in the set of extended nonnegative real numbers.

For an extended nonnegative real number `p` greater than or equal to 1, `p` represents a positive real number if and only if `p` is finite.


theorem Set.Nontrivial.le_infsep_iff :
    ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {s : Set α} {d : ℝ},
      Set.Nontrivial s → (d ≤ Set.infsep s ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ dist x y) :=
  by sorry

This theorem states that for any type `α` that forms a pseudometric space, for any nontrivial set `s` of `α`, and for any real number `d`, the condition `d` being less than or equal to the infimum separation of `s` is equivalent to the condition that for any two distinct elements `x` and `y` in `s`, the distance between `x` and `y` is greater than or equal to `d`. Here, a set is nontrivial if it has at least two distinct elements, and the infimum separation of a set is the greatest lower bound of the distances between all pairs of distinct elements in the set.

For any pseudometric space `α` and nontrivial set `s` in `α`, the infimum separation of `s` equals the smallest distance `d` such that for all distinct `x, y` in `s`, the distance between `x` and `y` is greater than or equal to `d`.


theorem Polynomial.separable_def :
    ∀ {R : Type u} [inst : CommSemiring R] (f : Polynomial R),
      Polynomial.Separable f ↔ IsCoprime f (Polynomial.derivative f) :=
  by sorry

The theorem `Polynomial.separable_def` states that for any commutative semiring `R` and any polynomial `f` of `R`, `f` is separable if and only if `f` and its derivative are coprime. In the context of this theorem, being coprime is defined as the existence of two elements `a` and `b` such that `a * f + b * derivative of f = 1`. This theorem therefore provides a characterization of separable polynomials in terms of their relationship with their derivatives.

A polynomial over a commutative semiring is separable if and only if it and its derivative are coprime.


theorem Int.mul_ediv_assoc : ∀ (a : ℤ) {b c : ℤ}, c ∣ b → a * b / c = a * (b / c) := by sorry

This theorem is about the relationship between integer division and multiplication in the context of divisibility. It states that for any integers `a`, `b`, and `c`, if `c` divides `b` (denoted as `c ∣ b`), then the integer division of `a * b` by `c` is equal to `a` multiplied by the integer division of `b` by `c`. In mathematical notation, this would be expressed as: if `c` divides `b`, then `(a * b) / c = a * (b / c)`. This theorem, therefore, illustrates an important property of integer division when it involves divisible numbers.

If `c` divides `b`, then `(a * b) / c = a * (b / c)` for any integers `a`, `b`, and `c`.


theorem ENNReal.tendsto_coe :
    ∀ {α : Type u_1} {f : Filter α} {m : α → NNReal} {a : NNReal},
      Filter.Tendsto (fun a => ↑(m a)) f (nhds ↑a) ↔ Filter.Tendsto m f (nhds a) :=
  by sorry

This theorem, `ENNReal.tendsto_coe`, states that for any type `α`, any filter `f` on `α`, any function `m` from `α` to the nonnegative real numbers (NNReal), and any nonnegative real number `a`, the function `m` tends to the neighborhood filter of `a` with respect to the filter `f` if and only if the function that applies `m` and then takes the real part also tends to the neighborhood filter of the real part of `a` with respect to the filter `f`. In mathematical terms, $\lim_{x \to a} m(x) = a$ if and only if $\lim_{x \to a} \text{Re}(m(x)) = \text{Re}(a)$, where the limits are taken with respect to the filter `f`.

For any filter `f` on type `α`, function `m` from `α` to NNReal, and real number `a`, `m` tends to the neighborhood filter of `a` with respect to `f` if and only if the real part of `m` tends to the neighborhood filter of the real part of `a` with respect to `f`. In Lean notation: `ENNReal.tendsto_coe ∘ m ≃ₛ[f] a ↔ ENNReal.tendsto_coe (Real.map Re) ∘ m ≃ₛ[f] (Real.re a)`.


theorem Finset.image₂_inter_union_subset_union :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s s' : Finset α}
      {t t' : Finset β} [inst_1 : DecidableEq α] [inst_2 : DecidableEq β],
      Finset.image₂ f (s ∩ s') (t ∪ t') ⊆ Finset.image₂ f s t ∪ Finset.image₂ f s' t' :=
  by sorry

This theorem states that for any types `α`, `β`, `γ` with `γ` having decidable equality and any binary function `f` from `α` and `β` to `γ`, the image of the function `f` applied to the intersection of two sets `s` and `s'` of `α` and the union of two sets `t` and `t'` of `β` is a subset of the union of the image of `f` applied to `s` and `t` and the image of `f` applied to `s'` and `t'`. This is basically a statement about the behavior of images under intersection and union in the context of binary functions and finite sets.

For any types `α`, `β`, `γ` with `γ` having decidable equality, and sets `s ⊆ α`, `s' ⊆ α`, `t ⊆ β`, `t' ⊆ β`, and binary function `f : α × β → γ`, `f`( `s` ∩ `s'`) ⊆ `f`( `s` ∪ `t`) ∪ `f`( `s'` ∪ `t'`) holds.


theorem iSup_congr :
    ∀ {α : Type u_1} {ι : Sort u_5} [inst : SupSet α] {f g : ι → α}, (∀ (i : ι), f i = g i) → ⨆ i, f i = ⨆ i, g i := by
  sorry

This theorem, `iSup_congr`, states that for all types `α` and `ι`, where `α` has a supremum operation (`SupSet`), if we have two functions `f` and `g` from `ι` to `α`, then if every element `i` in `ι` maps to the same element in `α` under both `f` and `g` (i.e., `f i = g i` for all `i` in `ι`), the supremum over all values of `f i` is equal to the supremum over all values of `g i`. In other words, the supremum is invariant under pointwise equal functions.

If `f` and `g` are pointwise equal functions from an index set `ι` to a type `α` with a supremum operation, then `SupSet (f ↥ ι) = SupSet (g ↥ ι)`.


CategoryTheory.Limits.HasBiproduct.mk

theorem CategoryTheory.Limits.HasBiproduct.mk :
    ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
      [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C},
      CategoryTheory.Limits.LimitBicone F → CategoryTheory.Limits.HasBiproduct F :=
  by sorry

This theorem states that for any category `C` with zero morphisms and any indexed family of objects `F` in `C`, if a limit bicone exists for `F`, then `F` has a biproduct. In other words, it assures us the existence of a biproduct (a concept in category theory combining both a product and a coproduct) for every object in the category `C` whenever a limit bicone (a certain structure involving limits in category theory) exists for `F`.

If a category with zero morphisms has an indexed family of objects with a limit bicone, then each object in the family has a biproduct.


theorem MeasureTheory.withDensity_eq_iff_of_sigmaFinite :
    ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SigmaFinite μ]
      {f g : α → ENNReal},
      AEMeasurable f μ → AEMeasurable g μ → (μ.withDensity f = μ.withDensity g ↔ f =ᶠ[MeasureTheory.Measure.ae μ] g) :=
  by sorry

The theorem `MeasureTheory.withDensity_eq_iff_of_sigmaFinite` states that for any measure space `α` with a sigma-finite measure `μ`, and any two functions `f` and `g` from `α` to the extended nonnegative real numbers (`ENNReal`), if `f` and `g` are both almost everywhere measurable (i.e., each coincides almost everywhere with a measurable function), then the measure `μ` with density `f` is equal to the measure `μ` with density `g` if and only if `f` is equal to `g` almost everywhere with respect to the measure `μ`. In other words, two almost everywhere measurable functions contribute the same density to a sigma-finite measure if and only if they are equal almost everywhere.

For any sigma-finite measure space `α` and almost everywhere measurable functions `f` and `g` from `α` to the extended nonnegative real numbers, `μ{f} = μ{g}` if and only if `f = g` almost everywhere with respect to `μ`.


theorem lt_or_lt_of_add_lt_add :
    ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Add α]
      [inst_2 : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a₁ a₂ b₁ b₂ : α},
      a₁ + b₁ < a₂ + b₂ → a₁ < a₂ ∨ b₁ < b₂ :=
  by sorry

This theorem, named `lt_or_lt_of_add_lt_add`, states that for any type `α` that has a linear order, an addition operation, and satisfies certain covariance properties, given four elements `a₁, a₂, b₁, b₂` of type `α`, if the sum of `a₁` and `b₁` is less than the sum of `a₂` and `b₂`, then either `a₁` is less than `a₂` or `b₁` is less than `b₂`. In other words, if the sum of two pairs of elements is in a certain order, then at least one element from each pair must also be in that order. The covariance properties ensure that the order and addition operations are compatible in a particular way.

If `α` is a type with a linear order and an additive structure satisfying covariance properties, then for all `a₁, a₂, b₁, b₂` in `α`, if `a₁ + b₁ < a₂ + b₂`, then either `a₁ < a₂` or `b₁ < b₂`.


theorem isGLB_singleton : ∀ {α : Type u} [inst : Preorder α] {a : α}, IsGLB {a} a := by sorry

This theorem states that for any type `α` equipped with a preorder, and for any element `a` of `α`, `a` is the greatest lower bound of the singleton set containing just `a`. In other words, if we consider the set that contains only the element `a`, there does not exist any lower bound which is strictly greater than `a`.

For any preordered type `α` and its element `a`, `a` is the greatest lower bound of the singleton set `{a}`.


theorem List.get?_eq_none : ∀ {α : Type u_1} {l : List α} {n : ℕ}, List.get? l n = none ↔ List.length l ≤ n := by sorry

The theorem `List.get?_eq_none` states that for any type `α`, any list `l` of `α`, and any natural number `n`, the function `List.get? l n` will return `none` if and only if the length of the list `l` is less than or equal to `n`. This means that you cannot access an element at an index in the list that is greater than or equal to the length of the list.

For any type α, list l of length n in α, and natural number m, if m > n then List.get? l m equals none.


AEMeasurable.congr

theorem AEMeasurable.congr :
    ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : MeasurableSpace β] {f g : α → β}
      {μ : MeasureTheory.Measure α}, AEMeasurable f μ → f =ᶠ[MeasureTheory.Measure.ae μ] g → AEMeasurable g μ :=
  by sorry

This theorem states that for any two functions `f` and `g` from a measurable space `α` to another measurable space `β`, along with a measure `μ` on `α`, if the function `f` is almost everywhere measurable with respect to measure `μ` and `f` is almost everywhere equal to `g` (in the measure-theoretic sense), then `g` is also almost everywhere measurable with respect to the same measure `μ`.

In simpler terms, if two functions are almost everywhere the same, and one of them is known to be almost everywhere measurable, then the other function must also be almost everywhere measurable.

If two functions from a measurable space to another, with respect to a given measure, are almost everywhere equal and one is almost everywhere measurable, then the other is also almost everywhere measurable.


theorem Real.arcsin_le_pi_div_two : ∀ (x : ℝ), Real.arcsin x ≤ Real.pi / 2 := by sorry

This theorem states that for any real number `x`, the arcsine of `x` (denoted as `Real.arcsin x` in Lean 4) is less than or equal to half of the mathematical constant π (denoted as `Real.pi / 2` in Lean 4). The arcsine function in Lean 4 returns values in the range `-π / 2 ≤ arcsin x ≤ π / 2`, and this theorem confirms the upper bound of this range.

For all real numbers x, the arcsine of x (arcsin x) is bounded above by π/2.


theorem LinearMap.ker_eq_bot' :
    ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_6} {M₂ : Type u_8} [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₂} {F : Type u_12} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] {f : F},
      LinearMap.ker f = ⊥ ↔ ∀ (m : M), f m = 0 → m = 0 :=
  by sorry

The theorem `LinearMap.ker_eq_bot'` states that for any types `R`, `R₂`, `M`, `M₂`, and `F`, given two semirings `R` and `R₂`, two additively commutative monoids `M` and `M₂`, modules `M` over `R` and `M₂` over `R₂`, a ring homomorphism `τ₁₂` from `R` to `R₂`, a type `F` which is a function-like from `M` to `M₂` and a semilinear map `f` from `M` to `M₂`, the kernel of the linear map `f` is the zero submodule if and only if for every element `m` of `M`, the implication is true that if `f m` equals zero then `m` equals zero. This theorem essentially describes the condition for a linear map to be injective or, equivalently, for its kernel to only contain the zero element.

The kernel of a semilinear map between modules over commutative rings is the zero submodule if and only if it maps every non-zero element to a non-zero image.


theorem Matrix.toLin'_one :
    ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_5} [inst_1 : DecidableEq n] [inst_2 : Fintype n],
      Matrix.toLin' 1 = LinearMap.id :=
  by sorry

This theorem states that for any commutative semiring `R` and any finite type `n` with decidable equality, the linear transformation corresponding to the identity matrix (denoted as `1` in Lean 4) is the identity linear map. In other words, the matrix-linear map correspondence preserves the notion of identity: just as multiplying by the identity matrix leaves a matrix unchanged, applying the identity linear map leaves a vector unchanged. This theorem thus connects the algebraic concept of identity with its counterpart in linear algebra.

For any commutative semiring `R` and finite type `n` with decidable equality, the identity matrix `1` in `R` corresponds to the identity linear map in the matrix-linear map correspondence.


theorem frobenius_inj :
    ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsReduced R] (p : ℕ) [inst_2 : ExpChar R p],
      Function.Injective ⇑(frobenius R p) :=
  by sorry

The theorem `frobenius_inj` states that for any type `R` which is a commutative ring and is reduced, and for any natural number `p` such that `R` has characteristic `p`, the Frobenius map that sends each element `x` in `R` to `x^p` is injective. This means that if `x^p = y^p` for some `x` and `y` in `R`, then `x = y`.

In a commutative, reduced ring `R` of characteristic `p`, the `p`-th power map is an injective homomorphism.


theorem toIocMod_mem_Ioc :
    ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroup α] [hα : Archimedean α] {p : α} (hp : 0 < p) (a b : α),
      toIocMod hp a b ∈ Set.Ioc a (a + p) :=
  by sorry

This theorem states that for any type `α` which forms a Linear Ordered Additive Commutative Group and is Archimedean, and for any positive `p`, given any `a` and `b` of type `α`, the result of the function `toIocMod` applied to `hp` (which is the proof that `p` is positive), `a`, and `b` will always be an element of the set `Set.Ioc` from `a` to `a + p`. In mathematical terms, you could say that the function `toIocMod` maps any `b` into the half-open interval `(a, a + p]`.

For any Archimedean Linear Ordered Additive Commutative Group `α` and positive `p` in `α`, the image of `b` under the `toIocMod` function lies in the half-open interval `(a, a + p]` for all `a` in `α`.


theorem Real.arcsin.proof_2 : -1 ≤ 1 := by sorry

This theorem establishes the basic numerical fact that negative one is less than or equal to positive one in the domain of real numbers. In mathematical notation, it simply is stating that $-1 \leq 1$. While this may seem obvious, in formal theorem proving, even these sorts of basic facts need to be established as theorems.

The theorem asserts that $-1 \leq 1$ in the realm of real numbers.


theorem MeasureTheory.Measure.absolutelyContinuous_of_le :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
      μ ≤ ν → MeasureTheory.Measure.AbsolutelyContinuous μ ν :=
  by sorry

This theorem states that, for any type `α` and any `MeasurableSpace` of `α`, and for any two measures `μ` and `ν` over `α`, if `μ` is less than or equal to `ν`, then `μ` is absolutely continuous with respect to `ν`. Here, being absolutely continuous means that for any set `s` of `α`, if `ν` measures `s` as having measure zero, then `μ` also measures `s` as having measure zero.

If `μ` is a measure that is less than or equal to `ν` for any two measures `μ` and `ν` over a `MeasurableSpace` `α`, then `μ` is absolutely continuous with respect to `ν`.


theorem ENNReal.tendsto_nat_nhds_top : Filter.Tendsto (fun n => ↑n) Filter.atTop (nhds ⊤) := by sorry

This theorem states that the sequence of natural numbers, when converted to extended non-negative real numbers (that's what `↑n` means), tends to infinity (`nhds ⊤`). More formally, for every neighborhood `U` of infinity in the extended non-negative real numbers, there exists a natural number `N` such that for all natural numbers `n` greater than `N`, `n` is an element of `U`. The function `Filter.Tendsto` is used to express this concept of limit in Lean 4. This theorem is usually used when dealing with sequences or functions that grow without bounds in the context of extended real numbers.

Given any neighborhood U of infinity in the extended non-negative real numbers, there exists a natural number N such that all natural numbers greater than N lie in U. (In Lean 4, this is expressed using the `Filter.Tendsto` function.)


theorem Polynomial.eval_nat_cast : ∀ {R : Type u} [inst : Semiring R] {x : R} {n : ℕ}, Polynomial.eval x ↑n = ↑n := by
  sorry

The theorem `Polynomial.eval_nat_cast` states that for any semiring `R`, any element `x` from `R`, and any natural number `n`, the evaluation of the polynomial represented by the natural number `n` (when `n` is interpreted as a constant polynomial) at the point `x` is equal to `n`. The result is expressed in `R` by casting `n` into `R`. Essentially, it says that a constant polynomial evaluated at any point will always yield the constant itself.

For any semiring R and its element x, the evaluation of the constant polynomial represented by a natural number n at x is equal to the value of the natural number n when cast into R.


/-- `zeroLocus` and `vanishingIdeal` form a galois connection.  -/
theorem PrimeSpectrum.gc_set :
    ∀ (R : Type u) [inst : CommSemiring R],
      GaloisConnection (fun s => PrimeSpectrum.zeroLocus s) fun t => ↑(PrimeSpectrum.vanishingIdeal t) :=
  by sorry

The theorem `PrimeSpectrum.gc_set` states that for any commutative semiring `R`, the functions `PrimeSpectrum.zeroLocus` and the coercion of `PrimeSpectrum.vanishingIdeal` form a Galois connection. In other words, for every set `s` and every topological space `t` in the prime spectrum of `R`, `PrimeSpectrum.zeroLocus s` is less than or equal to `t` if and only if `s` is less than or equal to the vanishing ideal of `t`.

The functions `PrimeSpectrum.zeroLocus` and the coercion of `PrimeSpectrum.vanishingIdeal` form a Galois connection in the prime spectrum of any commutative semiring `R`. That is, for all sets `s` and topological spaces `t`, `PrimeSpectrum.zeroLocus s ⇐ t` if and only if `s ⊆ vanishingIdeal t`.


theorem Filter.le_lift :
    ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} {h : Filter β},
      h ≤ Filter.lift f g ↔ ∀ s ∈ f, h ≤ g s :=
  by sorry

The theorem `Filter.le_lift` states that for any types `α` and `β`, any filter `f` on `α`, any function `g` from sets of `α` to filters on `β`, and any filter `h` on `β`, the filter `h` is less than or equal to the filter obtained by lifting `f` via `g` if and only if, for all sets `s` in the filter `f`, `h` is less than or equal to the filter `g(s)`. In other words, it provides a condition for a filter on `β` to be below the push-forward of a filter on `α` along a function mapping each set to a filter.

For filters $f$ on type $\alpha$, functions $g$ from sets of $\alpha$ to filters on type $\beta$, and filters $h$ on $\beta$, $h \leq \bigl(\mathop{\mathrm{lift}}_{\alpha \rightarrow \beta} f\bigr) (g) \iff \forall s \in f, h \leq g(s)$.


theorem differentiableWithinAt_univ :
    ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
      [inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
      {x : E}, DifferentiableWithinAt 𝕜 f Set.univ x ↔ DifferentiableAt 𝕜 f x :=
  by sorry

The theorem `differentiableWithinAt_univ` states that for any nontrivially normed field `𝕜`, any normed additive commutative groups `E` and `F` which are also normed spaces over `𝕜`, any function `f` from `E` to `F`, and any point `x` in `E`, the function `f` is differentiable at the point `x` within the universal set (which includes all elements of `E`) if and only if `f` is differentiable at the point `x`. Basically, being differentiable everywhere is equivalent to being differentiable at a particular point.

For any nontrivially normed field `𝕜`, and normed additive commutative groups `E` and `F` over `𝕜` as normed spaces, a function `f` from `E` to `F` is differentiable at every point `x` in `E` if and only if it is differentiable at `x`.


theorem Finset.disjoint_coe : ∀ {α : Type u_1} {s t : Finset α}, Disjoint ↑s ↑t ↔ Disjoint s t := by sorry

This theorem states that for any two finsets `s` and `t` of some type `α`, the property of the coerced sets `↑s` and `↑t` being disjoint is equivalent to the property of the finsets `s` and `t` themselves being disjoint. In the context of lattice theory, two elements are considered disjoint if their infimum (greatest lower bound) is the bottom element; this theorem generalizes this concept to finsets. The disjointness checks whether any element `x` that is less than or equal to both `s` and `t` must be less than or equal to the bottom element `⊥`.

For any finsets `s` and `t` of type `α` in Lean 4, `s` and `t` are disjoint if and only if their coerced sets `↑s` and `↑t` have no common element, i.e., their infimum is the bottom element.


/-- If an element `a` divides another element `b` in a ring, `a` divides the sum of `b` and another
element `c` iff `a` divides `c`.  -/
theorem dvd_add_right : ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ b → (a ∣ b + c ↔ a ∣ c) := by sorry

This theorem states that, in any non-unital ring, if a given element 'a' divides another element 'b', then 'a' divides the sum of 'b' and another element 'c' if and only if 'a' divides 'c'. This means that the divisibility of 'a' in the sum 'b + c' solely depends on its divisibility in 'c' when 'a' is already a divisor of 'b'.

In a non-unital ring, if 'a' divides 'b', then 'a' divides 'b + c' if and only if 'a' divides 'c'.


theorem Real.log_pos_iff : ∀ {x : ℝ}, 0 < x → (0 < Real.log x ↔ 1 < x) := by sorry

This theorem states that for any real number `x`, if `x` is greater than `0`, then the real logarithm of `x` is positive if and only if `x` is greater than `1`. This establishes a connection between the positivity of logarithm values and the magnitude of their inputs in relation to `1`, given the precondition that these inputs are positive.

For any real number `x` greater than `0`, the natural logarithm of `x` is positive if and only if `x` is greater than `1`.


theorem AddSubgroup.coe_add : ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) (x y : ↥H), ↑(x + y) = ↑x + ↑y :=
  by sorry

This theorem states that for any additive group `G` and any additive subgroup `H` of `G`, the sum of two elements `x` and `y` in the subgroup `H` is the same whether the sum is computed inside the subgroup or in the containing group. In other words, the act of summing two elements is the same regardless if it's done in the larger group `G` or the subgroup `H`; the coercion of the sum from the subgroup to the group is the same as the sum of the individual coercions.

For any additive group G and additive subgroup H, the sum of two elements in H is equal to their sum in G.


theorem MeasureTheory.norm_integral_le_integral_norm :
    ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
      {μ : MeasureTheory.Measure α} (f : α → G), ‖∫ (a : α), f a ∂μ‖ ≤ ∫ (a : α), ‖f a‖ ∂μ :=
  by sorry

The theorem `MeasureTheory.norm_integral_le_integral_norm` states that for any normed additive commutative group `G` and any normed space `G` over the reals `ℝ`, given a measurable space `α` and a measure `μ` on that space, the norm of the integral of a function `f` from `α` to `G` with respect to `μ` is less than or equal to the integral of the norm of `f` with respect to `μ`. This is a formal statement of the inequality of integrals in the context of measure theory, and it is a specific instance of the more general principle that the "size" of the integral (as measured by the norm) is controlled by the integral of the "sizes" (norms) of the function values.

For any measurable space `(α, Σ, μ)`, normed additive commutative group `G` over the reals `ℝ`, and measurable function `f : α → G`, the integral of the norm of `f` with respect to `μ` is greater than or equal to the norm of the integral of `f` with respect to `μ`. (The theorem in the given statement is actually the negative of this, which is why the inequality is reversed.)


theorem Pretrivialization.coe_fst :
    ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
      {proj : Z → B} (e : Pretrivialization F proj) {x : Z}, x ∈ e.source → (↑e x).1 = proj x :=
  by sorry

This theorem states that for any given types `B`, `F`, and `Z`, where `B` and `F` are topological spaces, a projection function `proj` from `Z` to `B`, a `Pretrivialization` `e` of `F` with respect to `proj`, and any given `x` of type `Z` that belongs to `e.source`, the first component of the tuple obtained by applying `e` to `x` (denoted (↑e x).1) is equal to the result of applying the projection function `proj` to `x`. Essentially, it asserts that the pretrivialization of a point `x` in its source set preserves the original projection in its first component.

For any `B`, `F`, `Z`, `proj`: a continuous function from `Z` to `B`, `Pretrivialization` `e` of `F` over `proj`, and `x` in `e.source`, (↑e x).1 = proj x.


/-- Fixed size neighborhoods of the diagonal belong to the uniform structure  -/
theorem edist_mem_uniformity :
    ∀ {α : Type u} [inst : PseudoEMetricSpace α] {ε : ENNReal}, 0 < ε → {p | edist p.1 p.2 < ε} ∈ uniformity α := by
  sorry

This theorem, titled "edist_mem_uniformity", asserts that for any type `α` that is a PseudoEMetricSpace (a type of metric space that might include infinite distances), and for any extended nonnegative real number `ε` that is greater than zero, the set of all pairs `p` such that the extended distance between the two elements of `p` is less than `ε`, is a member of the uniformity of `α`. A uniformity is a structure that encapsulates the concept of being "uniformly close" in a uniform space, and in this case, it's saying that such pairs are close in the sense defined by the uniform structure of this space. This is a fundamental property in the study of metric and topological spaces.

For any PseudoEMetricSpace α and ε > 0, the set of pairs p with edist α p < ε is a uniformity open subset of α.


theorem Finset.sum_range :
    ∀ {β : Type u_2} [inst : AddCommMonoid β] {n : ℕ} (f : ℕ → β),
      (Finset.sum (Finset.range n) fun i => f i) = Finset.sum Finset.univ fun i => f ↑i :=
  by sorry

This theorem, named `Finset.sum_range`, states that for any given type `β` that is an additive commutative monoid, any natural number `n`, and any function `f` from natural numbers to `β`, the sum of the function `f` over the range of natural numbers less than `n` is equal to the sum of the function `f` over all elements in the universal finite set of natural numbers. Concretely, if we apply the function `f` to each natural number less than `n` and take the sum, it will be the same as if we applied `f` to every natural number in the finite universal set and summed the results.

For any additive commutative monoid type `β`, natural number `n`, and function `f` from natural numbers to `β`, the sum of `f` over the finite set of natural numbers less than `n` equals the sum of `f` over the universal set of natural numbers.


theorem Nat.sInf_le : ∀ {s : Set ℕ} {m : ℕ}, m ∈ s → sInf s ≤ m := by sorry

This theorem states that for any set of natural numbers `s` and any natural number `m`, if `m` is an element of the set `s`, then the infimum (greatest lower bound) of the set `s` is less than or equal to `m`. The function `sInf s` returns the infimum of the set `s`. This implies that `m` is greater than or equal to the smallest natural number in the set `s`, which is the definition of the infimum in the context of natural numbers.

For any set of natural numbers `s` and natural number `m`, if `m` is an element of `s`, then the infimum of `s` is less than or equal to `m`. (In other words, `inf s <= m` whenever `m` is in `s`.)


theorem eq_true_of_decide : ∀ {p : Prop} {x : Decidable p}, decide p = true → p = True := by sorry

This theorem, `eq_true_of_decide`, states that for any proposition `p` and any instance `x` of `Decidable p` (i.e., `p` is a decidable proposition), if the `decide` function returns `true` when applied to `p`, then `p` must be equivalent to `True`. In other words, if our decision-making process declares `p` to be `true`, then `p` is indeed a true proposition.

If `p` is a decidable proposition and `decide p` returns `true`, then `p ≡ True`.


IsAddUnit.map

theorem IsAddUnit.map :
    ∀ {F : Type u_1} {M : Type u_4} {N : Type u_5} [inst : FunLike F M N] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
      [inst_3 : AddMonoidHomClass F M N] (f : F) {x : M}, IsAddUnit x → IsAddUnit (f x) :=
  by sorry

The theorem `IsAddUnit.map` states that for any types `F`, `M`, and `N`, if `F` is a function-like object mapping from `M` to `N`, `M` and `N` are both addmonoids, and `F` is a homomorphism between these addmonoids, then for any function `f` of type `F` and any element `x` of type `M`, if `x` is an additive unit in `M` (i.e., it has a two-sided additive inverse), the image of `x` under `f` is also an additive unit in `N`. In other words, homomorphisms preserve the property of being an additive unit.

If `F` is a homomorphism between addmonoids `M` and `N`, and `x` is an additive unit in `M`, then `F(x)` is an additive unit in `N`.


/-- A subring contains the ring's 0.  -/
theorem Subring.zero_mem : ∀ {R : Type u} [inst : Ring R] (s : Subring R), 0 ∈ s := by sorry

This theorem states that for any given ring `R`, the zero element of that ring is always a member of any subring `s` of `R`. In other words, it confirms that zero, which is an identity element of addition in the ring, is also included in all of its subrings, in accordance with the definition of a subring in ring theory.

For any subring `s` of a ring `R`, the additive identity (zero) of `R` is an element of `s`.


theorem NonUnitalSubring.gc_map_comap :
    ∀ {F : Type w} {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S]
      [inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] (f : F),
      GaloisConnection (NonUnitalSubring.map f) (NonUnitalSubring.comap f) :=
  by sorry

The theorem `NonUnitalSubring.gc_map_comap` states that for all types `F`, `R`, `S`, where `R` and `S` are non-unital non-associative rings, `F` is a function-like object from `R` to `S`, and `F` forms a non-unital ring homomorphism between `R` and `S`; for any term `f` of type `F`, there is a Galois connection between the `map` operation and `comap` operation on non-unital subrings induced by `f`. In other words, for any two subrings `a` of `R` and `b` of `S`, `a` is mapped to a subring less than or equal to `b` if and only if `a` is less than or equal to the preimage of `b` under the homomorphism `f`.

For any non-unital non-associative rings R, S, and a function-like object F from R to S that is a non-unital ring homomorphism, there is a Galois connection between the map and comap operations on non-unital subrings of R and S induced by F.


theorem Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle._auxLemma.9 :
    ∀ {M : Type u} [inst : AddMonoid M] (a : M), a + a = 2 • a := by sorry

This theorem states that for any type `M` that has an `AddMonoid` instance, for any element `a` of type `M`, the sum of `a` and `a` is equal to two times `a`. In mathematical terms, it means that for any element in an additive monoid, doubling the element through addition is the same as scalar multiplication by 2.

For any additive monoid `M` and element `a` in `M`, the operation of adding `a` to itself twice is equivalent to multiplying `a` by 2. (Or, more concisely: `2 * a = a + a` for all `a` in an additive monoid.)


/-- A cardinal lifted to the zero universe equals itself.  -/
theorem Cardinal.lift_uzero : ∀ (a : Cardinal.{u}), Cardinal.lift.{0, u} a = a := by sorry

This theorem states that for any cardinal number `a` in any universe `u`, lifting `a` to the zero universe results in `a` itself. In other words, the operation of lifting a cardinal to the zero universe is an identity operation. It doesn't change the cardinal number. This is formally represented in Lean 4 as `Cardinal.lift.{0, u} a = a` for any `a : Cardinal.{u}`.

For any cardinal number `a` in any universe, the operation of lifting `a` to the zero universe results in `a` itself. In Lean 4 notation: `Cardinal.lift.{0, u} a = a` for any `a : Cardinal.{u}` .


/-- **Darboux's theorem**: the image of a `Set.OrdConnected` set under `f'` is a `Set.OrdConnected`
set, `HasDerivWithinAt` version.  -/
theorem Set.OrdConnected.image_hasDerivWithinAt :
    ∀ {f f' : ℝ → ℝ} {s : Set ℝ},
      Set.OrdConnected s → (∀ x ∈ s, HasDerivWithinAt f (f' x) s x) → Set.OrdConnected (f' '' s) :=
  by sorry

**Darboux's theorem** states that if a set `s` of real numbers is connected in order (that is, for any two numbers in the set, all numbers between them are also in the set), and a function `f` has a derivative `f'` within the set `s` at each point `x` in `s`, then the image of the set `s` under the function `f'` is also connected in order. In other words, the derivative `f'` preserves the order connectedness property of the set `s`.

If a connected-in-order set of real numbers `s` and its continuous derivative `f'` are defined over `s`, then the image `f'(s)` is also a connected-in-order set.


theorem PartialHomeomorph.IsImage.symm_iff :
    ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
      {e : PartialHomeomorph X Y} {s : Set X} {t : Set Y},
      PartialHomeomorph.IsImage (PartialHomeomorph.symm e) t s ↔ PartialHomeomorph.IsImage e s t :=
  by sorry

This theorem states that for any given partial homeomorphism `e` between two topological spaces `X` and `Y`, and any two sets `s` in `X` and `t` in `Y`, the set `t` is an image of the set `s` under the inverse of the homeomorphism `e` if and only if the set `s` is an image of the set `t` under the homeomorphism `e`. Intuitively, this theorem provides a condition for when we can reverse the direction of mapping by a homeomorphism when considering images of sets.

For any partial homeomorphism between topological spaces, the inverse image and image of two sets are equal if and only if the sets are each other's images under that homeomorphism.


/-- Reorder a sum.

The difference with `Finset.sum_nbij` is that the bijection is specified with an inverse, rather
than as a surjective injection.

The difference with `Finset.sum_bij'` is that the bijection and its inverse are non-dependent
functions, rather than being allowed to use membership of the domains of the sums.

The difference with `Finset.sum_equiv` is that bijectivity is only required to hold on the domains
of the sums, rather than on the entire types. -/
theorem Finset.sum_nbij' :
    ∀ {ι : Type u_6} {κ : Type u_7} {α : Type u_8} [inst : AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α}
      {g : κ → α} (i : ι → κ) (j : κ → ι),
      (∀ a ∈ s, i a ∈ t) →
        (∀ a ∈ t, j a ∈ s) →
          (∀ a ∈ s, j (i a) = a) →
            (∀ a ∈ t, i (j a) = a) →
              (∀ a ∈ s, f a = g (i a)) → (Finset.sum s fun x => f x) = Finset.sum t fun x => g x :=
  by sorry

This theorem, named `Finset.sum_nbij'`, states that for any two finite sets `s` and `t`, each element of `s` and `t` are associated with a function `f: ι → α` and `g: κ → α`, respectively, where `ι` and `κ` are the types of elements in `s` and `t` respectively, and `α` is a set equipped with an addition and a zero element (an additive commutative monoid). If there exist two functions `i: ι → κ` and `j: κ → ι` such that `i` maps each element of `s` into `t`, `j` maps each element of `t` into `s`, the composition of `j` and `i` is the identity on `s`, the composition of `i` and `j` is the identity on `t`, and `f` and `g ∘ i` are equal on `s`, then the sum of the values of `f` over `s` equals the sum of the values of `g` over `t`.

This theorem is a variant of other similar theorems about reordering the sum over a finite set, with the key difference being the specific way in which the bijection between the sets is specified and the requirements for the bijection's properties.

If two finite sets `s` and `t` have a bijection `i: s ≃ t` such that the functions `f: s → α` and `g: t → α` satisfy `f = g ∘ i` and the bijection properties hold, then `∑ x in s, f x = ∑ y in t, g y`.


theorem Filter.Eventually.prod_nhds :
    ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X → Prop} {q : Y → Prop}
      {x : X} {y : Y},
      (∀ᶠ (x : X) in nhds x, p x) → (∀ᶠ (y : Y) in nhds y, q y) → ∀ᶠ (z : X × Y) in nhds (x, y), p z.1 ∧ q z.2 :=
  by sorry

The theorem `Filter.Eventually.prod_nhds` states that for any two types `X` and `Y` with topological space structures, given predicates `p` and `q` on `X` and `Y` respectively, and points `x` in `X` and `y` in `Y`, if all points sufficiently close to `x` (in the sense of the neighborhood filter) satisfy predicate `p`, and all points sufficiently close to `y` satisfy predicate `q`, then all points sufficiently close to the pair `(x, y)` (in the Cartesian product topology) will satisfy both `p` on the first component and `q` on the second component. That is, neighborhood properties of individual points extend naturally to the product topology.

For any topological spaces X and Y, and points x in X and y in Y with predicates p on X and q on Y such that p holds for all points near x and q holds for all points near y, the predicates p and q hold for all points near the pair (x, y) in the product topology.


ContMDiff.contMDiffOn

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

The theorem `ContMDiff.contMDiffOn` asserts that for every nontrivially normed field `𝕜`, normed add-commutative groups `E` and `E'`, normed spaces `𝕜E` and `𝕜E'`, topological spaces `H`, `M`, `H'`, `M'`, models with corners `I` and `I'`, and charted spaces `H'M'` and `HM`, if a function `f` from `M` to `M'` is continuously differentiable to any order `n`, then it is also continuously differentiable to the same order `n` on any subset `s` of `M`. In other words, if a function is continuously differentiable everywhere, it remains continuously differentiable when restricted to any subset of its domain.

If a function is continuously differentiable of order `n` on a normed space, then it is also continuously differentiable of order `n` on any subset of its domain.


PartialEquiv.IsImage.symm

theorem PartialEquiv.IsImage.symm :
    ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
      PartialEquiv.IsImage e s t → PartialEquiv.IsImage (PartialEquiv.symm e) t s :=
  by sorry

This theorem states that given any types `α` and `β`, a partial equivalence `e` between these types, and sets `s` of type `α` and `t` of type `β`, if `t` is an image of `s` under the partial equivalence `e`, then `s` is also an image of `t` under the inverse of the partial equivalence `e`. In other words, the image relationship under a partial equivalence and its inverse is symmetric.

If `e` is a partial equivalence between types `α` and `β`, and `s` of type `α` is the image of `t` of type `β` under `e`, then `t` is the image of `s` under the inverse of `e`.


theorem MeasureTheory.Measure.lintegral_rnDeriv_lt_top :
    ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [inst : MeasureTheory.IsFiniteMeasure μ],
      ∫⁻ (x : α), μ.rnDeriv ν x ∂ν < ⊤ :=
  by sorry

This theorem states that for any type `α` and measurable space `m` on `α`, for any two measures `μ` and `ν` on `α`, if `μ` is a finite measure, then the Lebesgue integral of the Radon-Nikodym derivative of `μ` with respect to `ν` over the entire space `α` is less than infinity. This is essentially saying that the total "weight" of the Radon-Nikodym derivative is finite under the given conditions.

For any measurable spaces `(α, Σ)` and measures `μ, ν` on `α` with `μ` finite, the integral of the Radon-Nikodym derivative of `μ` with respect to `ν` over `α` is finite.


theorem Real.sqrt_eq_zero_of_nonpos : ∀ {x : ℝ}, x ≤ 0 → Real.sqrt x = 0 := by sorry

The theorem `Real.sqrt_eq_zero_of_nonpos` asserts that for any real number `x`, if `x` is less than or equal to zero, then the square root of `x` is equal to zero. In mathematical notation, this can be stated as: for all \(x \in \mathbb{R}\), if \(x \leq 0\), then \(\sqrt{x} = 0\).

For all real numbers x, if x ≤ 0 then √x = 0.


theorem Sum.Lex.inr_le_inr_iff :
    ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a b : β},
      toLex (Sum.inr a) ≤ toLex (Sum.inr b) ↔ a ≤ b :=
  by sorry

This theorem, `Sum.Lex.inr_le_inr_iff`, asserts that for any two types `α` and `β` with a less than or equal to order (`LE`), and for any two elements `a` and `b` of type `β`, the `toLex` function applied to `Sum.inr a` is less than or equal to the `toLex` function applied to `Sum.inr b` if and only if `a` is less than or equal to `b`. Here, `Sum.inr` is a function that injects `β` into the sum type `α ⊕ β`. The `toLex` function is an identity function that maps elements of a type to their lexicographical ordering.

For all types `α ≤ β` and elements `a ∈ β`, `toLex (Sum.inr a) ≤ toLex (Sum.inr b)` if and only if `a ≤ b` in `β`.


theorem Mathlib.GroupTheory.Submonoid.Basic._auxLemma.8 :
    ∀ {M : Type u_1} [inst : MulOneClass M] {x : M}, (x ∈ ⊥) = (x = 1) := by sorry

This theorem states that for any type `M` which has a structure of `MulOneClass` (meaning it has multiplication and a multiplicative identity), a given element `x` of type `M` belongs to the trivial subgroup (denoted by `⊥`) if and only if `x` is equal to the multiplicative identity (denoted by `1`). In mathematical terms, for any element `x` in a multiplication-inclusive set with identity, `x` is in the trivial group if and only if `x` equals the identity.

For any type `M` with multiplication and identity, an element `x` in `M` lies in the trivial subgroup if and only if `x = 1`.


theorem Mathlib.GroupTheory.Submonoid.Basic._auxLemma.9 :
    ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, (x ∈ ⊥) = (x = 0) := by sorry

This theorem from the Mathlib Group Theory Submonoid Basic states that for any type `M` which has an `AddZeroClass` instance (which means it has addition and zero elements), for any element `x` of `M`, `x` belongs to the bottom submonoid (`⊥`) if and only if `x` is the zero element. Here, `⊥` represents the trivial submonoid consisting only of the zero element. This theorem is essentially saying that the only element in the trivial submonoid is zero.

For any additive type M, an element x belongs to the trivial submonoid if and only if x is the additive zero.


theorem Prod.mk.inj_right : ∀ {α : Type u_5} {β : Type u_6} (b : β), Function.Injective fun a => (a, b) := by sorry

The theorem `Prod.mk.inj_right` states that for all types `α` and `β`, and for any given value `b` of type `β`, the function that takes an input `a` of type `α` and pairs it with `b` to form a tuple `(a, b)` is injective. In other words, if this function maps two different inputs from `α` to the same tuple `(a, b)`, then those two inputs must have been the same to begin with. This is a particular case of injectivity where the second component of the tuple is kept constant.

For any types `α` and `β`, the function that maps `α` to the tuple `(-, b)` with a fixed `β` value `b` is an injection.


theorem compl_iInf :
    ∀ {α : Type u} {ι : Sort w} [inst : CompleteBooleanAlgebra α] {f : ι → α}, (iInf f)ᶜ = ⨆ i, (f i)ᶜ := by sorry

The theorem `compl_iInf` states that for any type `α` that forms a complete Boolean algebra and a function `f` from any sort `ι` to `α`, the complement of the indexed infimum of `f` is equal to the indexed supremum of the complement of `f`. In mathematical terms, this can be written as: for all `ι` and `α` such that `α` is a complete Boolean algebra, and any function `f: ι → α`, it holds that `(iInf f)ᶜ = ⨆ i, (f i)ᶜ`. This theorem captures the duality between the supremum and infimum operations in the context of a complete Boolean algebra.

In a complete Boolean algebra, the complement of the indexed infimum of a function equals the indexed supremum of the complements.


theorem map_wittStructureInt :
    ∀ (p : ℕ) {idx : Type u_2} [hp : Fact (Nat.Prime p)] (Φ : MvPolynomial idx ℤ) (n : ℕ),
      (MvPolynomial.map (Int.castRingHom ℚ)) (wittStructureInt p Φ n) =
        wittStructureRat p ((MvPolynomial.map (Int.castRingHom ℚ)) Φ) n :=
  by sorry

The theorem `map_wittStructureInt` states that for any natural number `p`, which is a prime number, any multivariate polynomial `Φ` with coefficients in integers, and any natural number `n`, the multivariate polynomial obtained by mapping the Witt structure of `Φ` over integers to rational numbers (`ℚ`) using the ring homomorphism function (`Int.castRingHom ℚ`), is equal to the Witt structure of the multivariate polynomial obtained by mapping `Φ` itself to rational numbers. This theorem provides a link between the Witt structure of a polynomial over integers and its counterpart over rational numbers using a ring homomorphism.

For any prime number p and multivariate polynomial Φ with integer coefficients, the Witt structure of Φ mapped to rational numbers via Int.castRingHom equals the Witt structure of Φ mapped to rational numbers directly.


theorem AlgHom.mem_range :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
      [inst_3 : Semiring B] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) {y : B}, y ∈ AlgHom.range φ ↔ ∃ x, φ x = y :=
  by sorry

The theorem `AlgHom.mem_range` states that for any commutative semiring `R`, semirings `A` and `B`, and algebra structures over `A` and `B`, given an algebra homomorphism `φ` from `A` to `B` and an element `y` of `B`, `y` belongs to the range of `φ` if and only if there exists an element `x` in `A` such that `φ(x) = y`. In other words, it is checking whether a particular element of `B` can be obtained by applying the algebraic homomorphism `φ` to some element of `A`.

For any commutative semirings R, semirings A and B, and algebra structures on A and B, an algebra homomorphism φ from A to B sends an element x in A to y in B if and only if y is in the image of φ.


theorem MeasureTheory.laverage_eq_lintegral :
    ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α)
      [inst : MeasureTheory.IsProbabilityMeasure μ] (f : α → ENNReal), ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ :=
  by sorry

This theorem, named `MeasureTheory.laverage_eq_lintegral`, states that for any type `α`, measurable space `m0` based on `α`, measure `μ` of type `MeasureTheory.Measure α` which is a probability measure (as specified by `MeasureTheory.IsProbabilityMeasure μ`), and a function `f` mapping from `α` to extended nonnegative real numbers (`ENNReal`), the lower Lebesgue integral (denoted by `⨍⁻`) of `f` with respect to `μ` is equal to the Lebesgue integral (denoted by `∫⁻`) of `f` with respect to `μ`.

In terms of mathematical language, it says that for all probability measures `μ` on a measurable space `α`, the lower Lebesgue integral of any function `f : α → [0, ∞]` with respect to `μ` is equal to its Lebesgue integral with respect to `μ`.

For any measurable space with a probability measure, the lower Lebesgue integral equals the Lebesgue integral of any measurable function.


theorem Mathlib.Algebra.GroupWithZero.Basic._auxLemma.1 :
    ∀ {M₀ : Type u_2} [inst : Mul M₀] [inst_1 : Zero M₀] [inst_2 : NoZeroDivisors M₀] {a b : M₀},
      a ≠ 0 → b ≠ 0 → (a * b = 0) = False :=
  by sorry

The theorem `Mathlib.Algebra.GroupWithZero.Basic._auxLemma.1` states that, for any type `M₀`, given a multiplication operation, a zero element, and the condition that there are no zero divisors, if `a` and `b` are elements of `M₀` and neither `a` nor `b` is equal to zero, then the statement that the product of `a` and `b` equals zero is always false. In other words, in a type with multiplication, zero, and no zero divisors, the product of any two non-zero elements cannot be zero.

In a group with multiplication and a zero element, without zero divisors, the product of any two non-zero elements is never zero.


theorem uniformContinuous_iff :
    ∀ {α : Type u_2} {β : Type u_3} {uα : UniformSpace α} {uβ : UniformSpace β} {f : α → β},
      UniformContinuous f ↔ uα ≤ UniformSpace.comap f uβ :=
  by sorry

The theorem `uniformContinuous_iff` states that for any types `α` and `β` equipped with uniform spaces `uα` and `uβ`, and a function `f : α → β`, the function `f` is uniformly continuous if and only if the uniform space `uα` is less than or equal to the uniform space `uβ` under the inverse image map `comap f`. In other words, a function is uniformly continuous if it does not increase the uniformity, i.e., if every entourage (considered as a measure of 'closeness') in `α` is mapped by `f` to an entourage in `β`.

A function between uniform spaces is uniformly continuous if and only if the inverse image of every entourage in the domain is an entourage in the codomain.


theorem Int.div_zero : ∀ (a : ℤ), Int.div a 0 = 0 := by sorry

This theorem in the Lean 4 language states that for any integer `a`, when `a` is divided by 0, the result is 0. In mathematical terms, this can be written as: ∀a ∈ ℤ, a/0 = 0.


theorem Mathlib.CategoryTheory.Comma.StructuredArrow._auxLemma.2 :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D}
      {X Y : CategoryTheory.CostructuredArrow S T} (f g : X ⟶ Y), (f = g) = (f.left = g.left) :=
  by sorry

This theorem states that in the context of category theory, given two categories `C` and `D` of types `u₁` and `u₂` respectively, a functor `S` from `C` to `D`, and an object `T` in `D`, for any two costructured arrows `X` and `Y` from `S` to `T`, any two morphisms `f` and `g` from `X` to `Y` are equal if and only if their left components are equal.

Given functors `S : C -> D` between categories `C` and `D`, and objects `T` in `D`, if for any two arrows `X, Y : S -> T`, morphisms `f, g : X -> Y` have equal left components, then `f = g`.


theorem Mathlib.CategoryTheory.Comma.StructuredArrow._auxLemma.1 :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {S : D} {T : CategoryTheory.Functor C D}
      {X Y : CategoryTheory.StructuredArrow S T} (f g : X ⟶ Y), (f = g) = (f.right = g.right) :=
  by sorry

The theorem states that, in the context of category theory, given any categories `C` and `D`, a functor `T` from `C` to `D`, an object `S` in `D`, and objects `X` and `Y` that are structured arrows from `S` to `T`, any two morphisms `f` and `g` from `X` to `Y` are equal if and only if their right components are equal. This theorem essentially states that the equality of morphisms in a comma category (specifically, structured arrows) can be determined by the equality of their right components, which are morphisms in `D`.

Given functors `T` from category `C` to `D`, objects `S` in `D`, and structured arrows `X ↓ S ↑ Y` in the comma category `Cdown D`, morphisms `f` and `g` from `X` to `Y` are equal if and only if their right components `T(f)` and `T(g)` are equal in `D`.


theorem Set.ssubset_insert : ∀ {α : Type u} {s : Set α} {a : α}, a ∉ s → s ⊂ insert a s := by sorry

This theorem states that for all types `α` and for any set `s` of type `α` and any element `a` of type `α`, if `a` is not a member of `s`, then `s` is a proper subset of the set resulting from inserting `a` into `s`. In other words, if you have a set and an element not in the set, adding the element to the set creates a set which is strictly larger than the original.

If `a` is not an element of set `s` of type `α`, then `insert a s` is a strictly larger set than `s`.


theorem Nat.Coprime.pow_left : ∀ {m k : ℕ} (n : ℕ), Nat.Coprime m k → Nat.Coprime (m ^ n) k := by sorry

The theorem `Nat.Coprime.pow_left` states that for any natural numbers `m`, `k`, and `n`, if `m` and `k` are coprime (i.e., their greatest common divisor is 1), then `m` raised to the power `n` and `k` are also coprime. This captures the property of coprimeness being preserved under exponentiation of one of the numbers.

If natural numbers `m` and `k` are coprime, then `m^n` and `k` are coprime for any natural number `n`.


theorem ne_iff_lt_or_gt : ∀ {α : Type u} [inst : LinearOrder α] {a b : α}, a ≠ b ↔ a < b ∨ a > b := by sorry

This theorem, `ne_iff_lt_or_gt`, states that for any type `α` equipped with a linear order, and for any two elements `a` and `b` of type `α`, the proposition "`a` is not equal to `b`" is equivalent to the proposition "`a` is less than `b` or `a` is greater than `b`". This theorem encapsulates one of the fundamental properties of linearly ordered sets, where two distinct elements must stand in a strict order relation.

For any linearly ordered type `α` and elements `a` and `b` of `α`, `a ≠ b` if and only if `a` is strictly less than `b` or `a` is strictly greater than `b`.


theorem Complex.hasStrictDerivAt_exp : ∀ (x : ℂ), HasStrictDerivAt Complex.exp (Complex.exp x) x := by sorry

This theorem states that, for every complex number `x`, the complex exponential function `Complex.exp` has a strict derivative at the point `x`, and this derivative is itself `Complex.exp x`. In mathematical terms, this means that the rate of change of the complex exponential function at any point `x` is equal to the value of the complex exponential function at that point. The notion of strict differentiability used here implies that the difference between the function values at two nearby points `y` and `z` tends to be proportional to the difference `y - z`, with the factor of proportionality given by the derivative, plus a term that goes to zero faster than `y - z` as `y, z → x`.

The complex exponential function `Complex.exp` is its own strict derivative.


theorem Filter.map₂_swap :
    ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (m : α → β → γ) (f : Filter α) (g : Filter β),
      Filter.map₂ m f g = Filter.map₂ (fun a b => m b a) g f :=
  by sorry

The `Filter.map₂_swap` theorem states that for any types `α`, `β`, and `γ` and any binary function `m : α → β → γ` and filters `f : Filter α` and `g : Filter β`, mapping with `m` over `f` and `g` is the same as swapping the arguments of `m` and mapping over `g` and `f`. In other words, the order of filters and the corresponding swap in the function's parameters do not affect the output when using the `Filter.map₂` function. This is reminiscent of the mathematical concept that the image of a function remains the same when the order of its arguments is interchanged.

For any types `α`, `β`, `γ`, filters `f : Filter α` and `g : Filter β`, and binary function `m : α → β → γ`, `Filter.map₂ m f g` is equal to `Filter.map₂ (λ x y => m y x) g f`.


Ordnode.Valid'.dual

theorem Ordnode.Valid'.dual :
    ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α},
      Ordnode.Valid' o₁ t o₂ → Ordnode.Valid' o₂ (Ordnode.dual t) o₁ :=
  by sorry

This theorem is about the validity of a dual operation on an ordered node in the context of ordered trees. Specifically, for any type `α` equipped with a preorder, given an ordered node `t` of type `α`, and two other elements `o₁` of type `α` attached with bottom (`⊥`) and `o₂` of type `α` attached with top (`⊤`), if the ordered node `t` is valid between `o₁` and `o₂` (i.e., `Ordnode.Valid' o₁ t o₂` is true), then the dual of the ordered node `t` is valid between `o₂` and `o₁` (i.e., `Ordnode.Valid' o₂ (Ordnode.dual t) o₁` is also true). This theorem essentially establishes the validity of a reversal operation in the context of ordered trees.

For any ordered node `t` in an ordered tree with respect to a preorder, if `Ordnode.Valid' o₁ t o₂` holds, then `Ordnode.Valid' o₂ (Ordnode.dual t) o₁` also holds. (The dual of an ordered node `t` reverses the order relationship between its elements.)


AlgebraicGeometry.isAffineOfIso

theorem AlgebraicGeometry.isAffineOfIso :
    ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : CategoryTheory.IsIso f] [h : AlgebraicGeometry.IsAffine Y],
      AlgebraicGeometry.IsAffine X :=
  by sorry

This theorem states that for any two schemes `X` and `Y` in algebraic geometry, if there is an isomorphism `f` between `X` and `Y` and `Y` is an affine scheme, then `X` is also an affine scheme. In other words, the property of being an affine scheme is preserved under isomorphism.

If `X` and `Y` are schemes in algebraic geometry with an isomorphism between them and `Y` is affine, then `X` is also affine.


theorem Ideal.mul_le_inf : ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, I * J ≤ I ⊓ J := by sorry

The theorem `Ideal.mul_le_inf` states that for any commutative semiring `R` and any two ideals `I` and `J` of `R`, the product of `I` and `J` is less than or equal to the infimum (greatest lower bound) of `I` and `J`. This theorem is a property of ideals in a commutative semiring that relates the multiplication of ideals with the operation of taking the infimum.

For any commutative semiring R and ideals I and J, I.mul J ≤ inf (I, J).


/-- **Alias** of `eq_of_ge_of_not_gt`. -/
theorem LE.le.eq_of_not_gt : ∀ {α : Type u} [inst : PartialOrder α] {a b : α}, a ≤ b → ¬a < b → b = a := by sorry

This theorem, named `LE.le.eq_of_not_gt`, states that for any type `α` with a partial order, if `a` and `b` are two elements of this type where `a` is less than or equal to `b` and `a` is not less than `b`, then `b` must be equal to `a`. Essentially, it gives us a way to establish equality between two elements in a partially ordered set based on ordering conditions.

If `α` is a type with a partial order, and `a` and `b` are elements of `α` with `a ≤ b` and `a < b` being false, then `a = b`.


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

This theorem states that the greatest common divisor (gcd) operation is commutative for any given type `α`, which is a cancel commutative monoid with zero and also a normalized gcd monoid. In other words, for any two elements `a` and `b` of this type, the gcd of `a` and `b` is the same as the gcd of `b` and `a`. This resembles the property in number theory that the order of the two numbers doesn't affect the outcome when computing the gcd.

For any type `α` that is a cancel commutative monoid with zero and a normalized gcd monoid, the gcd of `a` and `b` equals the gcd of `b` and `a` for all `a`, `b` in `α`.


theorem List.sublist_append_left : ∀ {α : Type u_1} (l₁ l₂ : List α), List.Sublist l₁ (l₁ ++ l₂) := by sorry

This theorem asserts that for any type 'α' and any two lists 'l₁' and 'l₂' of that type, 'l₁' is a sublist of the concatenation of 'l₁' and 'l₂'. In other words, if you concatenate a list with any other list, the original list will always be a sublist of the resulting list.

For any type 'α' and any lists 'l₁' and 'l₂' of that type, 'l₁' is a sublist of the concatenation of 'l₁' and 'l₂'. In mathematical notation: if $l\_1$ and $l\_2$ are lists of type $\alpha$, then $l\_1 \subseteq l\_1 \oplus l\_2$, where $\oplus$ denotes list concatenation.


theorem lie_self : ∀ {L : Type v} [inst : LieRing L] (x : L), ⁅x, x⁆ = 0 := by sorry

This theorem, referred to as `lie_self`, states that for all elements `x` of a type `L`, where `L` is equipped with a Lie ring structure (denoted by `[inst : LieRing L]`), the Lie bracket of `x` with itself (denoted by `⁅x, x⁆`) equals zero. In other words, for any element in a Lie ring, the Lie bracket of the element with itself is always zero. The notation `⁅x, x⁆` is used to represent the Lie bracket, which is a binary operation that combines two elements in the Lie ring.

For any element x in a Lie ring L, the Lie bracket [x, x] equals zero.


theorem le_add_iff_nonneg_left :
    ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
      [inst_3 : ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α) {b : α},
      a ≤ b + a ↔ 0 ≤ b :=
  by sorry

This theorem, `le_add_iff_nonneg_left`, states that for any type `α` equipped with an addition operation and a less-than-or-equal-to (`≤`) relation satisfying specific properties (these properties are encoded by the `AddZeroClass`, `CovariantClass`, and `ContravariantClass` classes), for any elements `a` and `b` of `α`, the element `a` is less than or equal to `b` added to `a` if and only if `0` is less than or equal to `b`. In mathematical terms, this theorem states that for all `a` and `b` in `α`, `a ≤ b + a` is equivalent to `0 ≤ b`.

For any type `α` with Addition and `≤` relation satisfying certain properties, `a ≤ b + a` if and only if `0 ≤ b`.


theorem TopologicalSpace.Opens.openEmbedding_obj_top :
    ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X), (IsOpenMap.functor ⋯).obj ⊤ = U := by sorry

This theorem states that for any topological space `X` in the category of topological spaces (`TopCat`) and for any open set `U` in that topological space, the object of the functor induced by an open map (defined by `IsOpenMap.functor`) applied to the top element (`⊤`) is equal to `U`. In other words, this theorem asserts that the functor produced by any open map maps the whole topological space `X` (represented by the top element `⊤`) onto any of its open subsets `U`.

For any topological space X and open set U, the functor induced by an open map maps the top element ⊤ of X to U.


theorem IsClosed.mem_of_tendsto :
    ∀ {X : Type u} {α : Type u_1} {x : X} {s : Set X} [inst : TopologicalSpace X] {f : α → X} {b : Filter α}
      [inst_1 : Filter.NeBot b], IsClosed s → Filter.Tendsto f b (nhds x) → (∀ᶠ (x : α) in b, f x ∈ s) → x ∈ s :=
  by sorry

This theorem states that, for every type `X` and `α`, any point `x` in `X`, and a set `s` of `X`, given a topological space structure on `X`, a function `f` from `α` to `X`, and a filter `b` on `α` which is not bottom, if `s` is a closed set, and the function `f` tends to the neighborhood filter of `x` as `b` tends to infinity (denoted by `Filter.Tendsto f b (nhds x)`), then if almost all elements `x` in `b` map to `s` under `f`, it follows that `x` is an element of `s`. In essence, this theorem is about the limit behavior of a function in a topological space and its relationship with closed sets.

Given a topological space `(X, top)`, a function `f : α -> X`, a point `x in X`, a filter `b on α` that is not bottom, and a closed set `s in X`, if `Filter.Tendsto f b (nhds x)` and `almost_all x in b are in s`, then `x is in s`.


theorem uniformCauchySeqOn_iff_uniformCauchySeqOnFilter :
    ∀ {α : Type u} {β : Type v} {ι : Type x} [inst : UniformSpace β] {F : ι → α → β} {s : Set α} {p : Filter ι},
      UniformCauchySeqOn F p s ↔ UniformCauchySeqOnFilter F p (Filter.principal s) :=
  by sorry

The theorem `uniformCauchySeqOn_iff_uniformCauchySeqOnFilter` establishes an equivalence between two forms of uniform Cauchy sequences. Specifically, for any type `α`, type `β` with a uniform space structure, type `ι`, a function `F` mapping from `ι` and `α` to `β`, a set `s` of type `α`, and a filter `p` on `ι`, the function `F` combined with filter `p` forms a uniformly Cauchy sequence on set `s` if and only if it forms a uniformly Cauchy sequence on the principal filter of set `s`. Essentially, this theorem provides a bridge between a set-based and a filter-based definition of uniform Cauchy sequences.

For any uniform space `(β, δ)`, type `α`, filter `p` on `ι`, set `s subseteq α`, function `F : ι -> α -> β`, the sequence `{F x | x in s}` is uniformly Cauchy with respect to `p` if and only if it is uniformly Cauchy with respect to the principal filter of `s`.


theorem List.Nodup.map_on :
    ∀ {α : Type u} {β : Type v} {l : List α} {f : α → β},
      (∀ x ∈ l, ∀ y ∈ l, f x = f y → x = y) → List.Nodup l → List.Nodup (List.map f l) :=
  by sorry

The theorem `List.Nodup.map_on` states that for any types `α` and `β`, and for any list `l` of type `α`, and any function `f` from `α` to `β`, if it holds that for all elements `x` and `y` in `l`, `f(x)` equals `f(y)` implies `x` equals `y`, then if `l` is a list with no duplicate elements, the list resulting from applying the function `f` to each element of `l` will also be a list with no duplicate elements. In other words, applying a function to each element of a list preserves the property of having no duplicate elements under the condition that the function gives distinct results for distinct elements.

If `f : α -> β` preserves equality on distinct elements of a list `l` of type `α` with no duplicates, then the image list `map f l` also has no duplicates.


Stream'.Seq.ext

theorem Stream'.Seq.ext :
    ∀ {α : Type u} {s t : Stream'.Seq α}, (∀ (n : ℕ), Stream'.Seq.get? s n = Stream'.Seq.get? t n) → s = t := by sorry

This theorem states that for any two sequences `s` and `t` of the same type `α`, if for all natural numbers `n`, the `n`-th element of sequence `s` is the same as the `n`-th element of sequence `t`, then the sequences `s` and `t` are equal. In other words, two sequences are equal if and only if their corresponding elements are equal at every position.

Two sequences of the same type are equal if and only if they have identical elements at corresponding positions.


theorem Real.sin_arcsin : ∀ {x : ℝ}, -1 ≤ x → x ≤ 1 → Real.sin (Real.arcsin x) = x := by sorry

The theorem `Real.sin_arcsin` is stating that for all real numbers x such that x is within the interval [-1, 1], the sine of the arcsine of x is equal to x. In other words, if you take the arcsine (the inverse sine function) of any real number between -1 and 1, and then take the sine of the result, you will get back your original number. This encapsulates the property of the inverse trigonometric function - the fact that applying a function and its inverse will yield the original value.

For all real x in the interval [-1, 1], sin(arcsin(x)) = x.


theorem subset_supClosure : ∀ {α : Type u_2} [inst : SemilatticeSup α] {s : Set α}, s ⊆ supClosure s := by sorry

This theorem states that for any type `α` that is a join-semilattice, and for any set `s` of elements of type `α`, `s` is a subset of the set generated by the `supClosure` operation applied to `s`. In other words, applying the `supClosure` operation to a set in a join-semilattice will always produce a set that includes the original set. The `supClosure` operation is defined so that it generates a set that is closed under the join operation of the semilattice.

For any join-semilattice type `α` and set `s` of elements in `α`, the `supClosure` of `s` includes `s`. In other words, `supClosure s ⊆ {x | ∃y ∈ s, x = sup s {y}}`.


theorem Nat.div_dvd_of_dvd : ∀ {m n : ℕ}, n ∣ m → m / n ∣ m := by sorry

This theorem establishes a property of division in the context of natural numbers. Specifically, it asserts that for any two natural numbers 'm' and 'n', if 'n' divides 'm' (denoted by `n ∣ m`), then the result of integer division of 'm' by 'n' (denoted by `m / n`) also divides 'm'. This theorem can be useful when dealing with problems related to divisibility and factorization in number theory.

If a natural number 'n' divides another natural number 'm', then 'm' divided by 'n' is a natural number that also divides 'm'.


theorem irrefl_of : ∀ {α : Sort u} (r : α → α → Prop) [inst : IsIrrefl α r] (a : α), ¬r a a := by sorry

This theorem states that for any type `α` and a binary relation `r` on `α`, if `r` is irreflexive (as indicated by `IsIrrefl α r`), then for any element `a` of type `α`, `r a a` cannot hold. In other words, no element is related to itself under an irreflexive relation.

For any type `α` and irreflexive binary relation `r` on `α`, there is no element `a` in `α` such that `r a a` holds.


theorem List.finRange.proof_1 : ∀ (n x : ℕ), x ∈ List.range n → x < n := by sorry

This theorem, identified as `List.finRange.proof_1`, states that for any natural numbers `n` and `x`, if `x` is an element of the list produced by the `List.range` function acting on `n` (i.e., a list of all natural numbers from `0` to `n` exclusive), then `x` is strictly less than `n`. Put in another way, every number in the range from `0` to `n` exclusive is less than `n`.

For all natural numbers n and x, if x is in the range 0 to n (exclusive), then x < n.


/-- Every ultrafilter `u` on `Ultrafilter α` converges to a unique
point of `Ultrafilter α`, namely `joinM u`.  -/
theorem ultrafilter_converges_iff :
    ∀ {α : Type u} {u : Ultrafilter (Ultrafilter α)} {x : Ultrafilter α}, ↑u ≤ nhds x ↔ x = joinM u := by sorry

This theorem states that for any given type `α`, every ultrafilter `u` on `Ultrafilter α` converges to a unique point of `Ultrafilter α`, which is `joinM u`. In other words, the ultrafilter `u` is less than or equal to the neighborhood filter of `x` if and only if `x` is equal to `joinM u`. Here, `joinM` is a function that takes a monadic value within another monadic context and combines the two contexts into one, while `nhds` is the neighborhood filter at `x` in a topological space `X`.

For any ultrafilter `u` on a type `α`, the unique point `x` in `α` such that `nhds x ⊆ u` is equal to `joinM u`.


theorem Set.subsingleton_iff_singleton : ∀ {α : Type u} {s : Set α} {x : α}, x ∈ s → (Set.Subsingleton s ↔ s = {x}) :=
  by sorry

This theorem states that for any type `α`, a set `s` of `α`, and an element `x` of `α`, if `x` is an element of `s`, then `s` is a subsingleton set (a set with at most one element) if and only if `s` is the set containing only the element `x`. In other words, a set `s` being a subsingleton is equivalent to `s` being a singleton set `{x}`, given that `x` is an element of `s`.

For any type `α` and set `s` of `α` containing an element `x`, `s` is a subsingleton if and only if `s = {x}`.


theorem isNoetherian_of_linearEquiv :
    ∀ {R : Type u_1} {M : Type u_2} {P : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M]
      [inst_2 : AddCommMonoid P] [inst_3 : Module R M] [inst_4 : Module R P],
      (M ≃ₗ[R] P) → ∀ [inst_5 : IsNoetherian R M], IsNoetherian R P :=
  by sorry

The theorem `isNoetherian_of_linearEquiv` states that for any semiring `R` and additively commutative monoids `M` and `P` that are also `R`-modules, if `M` is linearly equivalent to `P` (denoted as `M ≃ₗ[R] P`), then if `M` is a Noetherian `R`-module, `P` is also a Noetherian `R`-module. In simpler terms, this theorem says that the property of being a Noetherian module is preserved under linear equivalence.

If `M` and `P` are additively commutative `R`-modules that are linearly equivalent and `M` is Noetherian, then `P` is also Noetherian.


theorem inducing_of_inducing_compose :
    ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
      [inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
      Continuous f → Continuous g → Inducing (g ∘ f) → Inducing f :=
  by sorry

This theorem states that for any three types `X`, `Y`, and `Z`, and for any two functions `f`: from `X` to `Y` and `g`: from `Y` to `Z`, given that `X`, `Y`, and `Z` each have a topology, if both `f` and `g` are continuous and the composition `g ∘ f` is an inducing function, then `f` is also an inducing function. In mathematical terms, if `g` and `f` are continuous maps between topological spaces such that the composition `g ∘ f` induces the topology of `Z` onto `X`, then `f` alone induces the topology of `Y` onto `X`.

If `X`, `Y`, and `Z` are topological spaces, `f: X → Y` and `g: Y → Z` are continuous functions with `g ∘ f` being an inducing function from `X` to `Z`, then `f` is an inducing function from `X` to `Y`.


theorem Measurable.ennreal_toNNReal :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ENNReal}, Measurable f → Measurable fun x => (f x).toNNReal :=
  by sorry

The theorem `Measurable.ennreal_toNNReal` states that for any type `α` with a measurable space structure and any function `f` from `α` to the extended nonnegative real numbers (`ENNReal`), if `f` is a measurable function, then the function that sends each element `x` in `α` to the nonnegative real part (`toNNReal`) of `f(x)` is also a measurable function. This means that the preimage of every measurable set under this new function is also measurable.

If `α` is a measurable space and `f : α → ENNReal` is a measurable function, then the function `x ↦ toNNReal (f x)` is also measurable.


theorem tendsto_mul :
    ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [inst_2 : ContinuousMul M] {a b : M},
      Filter.Tendsto (fun p => p.1 * p.2) (nhds (a, b)) (nhds (a * b)) :=
  by sorry

The theorem `tendsto_mul` states that for any type `M` with a topological space structure, a multiplication operation, and assuming the multiplication operation is continuous, given any two points labelled `a` and `b` in `M`, the limit of the function that takes a pair `p` to the product of the elements of the pair, as the pair `p` approaches `(a, b)` in the topology of `M`, is equal to the product `a * b`. In other words, in a topological space with continuous multiplication, the limit of the multiplication function at any point is just the multiplication of the coordinates of the point.

Given a topological space `M` with a continuous multiplication operation, the limit of the function `λp, a * b` as `p` approaches `(a, b)` in the topology of `M` is equal to `a * b`.


theorem nsmul_add : ∀ {M : Type u} [inst : AddCommMonoid M] (a b : M) (n : ℕ), n • (a + b) = n • a + n • b := by sorry

This theorem, `nsmul_add`, is about the operations in an additive commutative monoid, represented by the type variable `M`. It states that for any elements `a` and `b` from the monoid, and any natural number `n`, the operation of n-fold addition (denoted by `n •`) distributes over the monoid addition operation. In mathematical terms, for any `a`, `b` in `M` and natural number `n`, `n` times the sum of `a` and `b` (`n • (a + b)`) is equal to the sum of `n` times `a` and `n` times `b` (`n • a + n • b`).

For any additive commutative monoid `M`, and natural number `n`, the operation of `n-fold addition` distributes over the monoid addition operation, i.e., `n • (a + b) = n • a + n • b` for all `a, b` in `M`.


theorem Set.sInter_subset_of_mem : ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, t ∈ S → ⋂₀ S ⊆ t := by sorry

The theorem `Set.sInter_subset_of_mem` states that for any type `α`, and for any set `S` of sets of `α`, and for any set `t` of `α`, if `t` is an element of `S`, then the intersection over all sets in `S` is a subset of `t`. In the language of set theory, this means if a set is part of a collection of sets, then the intersection of all those sets is included within that particular set.

For any type `α`, if `S` is a set of sets of `α` and `t` is an element of `S`, then `∩S ⊆ t`.


theorem MeasureTheory.Measure.prod_sum :
    ∀ {α : Type u_1} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {ι : Type u_7}
      {ι' : Type u_8} [inst_2 : Countable ι'] (m : ι → MeasureTheory.Measure α) (m' : ι' → MeasureTheory.Measure β)
      [inst_3 : ∀ (n : ι'), MeasureTheory.SFinite (m' n)],
      MeasureTheory.Measure.prod (MeasureTheory.Measure.sum m) (MeasureTheory.Measure.sum m') =
        MeasureTheory.Measure.sum fun p => MeasureTheory.Measure.prod (m p.1) (m' p.2) :=
  by sorry

This theorem states that for any index sets `ι` and `ι'` (where `ι'` is countable), and corresponding families of measures `m` on a measurable space `α` and `m'` on a measurable space `β` (such that every measure `m'(n)` for `n` in `ι'` is s-finite), the measure of the product of the sum of the `m` measures and the sum of the `m'` measures is equal to the sum of the measures of the products of the `m` and `m'` measures, indexed by pairs of elements from `ι` and `ι'`. In mathematical terms, it asserts that `(∑m)⨂(∑m') = ∑(m⨂m')` over the product space `α × β`.

For countable index sets `ι` and `ι'`, and families of s-finite measures `m` on a measurable space `α` and `m'` on a measurable space `β`, the measure of the product of the sum of `m` and the sum of `m'` is equal to the sum of the measures of the products of `m` and `m'`. That is, `(∑m)⨂(∑m') = ∑(m⨂m')` over the product space `α × β`.


theorem Mathlib.Topology.Category.TopCat.Limits.Products._auxLemma.2 :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
      (CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) :=
  by sorry

This theorem states that for any category `C` and objects `X`, `Y`, `Z` in `C`, and an isomorphism `α` from `X` to `Y`, as well as morphisms `f` from `X` to `Z` and `g` from `Y` to `Z`, the statement that the composition of the inverse of `α` and `f` equals `g` is equivalent to the statement that `f` equals the composition of `α` and `g`.

In other words, if you have an isomorphism between two objects in a category and you map one of these objects to a third object, you can "reverse" the isomorphism and then perform the mapping to achieve the same result as if you had performed the mapping first and then applied the isomorphism.

For any category C, isomorphism α from X to Y, and morphisms f: X → Z and g: Y → Z, the equality of α⁻¹ ∘ f and g is equivalent to the equality of f and α ∘ g.


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

For specific bases see `uniformity_basis_dist`, `uniformity_basis_dist_inv_nat_succ`,
and `uniformity_basis_dist_inv_nat_pos`.  -/
theorem Metric.mk_uniformity_basis :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {β : Type u_3} {p : β → Prop} {f : β → ℝ},
      (∀ (i : β), p i → 0 < f i) →
        (∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε) → Filter.HasBasis (uniformity α) p fun i => {p | dist p.1 p.2 < f i} :=
  by sorry

This theorem states that for any type `α` that is a pseudo metric space and any type `β`, given a function `f : β → ℝ` and a property `p : β → Prop`, if the function `f` maps the set `{i | p i}` to a set of positive numbers that accumulates to zero, then the sets `{p | dist p.1 p.2 < f i}`, where `i` satisfies property `p`, form a basis for the uniformity of `α`. In other words, any neighborhood of the diagonal in the uniformity of `α` can be made arbitrarily small by selecting appropriate `i` such that `p i` is true and `f i` is sufficiently small. This theorem provides a way to construct a basis for the uniformity in a pseudo metric space given a function that maps to a set of positive numbers that accumulate to zero.

Given a pseudo metric space `α`, a function `f : β → ℝ` mapping the set `{i : β | p i}` to summable positive numbers, and a property `p : β → Prop`, the sets `{i : β | p i}`, where `i` satisfies `dist p.1 p.2 < f i,` form a basis for the uniformity of `α`.