Documentation

TauCeti.Topology.Algebra.RestrictedProduct.Congr.Left

Reindexing a restricted product along an equivalence of index types #

An equivalence e : ι' ≃ ι of index types identifies the restricted product of a family G of types indexed by ι with the restricted product of the pulled-back family j ↦ G (e j) indexed by ι', coordinatewise: x corresponds to j ↦ x (e j). This is the restricted-product analogue of Equiv.piCongrLeft. The restrictedness conditions match because e carries the cofinite filter to the cofinite filter (Function.Injective.comap_cofinite_eq), so no filter compatibility hypothesis is needed. Both directions are maps out of a single restricted product and are coordinatewise a homeomorphism of the ambient products on every principal stage, so both are continuous for every reference family.

The identification is stated at two levels.

The statement shape and the pinning equation … y (e j) = y j follow the declarations Equiv.restrictedProductCongrLeft and MulEquiv.restrictedProductCongrLeft of the FLT project (ImperialCollegeLondon/FLT, file FLT/Mathlib/Topology/Algebra/RestrictedProduct/Equiv.lean, source commit a9efe585de92be60be84ac1d14ced5a1b0944333, Apache 2.0), by Kevin Buzzard and Salvatore Mercuri, specialised to the cofinite filter on both sides. restrictedProductReindex and its coordinate lemmas follow FLT's Equiv.restrictedProductCongrLeft', the same equivalence in the orientation x ↦ (j ↦ x (e j)).

References #

def TauCeti.restrictedProductCongrLeftEquiv {ι : Type u} {ι' : Type v} {G : ι → Type w} (A : (i : ι) → Set (G i)) (e : ι' ≃ ι) :
RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => A (e j)) Filter.cofinite ≃ RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => A i) Filter.cofinite

Reindexing a restricted product along an equivalence e : ι' ≃ ι of index types, in the orientation of Equiv.piCongrLeft: from the restricted product of the pulled-back family over ι' to the restricted product over ι. The image of y has coordinate y j at e j, and the inverse sends x to j ↦ x (e j); it is Mathlib's RestrictedProduct.mapAlong along e with identity coordinate maps.

Instances For
    @[simp]
    theorem TauCeti.restrictedProductCongrLeftEquiv_apply_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} (A : (i : ι) → Set (G i)) (e : ι' ≃ ι) (y : RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => A (e j)) Filter.cofinite) (j : ι') :

    The reindexed element has coordinate y j at e j; as e is surjective, this pins restrictedProductCongrLeftEquiv.

    @[simp]
    theorem TauCeti.restrictedProductCongrLeftEquiv_symm_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} (A : (i : ι) → Set (G i)) (e : ι' ≃ ι) (x : RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => A i) Filter.cofinite) (j : ι') :

    The inverse of the reindexing equivalence sends x to j ↦ x (e j).

    theorem TauCeti.continuous_restrictedProductCongrLeftEquiv {ι : Type u} {ι' : Type v} {G : ι → Type w} (A : (i : ι) → Set (G i)) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

    Reindexing is continuous for every reference family.

    theorem TauCeti.continuous_restrictedProductCongrLeftEquiv_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} (A : (i : ι) → Set (G i)) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

    The inverse of the reindexing equivalence is continuous for every reference family.

    def TauCeti.restrictedProductCongrLeft {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :
    RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite ≃* RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite

    Reindexing a restricted product along an equivalence e : ι' ≃ ι of index types, as a multiplicative equivalence, from the restricted product of the pulled-back family over ι' to the restricted product over ι. The image of y has coordinate y j at e j.

    Instances For
      def TauCeti.addRestrictedProductCongrLeft {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :
      RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite ≃+ RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite

      Reindexing a restricted product along an equivalence e : ι' ≃ ι of index types, as an additive equivalence, from the restricted product of the pulled-back family over ι' to the restricted product over ι. The image of y has coordinate y j at e j.

      Instances For
        theorem TauCeti.restrictedProductCongrLeft_toEquiv {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :
        ↑(restrictedProductCongrLeft U e) = restrictedProductCongrLeftEquiv (fun (i : ι) => ↑(U i)) e

        The underlying equivalence of restrictedProductCongrLeft is the reindexing equivalence of the underlying reference sets.

        theorem TauCeti.addRestrictedProductCongrLeft_toEquiv {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :

        The underlying equivalence of addRestrictedProductCongrLeft is the reindexing equivalence of the underlying reference sets.

        @[simp]
        theorem TauCeti.restrictedProductCongrLeft_apply_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (y : RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite) (j : ι') :
        ((restrictedProductCongrLeft U e) y) (e j) = y j

        The reindexed element has coordinate y j at e j; as e is surjective, this pins restrictedProductCongrLeft.

        @[simp]
        theorem TauCeti.addRestrictedProductCongrLeft_apply_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (y : RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite) (j : ι') :
        ((addRestrictedProductCongrLeft U e) y) (e j) = y j

        The additively reindexed element has coordinate y j at e j; as e is surjective, this pins addRestrictedProductCongrLeft.

        theorem TauCeti.restrictedProductCongrLeft_symm_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (x : RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite) (j : ι') :
        ((restrictedProductCongrLeft U e).symm x) j = x (e j)

        The inverse of restrictedProductCongrLeft sends x to j ↦ x (e j).

        theorem TauCeti.addRestrictedProductCongrLeft_symm_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (x : RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite) (j : ι') :

        The inverse of addRestrictedProductCongrLeft sends x to j ↦ x (e j).

        def TauCeti.restrictedProductReindex {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :
        RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite ≃* RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite

        Reindexing a restricted product along an equivalence e : ι' ≃ ι of index types, in the orientation x ↦ (j ↦ x (e j)): the inverse of restrictedProductCongrLeft.

        Instances For
          def TauCeti.addRestrictedProductReindex {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :
          RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite ≃+ RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite

          Reindexing a restricted product along an equivalence e : ι' ≃ ι of index types, as an additive equivalence, in the orientation x ↦ (j ↦ x (e j)): the inverse of addRestrictedProductCongrLeft.

          Instances For
            @[simp]
            theorem TauCeti.restrictedProductCongrLeft_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :

            The inverse of restrictedProductCongrLeft is restrictedProductReindex.

            @[simp]
            theorem TauCeti.addRestrictedProductCongrLeft_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :

            The inverse of addRestrictedProductCongrLeft is addRestrictedProductReindex.

            @[simp]
            theorem TauCeti.restrictedProductReindex_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :

            The inverse of restrictedProductReindex is restrictedProductCongrLeft.

            @[simp]
            theorem TauCeti.addRestrictedProductReindex_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) :

            The inverse of addRestrictedProductReindex is addRestrictedProductCongrLeft.

            @[simp]
            theorem TauCeti.restrictedProductReindex_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (x : RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite) (j : ι') :
            ((restrictedProductReindex U e) x) j = x (e j)

            restrictedProductReindex sends x to j ↦ x (e j).

            @[simp]
            theorem TauCeti.addRestrictedProductReindex_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (x : RestrictedProduct (fun (i : ι) => G i) (fun (i : ι) => ↑(U i)) Filter.cofinite) (j : ι') :
            ((addRestrictedProductReindex U e) x) j = x (e j)

            addRestrictedProductReindex sends x to j ↦ x (e j).

            theorem TauCeti.restrictedProductReindex_symm_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (y : RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite) (j : ι') :
            ((restrictedProductReindex U e).symm y) (e j) = y j

            The inverse of restrictedProductReindex has coordinate y j at e j; as e is surjective, this pins it.

            theorem TauCeti.addRestrictedProductReindex_symm_apply {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) (y : RestrictedProduct (fun (j : ι') => G (e j)) (fun (j : ι') => ↑(U (e j))) Filter.cofinite) (j : ι') :
            ((addRestrictedProductReindex U e).symm y) (e j) = y j

            The inverse of addRestrictedProductReindex has coordinate y j at e j; as e is surjective, this pins it.

            theorem TauCeti.continuous_restrictedProductCongrLeft {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            restrictedProductCongrLeft is continuous for every reference family.

            theorem TauCeti.continuous_addRestrictedProductCongrLeft {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            addRestrictedProductCongrLeft is continuous for every reference family.

            theorem TauCeti.continuous_restrictedProductCongrLeft_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            The inverse of restrictedProductCongrLeft is continuous for every reference family.

            theorem TauCeti.continuous_addRestrictedProductCongrLeft_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            The inverse of addRestrictedProductCongrLeft is continuous for every reference family.

            theorem TauCeti.continuous_restrictedProductReindex {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            restrictedProductReindex is continuous for every reference family.

            theorem TauCeti.continuous_addRestrictedProductReindex {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            addRestrictedProductReindex is continuous for every reference family.

            theorem TauCeti.continuous_restrictedProductReindex_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Mul (G i)] [∀ (i : ι), MulMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            The inverse of restrictedProductReindex is continuous for every reference family.

            theorem TauCeti.continuous_addRestrictedProductReindex_symm {ι : Type u} {ι' : Type v} {G : ι → Type w} {S : ι → Type z} [(i : ι) → SetLike (S i) (G i)] [(i : ι) → Add (G i)] [∀ (i : ι), AddMemClass (S i) (G i)] (U : (i : ι) → S i) (e : ι' ≃ ι) [(i : ι) → TopologicalSpace (G i)] :

            The inverse of addRestrictedProductReindex is continuous for every reference family.