Documentation

TauCeti.Topology.Algebra.RestrictedProduct.Sum

Splitting a restricted product over a sum of index types #

A restricted product indexed by ι₁ ⊕ ι₂ is the product of the restricted products over the two summands. The factors need only carry a multiplication and the reference sets need only be closed under it (MulMemClass), so the splitting is a MulEquiv for submonoids and subgroups alike. For a filter 𝓕 on ι₁ ⊕ ι₂ the summand filters are the comaps 𝓕.comap Sum.inl and 𝓕.comap Sum.inr, and the algebraic content is that 𝓕 is recovered from them (Filter.map_comap_inl_sup_map_comap_inr), so the restrictedness conditions match up in both directions; the equivalence restrictedProductSum is the restriction of Equiv.sumPiEquivProdPi to the restricted subtypes. It takes the two summand filters as arguments together with the equations identifying them with the comaps, so that each can be given in its preferred form: for the cofinite filter both comaps are cofinite again, because Sum.inl and Sum.inr are injective (Function.Injective.comap_cofinite_eq). The summand filters need not be cofinite in general: for 𝓕 = 𝓟 (Set.range Sum.inl) the second comap is ⊥, and the right factor is the unrestricted product Π j, G (Sum.inr j).

The forward map is continuous for every filter and every reference family (continuous_restrictedProductSum). The inverse is a map out of a product of two restricted products, and its continuity depends on the filter and on the reference family. For a principal filter it is continuous for every family (continuous_restrictedProductSum_symm_of_principal), and hence so is its composite with the inclusions of principal stages (continuous_restrictedProductSum_symm_comp_prodMap_inclusion). For the cofinite filter, Mathlib's universal property with parameters passes from the stages to the restricted products when the reference subsets are open: over both summands (continuous_restrictedProductSum_symm, the openness hypothesis under which RestrictedProduct.isTopologicalGroup holds), or over the right summand alone when the left summand is finite (continuous_restrictedProductSum_symm_of_finite_left). Under either hypothesis restrictedProductSum is a homeomorphism. Openness cannot be dropped altogether: not_continuous_restrictedProductSum_symm, in TauCeti.Topology.Algebra.RestrictedProduct.NotContinuousMul, exhibits a family with trivial reference subgroups for which the inverse is discontinuous.

Everything here is also stated for additive structures (addRestrictedProductSum, …).

References #

def TauCeti.restrictedProductSum {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) :
RestrictedProduct (fun (k : ι₁ ⊕ ι₂) => G k) (fun (k : ι₁ ⊕ ι₂) => ↑(U k)) 𝓕 ≃* RestrictedProduct (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) 𝓕₁ × RestrictedProduct (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) 𝓕₂

A restricted product over ι₁ ⊕ ι₂ with respect to a filter 𝓕 is the product of the restricted products over the two summands with respect to the comaps of 𝓕 along Sum.inl and Sum.inr, coordinatewise the identity in both directions.

Instances For
    def TauCeti.addRestrictedProductSum {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) :
    RestrictedProduct (fun (k : ι₁ ⊕ ι₂) => G k) (fun (k : ι₁ ⊕ ι₂) => ↑(U k)) 𝓕 ≃+ RestrictedProduct (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) 𝓕₁ × RestrictedProduct (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) 𝓕₂

    An additive restricted product over ι₁ ⊕ ι₂ with respect to a filter 𝓕 is the product of the restricted products over the two summands with respect to the comaps of 𝓕 along Sum.inl and Sum.inr, coordinatewise the identity in both directions.

    Instances For
      @[simp]
      theorem TauCeti.restrictedProductSum_apply_inl {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (x : RestrictedProduct (fun (k : ι₁ ⊕ ι₂) => G k) (fun (k : ι₁ ⊕ ι₂) => ↑(U k)) 𝓕) (i : ι₁) :
      ((restrictedProductSum U h₁ h₂) x).1 i = x (Sum.inl i)

      The left component of the splitting is the restriction of coordinates to ι₁.

      @[simp]
      theorem TauCeti.addRestrictedProductSum_apply_inl {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (x : RestrictedProduct (fun (k : ι₁ ⊕ ι₂) => G k) (fun (k : ι₁ ⊕ ι₂) => ↑(U k)) 𝓕) (i : ι₁) :
      ((addRestrictedProductSum U h₁ h₂) x).1 i = x (Sum.inl i)

      The left component of the additive splitting is the restriction of coordinates to ι₁.

      @[simp]
      theorem TauCeti.restrictedProductSum_apply_inr {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (x : RestrictedProduct (fun (k : ι₁ ⊕ ι₂) => G k) (fun (k : ι₁ ⊕ ι₂) => ↑(U k)) 𝓕) (j : ι₂) :
      ((restrictedProductSum U h₁ h₂) x).2 j = x (Sum.inr j)

      The right component of the splitting is the restriction of coordinates to ι₂.

      @[simp]
      theorem TauCeti.addRestrictedProductSum_apply_inr {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (x : RestrictedProduct (fun (k : ι₁ ⊕ ι₂) => G k) (fun (k : ι₁ ⊕ ι₂) => ↑(U k)) 𝓕) (j : ι₂) :
      ((addRestrictedProductSum U h₁ h₂) x).2 j = x (Sum.inr j)

      The right component of the additive splitting is the restriction of coordinates to ι₂.

      @[simp]
      theorem TauCeti.restrictedProductSum_symm_apply_inl {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (y : RestrictedProduct (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) 𝓕₁ × RestrictedProduct (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) 𝓕₂) (i : ι₁) :
      ((restrictedProductSum U h₁ h₂).symm y) (Sum.inl i) = y.1 i

      The inverse of the splitting reads its Sum.inl coordinates off the left factor.

      @[simp]
      theorem TauCeti.addRestrictedProductSum_symm_apply_inl {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (y : RestrictedProduct (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) 𝓕₁ × RestrictedProduct (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) 𝓕₂) (i : ι₁) :
      ((addRestrictedProductSum U h₁ h₂).symm y) (Sum.inl i) = y.1 i

      The inverse of the additive splitting reads its Sum.inl coordinates off the left factor.

      @[simp]
      theorem TauCeti.restrictedProductSum_symm_apply_inr {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (y : RestrictedProduct (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) 𝓕₁ × RestrictedProduct (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) 𝓕₂) (j : ι₂) :
      ((restrictedProductSum U h₁ h₂).symm y) (Sum.inr j) = y.2 j

      The inverse of the splitting reads its Sum.inr coordinates off the right factor.

      @[simp]
      theorem TauCeti.addRestrictedProductSum_symm_apply_inr {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) (y : RestrictedProduct (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) 𝓕₁ × RestrictedProduct (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) 𝓕₂) (j : ι₂) :
      ((addRestrictedProductSum U h₁ h₂).symm y) (Sum.inr j) = y.2 j

      The inverse of the additive splitting reads its Sum.inr coordinates off the right factor.

      theorem TauCeti.continuous_restrictedProductSum {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] :

      The splitting over a sum is continuous for every filter and every reference family; unlike its inverse, it needs no hypothesis on either.

      theorem TauCeti.continuous_addRestrictedProductSum {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] :

      The additive splitting over a sum is continuous for every filter and every reference family; unlike its inverse, it needs no hypothesis on either.

      theorem TauCeti.continuous_restrictedProductSum_symm_of_principal {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] {T : Set (ι₁ ⊕ ι₂)} (hT₁ : Filter.comap Sum.inl (Filter.principal T) = 𝓕₁) (hT₂ : Filter.comap Sum.inr (Filter.principal T) = 𝓕₂) :

      For a principal filter on ι₁ ⊕ ι₂ the inverse of the splitting is continuous for every reference family, so that the splitting is a homeomorphism: the target is a principal stage, whose topology is induced from the product.

      theorem TauCeti.continuous_addRestrictedProductSum_symm_of_principal {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] {T : Set (ι₁ ⊕ ι₂)} (hT₁ : Filter.comap Sum.inl (Filter.principal T) = 𝓕₁) (hT₂ : Filter.comap Sum.inr (Filter.principal T) = 𝓕₂) :

      For a principal filter on ι₁ ⊕ ι₂ the inverse of the additive splitting is continuous for every reference family, so that the splitting is a homeomorphism: the target is a principal stage, whose topology is induced from the product.

      theorem TauCeti.continuous_restrictedProductSum_symm_comp_prodMap_inclusion {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] {S₁ : Set ι₁} {S₂ : Set ι₂} (hS₁ : 𝓕₁ ≤ Filter.principal S₁) (hS₂ : 𝓕₂ ≤ Filter.principal S₂) :
      Continuous (⇑(restrictedProductSum U h₁ h₂).symm ∘ Prod.map (RestrictedProduct.inclusion (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) hS₁) (RestrictedProduct.inclusion (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) hS₂))

      On principal stages the inverse of the splitting over a sum is continuous for every filter and every reference family: for the cofinite filter, openness of the reference subsets is needed only to pass from the stages to the restricted products themselves.

      theorem TauCeti.continuous_addRestrictedProductSum_symm_comp_prodMap_inclusion {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] {𝓕 : Filter (ι₁ ⊕ ι₂)} {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} (U : (k : ι₁ ⊕ ι₂) → S k) (h₁ : Filter.comap Sum.inl 𝓕 = 𝓕₁) (h₂ : Filter.comap Sum.inr 𝓕 = 𝓕₂) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] {S₁ : Set ι₁} {S₂ : Set ι₂} (hS₁ : 𝓕₁ ≤ Filter.principal S₁) (hS₂ : 𝓕₂ ≤ Filter.principal S₂) :
      Continuous (⇑(addRestrictedProductSum U h₁ h₂).symm ∘ Prod.map (RestrictedProduct.inclusion (fun (i : ι₁) => G (Sum.inl i)) (fun (i : ι₁) => ↑(U (Sum.inl i))) hS₁) (RestrictedProduct.inclusion (fun (j : ι₂) => G (Sum.inr j)) (fun (j : ι₂) => ↑(U (Sum.inr j))) hS₂))

      On principal stages the inverse of the additive splitting over a sum is continuous for every filter and every reference family: for the cofinite filter, openness of the reference subsets is needed only to pass from the stages to the restricted products themselves.

      theorem TauCeti.continuous_restrictedProductSum_symm {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] (U : (k : ι₁ ⊕ ι₂) → S k) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] (hU : ∀ (k : ι₁ ⊕ ι₂), IsOpen ↑(U k)) :

      The inverse of the splitting over a sum, for the cofinite filter, is continuous when every reference subset is open. This is the same openness hypothesis under which Mathlib's RestrictedProduct.isTopologicalGroup holds; the forward direction continuous_restrictedProductSum needs no such hypothesis.

      theorem TauCeti.continuous_addRestrictedProductSum_symm {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] (U : (k : ι₁ ⊕ ι₂) → S k) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] (hU : ∀ (k : ι₁ ⊕ ι₂), IsOpen ↑(U k)) :

      The inverse of the additive splitting over a sum, for the cofinite filter, is continuous when every reference subset is open. This is the same openness hypothesis under which Mathlib's RestrictedProduct.isTopologicalAddGroup holds; the forward direction continuous_addRestrictedProductSum needs no such hypothesis.

      theorem TauCeti.continuous_restrictedProductSum_symm_of_finite_left {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Mul (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), MulMemClass (S k) (G k)] (U : (k : ι₁ ⊕ ι₂) → S k) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] [Finite ι₁] (hU : ∀ (j : ι₂), IsOpen ↑(U (Sum.inr j))) :

      The inverse of the splitting over a sum, for the cofinite filter, is continuous when the left summand is finite and every reference subset over the right summand is open; the reference subsets over the finite summand need not be open.

      theorem TauCeti.continuous_addRestrictedProductSum_symm_of_finite_left {ι₁ : Type u₁} {ι₂ : Type u₂} {G : ι₁ ⊕ ι₂ → Type v} {S : ι₁ ⊕ ι₂ → Type w} [(k : ι₁ ⊕ ι₂) → Add (G k)] [(k : ι₁ ⊕ ι₂) → SetLike (S k) (G k)] [∀ (k : ι₁ ⊕ ι₂), AddMemClass (S k) (G k)] (U : (k : ι₁ ⊕ ι₂) → S k) [(k : ι₁ ⊕ ι₂) → TopologicalSpace (G k)] [Finite ι₁] (hU : ∀ (j : ι₂), IsOpen ↑(U (Sum.inr j))) :

      The inverse of the additive splitting over a sum, for the cofinite filter, is continuous when the left summand is finite and every reference subset over the right summand is open; the reference subsets over the finite summand need not be open.