theorem AlgHom.toLinearMap_injective :
    ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
      [inst_3 : Algebra R A] [inst_4 : Algebra R B], Function.Injective AlgHom.toLinearMap :=
  by sorry

The theorem `AlgHom.toLinearMap_injective` states that for any commutative semiring `R` and any two semirings `A` and `B` over `R`, the function `AlgHom.toLinearMap`, which converts an algebra homomorphism from `A` to `B` over `R` to a linear map, is injective. In other words, if two different algebra homomorphisms are mapped to the same linear map by `AlgHom.toLinearMap`, then those algebra homomorphisms were actually the same to begin with.

If two algebra homomorphisms from commutative semirings over a common base ring map to the same linear map under `AlgHom.toLinearMap`, then they are equal as homomorphisms.


theorem Mathlib.Data.Finset.Lattice._auxLemma.17 :
    ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (f : β → α) (S : Finset β),
      (Finset.sup S f = ⊥) = ∀ s ∈ S, f s = ⊥ :=
  by sorry

This theorem states that for any types `α` and `β` with `α` being a semilattice sup and order bot, and given a function `f` from `β` to `α` and a finite set `S` of type `β`, the supremum of the set `S` under the function `f` is equal to the bottom element of `α` if and only if for every element `s` in `S`, the value of the function `f` at `s` is equal to the bottom element of `α`. In other words, all elements of `S` map to the least element in `α` under function `f` if the supremum of the mapped set is also the least element in `α`.

For any semilattice sup and order bot types `α` and `β`, function `f`: `β → α`, and finite set `S` ⊆ `β`, if for all `s` ∈ `S`, `f(s)` = bot(`α`), then `sup(map(f, S))` = bot(`α`).


/-- The rays given by two nonzero vectors are equal if and only if those vectors
satisfy `SameRay`.  -/
theorem ray_eq_iff :
    ∀ {R : Type u_1} [inst : StrictOrderedCommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M]
      [inst_2 : Module R M] {v₁ v₂ : M} (hv₁ : v₁ ≠ 0) (hv₂ : v₂ ≠ 0),
      rayOfNeZero R v₁ hv₁ = rayOfNeZero R v₂ hv₂ ↔ SameRay R v₁ v₂ :=
  by sorry

The theorem `ray_eq_iff` states that for any type `R` with a strict ordered commutative semiring structure, any type `M` with an additive commutative monoid structure and a module over `R`, and any two nonzero vectors `v₁` and `v₂` from `M`, the rays given by `v₁` and `v₂` are equal if and only if `v₁` and `v₂` satisfy the `SameRay` condition. In the context of this theorem, `SameRay` condition is satisfied if either one of `v₁` or `v₂` is zero, or there exist some positive multiples `r₁` and `r₂` of `v₁` and `v₂` respectively, such that `r₁ • v₁ = r₂ • v₂` (where `•` denotes scalar multiplication).

For any strict ordered commutative semiring `R`, additive commutative monoid `M` over `R` with module structure, and nonzero vectors `v₁` and `v₂` in `M`, `Ray v₁ = Ray v₂` if and only if there exist positive multiples `r₁` and `r₂` such that `r₁ • v₁ = r₂ • v₂`.


theorem Mathlib.Topology.FiberBundle.Constructions._auxLemma.4 :
    ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) := by sorry

This theorem, named `Mathlib.Topology.FiberBundle.Constructions._auxLemma.4`, states that for any types `α` and `β`, a function `f` from `α` to `β`, a set `s` of elements of type `β`, and an element `a` of type `α`, the statement "element `a` is in the preimage of set `s` under function `f`" is equivalent to the statement "the image of `a` under function `f` is in the set `s`".

In mathematical terms, this theorem corresponds to the basic definition of the preimage of a set under a function: $a \in f^{-1}(s)$ if and only if $f(a) \in s$.

For any function $f: \alpha \to \beta$ and sets $s \subseteq \beta$ and $a \in \alpha$, $a \in f^{-1}(s)$ if and only if $f(a) \in s$.


theorem nonLindelof_univ :
    ∀ (X : Type u_2) [inst : TopologicalSpace X] [inst_1 : NonLindelofSpace X], ¬IsLindelof Set.univ := by sorry

This theorem states that for any type `X` equipped with a topology (i.e. `X` is a topological space) and also having the property that it is a non-Lindelöf space (i.e., it does not meet the Lindelöf property), the universal set of `X` cannot be a Lindelöf set. In other words, if a topological space does not satisfy the Lindelöf condition (which requires that every open cover has a countable subcover), then its universal set, containing all its elements, also does not satisfy this condition.

If a topological space `X` is non-Lindelöf, then its universal set is not Lindelöf.


IsLindelof.union

theorem IsLindelof.union :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsLindelof s → IsLindelof t → IsLindelof (s ∪ t) := by
  sorry

The theorem `IsLindelof.union` states that for any type `X` with a topological space structure and any two sets `s` and `t` of type `X`, if both `s` and `t` are Lindelöf sets, then their union `s ∪ t` is also a Lindelöf set. In other words, in a topological space, the union of two Lindelöf sets is still a Lindelöf set. Here, a set is Lindelöf if every non-trivial filter with the countable intersection property that contains the set, has a cluster point within the set.

In a topological space, the union of two Lindelöf sets is a Lindelöf set.


FirstOrder.Language.Equiv.ext

theorem FirstOrder.Language.Equiv.ext :
    ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : FirstOrder.Language.Structure L M]
      [inst_1 : FirstOrder.Language.Structure L N] ⦃f g : FirstOrder.Language.Equiv L M N⦄,
      (∀ (x : M), f x = g x) → f = g :=
  by sorry

The theorem `FirstOrder.Language.Equiv.ext` states that for any first-order language `L` and any two types `M` and `N` that are structures of `L`, if two equivalence mappings `f` and `g` from `M` to `N` are such that for every element `x` in `M`, `f(x)` is equal to `g(x)`, then `f` and `g` are equal. This is a property of extensionality in the context of first-order logic language structures, asserting that two equivalence mappings are equal if they act the same way on every element of their domain.

If `f` and `g` are equivalence mappings from a first-order language structure `M` to another structure `N` such that `f(x) = g(x)` for all `x` in `M`, then `f = g`.


theorem MvPolynomial.ext_iff :
    ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p q : MvPolynomial σ R),
      p = q ↔ ∀ (m : σ →₀ ℕ), MvPolynomial.coeff m p = MvPolynomial.coeff m q :=
  by sorry

This theorem states that for any commutative semiring `R` and any type `σ`, two multivariate polynomials `p` and `q` with variables indexed by `σ` and coefficients from `R` are equal if and only if their coefficients for every monomial `m` (represented as a function from `σ` to ℕ) are equal. In other words, two multivariate polynomials are identical if they have the same coefficients for all their monomials.

Given a commutative semiring `R` and multivariate polynomials `p` and `q` over `R` with variables indexed by `σ`, `p` equals `q` if and only if for all functions `m` from `σ` to ℕ, the coefficients of `p` and `q` corresponding to monomial `m` are equal.


theorem SetTheory.PGame.powHalf_moveLeft :
    ∀ (n : ℕ) (i : SetTheory.PGame.LeftMoves (SetTheory.PGame.powHalf n)),
      SetTheory.PGame.moveLeft (SetTheory.PGame.powHalf n) i = 0 :=
  by sorry

This theorem from set theory, in the context of combinatorial game theory, states that for any natural number `n` and any valid move `i` for the Left player in the game `SetTheory.PGame.powHalf n`, the game that results after the Left player makes move `i` is the zero game. In other words, no matter what move the Left player makes in the game `SetTheory.PGame.powHalf n`, the resulting game is equivalent to the game where no moves are possible, which is denoted as `0` in game theory.

For all natural numbers `n` and valid moves `i` for the Left player in the game `SetTheory.PGame.powHalf n`, the resulting game is the zero game.


LipschitzWith.prod

/-- If `f` and `g` are Lipschitz functions, so is the induced map `f × g` to the product type.  -/
theorem LipschitzWith.prod :
    ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
      [inst_2 : PseudoEMetricSpace γ] {f : α → β} {Kf : NNReal},
      LipschitzWith Kf f →
        ∀ {g : α → γ} {Kg : NNReal}, LipschitzWith Kg g → LipschitzWith (max Kf Kg) fun x => (f x, g x) :=
  by sorry

This theorem states that if you have two functions `f` and `g` that are Lipschitz continuous, with Lipschitz constants `Kf` and `Kg` respectively, then the function that maps `x` to the pair `(f x, g x)` is also Lipschitz continuous. The Lipschitz constant of this composite function is the maximum of `Kf` and `Kg`.

If functions `f` and `g` are Lipschitz continuous with constants `Kf` and `Kg` respectively, then the function `(x ↔⟩ (f x, g x))` is Lipschitz continuous with constant `max Kf Kg`.


theorem Finset.sum_coe_sort :
    ∀ {α : Type u_3} {β : Type u_4} (s : Finset α) (f : α → β) [inst : AddCommMonoid β],
      (Finset.sum Finset.univ fun i => f ↑i) = Finset.sum s fun i => f i :=
  by sorry

This theorem states that for any type `α`, a finite set `s` of type `α`, and a function `f` from `α` to another type `β` which forms an additive commutative monoid, the sum of the function `f` applied to all elements in the universal finite set of type `α` (represented by `Finset.univ`), where each element is type-casted using the `↑` operator, is equal to the sum of the function `f` applied to all elements in the finite set `s`. In other words, summing over all possible elements (using `Finset.univ`) and summing over the elements in `s` yield the same result, provided we interpret elements of `α` as elements of `β` using the coercion function (the `↑` operator).

For any additive commutative monoid homomorphism `f` from type `α` to type `β`, and finite set `s` of `α`, the sum of `f` applied to every element in the universal set `Finset.univ` of type `α` equals the sum of `f` applied to all elements in the finite set `s`.


theorem contMDiffAt_const :
    ∀ {𝕜 : 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']
      {x : M} {n : ℕ∞} {c : M'}, ContMDiffAt I I' n (fun x => c) x :=
  by sorry

This theorem, `contMDiffAt_const`, states that for any nontrivially normed field `𝕜`, a normed additive commutative group `E`, a normed space `𝕜 E`, a topological space `H`, a model with corners `I` with respect to `𝕜, E, H`, a topological space `M`, a charted space `H M`, a normed additive commutative group `E'`, a normed space `𝕜 E'`, a topological space `H'`, a model with corners `I'` with respect to `𝕜, E', H'`, a topological space `M'`, a charted space `H' M'`, an element `x` of `M`, an infinite natural number `n`, and a constant `c` of `M'`, the function that maps every element to the constant `c` is continuously differentiable at `x` with respect to the models with corners `I` and `I'`. Similarly, this theorem could be stated as "a constant function is continuously differentiable at any point".

Given nontrivially normed fields 𝕜, normed additive commutative groups E, and continuous functions f : M -> M' between topological spaces with charts H M and H' M' respectively, where f maps each point x in M to a constant c in M', the function f is continuously differentiable at x with respect to the models with corners I and I'.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.22 : (¬False) = True := by sorry

This theorem states that the negation of 'False' is 'True'. In the context of boolean logic, where '¬' represents the logical 'not' operation, this theorem asserts the fundamental law that 'not False' equates to 'True'.

The theorem asserts that the negation of False is True, or equivalently, not False equals True.


theorem nhdsWithin_Iic_basis' :
    ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderTopology α] {a : α},
      (∃ l, l < a) → Filter.HasBasis (nhdsWithin a (Set.Iic a)) (fun l => l < a) fun l => Set.Ioc l a :=
  by sorry

This theorem states that for any type `α` endowed with a topological space structure, a linear order structure, and an order topology structure, and for a given element `a` from `α`, if there exists an element `l` less than `a`, then the filter of neighborhoods within `Set.Iic a` (the set of all values less than or equal to `a`) at `a` has a basis indexed by elements less than `a`, with each basis element being the left-open right-closed interval `Set.Ioc l a` (the set of all values greater than `l` and less than or equal to `a`).

In simpler terms, this theorem provides a way to generate a basis for the neighborhood filter around a point `a` in a topological space, specifically within the set of all points less than or equal to `a`, by using open-closed intervals that end at `a` and begin from any point less than `a`.

For any topological space `(α, top)` endowed with a linear order `≤` and for any element `a ∈ α` with a predecessor `l`, the filter basis of neighborhoods at `a` within `Set.Iic a` is given by the collection of left-open right-closed intervals `Set.Ioc l a`.


theorem Mathlib.Topology.Instances.ENNReal._auxLemma.45 :
    ∀ {α : Type u_1} {f : α → ENNReal}, (∑' (i : α), f i = 0) = ∀ (i : α), f i = 0 := by sorry

The theorem states that for any type `α` and any function `f` from `α` to the extended nonnegative real numbers (usually denoted as [0, ∞]), the sum over all `α` of the function `f` is equal to 0 if and only if for all `α`, the function `f` at `α` is equal to 0. In mathematical terms, given a set `α` and a function `f : α → [0, ∞]`, we have `∑' f = 0` if and only if `∀ i ∈ α, f(i) = 0`.

The theorem asserts that a function `f : α → [0, ∞]` sums to zero over all `α` if and only if each `i ∈ α` has `f(i) = 0`.


theorem Set.mem_ordConnectedComponent :
    ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {x y : α},
      y ∈ Set.ordConnectedComponent s x ↔ Set.uIcc x y ⊆ s :=
  by sorry

This theorem states that for any given type `α` with a linear order, any set `s` of type `α`, and any two elements `x` and `y` of type `α`, `y` is a member of the order-connected component of `x` in set `s` if and only if the set of elements lying between `x` and `y`, inclusive, is a subset of `s`. In other words, `y` is in the order-connected component of `x` if all elements between `x` and `y`, inclusive, are also in the set `s`.

For a linear ordered type `α` and a subset `s` of `α`, an element `y` belongs to the order-connected component of `x` in `s` if and only if the interval [`x`, `y`] (inclusive) is a subset of `s`.


theorem sInf_image' :
    ∀ {α : Type u_1} {β : Type u_2} [inst : InfSet α] {s : Set β} {f : β → α}, sInf (f '' s) = ⨅ a, f ↑a := by sorry

This theorem, named `sInf_image'`, states that for any two types `α` and `β`, where `α` has an instance of `InfSet`, and for any set `s` of type `β` and any function `f` from `β` to `α`, the infimum (`sInf`) of the image of `s` under `f` (written as `f '' s`) is equal to the infimum (`⨅ a`) over all elements `a` in the set `s` of `f` applied to `a`. Here, `↑a` is used to denote elements `a` of the set `s`, and `⨅` represents the infimum or greatest lower bound. In simpler terms, it says that the greatest lower bound of the image of a set under a function is the same as the greatest lower bound of the function values at each point in the set.

For any set `s` of type `β` with infimum `i`, and any function `f` from `β` to a type `α` with an infimum structure, the infimum of `f'' s` is equal to `i.map f`.


theorem one_le_div' :
    ∀ {α : Type u} [inst : Group α] [inst_1 : LE α]
      [inst_2 : CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α},
      1 ≤ a / b ↔ b ≤ a :=
  by sorry

This theorem, `one_le_div'`, states that for any type `α` that has a group structure and a less-than-or-equal-to (`≤`) relation, and where the multiplication operation is covariant, for any two elements `a` and `b` of type `α`, `1` is less than or equal to the division of `a` by `b` if and only if `b` is less than or equal to `a`. In other words, if you can meaningfully divide and compare elements in `α`, this theorem relates the ordering of `a` and `b` to the ordering of `1` and `a / b`.

For any type `α` with group structure and a `≤` relation where multiplication is covariant, `1 ≤ a / b` if and only if `b ≤ a`.


theorem Matroid.Dep.not_indep : ∀ {α : Type u_1} {M : Matroid α} {D : Set α}, M.Dep D → ¬M.Indep D := by sorry

This theorem states that for any type `α`, any `Matroid` `M` over `α`, and any set `D` of `α`, if `D` is a dependent set in `M` then `D` cannot be an independent set in `M`. In other words, a set cannot be both dependent and independent in the context of the same matroid.

In a matroid, no set can be both dependent and independent.


theorem List.norm_prod_le' :
    ∀ {α : Type u_1} [inst : SeminormedRing α] {l : List α}, l ≠ [] → ‖List.prod l‖ ≤ List.prod (List.map norm l) := by
  sorry

This theorem, `List.norm_prod_le'`, states that for any given list `l` of elements of a type `α`, where `α` is a seminormed ring, if the list `l` is not empty, the norm of the product of all elements in `l` is less than or equal to the product of the norms of all elements in `l`. In mathematical terms, if we denote the list as $l = [a_1, a_2, ..., a_n]$, the theorem states that $\| a_1 \times a_2 \times ... \times a_n \| \leq \|a_1\| \times \|a_2\| \times ... \times \|a_n\|$.

For any non-empty list `l` of elements from a seminormed ring `α`, the norm of their product is less than or equal to the product of their individual norms: $\| \prod_{i=1}^n a\_i \| \leq \prod_{i=1}^n \|a\_i\|$.


theorem one_divp : ∀ {α : Type u} [inst : Monoid α] (u : αˣ), 1 /ₚ u = ↑u⁻¹ := by sorry

This theorem, named `one_divp`, states that for any type `α` that forms a Monoid (a kind of algebraic structure), and any non-zero element `u` of type `α`, the value of 1 divided by `u` (expressed as `1 /ₚ u`) is equal to the inverse of `u` (expressed as `↑u⁻¹`). In terms of algebra, it's stating that division by an element in a Monoid is equivalent to multiplying by its inverse.

For any Monoid type `α` and non-zero element `u` of `α`, `1 /ₚ u = ↑u⁻¹`. That is, division by `u` equals the multiplicative inverse of `u`.


theorem Nat.compare_def_lt :
    ∀ (a b : ℕ), compare a b = if a < b then Ordering.lt else if b < a then Ordering.gt else Ordering.eq := by sorry

This theorem, `Nat.compare_def_lt`, states that for any two natural numbers `a` and `b`, the comparison of `a` and `b` is defined as follows: if `a` is less than `b`, then the result of the comparison is `Ordering.lt` (less than); if `b` is less than `a`, then the result is `Ordering.gt` (greater than); and if neither of these cases is true (that is, `a` and `b` are equal), then the result is `Ordering.eq` (equal).

For all natural numbers `a` and `b`, `a` < `b` if and only if `Ordering.lt` is the result of comparing `a` and `b`, while `a` > `b` if and only if `Ordering.gt` is the result, and `a` = `b` if and only if `Ordering.eq` is the result.


/-- ε-characterization of the closure in pseudometric spaces -/
theorem Metric.mem_closure_iff :
    ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {a : α}, a ∈ closure s ↔ ∀ ε > 0, ∃ b ∈ s, dist a b < ε :=
  by sorry

This theorem, termed as the "ε-characterization of the closure in pseudometric spaces", states that for any type `α` that is a PseudoMetric space, for any set `s` of elements of type `α`, and for any element `a` of type `α`, `a` is in the closure of `s` if and only if for all `ε` greater than 0, there exists an element `b` in `s` such that the distance between `a` and `b` is less than `ε`. In simpler terms, an element is in the closure of a set in a pseudometric space if for any small positive distance, there's a point in the set that is within that distance from the element.

In a pseudometric space, an element belongs to the closure of a set if and only if for every positive distance, there exists an element in the set within that distance.


theorem AlgebraicGeometry.Scheme.comp_val_base :
    ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z),
      (CategoryTheory.CategoryStruct.comp f g).val.base = CategoryTheory.CategoryStruct.comp f.val.base g.val.base :=
  by sorry

The theorem `AlgebraicGeometry.Scheme.comp_val_base` states that for any three schemes `X`, `Y`, and `Z` in algebraic geometry, and any two morphisms `f` from `X` to `Y` and `g` from `Y` to `Z`, the base of the value of the composition of `f` and `g` (expressed as `(CategoryTheory.CategoryStruct.comp f g).val.base`) is equal to the composition of the bases of the values of `f` and `g` (expressed as `CategoryTheory.CategoryStruct.comp f.val.base g.val.base`). In essence, this theorem ensures that the process of composition in the category of schemes respects the underlying structure of the schemes.

The base of the composition of two morphisms in the category of schemes is equal to the composition of their bases.


theorem RingHom.map_list_sum :
    ∀ {β : Type u_4} {γ : Type u_5} [inst : NonAssocSemiring β] [inst_1 : NonAssocSemiring γ] (f : β →+* γ)
      (l : List β), f (List.sum l) = List.sum (List.map (⇑f) l) :=
  by sorry

The theorem `RingHom.map_list_sum` states that for any list of elements from a non-associative semiring `β` and a ring homomorphism `f` from `β` to another non-associative semiring `γ`, the application of `f` to the sum of the list is equal to the sum of the list obtained by mapping `f` over the original list. In other words, summing the list after the map is the same as mapping after summing the list, illustrating the property of homomorphisms preserving the sum operation.

For any semiring homomorphism between non-associative semirings and a list of elements from the source semiring, the homomorphism applied to the sum of the list equals the sum of the homomorphisms applied to the individual list elements.


/-- Naturality of the `prodComparison` morphism in both arguments.  -/
theorem CategoryTheory.Limits.prodComparison_natural :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{w, u₂} D]
      (F : CategoryTheory.Functor C D) {A A' B B' : C} [inst_2 : CategoryTheory.Limits.HasBinaryProduct A B]
      [inst_3 : CategoryTheory.Limits.HasBinaryProduct A' B']
      [inst_4 : CategoryTheory.Limits.HasBinaryProduct (F.obj A) (F.obj B)]
      [inst_5 : CategoryTheory.Limits.HasBinaryProduct (F.obj A') (F.obj B')] (f : A ⟶ A') (g : B ⟶ B'),
      CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.prod.map f g))
          (CategoryTheory.Limits.prodComparison F A' B') =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prodComparison F A B)
          (CategoryTheory.Limits.prod.map (F.map f) (F.map g)) :=
  by sorry

The theorem `CategoryTheory.Limits.prodComparison_natural` establishes the naturality of the `prodComparison` morphism in both arguments in the context of category theory. Specifically, given categories `C` and `D`, a functor `F` from `C` to `D`, and objects `A`, `A'`, `B`, `B'` in `C` that have binary products both in `C` and in the image of `F`, along with morphisms `f` from `A` to `A'` and `g` from `B` to `B'`, the theorem states that the composition of the functor's map applied to the product map of `f` and `g` followed by the product comparison of `F` on `A'` and `B'` equals the composition of the product comparison of `F` on `A` and `B` followed by the product map of the functor's map applied to `f` and `g`. This naturality property captures the notion that the diagram involving these morphisms and objects commutes.

Given functors F from category C to D, and objects A, A', B, B' in C with binary products, morphisms f : A → A' and g : B → B' in C, the naturality of prodComparison morphism in prodComparison\_natural theorem asserts that F(π\_1(f, g)) = π'_1(F(f), F(g)) ∘ prodComparison(F(A), F(B)). Here, π\_1 denotes the first projection of the product, and π'_1 the first projection of the product in the image of F.


theorem Matrix.fromBlocks_one :
    ∀ {l : Type u_1} {m : Type u_2} {α : Type u_12} [inst : DecidableEq l] [inst_1 : DecidableEq m] [inst_2 : Zero α]
      [inst_3 : One α], Matrix.fromBlocks 1 0 0 1 = 1 :=
  by sorry

This theorem states that for any types `l` and `m`, and any type `α` that has a zero and a one, if equality is decidable for the types `l` and `m`, then forming a block matrix from four matrices, specifically, the 1 matrix, the 0 matrix, another 0 matrix, and another 1 matrix, is equal to the 1 matrix. This essentially asserts that the block matrix of the unit matrices and zero matrices conforms to the identity matrix in matrix arithmetic.

For types `l` and `m` with decidable equality and any type `α` with zero and one, the block matrix of the identity (1) and zero (0) matrices of sizes compatible with `α` is equal to the identity matrix.


/-- The intersection of a Lindelöf set and a closed set is a Lindelöf set.  -/
theorem IsLindelof.inter_right :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsLindelof s → IsClosed t → IsLindelof (s ∩ t) := by sorry

The theorem states that the intersection of a Lindelöf set and a closed set is also a Lindelöf set. In more detail, given any type `X` that has a topological space structure and any two sets `s` and `t` of this type, if `s` is a Lindelöf set (meaning every nontrivial filter with the countable intersection property that contains `s` has a cluster point in `s`) and `t` is a closed set, then their intersection `(s ∩ t)` is also a Lindelöf set.

If `s` is a Lindelöf set and `t` is a closed set in a topological space, then their intersection `s ∩ t` is also a Lindelöf set.


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

The theorem `Submodule.comap_map_eq_of_injective` states that for any two types `R` and `R₂` that form semirings, any two types `M` and `M₂` that form additive commutative monoids and are modules over `R` and `R₂` respectively, a ring homomorphism `σ₁₂` from `R` to `R₂` that is surjective, a type `F` that is a function-like from `M` to `M₂`, and a semilinear map from `F` to `σ₁₂` in the context of `M` and `M₂`. Given any function `f` of type `F` that is injective and any submodule `p` of `M`, the submodule obtained by first mapping `p` using `f` and then performing the comap operation of `f` on the result equals `p`.

In even more layman's terms, if you have an injective function and you apply it to a submodule, then 'undo' the function using a comap operation, you get your original submodule back. This is a kind of 'inverse operation' property for injective functions and submodules.

For any injective semilinear map `F` from an additive commutative monoid `M` (a `R`-module) to an additive commutative monoid `M₂` (an `R₂`-module), and any surjective ring homomorphism `σ₁₂` from `R` to `R₂`, if `p` is a submodule of `M`, then `(map F '' p) = comap F '' p`.


theorem MvPowerSeries.map_C :
    ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (a : R),
      (MvPowerSeries.map σ f) ((MvPowerSeries.C σ R) a) = (MvPowerSeries.C σ S) (f a) :=
  by sorry

The theorem `MvPowerSeries.map_C` states that for any types `σ`, `R`, `S` with `R` and `S` being semirings, and for each ring homomorphism `f` from `R` to `S` and each element `a` of `R`, the operation of first applying the constant homomorphism `MvPowerSeries.C σ R` to `a` to get a multivariate power series over `R` and then applying the map `MvPowerSeries.map σ f` to the result is the same as first applying `f` to `a` to get an element of `S` and then applying the constant homomorphism `MvPowerSeries.C σ S` to the result. In other words, mapping and constant conversion commute in this context.

For any semirings R and S, ring homomorphism f from R to S, and element a in R, the constant homomorphism applied to a in R and then mapped to S using f is equal to mapping a in R to S using f and then applying the constant homomorphism in S.


/-- This lemma also holds for `ENNReal`, but we need a different proof for that.  -/
theorem tsub_lt_tsub_iff_right :
    ∀ {α : Type u_1} [inst : CanonicallyLinearOrderedAddCommMonoid α] [inst_1 : Sub α] [inst_2 : OrderedSub α]
      {a b c : α} [inst_3 : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1],
      c ≤ a → (a - c < b - c ↔ a < b) :=
  by sorry

This theorem states a property about subtraction in a certain kind of mathematical structure called "canonically linear ordered additive commutative monoid" with an "ordered subtraction" operation. In this setting, for any three elements `a`, `b`, and `c`, if `c` is less than or equal to `a`, then `a` minus `c` is less than `b` minus `c` if and only if `a` is less than `b`. This essentially describes how subtracting the same amount from two quantities preserves the order between the quantities. Note that this theorem is also valid for extended non-negative real numbers, but its proof in that case is different.

In a canonically linear ordered additive commutative monoid, for all elements `a`, `b`, and `c`, if `c` ≤ `a`, then `a - c` < `b - c` if and only if `a` < `b`.


theorem Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.10 :
    ∀ {V : Type u} (G : SimpleGraph V) (v w : V), Gᶜ.Adj v w = (v ≠ w ∧ ¬G.Adj v w) := by sorry

The theorem `Mathlib.Combinatorics.SimpleGraph.Basic._auxLemma.10` states that for any type `V` and for any simple graph `G` of type `V`, and for any vertices `v` and `w` in this graph, `v` and `w` are adjacent in the complement of `G` if and only if `v` is not equal to `w` and `v` and `w` are not adjacent in `G`. Simply put, it defines the adjacency in the complement graph in terms of the original graph.

For any simple graph G and vertices v and w, v and w are adjacent in the complement graph if and only if they are not equal and not adjacent in G.


theorem Finset.image_toFinset :
    ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} [inst_1 : DecidableEq α] {s : Multiset α},
      Finset.image f (Multiset.toFinset s) = Multiset.toFinset (Multiset.map f s) :=
  by sorry

This theorem states that for any two types `α` and `β` where `β` has a decidable equality, for any function `f` from `α` to `β`, and for any equation with decidable equality in `α`, if you apply the function `f` to a multiset `s` of type `α`, convert it to a finiset and then take the image under `f`, it is equal to mapping the function `f` to the multiset `s` first and then converting it to a finiset. In other words, the order of operations - finiset conversion and image under a function - does not matter.

For any functions `f: α → β` with decidable equality and decidable types `α` and `β`, the application of `f` to a multiset `s` of type `α`, conversion to a finiset, and taking the image under `f` is equal to first mapping `f` to `s` and then converting the resulting multiset to a finiset.


theorem UniformSpace.Completion.denseRange_coe : ∀ {α : Type u_1} [inst : UniformSpace α], DenseRange ↑α := by sorry

This theorem states that for any type `α` equipped with a Uniform Space structure, the coercion function from `α` to its completion (denoted by `↑α`) has a dense range. In other words, the image (or range) of the original set `α` under the coercion function is a dense subset of the completion of `α`. In terms of topology, this means that every point in the completion of `α` can be approximated as closely as desired by points from `α`.

For any uniform space `(α, τ)`, the coercion function from `α` to its completion `(↑α, τ↑)` has a dense range.


theorem Nat.mem_divisors_self : ∀ (n : ℕ), n ≠ 0 → n ∈ Nat.divisors n := by sorry

The theorem `Nat.mem_divisors_self` states that for any natural number `n` that is not zero, `n` is a member of its own set of divisors. That is, a natural number `n` (except for 0) divides itself. In the language of set theory, this means `n` belongs to the set of its own divisors.

For any non-zero natural number `n`, `n` is a divisor of itself.


theorem HahnSeries.SummableFamily.isPWO_iUnion_support :
    ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R] {α : Type u_3}
      (s : HahnSeries.SummableFamily Γ R α), Set.IsPWO (⋃ a, HahnSeries.support (s a)) :=
  by sorry

This theorem states that for all types `Γ`, `R`, and `α`, and given a partial order on `Γ` and an additive commutative monoid on `R`, for any summable family `s` of Hahn series over `Γ` and `R` indexed by `α`, the set union of the supports of the Hahn series in the summable family is partially well-ordered. In other words, any infinite sequence from this set union contains a monotone subsequence of length 2, i.e., an infinite monotone subsequence. The "support" of a Hahn series is defined as the set of indices whose coefficients are nonzero, and being "partially well-ordered" is a property of a subset of a preorder.

Given a summable family of Hahn series over a partially ordered type `Γ` and an additive commutative monoid `R`, the set union of their supports is a partially well-ordered set, containing an infinite monotone subsequence.


/-- If `F` creates the limit of `K` and `K ⋙ F` has a limit, then `K` has a limit.  -/
theorem CategoryTheory.hasColimit_of_created :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂}
      [inst_1 : CategoryTheory.Category.{v₂, u₂} D] {J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J]
      (K : CategoryTheory.Functor J C) (F : CategoryTheory.Functor C D)
      [inst_3 : CategoryTheory.Limits.HasColimit (CategoryTheory.Functor.comp K F)]
      [inst_4 : CategoryTheory.CreatesColimit K F], CategoryTheory.Limits.HasColimit K :=
  by sorry

This theorem states that if a functor `F` creates the colimit of another functor `K` and the composition of `K` and `F` has a colimit, then `K` itself also has a colimit. In this context, a colimit is a way of defining the "limit" of a diagram (represented as a functor `K`) within a category, and "creating a colimit" means providing a way to construct such a limit. This theorem provides a condition under which we can be sure that a given functor has a colimit within its category.

If functor `F` creates colimits and the composition of `F` and `K` has a colimit, then functor `K` also has a colimit.


/-- Unfold the definition of `dimH` using `[MeasurableSpace X] [BorelSpace X]` from the
environment.  -/
theorem dimH_def :
    ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (s : Set X),
      dimH s = ⨆ d, ⨆ (_ : ↑↑(MeasureTheory.Measure.hausdorffMeasure ↑d) s = ⊤), ↑d :=
  by sorry

The theorem `dimH_def` provides the explicit formulation for the Hausdorff dimension of a set in an extended metric space. Specifically, for any set `s` in a type `X` that forms an extended metric space and also supports the concepts of measurability and Borel measurability, the Hausdorff dimension of `s` is the supremum (the least upper bound) of all real numbers `d` such that the Hausdorff measure of `s` with respect to `d` is infinite.

The Hausdorff dimension of a measurable and Borel measurable set in an extended metric space is the supremum of real numbers d such that the Hausdorff measure of the set with respect to d is infinite.


theorem Int.fract_eq_iff :
    ∀ {α : Type u_2} [inst : LinearOrderedRing α] [inst_1 : FloorRing α] {a b : α},
      Int.fract a = b ↔ 0 ≤ b ∧ b < 1 ∧ ∃ z, a - b = ↑z :=
  by sorry

The theorem `Int.fract_eq_iff` states that for any type `α` that forms a linear ordered ring and has a floor function, and for any two elements `a` and `b` of `α`, the fractional part of `a` being equal to `b` is equivalent to `b` being greater than or equal to zero and less than one, and there exists an integer `z` such that `a` minus `b` equals to `z`. In mathematical terms, this theorem states that $fract(a) = b$ if and only if $0 \leq b < 1$ and there exists an integer $z$ such that $a - b = z$.

The theorem `Int.fract_eq_iff` asserts that for any type `α` with a floor function and ordering, the fractional parts of elements `a` and `b` are equal if and only if `b` is between 0 and 1, and `a` equals `b` plus an integer.


theorem bot_covBy_iff : ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, ⊥ ⋖ a ↔ IsAtom a := by
  sorry

This theorem states that for any type `α` which is a partial order and has a least element, a specific element `a` of this type is covered by the least element if and only if `a` is an atom. Here, an atom of an `OrderBot` is defined as an element which has no other element between it and the least element, and it is not the least element itself. "Covered by" means that there's no other element between these two elements. In mathematical terms, we say `⊥` covers `a` if there is no element `b` such that `⊥ < b < a`.

For any partial order type `α` with a least element, an element `a` is covered by the least element if and only if `a` is an atom (i.e., there is no element between `a` and the least element).


theorem List.zipWithAll_nil_right :
    ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : Option α → Option α_1 → α_2} {as : List α},
      List.zipWithAll f as [] = List.map (fun a => f (some a) none) as :=
  by sorry

The `List.zipWithAll_nil_right` theorem states that for any list `as` of type `List α` and a function `f` of type `(Option α → Option α_1 → α_2)`, applying `List.zipWithAll` with `f` to `as` and an empty list results in the same list as applying `List.map` to `as` with a function that applies `f` to `Some a` and `None` for each element `a` in `as`. In other words, if you try to 'zip together' a list with an empty list using a function that operates on optional elements, you'll get back a list that's been transformed by that function treating all elements of the original list as present (`Some a`) and all elements of the empty list as absent (`None`).

For any list `as` of type `List α` and function `f` of type `Option α → Option α₁ → α₂`, `List.zipWithAll as [] f = List.map (λx => Some x >>= fun _ => Some (f (Some x) None)) as`.


/-- Symmetric entourages form a basis of `𝓤 α`  -/
theorem UniformSpace.hasBasis_symmetric :
    ∀ {α : Type ua} [inst : UniformSpace α],
      Filter.HasBasis (uniformity α) (fun s => s ∈ uniformity α ∧ SymmetricRel s) id :=
  by sorry

The theorem `UniformSpace.hasBasis_symmetric` states that for any type `α` with a `UniformSpace` structure, the filter `uniformity α` has a basis composed of those sets `s` which are both members of `uniformity α` and satisfy the property `SymmetricRel s` (meaning that the set `s` remains the same when the elements of each pair in the set are swapped). In essence, this theorem tells us that we can construct the uniformity of a uniform space using only symmetric neighborhoods.

The `UniformSpace.hasBasis_symmetric` theorem in Lean 4 asserts that the basis of a uniform space's uniformity consists of symmetric neighborhoods.


theorem ENNReal.div_le_of_le_mul : ∀ {a b c : ENNReal}, a ≤ b * c → a / c ≤ b := by sorry

This theorem states that for all extended nonnegative real numbers `a`, `b`, and `c`, if `a` is less than or equal to the product of `b` and `c`, then the quotient of `a` and `c` is less than or equal to `b`. In mathematical notation, this can be written as: given $a, b, c \in [0, \infty]$ (extended nonnegative real numbers), if $a \leq b \cdot c$, then $\frac{a}{c} \leq b$.

For all extended nonnegative real numbers $a$, $b$, and $c$, if $a \leq b \cdot c$, then $\frac{a}{c} \leq b$.


theorem GeneralizedContinuedFraction.terminatedAt_iff_s_none :
    ∀ {α : Type u_1} {g : GeneralizedContinuedFraction α} {n : ℕ},
      GeneralizedContinuedFraction.TerminatedAt g n ↔ Stream'.Seq.get? g.s n = none :=
  by sorry

The theorem `GeneralizedContinuedFraction.terminatedAt_iff_s_none` states that for any type `α`, any generalized continued fraction `g` of type `α`, and any natural number `n`, the generalized continued fraction `g` is said to be terminated at position `n` if and only if the `n`th element of the sequence of `g` does not exist, i.e., is `none`. In other words, it provides a criterion for termination of a generalized continued fraction in terms of the absence of the `n`th element in its underlying sequence.

A generalized continued fraction of type `α` is terminated at position `n` if and only if its `n`th element is `none`.


theorem Asymptotics.IsBigOWith.comp_tendsto :
    ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E}
      {g : α → F} {l : Filter α},
      Asymptotics.IsBigOWith c l f g →
        ∀ {k : β → α} {l' : Filter β}, Filter.Tendsto k l' l → Asymptotics.IsBigOWith c l' (f ∘ k) (g ∘ k) :=
  by sorry

The theorem `Asymptotics.IsBigOWith.comp_tendsto` states that for any two functions `f` and `g` from a type `α` to normed spaces `E` and `F` respectively, if at some filter `l` on `α`, `f` is big O of `g` with constant `c` (i.e., `f` is eventually at most `c` times `g`), then for any function `k` from a type `β` to `α` and any filter `l'` on `β`, if `k` tends to `l` at `l'`, then `(f ∘ k)` is also big O of `(g ∘ k)` with the same constant `c` at `l'`. In other words, the big O order of growth is preserved under composition with a function that tends to the original filter.

If function `f` is big O of `g` at filter `l` on type `α` with constant `c`, then `(f ∘ k)` is big O of `(g ∘ k)` at filter `l'` on type `β` with constant `c`, given that `k` tends to `l` at `l'`.


theorem Nat.mul_add : ∀ (n m k : ℕ), n * (m + k) = n * m + n * k := by sorry

This theorem states that for all natural numbers `n`, `m`, and `k`, the product of `n` and the sum of `m` and `k` is equal to the sum of the product of `n` and `m` and the product of `n` and `k`. In mathematical terms, it expresses the distributive property of multiplication over addition for natural numbers: `n*(m+k) = n*m + n*k`.

For all natural numbers `n`, `m`, and `k`, the product of `n` with the sum of `m` and `k` is equal to the sum of the products of `n` with `m` and `k` (distributive property of multiplication over addition).


AddMonoid.ext

theorem AddMonoid.ext : ∀ {M : Type u} ⦃m₁ m₂ : AddMonoid M⦄, HAdd.hAdd = HAdd.hAdd → m₁ = m₂ := by sorry

The theorem `AddMonoid.ext` states that for any type `M`, if `m₁` and `m₂` are two additive monoids on `M` such that their addition operations (`HAdd.hAdd`) are equivalent, then `m₁` and `m₂` must be the same additive monoid. In other words, this theorem asserts the uniqueness of the additive monoid structure on `M` in terms of its addition operation.

If two additive monoids on a type `M` have equivalent addition operations, then they are equal.


theorem dite_eq_right_iff :
    ∀ {α : Sort u_1} {b : α} {P : Prop} [inst : Decidable P] {A : P → α},
      (dite P A fun x => b) = b ↔ ∀ (h : P), A h = b :=
  by sorry

The theorem `dite_eq_right_iff` states that for any type `α`, element `b` of type `α`, proposition `P`, and function `A` from `P` to `α`, the expression `(dite P A fun x => b)` equals `b` if and only if for all proofs `h` of `P`, `A h` equals `b`. Here `dite` is a construct that, given a proposition `P`, a function `A` from `P` to `α`, and a default value `b`, selects `A h` if `P` is true for some `h`, and `b` otherwise. This theorem is about the equality relationship between the `dite` construct and its default value.

For any type α, proposition P, element b of α, and function A from P to α, the expression (dite P A b) equals b if and only if for all h proving P, Ah equals b.


theorem Polynomial.aeval_algebraMap_apply :
    ∀ {R : Type u_1} {A : Type u_2} (B : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring A]
      [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra A B] [inst_5 : Algebra R B]
      [inst_6 : IsScalarTower R A B] (x : A) (p : Polynomial R),
      (Polynomial.aeval ((algebraMap A B) x)) p = (algebraMap A B) ((Polynomial.aeval x) p) :=
  by sorry

The theorem `Polynomial.aeval_algebraMap_apply` states that for any commutative semirings `R` and `A`, a semiring `B`, and any `x` in `A` and polynomial `p` over `R`, if `A` and `B` are `R`-algebras and `B` is an `A`-algebra with `R` being a scalar tower, then the `R`-algebra homomorphism of `p`, created by sending the variable in `p` to `x` mapped into `B`, is equal to the result of mapping the `R`-algebra homomorphism of `p` into `B`, where the homomorphism is created by sending the variable in `p` to `x`. This basically means that mapping `x` into `B` first and then applying the homomorphism is the same as applying the homomorphism first and then mapping the result into `B`.

For any commutative semirings R, A, and B, given an R-algebra homomorphism from R[x] to B, an R-algebra homomorphism from A to B, and an element x in A, if R is a scalar tower in B and A is an R-algebra, then evaluating p(x) in B via the homomorphism from A is equivalent to applying the homomorphism from R[x] to B to the polynomial p and then evaluating at x.


theorem Ordinal.deriv_succ :
    ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}) (o : Ordinal.{u_1}),
      Ordinal.deriv f (Order.succ o) = Ordinal.nfp f (Order.succ (Ordinal.deriv f o)) :=
  by sorry

The theorem `Ordinal.deriv_succ` states that for any normal function `f` from an ordinal to another ordinal, and for any ordinal `o`, the derivative of `f` at the successor of `o` is equal to the next fixed point of `f` at the successor of the derivative of `f` at `o`. In other words, it formalizes the relationship between the derivative of a normal function at a certain point and the next fixed point of the function at a related point.

For any normal function from an ordinal to an ordinal, the derivative at the successor of an ordinal is the next fixed point at the successor of the derivative.


theorem Metric.smul_closedBall :
    ∀ {G : Type v} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : Group G] [inst_2 : MulAction G X]
      [inst_3 : IsometricSMul G X] (c : G) (x : X) (r : ℝ), c • Metric.closedBall x r = Metric.closedBall (c • x) r :=
  by sorry

The theorem `Metric.smul_closedBall` states that for any pseudometric space `X`, any group `G`, and any action of `G` on `X` that is isometric, scalar multiplication of a closed ball in `X` with center `x` and radius `r` by an element `c` from `G` results in another closed ball with center `c • x` and the same radius `r`. In other words, the action of `G` scales the center of the closed ball without changing its radius or the distances between the points within the ball.

For any pseudometric space X, group G acting isometrically on X, and closed ball B in X with center x and radius r, the scalar multiplication of B by c in G results in another closed ball with center c • x and radius r.


theorem Nat.bitwise_bit :
    ∀ {f : Bool → Bool → Bool},
      autoParam (f false false = false) _auto✝ →
        ∀ (a : Bool) (m : ℕ) (b : Bool) (n : ℕ),
          Nat.bitwise f (Nat.bit a m) (Nat.bit b n) = Nat.bit (f a b) (Nat.bitwise f m n) :=
  by sorry

The theorem `Nat.bitwise_bit` states that for any boolean function `f` (with an automatically provided parameter that `f` of two `false` values equals `false`), and for any boolean values `a` and `b` and natural numbers `m` and `n`, the `bitwise` operation of `f` on the bit representation of `m` and `n` with appended bits `a` and `b` respectively, is equal to the bit representation of the `bitwise` operation of `f` on `m` and `n` with appended bit as `f` of `a` and `b`. In other words, it describes a property of the `bitwise` operation in terms of bit extension and boolean functions.

For any boolean function `f` and natural numbers `m`, `n` with bit representations `x_m` and `x_n` respectively, and any boolean values `a` and `b`, the bitwise operation of `f` on `x_m` and `x_n` extended with bits `a` and `b` respectively, equals the bitwise operation of `f` on `x_m` and `x_n` extended with the bit `f(a, b)`.


theorem CategoryTheory.comp_dite :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : Prop} [inst_1 : Decidable P] {X Y Z : C} (f : X ⟶ Y)
      (g : P → (Y ⟶ Z)) (g' : ¬P → (Y ⟶ Z)),
      CategoryTheory.CategoryStruct.comp f (if h : P then g h else g' h) =
        if h : P then CategoryTheory.CategoryStruct.comp f (g h) else CategoryTheory.CategoryStruct.comp f (g' h) :=
  by sorry

This theorem is about the composition of morphisms in category theory, specifically within the context of a decision problem. The theorem, named `CategoryTheory.comp_dite`, states that for any category `C`, any proposition `P`, and any three objects `X`, `Y`, `Z` in `C`, for a morphism `f` from `X` to `Y`, and two morphisms `g` and `g'` from `Y` to `Z` that depend on whether `P` is true or false, the composition of `f` with the morphism chosen by a decision on `P` is equal to the composition of `f` with the morphism determined by the same decision on `P`. In other words, it doesn't matter if we decide `P` before or after composing the morphisms, the result will be the same.

For any category C, proposition P, and objects X, Y, Z, morphisms f : X -> Y, g : Y -> Z if P then g, g' : Y -> Z if not P, the commutative diagram P->(g = g')->(f.comp.g)<-(f.comp.g') holds, i.e., f.comp.g = f.comp.g' (regardless of the order of choosing g or g' based on P).


theorem Encodable.decode_ofEquiv :
    ∀ {α : Type u_3} {β : Type u_4} [inst : Encodable α] (e : β ≃ α) (n : ℕ),
      Encodable.decode n = Option.map (⇑e.symm) (Encodable.decode n) :=
  by sorry

The theorem `Encodable.decode_ofEquiv` states that for any types `α` and `β`, given that `α` is encodable and there is an equivalence `e` between `β` and `α`, for any natural number `n`, decoding `n` as an `α` and then mapping the inverse of `e` over the result is the same as just decoding `n` directly. In other words, it ensures that the decoding process respects the provided equivalence between the two types. This theorem essentially states that the decoding operation is invariant under applying the equivalence.

For any encodable types `α` and `β` with an equivalence `e`, decoding a natural number `n` as `α` and applying `e.symm` to the result is equivalent to directly decoding `n` as `β`.


theorem Multiset.add_eq_union_iff_disjoint :
    ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s + t = s ∪ t ↔ Multiset.Disjoint s t := by sorry

The theorem `Multiset.add_eq_union_iff_disjoint` states that for any type `α` with decidable equality and any two multisets `s` and `t` of type `α`, the sum of `s` and `t` is equal to the union of `s` and `t` if and only if `s` and `t` are disjoint. Here, a multiset is a generalization of a set that allows multiple instances of the elements, and two multisets are said to be disjoint if they don't have any element in common. The sum of two multisets includes all elements from both, potentially with duplicates, while their union includes each element only once. Therefore, their sum and union are equal if and only if there are no common elements, i.e., they are disjoint.

For any type `α` with decidable equality, two multisets `s` and `t` of type `α` have equal sum and union if and only if they are disjoint.


theorem Polynomial.X_ne_zero : ∀ {R : Type u} [inst : Semiring R] [inst_1 : Nontrivial R], Polynomial.X ≠ 0 := by sorry

This theorem states that for any type `R` with an instance of a semiring and nontriviality, the polynomial variable `X` (also known as an indeterminate) is not equal to zero. In other words, in any nontrivial semiring, the polynomial that represents a single indeterminate term (i.e., $x$ in standard algebraic notation, where $x$ is a non-zero scalar) will never be equal to zero.

In any nontrivial semiring, the indeterminate (or polynomial variable) is non-zero.


theorem MeasureTheory.Memℒp.of_le :
    ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
      [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : α → E} {g : α → F},
      MeasureTheory.Memℒp g p μ →
        MeasureTheory.AEStronglyMeasurable f μ → (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ ‖g x‖) → MeasureTheory.Memℒp f p μ :=
  by sorry

The theorem `MeasureTheory.Memℒp.of_le` states that for all types `α`, `E`, and `F`, a measurable space `m0` on `α`, an extended real number `p`, and a measure `μ` on `α`, and given normed add commutative groups over `E` and `F`, if a function `g` from `α` to `F` belongs to the space of `ℒp` functions with respect to measure `μ` (`MeasureTheory.Memℒp g p μ`), a function `f` from `α` to `E` is almost everywhere strongly measurable with respect to measure `μ` (`MeasureTheory.AEStronglyMeasurable f μ`), and for almost every `x` in `α` the norm of `f x` is less than or equal to the norm of `g x` (`∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ ‖g x‖`), then `f` also belongs to the space of `ℒp` functions with respect to measure `μ` (`MeasureTheory.Memℒp f p μ`). This theorem is essentially saying that the set of `ℒp` functions is closed under taking almost everywhere less-than-or-equal-to bounded variants.

If a function `f` from a measurable space to a normed add commutative group is almost everywhere strongly measurable, belongs to `ℒp` for some `p`, and has almost everywhere norm less than or equal to another `ℒp` function `g`, then `f` is also in `ℒp`.


theorem Mathlib.NumberTheory.Divisors._auxLemma.15 :
    ∀ {n : ℕ} {x : ℕ × ℕ}, (x ∈ Nat.divisorsAntidiagonal n) = (x.1 * x.2 = n ∧ n ≠ 0) := by sorry

The theorem `Mathlib.NumberTheory.Divisors._auxLemma.15` states that for every natural number `n` and every pair of natural numbers `x`, the pair `x` is in the set of divisors antidiagonal of `n` if and only if the product of the elements of `x` equals `n` and `n` is not equal to zero. The "divisors antidiagonal" of a number `n` is defined as the set of all pairs of natural numbers `(x, y)` such that `x * y = n`.

The theorem `Mathlib.NumberTheory.Divisors._auxLemma.15` asserts that a pair `(x, y)` of natural numbers is in the set of divisors antidiagonal of a natural number `n` if and only if `x * y = n` and `n` is non-zero.


theorem Matrix.empty_add_empty : ∀ {α : Type u} [inst : Add α] (v w : Fin 0 → α), v + w = ![] := by sorry

This theorem states that for any type `α` that supports addition, the sum of two empty vectors, `v` and `w`, of type `α` is an empty vector. In other words, if we take two vectors of size 0 (thus empty) and add them together, the result is another empty vector. This theorem follows logically from the fact that the sum of two empty structures is always empty, valid under the assumption that the type `α` allows for an addition operation.

For any type `α` with an addition operation, the sum of two empty vectors of type `α` is an empty vector.


HasSum.sub

theorem HasSum.sub :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α]
      [inst_2 : TopologicalAddGroup α] {f g : β → α} {a₁ a₂ : α},
      HasSum f a₁ → HasSum g a₂ → HasSum (fun b => f b - g b) (a₁ - a₂) :=
  by sorry

The theorem `HasSum.sub` states that for any two functions `f` and `g` from a type `β` to a type `α`, if `f` has a sum `a₁` and `g` has a sum `a₂` (where `α` is a topological add commutative group), then the function that maps each element of `β` to the difference of the corresponding values of `f` and `g` also has a sum, which is the difference of `a₁` and `a₂`. In mathematical terms, if $\sum f = a₁$ and $\sum g = a₂$, then $\sum (f-g) = a₁ - a₂$.

If functions $f$ and $g$ from type $\beta$ to a topological add commutative group $\alpha$ have sums $a\_1$ and $a\_2$ respectively, then their difference $f-g$ has sum $a\_1 - a\_2$.


theorem Equiv.rightInverse_symm : ∀ {α : Sort u} {β : Sort v} (f : α ≃ β), Function.RightInverse ⇑f.symm ⇑f := by sorry

The theorem `Equiv.rightInverse_symm` states that for any equivalence relation `f` between two types `α` and `β`, the function `f.symm` (the inverse of `f`) is a right inverse to `f`. In other words, if we apply `f` and then apply `f.symm` (i.e., we perform the composition `f ∘ f.symm`), we get the identity function on the type `β`. This is a property of all equivalence relations in Lean 4.

For any equivalence relation `f` between types `α` and `β` in Lean 4, `f.symm` is a right inverse to `f`, i.e., `f ∘ f.symm = idβ`.


theorem CategoryTheory.Limits.IsTerminal.comp_from :
    ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z : C} (t : CategoryTheory.Limits.IsTerminal Z)
      {X Y : C} (f : X ⟶ Y),
      CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.IsTerminal.from t Y) =
        CategoryTheory.Limits.IsTerminal.from t X :=
  by sorry

The theorem `CategoryTheory.Limits.IsTerminal.comp_from` states that for any category `C` and any terminal object `Z` in `C`, for any objects `X`, `Y` in `C` and any morphism `f` from `X` to `Y`, the composition of `f` with the unique morphism from `Y` to the terminal object `Z` is equal to the unique morphism from `X` to `Z`. This is essentially asserting the uniqueness property of the morphism to the terminal object in a category.

For any category `C` with a terminal object `Z`, given objects `X`, `Y` in `C` and a morphism `f : X → Y`, the unique morphisms from `Y` to `Z` and from `X` to `Z` are equal, i.e., `f ∘ u = t`, where `u` is the unique morphism from `Y` to `Z`, and `t` is the unique morphism from `X` to `Z`.


/-- A continuous function with compact support is integrable on the whole space.  -/
theorem Continuous.integrable_of_hasCompactSupport :
    ∀ {X : Type u_1} {E : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X]
      [inst_2 : NormedAddCommGroup E] {f : X → E} {μ : MeasureTheory.Measure X} [inst_3 : OpensMeasurableSpace X]
      [inst_4 : MeasureTheory.IsFiniteMeasureOnCompacts μ],
      Continuous f → HasCompactSupport f → MeasureTheory.Integrable f μ :=
  by sorry

The theorem states that if we have a continuous function `f` from a measurable and topological space `X` to a normed additive commutative group `E`, and if this function `f` has compact support, then `f` is integrable with respect to a measure `μ` on `X`. Here integrability means that `f` is measurable and the integral `∫⁻ a, ‖f a‖ ∂μ` is finite. Also, the measure `μ` is assumed to be finite on compacts and the topological space `X` is assumed to be open and measurable. Compact support of `f` means that the closure of the support of `f` is compact or equivalently `f` is equal to `0` outside a compact set.

If `f` is a continuous function from a measurable and open, topological space `X` with finite measure on compacts, having compact support, then `f` is integrable with respect to a finite measure `μ` on `X`.


SetTheory.PGame.Numeric.moveLeft

theorem SetTheory.PGame.Numeric.moveLeft :
    ∀ {x : SetTheory.PGame},
      SetTheory.PGame.Numeric x →
        ∀ (i : SetTheory.PGame.LeftMoves x), SetTheory.PGame.Numeric (SetTheory.PGame.moveLeft x i) :=
  by sorry

This theorem states that for any pre-game `x` in set theory, if `x` is numeric (i.e., every element in the left set `L` is less than every element in the right set `R`, and all elements of `L` and `R` are numeric), then for every allowable move `i` by the Left player, the resulting pre-game after Left makes move `i` will also be numeric. In other words, making a valid move in a numeric pre-game will result in another numeric pre-game.

For any pre-game `x` in set theory that is numeric and for every allowable move `i` by the Left player, the resulting pre-game is also numeric.


theorem Set.bijective_iff_bijOn_univ :
    ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Bijective f ↔ Set.BijOn f Set.univ Set.univ := by sorry

This theorem states that for any two types `α` and `β` and a function `f` from `α` to `β`, the function `f` is bijective if and only if `f` is bijective on the universal sets of `α` and `β`. In other words, a function `f` is both injective (each element of `α` maps to a unique element of `β`) and surjective (every element of `β` is the image of some element of `α`) if and only if the same properties hold when considering all elements of the types `α` and `β`.

A function between types is bijective if and only if it is both injective and surjective on their universal sets.


theorem isCompact_iUnion :
    ∀ {X : Type u} [inst : TopologicalSpace X] {ι : Sort u_2} {f : ι → Set X} [inst_1 : Finite ι],
      (∀ (i : ι), IsCompact (f i)) → IsCompact (⋃ i, f i) :=
  by sorry

The theorem `isCompact_iUnion` states that for any type `X` with a topological structure and a finite index set `ι`, if each set `f(i)` for `i` in `ι` is compact, then the union of all these sets `f(i)` is also compact. In more mathematical terms, if `f : ι → Set X` is a family of compact subsets indexed by a finite index set `ι`, then the union ⋃_{i in ι} f(i) is also a compact subset of `X`.

If `X` is a topological space and `f : ι → Compact X` is a family of compact subsets indexed by a finite set `ι`, then `⋃_{i in ι} f(i)` is a compact subset of `X`.


theorem inner_eq_zero_symm :
    ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
      {x y : E}, ⟪x, y⟫_𝕜 = 0 ↔ ⟪y, x⟫_𝕜 = 0 :=
  by sorry

This theorem states that for any types `𝕜` and `E`, given `𝕜` has a structure of `RCLike` (i.e., it behaves like a ring with conjugation), `E` is a normed add commutative group, and `E` is also an inner product space over `𝕜`, the inner product of two elements `x` and `y` of `E` is zero if and only if the inner product of `y` and `x` is also zero. This means the condition of zero inner product is symmetric with respect to the two elements.

For any type `𝕜` with an `RCLike` structure and `E` a normed add commutative group and inner product space over `𝕜`, the inner product is symmetric: `∀ x y : E, x ⋅ y = y ⋅ x`.


theorem OrderIso.symm_apply_le :
    ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {x : α} {y : β},
      (OrderIso.symm e) y ≤ x ↔ y ≤ e x :=
  by sorry

This theorem states that for any types `α` and `β` equipped with a less-than-or-equal-to (`≤`) relation, and given an order isomorphism `e` between `α` and `β`, the less-than-or-equal-to (`≤`) relation between the image of a variable `y` under the inverse of the isomorphism `(OrderIso.symm e) y` and a variable `x` in `α`, is equivalent to the relation of `y` being less than or equal to the image of `x` under the isomorphism `e x`. In mathematical terms, this is saying that `(OrderIso.symm e) y ≤ x` if and only if `y ≤ e x` for all `x` in `α` and `y` in `β`.

For any order isomorphisms between types `α` and `β` and for all `x` in `α` and `y` in `β`, `(OrderIso.symm e) y ≤ x` if and only if `y ≤ e x`.


theorem Commute.add_left :
    ∀ {R : Type x} [inst : Distrib R] {a b c : R}, Commute a c → Commute b c → Commute (a + b) c := by sorry

This theorem states that for any type `R` that has a distributive operation, if two elements `a` and `c` commute (i.e., `a * c = c * a`) and two elements `b` and `c` also commute, then the sum of `a` and `b` commutes with `c` (i.e., `(a + b) * c = c * (a + b)`). In other words, if multiplication by `c` commutes with both `a` and `b`, then it also commutes with the sum of `a` and `b`. This theorem is a statement about the commutativity of multiplication over addition in distributive structures.

If `R` is a distributive type with commutative multiplication, and `a`, `b`, and `c` are commuting elements, then `(a + b) * c = c * (a + b)`.


theorem MeasureTheory.Measure.bind_apply :
    ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
      {m : MeasureTheory.Measure α} {f : α → MeasureTheory.Measure β} {s : Set β},
      MeasurableSet s → Measurable f → ↑↑(MeasureTheory.Measure.bind m f) s = ∫⁻ (a : α), ↑↑(f a) s ∂m :=
  by sorry

The theorem `MeasureTheory.Measure.bind_apply` states that for any types `α` and `β` that are equipped with measurable spaces, given a measure `m` on `α`, a function `f` from `α` to the set of measures on `β`, and a set `s` in `β`, if `s` is a measurable set and `f` is a measurable function, then the measure of `s` under the measure obtained by binding `m` and `f` is equal to the integral over `α` of the function that sends `a` in `α` to the measure of `s` under the measure `f(a)`, with respect to the measure `m`. In other words, it shows how the `bind` operation on measures interacts with the application of a measure to a set, in terms of an integral of measures.

For measurable spaces (α, m) and (β, ν), measurable function f : α → ν, and measurable set s ∈ β, the integral of the function mapping a ∈ α to ν(s under f(a)) with respect to m equals the measure of s under the measure obtained by binding m and f.


List.Sublist.append

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

This theorem states that for any type `α` and any lists `l₁`, `l₂`, `r₁`, and `r₂` of this type, if `l₁` is a sublist of `l₂` and `r₁` is a sublist of `r₂`, then the list formed by appending `l₁` and `r₁` will be a sublist of the list formed by appending `l₂` and `r₂`. In mathematical terms, this can be written as: ∀α, l₁, l₂, r₁, r₂ ∈ List(α), l₁ ⊆ l₂ ∧ r₁ ⊆ r₂ → (l₁ ++ r₁) ⊆ (l₂ ++ r₂).

If `l₁` is a sublist of `l₂` and `r₁` is a sublist of `r₂`, then the concatenation of `l₁` and `r₁` is a sublist of the concatenation of `l₂` and `r₂` (for all types `α`).


theorem List.count_append :
    ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l₁ l₂ : List α),
      List.count a (l₁ ++ l₂) = List.count a l₁ + List.count a l₂ :=
  by sorry

The theorem `List.count_append` states that for any type `α` with decidable equality, for any element `a` of type `α`, and for any two lists `l₁` and `l₂` of type `α`, the number of occurrences of `a` in the concatenation of `l₁` and `l₂` is equal to the sum of the number of occurrences of `a` in `l₁` and the number of occurrences of `a` in `l₂`. In other words, counting an element in the combined list is equivalent to counting the element in each list separately and adding the results.

For any type `α` with decidable equality, the number of occurrences of an element `a` in the concatenation of lists `l₁` and `l₂` equals the sum of the number of occurrences of `a` in `l₁` and the number of occurrences of `a` in `l₂`.


theorem CategoryTheory.Arrow.w_assoc :
    ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g) {Z : T}
      (h : g.right ⟶ Z),
      CategoryTheory.CategoryStruct.comp sq.left (CategoryTheory.CategoryStruct.comp g.hom h) =
        CategoryTheory.CategoryStruct.comp f.hom (CategoryTheory.CategoryStruct.comp sq.right h) :=
  by sorry

This theorem states that for any category `T`, and any two objects `f` and `g` in the arrow category of `T` with a morphism `sq` from `f` to `g`, and any object `Z` in `T` with a morphism `h` from `g.right` to `Z`, the composition of the morphism `sq.left` with the composition of `g.hom` and `h` is equal to the composition of `f.hom` with the composition of `sq.right` and `h`. In other words, the theorem is stating a property of commutative squares in the arrow category, where the paths around the square via different routes yield the same result, a fundamental property in category theory.

For any commutative square in a category, the composition of the morphisms along the two parallel paths is equal.


theorem Hyperreal.IsSt.st_eq : ∀ {x : ℝ*} {r : ℝ}, Hyperreal.IsSt x r → Hyperreal.st x = r := by sorry

The theorem `Hyperreal.IsSt.st_eq` states that for any hyperreal number `x` and any real number `r`, if `r` is the standard part of `x` (i.e., `r` is as close to `x` as possible, but still a standard real number), then the standard part function `Hyperreal.st` applied to `x` equals `r`. This is a formalization of the idea that the standard part of a hyperreal number is the real number that is closest to it while remaining within any infinitesimal distance.

For any hyperreal number `x` and its standard part `r`, `Hyperreal.st x = r`.


theorem Nat.even_iff_not_odd : ∀ {n : ℕ}, Even n ↔ ¬Odd n := by sorry

This theorem states that for every natural number `n`, `n` is even if and only if `n` is not odd. Here, a number is defined as being even if it can be expressed as the sum of two identical numbers, and as being odd if it can be represented as `2*k + 1` for some natural number `k`. In other words, a natural number cannot be both even and odd simultaneously.

A natural number is even if and only if it is not odd. Equivalently, a natural number is even if and only if it can be written as 2 times some natural number, and it is odd if and only if it can be written as 2 times some natural number plus 1.


theorem Embedding.map_nhdsWithin_eq :
    ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
      Embedding f → ∀ (s : Set α) (x : α), Filter.map f (nhdsWithin x s) = nhdsWithin (f x) (f '' s) :=
  by sorry

This theorem states that for any two types `α` and `β`, each equipped with a topological space structure, and any function `f` from `α` to `β` that is an embedding, the image under `f` of the "neighborhood within" filter at a point `x` in a set `s` in `α` is equal to the "neighborhood within" filter at the image of `x` under `f` in the image of `s` under `f`. In mathematical terms, this can be expressed as: for a topological embedding `f : α → β`, the forward map of the filter `nhdsWithin x s` under `f` is equal to `nhdsWithin (f x) (f '' s)`, where `nhdsWithin x s` represents the intersection of a neighborhood of `x` with the set `s`, and `f '' s` is the image of `s` under the function `f`.

For a topological embedding `f : α → β`, the image under `f` of the neighborhood filter of a point `x` in a set `s` in `α` is equal to the neighborhood filter of the image of `x` in the image of `s` under `f`.


Asymptotics.IsBigOWith.congr

theorem Asymptotics.IsBigOWith.congr :
    ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c₁ c₂ : ℝ} {l : Filter α}
      {f₁ f₂ : α → E} {g₁ g₂ : α → F},
      Asymptotics.IsBigOWith c₁ l f₁ g₁ →
        c₁ = c₂ → (∀ (x : α), f₁ x = f₂ x) → (∀ (x : α), g₁ x = g₂ x) → Asymptotics.IsBigOWith c₂ l f₂ g₂ :=
  by sorry

The theorem `Asymptotics.IsBigOWith.congr` states that for any two real numbers `c₁` and `c₂`, any two functions `f₁` and `f₂` from a type `α` to a normed type `E`, and any two functions `g₁` and `g₂` from `α` to another normed type `F`, if `f₁` is Big-O of `g₁` with respect to the filter `l` and the constant `c₁`, and if `c₁` equals `c₂`, `f₁` equals `f₂` for all `x` in `α`, and `g₁` equals `g₂` for all `x` in `α`, then `f₂` is also Big-O of `g₂` with respect to the filter `l` and the constant `c₂`. In other words, Big-O notation is congruent with respect to the constants and the functions involved.

If `f₁` is Big-O of `g₁` with respect to filter `l` and constant `c₁`, `c₁ = c₂`, `f₁ = f₂`, and `g₁ = g₂` hold for all `x` in `α`, then `f₂` is Big-O of `g₂` with respect to filter `l` and constant `c₂`.


theorem AEMeasurable.div_const :
    ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : Div G] {m : MeasurableSpace α} {f : α → G}
      {μ : MeasureTheory.Measure α} [inst_2 : MeasurableDiv G],
      AEMeasurable f μ → ∀ (c : G), AEMeasurable (fun x => f x / c) μ :=
  by sorry

The theorem `AEMeasurable.div_const` states that for any type `G` with a `MeasurableSpace` and a `Div` instance, any measurable space `α`, any function `f` from `α` to `G`, and any measure `μ` on `α`, if `f` is almost everywhere measurable with respect to `μ`, then for any constant `c` in `G`, the function `fun x => f x / c` (which maps each `x` in `α` to `f(x)/c` in `G`) is almost everywhere measurable with respect to `μ` as well. This theorem essentially says that dividing an almost everywhere measurable function by a constant results in another function that is still almost everywhere measurable.

If `f` is almost everywhere measurable with respect to measure `μ` on measurable space `α` and `G` is a type with a `Div` instance, then the function `x ↦ f x / c` is almost everywhere measurable for any constant `c` in `G`.


theorem BumpCovering.IsSubordinate.toPartitionOfUnity :
    ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} {f : BumpCovering ι X s} {U : ι → Set X},
      BumpCovering.IsSubordinate f U → PartitionOfUnity.IsSubordinate (BumpCovering.toPartitionOfUnity f) U :=
  by sorry

The theorem `BumpCovering.IsSubordinate.toPartitionOfUnity` states that for any type `ι`, any type `X` with a topological space structure, any set `s` of type `X`, any bump covering `f` of type `BumpCovering ι X s`, and any family of sets `U` indexed by `ι`, if the bump covering `f` is subordinate to the family of sets `U` (meaning that for each index `i`, the closure of the support of `f i` is a subset of `U i`), then the partition of unity obtained from the bump covering `f` (denoted `BumpCovering.toPartitionOfUnity f`) is also subordinate to the same family of sets `U`.

If a bump covering is subordinate to a family of sets, then the partition of unity obtained from the bump covering is also subordinate to the same family.


Quot.exact

theorem Quot.exact : ∀ {α : Type u} (r : α → α → Prop) {a b : α}, Quot.mk r a = Quot.mk r b → EqvGen r a b := by sorry

This theorem, `Quot.exact`, states that for any type `α` and an equivalence relation `r` on `α`, if two quotient types created by `Quot.mk` with inputs `a` and `b` are equal, then `a` and `b` are `EqvGen` related with respect to `r`. In other words, it essentially says that if two quotient types are the same, then the original elements that were used to create those quotient types must be related by the equivalence relation `r` that defines the quotient space.

If two quotient types created by an equivalence relation are equal in Lean, then the corresponding elements are related by the equivalence relation.


theorem CategoryTheory.Iso.symm_symm_eq :
    ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y), α.symm.symm = α := by sorry

This theorem states that in the setting of category theory, for any category `C` and any two objects `X` and `Y` in `C`, the double inversion (or double symmetry) of an isomorphism `α` from `X` to `Y` equals the original isomorphism `α`. In other words, if you have an isomorphism and apply the 'inverse' operation twice, you recover the original isomorphism.

In category theory, for any isomorphism α : X ↔ Y between objects X and Y, α⁻ⁱⁱ = α holds. (Here, α⁻ⁱ denotes the double inverse or double dual of α.)


theorem TrivSqZeroExt.inl_add :
    ∀ {R : Type u} (M : Type v) [inst : Add R] [inst_1 : AddZeroClass M] (r₁ r₂ : R),
      TrivSqZeroExt.inl (r₁ + r₂) = TrivSqZeroExt.inl r₁ + TrivSqZeroExt.inl r₂ :=
  by sorry

This theorem, `TrivSqZeroExt.inl_add`, states that for any two elements `r₁` and `r₂` of type `R` (where `R` is any type with an addition operation) and `M` is any type with zero and an addition operation, the function `TrivSqZeroExt.inl` (which maps an element of `R` to a pair in `TrivSqZeroExt R M` consisting of that element and zero) preserves the addition operation. In other words, applying this function to the sum of `r₁` and `r₂` yields the same result as summing the results of applying this function to `r₁` and `r₂` separately.

For any types `R` with addition and `M` with zero and addition, the function `TrivSqZeroExt.inl : R -> TrivSqZeroExt R M` preserves addition, that is, `TrivSqZeroExt.inl (r₁ + r₂) = TrivSqZeroExt.inl r₁ + TrivSqZeroExt.inl r₂`.


theorem CategoryTheory.Limits.coconeOfConeLeftOp_ι_app :
    ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃}
      [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J Cᵒᵖ}
      (c : CategoryTheory.Limits.Cone F.leftOp) (j : J),
      (CategoryTheory.Limits.coconeOfConeLeftOp c).ι.app j = (c.π.app (Opposite.op j)).op :=
  by sorry

This theorem states that in category theory, for any category J (of objects `u₁` and morphisms `v₁`), any category C (of objects `u₃` and morphisms `v₃`), any contravariant functor F from J to the opposite category of C, any cone c on the opposite functor of F, and any object j in J, the application of the natural transformation `ι` of the cocone derived from c by `coconeOfConeLeftOp` to the object j is equal to the opposite of the application of the natural transformation `π` of the cone c to the opposite of the object j.

For any contravariant functor F from category J to the opposite category of C, any cone c on the opposite functor of F, and any object j in J, the natural transformation from the cocone derived from c to j is equal to the opposite of the natural transformation from c to the opposite of j.


theorem Finsupp.support_add_eq :
    ∀ {α : Type u_1} {M : Type u_5} [inst : AddZeroClass M] [inst_1 : DecidableEq α] {g₁ g₂ : α →₀ M},
      Disjoint g₁.support g₂.support → (g₁ + g₂).support = g₁.support ∪ g₂.support :=
  by sorry

This theorem states that for any two functions `g₁` and `g₂` that map elements from a general type `α` to an additive monoid `M` with a zero element and having a decidable equality, if the supports (the set of points where the function is nonzero) of these functions are disjoint (in the sense that any element that is less than or equal to both of the supports is less than or equal to the bottom element of the order), then the support of the sum of these functions is equal to the union of their individual supports. In simpler terms, if two functions are nonzero at different sets of points, the set of points where their sum is nonzero is just the combination of the points where the original functions were nonzero.

If `g₁` and `g₂` are functions from a type `α` to an additive monoid `M` with decidable equality, and the supports of `g₁` and `g₂` are disjoint, then the support of `g₁ + g₂` is equal to the union of the supports of `g₁` and `g₂`.


theorem Multiset.coe_reverse : ∀ {α : Type u_1} (l : List α), ↑(List.reverse l) = ↑l := by sorry

This theorem states that for any type `α` and any list `l` of elements of type `α`, the multiset representation of the reversed list `l` is equal to the multiset representation of the original list `l`. In other words, reversing the order of elements in the list does not change its multiset representation, as multisets are collections of elements where order does not matter.

For any type `α` and list `l` of elements of type `α`, the multiset representation of list `l` is equal to the multiset representation of its reverse.


theorem GaloisConnection.l_eq_bot :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : PartialOrder β] [inst_2 : OrderBot β] {l : α → β}
      {u : β → α}, GaloisConnection l u → ∀ {x : α}, l x = ⊥ ↔ x ≤ u ⊥ :=
  by sorry

This theorem states that for any types `α` and `β` with a preorder on `α`, a partial order on `β`, and a least element (denoted as `⊥`) in `β`, and any functions `l: α → β` and `u: β → α` that form a Galois connection, then for any element `x` of `α`, `l x` is equal to the least element in `β` if and only if `x` is less than or equal to `u ⊥`. This theorem is crucial in connecting the concept of a Galois connection to the properties of the associated order structures.

For any Galois connection between preordered type `α` and partially ordered type `β` with a least element `⊥`, the image `l(x)` of an element `x` in `α` under `l` is equal to `⊥` if and only if `x` is less than or equal to `u⊥` in `α`.


theorem StrictConvexOn.add_convexOn :
    ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : OrderedSemiring 𝕜] [inst_1 : AddCommMonoid E]
      [inst_2 : OrderedCancelAddCommMonoid β] [inst_3 : SMul 𝕜 E] [inst_4 : DistribMulAction 𝕜 β] {s : Set E}
      {f g : E → β}, StrictConvexOn 𝕜 s f → ConvexOn 𝕜 s g → StrictConvexOn 𝕜 s (f + g) :=
  by sorry

The theorem `StrictConvexOn.add_convexOn` states that for any ordered semiring `𝕜`, a set `s` of elements of type `E`, and two functions `f` and `g` from `E` to `β` such that `f` is strictly convex on `s` and `g` is convex on `s`, the function `f + g` (which represents the pointwise addition of `f` and `g`) is also strictly convex on `s`. Here, an ordered semiring is a mathematical structure with two operations that generalize the arithmetic operations of addition and multiplication, and a set `s` is strictly convex if for any two distinct points in `s`, all points on the line segment between them but not including the endpoints are inside `s`.

If `𝕜` is an ordered semiring, `s` is a strictly convex subset of `E`, and `f` and `g` are functions from `E` to `β` with `f` strictly convex on `s` and `g` convex on `s`, then `f + g` is strictly convex on `s`.


theorem StieltjesFunction.iInf_rat_gt_eq : ∀ (f : StieltjesFunction) (x : ℝ), ⨅ r, ↑f ↑↑r = ↑f x := by sorry

This theorem states that for any Stieltjes function 'f' and any real number 'x', the infimum (greatest lower bound) of the values of 'f' on the set of rational numbers 'r' is equal to the value of 'f' at 'x'. In other words, for all Stieltjes functions and real numbers, the function value at that real number is the lowest possible value that the function can take on the rationals.

For any Stieltjes function `f` and real number `x`, the infimum of `f` over rational numbers equals `f`(x).


theorem AbsoluteValue.sub_le :
    ∀ {R : Type u_5} {S : Type u_6} [inst : Ring R] [inst_1 : OrderedSemiring S] (abv : AbsoluteValue R S) (a b c : R),
      abv (a - c) ≤ abv (a - b) + abv (b - c) :=
  by sorry

This theorem states that for any types `R` and `S`, where `R` is a ring and `S` is an ordered semiring, and any absolute value function `abv` from `R` to `S`, and for any elements `a`, `b`, and `c` in `R`, the absolute value of `(a - c)` is less than or equal to the sum of the absolute values of `(a - b)` and `(b - c)`. This is a formal representation of the triangle inequality in the context of absolute values in arbitrary rings.

For any rings R and ordered semirings S, absolute value functions abv from R to S, and elements a, b, c in R, |a - c| ≤ |a - b| + |b - c| (triangle inequality for absolute values).


theorem Filter.mem_cocompact' :
    ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, s ∈ Filter.cocompact X ↔ ∃ t, IsCompact t ∧ sᶜ ⊆ t := by
  sorry

The theorem `Filter.mem_cocompact'` states that for any type `X`, equipped with a topological structure, and for any set `s` of type `X`, the set `s` is a member of the filter `cocompact` of `X` if and only if there exists a set `t` which is compact and the complement of `s` is a subset of `t`. Here, a set `t` is said to be compact if for every non-trivial filter `f` that contains `t`, there exists an element `a` in `t` such that every set of `f` intersects every neighborhood of `a`. The `cocompact` filter of `X` is the filter generated by the complements of all compact sets in `X`.

A set `s` in a topological space `X` belongs to the cocompact filter if and only if its complement is a subset of some compact set.


HasSum.op

theorem HasSum.op :
    ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α},
      HasSum f a → HasSum (fun a => MulOpposite.op (f a)) (MulOpposite.op a) :=
  by sorry

This theorem, named `HasSum.op`, says that for any types `α` and `β` where `α` is an additive commutative monoid and also has a topological space structure, and for any function `f` from `β` to `α` and any element `a` of `α`, if the series defined by `f` has a sum equal to `a`, then the series defined by the function which applies the operation `MulOpposite.op` to `f(a)` also has a sum, and this sum is equal to the opposite of `a` under the `MulOpposite.op` operation. In other words, the sum of the `MulOpposite.op` applied series is the `MulOpposite.op` of the sum of the original series.

For any additive commutative monoid `α` with a topological space structure and function `f: β → α`, if the series defined by `f` sums to an element `a` in `α`, then the series defined by `MulOpposite.op ∘ f` sums to `MulOpposite.op a`.


theorem eventually_nhdsWithin_of_forall :
    ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {a : α} {p : α → Prop},
      (∀ x ∈ s, p x) → ∀ᶠ (x : α) in nhdsWithin a s, p x :=
  by sorry

This theorem states that for any type `α` equipped with a topology (a `TopologicalSpace α`), any subset `s` of `α`, any point `a` in `α`, and any property `p` that the elements of `α` may or may not satisfy, if every element in subset `s` satisfies the property `p`, then eventually, every point `x` in the neighborhood within `s` of point `a` also satisfies property `p`. In other words, the property `p` holds true for all points in an arbitrary close neighborhood of `a`, if it holds true for all points in `s`. This theorem is a statement about the "local" behavior of the property `p` at point `a` within the given set `s`.

Given a topological space `(α, top)`, a subset `s ⊆ α`, a point `a ∈ α`, and a property `p(x) : Prop`, if `∀ x ∈ s, p(x)` holds, then for every neighborhood `U` of `a` in `s`, `∀ x ∈ U, p(x)` also holds.


theorem Function.const_le_const :
    ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Nonempty β] {a b : α},
      Function.const β a ≤ Function.const β b ↔ a ≤ b :=
  by sorry

The theorem `Function.const_le_const` states that, for all types `α` and `β`, where `α` has a preorder and `β` is nonempty, and for all elements `a` and `b` of `α`, the constant function with value `a` for the type `β` is less than or equal to the constant function with value `b` for the same type `β` if and only if `a` is less than or equal to `b`. It essentially relates the order of the values of two constant functions to the order of their function values.

For all types with a preorder, and for all constants `a` and `b` of such a type, the constant functions with values `a` and `b` are equal if and only if `a` is less than or equal to `b`. (Note: The given Lean theorem statement states that the constant functions are related by the preorder, but the mathematical statement more directly states that the constants themselves are related by the preorder relation.)


/-- Two affine subspaces with the same direction and nonempty intersection are equal.  -/
theorem AffineSubspace.ext_of_direction_eq :
    ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
      [inst_3 : AddTorsor V P] {s1 s2 : AffineSubspace k P},
      AffineSubspace.direction s1 = AffineSubspace.direction s2 → Set.Nonempty (↑s1 ∩ ↑s2) → s1 = s2 :=
  by sorry

The theorem `AffineSubspace.ext_of_direction_eq` states that for any ring `k`, additive commutative group `V`, and add-torsor `V P`, if we have two affine subspaces `s1` and `s2` of `k P`, and the direction of `s1` is equal to the direction of `s2`, then if the intersection of `s1` and `s2` is non-empty, `s1` and `s2` must be the same affine subspace. In simple terms, two affine subspaces are equal if they point in the same direction and they share at least one common point.

If two affine subspaces of a ring with additive commutative group have equal directions and non-empty intersection, then they are equal.


theorem LowerSet.coe_iInf₂ :
    ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : LE α] (f : (i : ι) → κ i → LowerSet α),
      ↑(⨅ i, ⨅ j, f i j) = ⋂ i, ⋂ j, ↑(f i j) :=
  by sorry

This theorem states that for any type `α` equipped with a less than or equal to relation (i.e., a pre-order), and for any indexed collection of sorts `ι` and `κ`, given a function `f` that takes an index `i` from `ι` and an index `j` from `κ i` and produces a lower set of `α`, the infimum (greatest lower bound) over all `i` and `j` of the elements of `f` is equal to the intersection over all `i` and `j` of the elements of `f`. In simple terms, it says that the greatest lower bound of a collection of lower sets can be obtained by intersecting all of those lower sets.

For any pre-order (α, ≤), given an indexed family of subsets {F i : ι → α : i ∈ ι} where each F i is a lower set, the infimum of the F i is equal to the intersection of the F i.


Finset.mk.injEq

theorem Finset.mk.injEq :
    ∀ {α : Type u_4} (val : Multiset α) (nodup : Multiset.Nodup val) (val_1 : Multiset α)
      (nodup_1 : Multiset.Nodup val_1),
      ({ val := val, nodup := nodup } = { val := val_1, nodup := nodup_1 }) = (val = val_1) :=
  by sorry

The theorem `Finset.mk.injEq` states that for any type `α`, and for any two multisets `val` and `val_1` of type `α` that have no duplicate elements (satisfying the `Multiset.Nodup` condition), the equality of two `Finset` objects, each constructed with `val` and `val_1` respectively along with their no-duplicates properties, is equivalent to the equality of `val` and `val_1` themselves. This implies that two `Finset`s are identical if and only if their underlying multisets are identical.

For any type `α` and multisets `val` and `val_1` of type `α` with no duplicate elements, the equality of the `Finset` objects constructed from `val` and `val_1` respectively implies and is implied by the equality of `val` and `val_1`.


theorem MeasureTheory.OuterMeasure.le_trim :
    ∀ {α : Type u_1} [inst : MeasurableSpace α] (m : MeasureTheory.OuterMeasure α),
      m ≤ MeasureTheory.OuterMeasure.trim m :=
  by sorry

This theorem states that for any outer measure `m` on a measurable space `α`, `m` is less than or equal to the trimmed outer measure `m.trim`. In other words, the original outer measure does not exceed the trimmed measure, which is the unique maximal outer measure that is less than or equivalent to the original outer measure when restricted to measurable sets.

For any outer measure `m` on a measurable space `α`, we have `m ≤ m.trim`.


theorem Filter.push_pull :
    ∀ {α : Type u} {β : Type v} (f : α → β) (F : Filter α) (G : Filter β),
      Filter.map f (F ⊓ Filter.comap f G) = Filter.map f F ⊓ G :=
  by sorry

The theorem `Filter.push_pull` states that for all types `α` and `β`, for any function `f` from `α` to `β`, and for any filters `F` on `α` and `G` on `β`, the forward map of the intersection of `F` and the preimage filter of `f` under `G` is equal to the intersection of the forward map of `F` and `G`. In other words, this theorem expresses a distributive property of the filter map operation with respect to the intersection of filters, in the context of a function and its preimage.

For any functions between types, the preimage filter of the function under the intersection of two filters is equal to the intersection of the function map and the filters.


theorem not_or_intro : ∀ {a b : Prop}, ¬a → ¬b → ¬(a ∨ b) := by sorry

This theorem, `not_or_intro`, states that for any two propositions `a` and `b`, if `a` is not true (denoted as `¬a`) and `b` is not true (denoted as `¬b`), then neither `a` nor `b` can be true (denoted as `¬(a ∨ b)`). In other words, it establishes that the negation of a disjunction (an 'or' statement) can be derived from the negations of its individual components.

The negation of the disjunction of two propositions is logically equivalent to the conjunction of their negations.


theorem Multiset.join_cons :
    ∀ {α : Type u_1} (s : Multiset α) (S : Multiset (Multiset α)), Multiset.join (s ::ₘ S) = s + Multiset.join S := by
  sorry

The theorem `Multiset.join_cons` states that for any type `α`, any multiset `s` of type `α`, and any multiset `S` of multisets of type `α`, the join operation on a multiset obtained by appending `s` to the front of `S` is equivalent to the multiset obtained by adding `s` to the multiset resulting from the join operation on `S`. In other words, the join operation distributes over the '+', or append, operation on multisets.

For any type `α`, the join of a multiset `s` with the multiset obtained by joining a multiset `S` of multisets of type `α` is equal to the multiset obtained by first joining the multisets in `S` and then appending `s`.


theorem Mathlib.Data.Set.Prod._auxLemma.50 :
    ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} {f : (i : ι) → α i},
      (f ∈ Set.pi s t) = ∀ i ∈ s, f i ∈ t i :=
  by sorry

This theorem states that for any index set `ι`, family of sets `t` indexed by `ι`, set `s` of indices from `ι`, and a function `f` that maps each element `i` in `ι` to an element in `α i`, the function `f` belongs to the set `Set.pi s t` (i.e., `f` is one of the dependent functions described by `Set.pi s t`) if and only if for all `i` in `s`, `f(i)` belongs to `t i`. In other words, `f` is in `Set.pi s t` exactly when `f` maps each index in `s` to an element within the corresponding set in the family `t`.

A function `f` belongs to `Set.pi s t` in Lean 4 if and only if for all `i` in `s`, `f(i)` is an element of `t(i)`.


theorem Finset.sum_Ico_consecutive :
    ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : ℕ → M) {m n k : ℕ},
      m ≤ n →
        n ≤ k →
          ((Finset.sum (Finset.Ico m n) fun i => f i) + Finset.sum (Finset.Ico n k) fun i => f i) =
            Finset.sum (Finset.Ico m k) fun i => f i :=
  by sorry

The theorem `Finset.sum_Ico_consecutive` states that for any given type `M` that forms an additive commutative monoid and a function `f` from natural numbers to `M`, if we have three natural numbers `m`, `n`, and `k` where `m` is less than or equal to `n` and `n` is less than or equal to `k`, the sum of the function `f` applied over all elements in the inclusive-exclusive interval from `m` to `n` and the sum of the function `f` applied over all elements in the inclusive-exclusive interval from `n` to `k` is equal to the sum of the function `f` applied over all elements in the inclusive-exclusive interval from `m` to `k`. Symbolically, this can be represented as $\sum_{i=m}^{n-1} f(i) + \sum_{i=n}^{k-1} f(i) = \sum_{i=m}^{k-1} f(i)$.

For any additive commutative monoid type M and function f from natural numbers to M, the sum of f over consecutive inclusive-exclusive intervals [m, n] and [n, k] equals the sum over the combined interval [m, k]. That is, $\sum\_{i=m}^{n-1} f(i) + \sum\_{i=n}^{k-1} f(i) = \sum\_{i=m}^{k-1} f(i)$.


theorem CategoryTheory.ComposableArrows.hom_ext_succ :
    ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {n : ℕ}
      {F G : CategoryTheory.ComposableArrows C (n + 1)} {f g : F ⟶ G},
      CategoryTheory.ComposableArrows.app' f 0 ⋯ = CategoryTheory.ComposableArrows.app' g 0 ⋯ →
        CategoryTheory.ComposableArrows.δ₀Functor.map f = CategoryTheory.ComposableArrows.δ₀Functor.map g → f = g :=
  by sorry

The theorem `CategoryTheory.ComposableArrows.hom_ext_succ` states that for any category `C` and natural number `n`, given two functors `F` and `G` that are instances of `ComposableArrows C (n + 1)` and two morphisms `f` and `g` from `F` to `G`, if the morphism induced on the 0th objects by `f` and `g` are equal and the mappings of `f` and `g` under the functor `δ₀Functor`, which forgets the first arrow, are also equal, then the two morphisms `f` and `g` themselves are equal. This theorem is a uniqueness result asserting that morphisms in the category of composable arrows are uniquely determined by their action on the 0th object and their action under the `δ₀Functor`.

If two morphisms in the category of composable arrows of length `n+1` over a category `C`, between functors `F` and `G` that are instances of `ComposableArrows C (n+1)`, have equal actions on the 0-objects and equal images under `δ₀Functor`, then they are equal.


/-- A function `f` maps upwards closed sets (atTop sets) to upwards closed sets when it is a
Galois insertion. The Galois "insertion" and "connection" is weakened to only require it to be an
insertion and a connection above `b'`.  -/
theorem Filter.map_atTop_eq_of_gc :
    ∀ {α : Type u_3} {β : Type u_4} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] {f : α → β} (g : β → α)
      (b' : β),
      Monotone f →
        (∀ (a : α), ∀ b ≥ b', f a ≤ b ↔ a ≤ g b) → (∀ b ≥ b', b ≤ f (g b)) → Filter.map f Filter.atTop = Filter.atTop :=
  by sorry

The theorem `Filter.map_atTop_eq_of_gc` states that for any two types `α` and `β` with a `SemilatticeSup` structure (a type of order where every two elements have a least upper bound), a function `f` from `α` to `β`, and its right inverse `g` from `β` to `α`, and a value `b'` of type `β`, if `f` is monotone (i.e., it preserves the order), and for all `a` of type `α` and `b` of type `β` greater than or equal to `b'`, `f a` is less than or equal to `b` if and only if `a` is less than or equal to `g b`, and for all `b` greater than or equal to `b'`, `b` is less than or equal to `f (g b)`, then the forward image of the filter `atTop` (which represents the limit as `α` approaches infinity) under `f` is also `atTop`. This theorem essentially tells us that a monotone function under certain conditions preserves the property of approaching infinity.

If `f : α → β` is a monotone function between semilattices with right inverse `g` such that for all `b' ∈ β` and `a ∈ α`, `f a ≤ b` if and only if `a ≤ g b` and for all `b ≥ b'`, `b ≤ f (g b)`, then `f''(Filter.atTop α) = Filter.atTop β`.


theorem IsometryEquiv.range_eq_univ :
    ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β),
      Set.range ⇑h = Set.univ :=
  by sorry

This theorem states that for any two types `α` and `β` equipped with `PseudoEMetricSpace` structures, if there is an isometry (denoted as `α ≃ᵢ β`), then the range of this isometric equivalence maps to the universal set of `β`. In other words, the isometry is surjective, mapping every element of `α` to some element in `β`.

Given types `α` and `β` with `PseudoEMetricSpace` structures and an isometry `α ≃ᵢ β`, every element in `α` is mapped to some element in `β`.