Documentation

TauCeti.AlgebraicGeometry.Curves.NodalGluing.Basic

The gluing quotient of a nodal curve at its flag pairs #

A nodal curve is obtained by gluing smooth curves at pairs of points. The gluing data is recorded by flag pairs: a flag pair names two normalization components together with the point of each of them that is identified. This file builds the underlying topological space of such a curve, the gluing quotient, and records its basic properties.

The model is the following.

The node set and its complement are intended to be the singular locus and the smooth locus of the nodal curve. This file only builds the underlying topological space, so the two names are names: nothing here is a statement about singularities or about smoothness.

References #

def TauCeti.NodalGluing.flagPointOf {ι : Type u_4} {Flag : Type u_5} {X : ι → Type u_6} (fst snd : Flag → ι) (fstPt : (f : Flag) → X (fst f)) (sndPt : (f : Flag) → X (snd f)) (p : Flag × Bool) :
(i : ι) × X i

The point of the disjoint union selected by a flag pair and a boolean: false selects the first point of the flag pair, true the second. This is the function whose injectivity is the hypothesis on the gluing data.

Instances For
    @[simp]
    theorem TauCeti.NodalGluing.flagPointOf_false {ι : Type u_4} {Flag : Type u_5} {X : ι → Type u_6} (fst snd : Flag → ι) (fstPt : (f : Flag) → X (fst f)) (sndPt : (f : Flag) → X (snd f)) (f : Flag) :
    flagPointOf fst snd fstPt sndPt (f, false) = ⟨fst f, fstPt f⟩

    The flag point selected by false is the first point of the flag pair.

    @[simp]
    theorem TauCeti.NodalGluing.flagPointOf_true {ι : Type u_4} {Flag : Type u_5} {X : ι → Type u_6} (fst snd : Flag → ι) (fstPt : (f : Flag) → X (fst f)) (sndPt : (f : Flag) → X (snd f)) (f : Flag) :
    flagPointOf fst snd fstPt sndPt (f, true) = ⟨snd f, sndPt f⟩

    The flag point selected by true is the second point of the flag pair.

    structure TauCeti.NodalGluing.FlagPairData (ι : Type u_4) (Flag : Type u_5) (X : ι → Type u_6) :
    Type (max (max u_4 u_5) u_6)

    The gluing data of a nodal curve: the flag pairs at which the normalization components are glued. A flag pair f names the two components fst f and snd f together with the points fstPt f and sndPt f of those components that are identified.

    The field flagPointOf_injective' says that the flag points are pairwise distinct: the two points of one flag pair are different, and no point of the disjoint union occurs in two different flag pairs. This is the hypothesis that makes the data the data of a nodal curve rather than of an arbitrary gluing of curves along points.

    The structure is bare gluing data: index maps and points on arbitrary types, with no topology and no curve structure.

    • fst : Flag → ι

      The first component glued at a flag pair.

    • snd : Flag → ι

      The second component glued at a flag pair.

    • fstPt (f : Flag) : X (self.fst f)

      The point of the first component at a flag pair.

    • sndPt (f : Flag) : X (self.snd f)

      The point of the second component at a flag pair.

    • flagPointOf_injective' : Function.Injective (flagPointOf self.fst self.snd self.fstPt self.sndPt)

      The flag points are pairwise distinct: the two points of one flag pair are different, and no point of the disjoint union occurs in two different flag pairs.

    Instances For
      def TauCeti.NodalGluing.fstPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :
      (i : ι) × X i

      The first point of a flag pair, as a point of the disjoint union of the components.

      Instances For
        def TauCeti.NodalGluing.sndPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :
        (i : ι) × X i

        The second point of a flag pair, as a point of the disjoint union of the components.

        Instances For
          theorem TauCeti.NodalGluing.fstPoint_def {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :
          fstPoint d f = ⟨d.fst f, d.fstPt f⟩

          The first point of a flag pair, with its two components.

          theorem TauCeti.NodalGluing.sndPoint_def {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :
          sndPoint d f = ⟨d.snd f, d.sndPt f⟩

          The second point of a flag pair, with its two components.

          def TauCeti.NodalGluing.flagPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (p : Flag × Bool) :
          (i : ι) × X i

          The two points of a flag pair, selected by a boolean: false selects the first point of the flag pair, true the second.

          Instances For
            theorem TauCeti.NodalGluing.flagPoint_injective {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

            The flag points are pairwise distinct. The points of the disjoint union that are glued -- the flag points -- are pairwise distinct: the two points of one flag pair are different, and no point occurs in two different flag pairs.

            @[simp]
            theorem TauCeti.NodalGluing.flagPoint_false {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :

            The first point of a flag pair is the flag point selected by false.

            @[simp]
            theorem TauCeti.NodalGluing.flagPoint_true {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :

            The second point of a flag pair is the flag point selected by true.

            theorem TauCeti.NodalGluing.fstPoint_injective {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

            Two flag pairs with the same first point are the same flag pair.

            theorem TauCeti.NodalGluing.sndPoint_injective {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

            Two flag pairs with the same second point are the same flag pair.

            theorem TauCeti.NodalGluing.fstPoint_ne_sndPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f g : Flag) :

            The first point of a flag pair is never the second point of a flag pair: a flag pair never pairs a point with itself.

            theorem TauCeti.NodalGluing.eq_of_flagPoint_mem {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {f g : Flag} {p : (i : ι) × X i} (hp : p = fstPoint d f ∨ p = sndPoint d f) (hq : p = fstPoint d g ∨ p = sndPoint d g) :
            f = g

            A flag point belongs to a unique flag pair.

            def TauCeti.NodalGluing.flagRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :

            The generating relation of the gluing: two points of the disjoint union are related when they are the two points of one flag pair. Its characterisation is flagRel_def.

            Instances For
              theorem TauCeti.NodalGluing.flagRel_def {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :
              flagRel d x y ↔ ∃ (f : Flag), x = fstPoint d f ∧ y = sndPoint d f ∨ x = sndPoint d f ∧ y = fstPoint d f

              The generating relation, characterised. Two points of the disjoint union are related by the generating relation exactly when they are the two points of one flag pair, in either order.

              theorem TauCeti.NodalGluing.flagRel_symm {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {x y : (i : ι) × X i} (h : flagRel d x y) :
              flagRel d y x

              The generating relation is symmetric.

              theorem TauCeti.NodalGluing.eq_of_flagRel_of_flagRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {x y z : (i : ι) × X i} (h₁ : flagRel d x y) (h₂ : flagRel d y z) :
              x = z

              The flag pairs form a matching. Two flag relations that meet in a point glue the same two points: the flag points being pairwise distinct forces the two flag pairs to be equal, so every chain of flag pairs reduces to equality or to a single generating step.

              def TauCeti.NodalGluing.gluedRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :

              The equivalence relation generated by the flag pairs. Two points of the disjoint union are glued together exactly when they are equal, or when they are the two points of one flag pair. Because the flag points are pairwise distinct, every chain of flag pairs reduces to equality or to a single generating step, so this is exactly the relation generated by the flag pairs. Its characterisation is gluedRel_def.

              Instances For
                theorem TauCeti.NodalGluing.gluedRel_def {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :
                gluedRel d x y ↔ x = y ∨ flagRel d x y

                The generated relation, characterised. Two points of the disjoint union are related by the generated relation exactly when they are equal or when they are the two points of one flag pair.

                theorem TauCeti.NodalGluing.gluedRel_symm {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {x y : (i : ι) × X i} (h : gluedRel d x y) :
                gluedRel d y x

                The glued relation is symmetric.

                theorem TauCeti.NodalGluing.gluedRel_trans {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {x y z : (i : ι) × X i} (h₁ : gluedRel d x y) (h₂ : gluedRel d y z) :
                gluedRel d x z

                The glued relation is transitive.

                theorem TauCeti.NodalGluing.flagRel_le_gluedRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                The generating relation is contained in the glued relation.

                theorem TauCeti.NodalGluing.gluedRel_iff_of_flagPoints {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {f g : Flag} {p q : (i : ι) × X i} (hp : p = fstPoint d f ∨ p = sndPoint d f) (hq : q = fstPoint d g ∨ q = sndPoint d g) :
                gluedRel d p q ↔ f = g

                The relation between two flag points. Two flag points of the disjoint union are related by gluedRel exactly when they belong to the same flag pair.

                theorem TauCeti.NodalGluing.gluedRel_equivalence {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                The glued relation, as an equivalence relation.

                theorem TauCeti.NodalGluing.gluedRel_iff_eqvGen {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :

                The generated relation is the equivalence closure of the generating relation. The equivalence relation gluedRel generated by the flag pairs is exactly Relation.EqvGen of the generating relation flagRel: two points of the disjoint union are glued together precisely when the generating relation relates them, or when they are equal.

                def TauCeti.NodalGluing.flagPointSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :
                Set ((i : ι) × X i)

                The points of the disjoint union that occur in a flag pair: the range of the flag points.

                Instances For
                  @[simp]
                  theorem TauCeti.NodalGluing.mem_flagPointSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x : (i : ι) × X i) :
                  x ∈ flagPointSet d ↔ ∃ (f : Flag), x = fstPoint d f ∨ x = sndPoint d f

                  A point of the disjoint union is a flag point when it occurs in a flag pair.

                  theorem TauCeti.NodalGluing.flagPointSet_eq_range {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                  The flag point set is the range of the flag points.

                  theorem TauCeti.NodalGluing.mem_flagPointSet_iff_exists_flagRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x : (i : ι) × X i) :
                  x ∈ flagPointSet d ↔ ∃ (y : (i : ι) × X i), flagRel d x y

                  Flag points are the points glued to another point. A point of the disjoint union is a flag point exactly when the generating relation relates it to some point.

                  theorem TauCeti.NodalGluing.flagRel_flagPoint_iff {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (p q : Flag × Bool) :
                  flagRel d (flagPoint d p) (flagPoint d q) ↔ q = (p.1, !p.2)

                  The partner of a flag point. The generating relation relates the flag points selected by p and q exactly when they are the two points of one flag pair: q is p with its boolean negated.

                  theorem TauCeti.NodalGluing.flagPointSet_finite {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [Finite Flag] :

                  The flag points of d form a finite set.

                  structure TauCeti.NodalGluing.Marking {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (L : Type u_4) :
                  Type (max (max u_1 u_3) u_4)

                  Marks on a nodal curve presented by flag-pair data, labelled by L: pairwise distinct points of the normalization, none of which is a flag point. These are the smooth marks of the curve: their images in the glued curve avoid the nodes.

                  • point : L → (i : ι) × X i

                    The point of the normalization carrying a label.

                  • point_injective : Function.Injective self.point

                    Distinct labels mark distinct points.

                  • point_notMem_flagPointSet (l : L) : self.point l ∉ flagPointSet d

                    No mark is a flag point.

                  Instances For
                    def TauCeti.NodalGluing.Marking.specialPoints {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} {d : FlagPairData ι Flag X} {L : Type u_4} (m : Marking d L) (i : ι) :
                    Set (X i)

                    The special points of the component i of a marked nodal curve: the points of X i which are flag points or marks. They are the special flags on that component counted by the stability condition 2 g_i - 2 + n_i > 0, the node branches being counted as flags.

                    Instances For
                      @[simp]
                      theorem TauCeti.NodalGluing.Marking.mem_specialPoints_iff {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} {d : FlagPairData ι Flag X} {L : Type u_4} {m : Marking d L} {i : ι} {x : X i} :
                      x ∈ m.specialPoints i ↔ ⟨i, x⟩ ∈ flagPointSet d ∨ ∃ (l : L), m.point l = ⟨i, x⟩

                      A point of the component i is special exactly when it is a flag point or a mark.

                      theorem TauCeti.NodalGluing.eq_or_mem_flagPointSet_of_gluedRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {a b : (i : ι) × X i} (h : gluedRel d a b) :

                      The generated relation relates two points of the disjoint union only when they are equal or when both of them are flag points.

                      def TauCeti.NodalGluing.gluedRelSetoid {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :
                      Setoid ((i : ι) × X i)

                      The generated relation as a setoid: the equivalence relation on the disjoint union of the normalization components that glues the points of the flag pairs together.

                      Instances For
                        @[simp]
                        theorem TauCeti.NodalGluing.gluedRelSetoid_r {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :

                        The relation of the setoid is the generated relation.

                        theorem TauCeti.NodalGluing.gluedRelSetoid_fstPoint_sndPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :

                        The two points of a flag pair are glued.

                        theorem TauCeti.NodalGluing.eq_or_eq_of_gluedRelSetoid_fstPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {f : Flag} {w : (i : ι) × X i} (h : (gluedRelSetoid d) (fstPoint d f) w) :
                        w = fstPoint d f ∨ w = sndPoint d f

                        The first point of a flag pair is glued only to itself and to the second point.

                        @[reducible, inline]
                        abbrev TauCeti.NodalGluing.GluedCurve {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :
                        Type (max u_3 u_1)

                        The glued space. The quotient of the disjoint union of the normalization components by the generated relation: the underlying topological space of the nodal curve. The topology is the quotient topology, i.e. the finest topology making the quotient map continuous.

                        Instances For
                          def TauCeti.NodalGluing.GluedCurve.lift {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {Y : Type u_4} (g : (i : ι) × X i → Y) (hg : ∀ (f : Flag), g (fstPoint d f) = g (sndPoint d f)) :
                          GluedCurve d → Y

                          The lifting property of the glued curve. A map out of the disjoint union of the normalization components that takes the same value on the two points of every flag pair descends to a map out of the glued curve: the glued curve is the quotient of the disjoint union by the relation identifying the two points of each flag pair.

                          Instances For
                            @[simp]
                            theorem TauCeti.NodalGluing.GluedCurve.lift_mk {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {Y : Type u_4} (g : (i : ι) × X i → Y) (hg : ∀ (f : Flag), g (fstPoint d f) = g (sndPoint d f)) (x : (i : ι) × X i) :
                            lift d g hg ⟦x⟧ = g x

                            The lift is the original map on the representatives. The lift of g to the glued curve agrees with g on the image of a point of the disjoint union.

                            theorem TauCeti.NodalGluing.GluedCurve.lift_unique {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) {Y : Type u_4} (g : (i : ι) × X i → Y) (hg : ∀ (f : Flag), g (fstPoint d f) = g (sndPoint d f)) (h : GluedCurve d → Y) (hh : ∀ (x : (i : ι) × X i), h ⟦x⟧ = g x) :
                            h = lift d g hg

                            The lift is unique. A map out of the glued curve that agrees with g on the images of the points of the disjoint union is the lift of g.

                            theorem TauCeti.NodalGluing.GluedCurve.continuous_lift {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] {Y : Type u_4} [TopologicalSpace Y] (g : (i : ι) × X i → Y) (hg : ∀ (f : Flag), g (fstPoint d f) = g (sndPoint d f)) (hcont : Continuous g) :
                            Continuous (lift d g hg)

                            A continuous map descends to a continuous map. The lift of a continuous map out of the disjoint union that is constant on the two points of every flag pair is continuous.

                            def TauCeti.NodalGluing.nodeSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                            The node set. The image of the flag points in the glued curve. It is intended to be the singular locus of the nodal curve, but this file only builds the underlying topological space.

                            Instances For
                              theorem TauCeti.NodalGluing.image_flagPointSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                              The node set is the image of the flag points under the quotient map.

                              def TauCeti.NodalGluing.nodeOfFlag {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :

                              The node point of a flag pair: the image of its first point in the glued curve.

                              Instances For
                                @[simp]
                                theorem TauCeti.NodalGluing.mk_fstPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :

                                The first point of a flag pair is sent to its node.

                                @[simp]
                                theorem TauCeti.NodalGluing.mk_sndPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f : Flag) :

                                The second point of a flag pair is sent to the same node as the first one.

                                @[simp]
                                theorem TauCeti.NodalGluing.mk_flagPoint {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (p : Flag × Bool) :

                                The flag point selected by p is sent to the node of its flag pair p.1.

                                @[simp]
                                theorem TauCeti.NodalGluing.nodeOfFlag_inj {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (f g : Flag) :

                                The fibres of the flag-pair map. Two flag pairs have the same node exactly when they are equal, so every non-empty fibre of nodeOfFlag is a singleton. The fibres over the points that are not nodes are empty.

                                theorem TauCeti.NodalGluing.nodeOfFlag_injective {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                                The flag-pair map to the node set is injective. Distinct flag pairs give distinct nodes, because the flag points are pairwise distinct.

                                @[simp]
                                theorem TauCeti.NodalGluing.mem_nodeSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (q : GluedCurve d) :
                                q ∈ nodeSet d ↔ ∃ (f : Flag), nodeOfFlag d f = q

                                The membership of the node set. A point of the glued curve is a node exactly when it is the node of a flag pair.

                                theorem TauCeti.NodalGluing.nodeSet_eq_range_nodeOfFlag {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                                The node set is the image of the flag pairs. The node set of the glued curve is the image of the flag pairs under nodeOfFlag.

                                theorem TauCeti.NodalGluing.nodeSet_finite {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [Finite Flag] :

                                The node set of the glued curve is finite: it is the image of the finite set of flag points.

                                @[simp]
                                theorem TauCeti.NodalGluing.preimage_nodeSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                                The preimage of the node set. The quotient map sends a point of the disjoint union to a node exactly when that point is a flag point: the preimage of the node set is the flag point set.

                                theorem TauCeti.NodalGluing.mem_flagPointSet_of_gluedRelSetoid_of_ne {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) ⦃x y : (i : ι) × X i⦄ :
                                (gluedRelSetoid d) x y → x ≠ y → x ∈ flagPointSet d

                                The generated relation identifies only flag points. Two distinct points of the disjoint union are related by the generated relation only when the first of them is a flag point.

                                theorem TauCeti.NodalGluing.flagRel_iff_mk_eq_and_ne {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) (x y : (i : ι) × X i) :

                                Flag pairs are the distinct points with the same image. Two points of the disjoint union are the two points of a flag pair exactly when they are distinct and are identified in the glued curve.

                                theorem TauCeti.NodalGluing.eq_of_mk_eq_of_notMem_flagPointSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} {d : FlagPairData ι Flag X} {x y : (i : ι) × X i} (hx : x ∉ flagPointSet d) (h : ⟦x⟧ = ⟦y⟧) :
                                x = y

                                The quotient map is injective off the flag points. A point of the disjoint union which is not a flag point is the only point in its class in the glued curve.

                                theorem TauCeti.NodalGluing.isClosed_nodeSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] :

                                The node set is closed. The node set of the glued curve is a closed subset of it, so its complement is open.

                                theorem TauCeti.NodalGluing.isOpen_compl_nodeSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] :

                                The complement of the node set is open, being the complement of the closed node set.

                                theorem TauCeti.NodalGluing.image_quotient_mk_compl {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) :

                                The image of the components minus their flag points. The quotient map sends the disjoint union of the normalization components minus their flag points onto the complement of the node set in the glued curve.

                                theorem TauCeti.NodalGluing.isClosed_gluedRel {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T2Space (X i)] [Finite Flag] :
                                IsClosed {p : ((i : ι) × X i) × (i : ι) × X i | gluedRel d p.1 p.2}

                                The generated relation is closed. The equivalence relation generated by the flag pairs is a closed subset of the product of the disjoint union of the normalization components with itself.

                                instance TauCeti.NodalGluing.t2Space_gluedCurve {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T2Space (X i)] [Finite Flag] :

                                The glued space is Hausdorff. The quotient of the disjoint union of the normalization components by the generated relation is a Hausdorff space, when the components are Hausdorff and when there are finitely many flag pairs.

                                theorem TauCeti.NodalGluing.isOpenEmbedding_domRestrict_quotient_mk {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] :

                                The quotient map is an open embedding away from the flag points. The quotient map restricted to the disjoint union of the normalization components minus their flag points is an open embedding.

                                noncomputable def TauCeti.NodalGluing.quotientMapOnComplNodeSetHomeomorph {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] :

                                The bundled homeomorphism of the complement of the node set. The quotient map, restricted to the points of the disjoint union that are not flag points, is a homeomorphism from them onto the complement of the node set in the glued curve.

                                Instances For
                                  @[simp]
                                  theorem TauCeti.NodalGluing.quotientMapOnComplNodeSetHomeomorph_apply {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] (x : ↑(flagPointSet d)ᶜ) :

                                  The bundled homeomorphism acts by the quotient map. On the complement of the flag points, the homeomorphism of the complement of the node set is the quotient map: it sends a point to its class in the glued curve.

                                  @[simp]
                                  theorem TauCeti.NodalGluing.quotientMapOnComplNodeSetHomeomorph_symm_apply {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} (d : FlagPairData ι Flag X) [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] (y : ↑(nodeSet d)ᶜ) :

                                  The inverse of the bundled homeomorphism lands in the same class. The inverse of the homeomorphism of the complement of the node set sends a point of the complement to a point of the disjoint union that represents it in the glued curve.

                                  Neighbourhoods of flag points #

                                  theorem TauCeti.NodalGluing.exists_mem_nhds_isConnected_sdiff_singleton_subset_compl_flagPointSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] {d : FlagPairData ι Flag X} {x : (i : ι) × X i} (hx : ∀ U ∈ nhds x, ∃ V ∈ nhds x, V ⊆ U ∧ IsConnected (V \ {x})) {U : Set ((i : ι) × X i)} (hU : U ∈ nhds x) :
                                  ∃ V ∈ nhds x, V ⊆ U ∧ V \ {x} ⊆ (flagPointSet d)ᶜ ∧ IsConnected (V \ {x})

                                  Around a point with arbitrarily small connected punctured neighbourhoods there are arbitrarily small neighbourhoods meeting no other flag point whose punctured versions are connected.

                                  theorem TauCeti.NodalGluing.dense_compl_flagPointSet {ι : Type u_1} {Flag : Type u_2} {X : ι → Type u_3} [(i : ι) → TopologicalSpace (X i)] [∀ (i : ι), T1Space (X i)] [Finite Flag] {d : FlagPairData ι Flag X} (hX : ∀ x ∈ flagPointSet d, ∀ U ∈ nhds x, ∃ V ∈ nhds x, V ⊆ U ∧ IsConnected (V \ {x})) :

                                  If the flag points have connected punctured neighbourhoods, then the points which are not flag points are dense.