Hamiltonian path finding function and associated tests

digraph.dot

@@ -0,0 +1,12 @@
+//dot
+digraph hgn{
+node [shape=circle]
+1
+2
+3
+1 -> 2
+1 -> 3
+2 -> 1
+2 -> 3
+3 -> 1
+}

doc/attr.xml

@@ -1599,23 +1599,23 @@ gap> FacialWalks(D3, rot);
     <Example><![CDATA[
 gap> D := Digraph([[]]);
 <immutable empty digraph with 1 vertex>
-gap> HamiltonianPath(D);
+gap> HamiltonianCycle(D);
 [ 1 ]
 gap> D := Digraph([[2], [1]]);
 <immutable digraph with 2 vertices, 2 edges>
-gap> HamiltonianPath(D);
+gap> HamiltonianCycle(D);
 [ 1, 2 ]
 gap> D := Digraph([[3], [], [2]]);
 <immutable digraph with 3 vertices, 2 edges>
-gap> HamiltonianPath(D);
+gap> HamiltonianCycle(D);
 fail
 gap> D := Digraph([[2], [3], [1]]);
 <immutable digraph with 3 vertices, 3 edges>
-gap> HamiltonianPath(D);
+gap> HamiltonianCycle(D);
 [ 1, 2, 3 ]
 gap> D := GeneralisedPetersenGraph(IsMutableDigraph, 5, 2);
 <mutable digraph with 10 vertices, 30 edges>
-gap> HamiltonianPath(D);
+gap> HamiltonianCycle(D);
 fail
 ]]></Example>
   </Description>

doc/examples.xml

@@ -1064,7 +1064,7 @@ gap> D := CirculantGraph(6, [2, 3]);
  with 6 vertices, 18 edges>
 gap> AutomorphismGroup(D) = DihedralGroup(IsPermGroup, 12);
 true
-gap> HamiltonianPath(D);
+gap> HamiltonianCycle(D);
 [ 1, 3, 5, 2, 6, 4 ]
 gap> IsCompleteDigraph(CirculantGraph(6, [1, 2, 3]));
 true]]></Example>

gap/attr.gd

@@ -67,6 +67,7 @@ DeclareOperation("DigraphAllChordlessCyclesOfMaximalLength",
 DeclareAttribute("DigraphAllChordlessCycles", IsDigraph);
 DeclareOperation("FacialWalks", [IsDigraph, IsList]);
 DeclareAttribute("HamiltonianPath", IsDigraph);
+DeclareAttribute("HamiltonianCycle", IsDigraph);
 DeclareAttribute("DigraphPeriod", IsDigraph);
 DeclareAttribute("DigraphLoops", IsDigraph);
 

gap/attr.gi

@@ -2262,6 +2262,54 @@ function(D)
 end);
 
 InstallMethod(HamiltonianPath, "for a digraph", [IsDigraph],
+function(D)
+    local iter, recpath, vertices, n, v, start, finish;
+
+    v := DigraphNrVertices(D);
+
+    # trivial cases
+    if v <= 1 then
+        return DigraphVertices(D);
+    elif v < 256 then
+        recpath := DigraphMonomorphism(ChainDigraph(v), D);
+        if recpath = fail then
+            return fail;
+        fi;
+        return ImageListOfTransformation(recpath, v);
+    fi;
+
+    # For large graphs: search all simple paths from every start to every end
+    n := v;   # Hamiltonian path must have exactly v vertices
+
+    for start in [1..v] do
+        for finish in [1..v] do
+
+            iter := IteratorOfPaths(D, start, finish);
+
+            while not IsDoneIterator(iter) do
+                recpath := NextIterator(iter);
+
+                # safety: ensure this is a path record with vertices
+                if not IsRecord(recpath) or not IsBound(recpath.vertices) then
+                    continue;
+                fi;
+
+                vertices := recpath.vertices;
+
+                # Hamiltonian path condition
+                if Length(vertices) = n and IsDuplicateFreeList(vertices) then
+                    return vertices;
+                fi;
+
+            od;
+
+        od;
+    od;
+
+    return fail;
+end);
+
+InstallMethod(HamiltonianCycle, "for a digraph", [IsDigraph],
 function(D)
   local path, iter, n;
 

gap/oper.gd

@@ -115,6 +115,7 @@ DeclareOperation("IsPerfectMatching", [IsDigraph, IsHomogeneousList]);
 DeclareOperation("IsDigraphPath",
                  [IsDigraph, IsHomogeneousList, IsHomogeneousList]);
 DeclareOperation("IsDigraphPath", [IsDigraph, IsList]);
+DeclareOperation("TestHamiltonianPath", [IsDigraph]);
 
 # 9. Connectivity . . .
 DeclareOperation("DigraphIsKing", [IsDigraph, IsPosInt, IsPosInt]);

gap/oper.gi

@@ -1586,6 +1586,40 @@ function(D, edges)
   return true;
 end);
 
+InstallMethod(TestHamiltonianPath, "for a digraph", [IsDigraph],
+function(D)
+    local P, edges, i;
+
+    P := HamiltonianPath(D);
+
+    if P = fail then
+        Print("HamiltonianPath returned fail.\n");
+        return false;
+    fi;
+
+    # convert vertex list to edge list
+    edges := [];
+    for i in [1 .. Length(P)-1] do
+        Add(edges, [ P[i], P[i+1] ]);
+    od;
+
+    # 2. Check if path has no repeated vertices
+    if not IsDuplicateFreeList(P) then
+        Print("FAIL: Path repeats vertices.\n");
+        return false;
+    fi;
+
+    # 3. Check if path length equals number of vertices
+    if Length(P) <> DigraphNrVertices(D) then
+        Print("FAIL: Path length is ", Length(P),
+              " but graph has ", DigraphNrVertices(D), " vertices.\n");
+        return false;
+    fi;
+
+    Print("SUCCESS: Path is a valid Hamiltonian path.\n");
+    return true;
+end);
+
 #############################################################################
 # 9.  Connectivity
 #############################################################################

gap/prop.gi

@@ -605,11 +605,11 @@ function(D)
       return true;
     fi;
   fi;
-  return HamiltonianPath(D) <> fail;
+  return HamiltonianCycle(D) <> fail;
 end);
 
 InstallMethod(IsHamiltonianDigraph, "for a digraph with hamiltonian path",
-[IsDigraph and HasHamiltonianPath], x -> HamiltonianPath(x) <> fail);
+[IsDigraph and HasHamiltonianPath], x -> HamiltonianCycle(x) <> fail);
 
 InstallMethod(IsDigraphCore, "for a digraph",
 [IsDigraph],

k4.dot

@@ -0,0 +1,20 @@
+//dot
+digraph hgn{
+node [shape=circle]
+1
+2
+3
+4
+1 -> 2
+1 -> 3
+1 -> 4
+2 -> 1
+2 -> 3
+2 -> 4
+3 -> 1
+3 -> 2
+3 -> 4
+4 -> 1
+4 -> 2
+4 -> 3
+}

my_digraph.dot

@@ -0,0 +1,23 @@
+//dot
+digraph hgn{
+subgraph lowverts{
+node [shape=circle, color=black]
+ edge [color=black]
+3
+}
+subgraph highverts{
+node [shape=circle, color=red]
+ edge [color=red]
+1
+2
+}
+subgraph lowverts{
+3 -> 1
+3 -> 3
+}
+subgraph highverts{
+1 -> 2
+1 -> 3 [color=black]
+2 -> 2
+}
+}

poset.dot

@@ -0,0 +1,11 @@
+//dot
+digraph hgn{
+node [shape=circle]
+1
+2
+3
+4
+1 -> 4
+3 -> 4
+3 -> 2
+}

preset.dot

@@ -0,0 +1,9 @@
+//dot
+digraph graphname {
+node [shape=Mrecord, height=0.5, fixedsize=true]ranksep=1;
+1 [label="4", width=0.5]
+2 [label="1|2|5", width=1.5]
+3 [label="3", width=0.5]
+2 -> 1
+3 -> 1
+}

tst/extreme/attr.tst

@@ -43,20 +43,20 @@ gap> circs := DigraphAllSimpleCircuits(gr);;
 gap> Length(circs);
 1291792
 
-#  HamiltonianPath and IsHamiltonianDigraph
+#  HamiltonianCycle and IsHamiltonianDigraph
 gap> g := CompleteDigraph(20);
 <immutable complete digraph with 20 vertices>
-gap> HamiltonianPath(g);
+gap> HamiltonianCycle(g);
 [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]
 gap> IsDigraphMonomorphism(CycleDigraph(20), 
 >                          g,
->                          Transformation(HamiltonianPath(g)));
+>                          Transformation(HamiltonianCycle(g)));
 true
 gap> IsHamiltonianDigraph(g);
 true
 gap> g := CompleteMultipartiteDigraph([1, 9, 1, 1, 2, 1, 1, 1]);
 <immutable complete multipartite digraph with 17 vertices, 198 edges>
-gap> HamiltonianPath(g);
+gap> HamiltonianCycle(g);
 fail
 gap> IsHamiltonianDigraph(g);
 false