Documentation

HexGraphIso.Nauty.Search.Generic

Completion of a sweep, an unwind to a level with an optional short prune, or exhaustion of the recursion bound.

Instances For
    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      The five node classifications in nauty's processnode. A better leaf carries the number of adjacency rows shared with the incumbent.

      Instances For
        Equations
        • One or more equations did not get rendered due to their size.
        Instances For

          The local operations of an individualization-refinement search. The state includes the partition and any policy-specific bookkeeping. Sweep entries are indices below n; a policy may interpret them as vertex labels or target-cell offsets.

          • visit : γ → Nat → Nat → σ → Nat × Nat × σ

            Refine a node and return its cell count and code.

          • recordFirst : Nat → Nat → σ → σ

            Save a first-path refinement code.

          • compareCodes : Nat → Nat → σ → σ

            Compare an off-path refinement code with the reference paths.

          • chooseTarget : Bool → γ → Nat → Nat → Nat → σ → Int × VSet n × Nat × σ

            Choose a target cell, its sweep entries, and its size.

          • firstterminal : Nat → σ → σ

            Install the first discrete leaf.

          • classify : γ → Nat → Nat → σ → Leaf × σ

            Classify an off-path node.

          • leafExit : Leaf → Nat → σ → Exit × σ

            Act on a node classification.

          • cheapCheck : Bool → Nat → σ → σ

            Update the cheap-automorphism boundary.

          • child : Bool → Nat → Nat → Nat → σ → σ

            Individualize the child identified by a sweep entry.

          • afterChildFirst : Nat → Nat → σ → σ

            Update first-path controls after the leftmost child.

          • leaveChild : Nat → σ → σ

            Remove a child's temporary bookkeeping.

          • orbit : σ → Nat → Nat

            Read the representative used to skip a sweep entry.

          • shortprune : VSet n → σ → VSet n

            Restrict the remaining sweep entries using the newest pair.

          • longprune : VSet n → σ → VSet n

            Restrict the remaining sweep entries using the stored pairs.

          • recover : Nat → Nat → σ → σ

            Restore the parent partition and comparison controls.

          • afterSweep : Bool → Nat → Nat → Nat → σ → σ

            Finish a complete sweep.

          Instances
            @[reducible, inline]

            A node continuation with its recursion bound supplied by the caller.

            Equations
            Instances For
              @[reducible, inline]

              A sweep continuation with both recursion bounds supplied by the caller.

              Equations
              Instances For
                def Hex.GraphIso.Nauty.Generic.nodeStep {n : Nat} {σ γ : Type} [Policy σ n] (ctx : γ) (tcLevel : Nat) (next : SweepFn σ n) (first : Bool) (level numcells : Nat) (st : σ) :
                Exit × σ

                The local node operations, followed by a supplied child sweep.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  def Hex.GraphIso.Nauty.Generic.resume {n : Nat} {σ γ : Type} [Policy σ n] (inf : Nat) (next : SweepFn σ n) (first : Bool) (level numcells tc tv1 tv : Nat) (cell : VSet n) (index : Nat) (st : σ) :

                  Apply the long filter, recover the parent, and visit the next surviving entry.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    def Hex.GraphIso.Nauty.Generic.advance {n : Nat} {σ γ : Type} [Policy σ n] (inf : Nat) (next : SweepFn σ n) (first : Bool) (level numcells tc tv1 tv : Nat) (cell : VSet n) (index : Nat) (st : σ) (exit : Exit) :

                    Consume a child's exit after fixed-point cleanup, passing a deeper unwind outward or filtering and resuming the current sweep.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      def Hex.GraphIso.Nauty.Generic.sweepStep {n : Nat} {σ γ : Type} [Policy σ n] (inf : Nat) (descend : NodeFn σ) (next : SweepFn σ n) (first : Bool) (level numcells tc tv1 tv : Nat) (tcell : VSet n) (index : Nat) (st : σ) :

                      One target vertex, followed by supplied node and sweep continuations.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        @[irreducible]
                        def Hex.GraphIso.Nauty.Generic.node {n : Nat} {σ γ : Type} [Policy σ n] (first : Bool) (ctx : γ) (inf tcLevel fuel level numcells : Nat) (st : σ) :
                        Exit × σ

                        Refine a node, classify it, and sweep its surviving children.

                        Equations
                        Instances For
                          @[irreducible]
                          def Hex.GraphIso.Nauty.Generic.sweep {n : Nat} {σ γ : Type} [Policy σ n] (first : Bool) (ctx : γ) (inf tcLevel fuel cfuel level numcells tc tv1 : Nat) (tv? : Option Nat) (tcell : VSet n) (index : Nat) (st : σ) :

                          Sweep surviving vertices, transporting exits below this level.

                          Equations
                          Instances For