From: Thomas Walker Lynch <eknp9n@reasoningtechnology.com>
Date: Tue, 14 Jan 2025 17:21:18 +0000 (+0000)
Subject: adds complete_context_path function to SRTM_Depth
X-Git-Url: https://git.reasoningtechnology.com/style/rt_dark_doc.css?a=commitdiff_plain;h=cc45234a2aab7e405bd6958dfe87cf460578dacc;p=Ariadne

adds complete_context_path function to SRTM_Depth
---

diff --git "a/developer/document\360\237\226\211/diagonal_traversal.txt" "b/developer/document\360\237\226\211/diagonal_traversal.txt"
index fb50b4f..a157bab 100644
--- "a/developer/document\360\237\226\211/diagonal_traversal.txt"
+++ "b/developer/document\360\237\226\211/diagonal_traversal.txt"
@@ -67,10 +67,10 @@ How diagonalization works:
     2. Populate diagonal_1 using child_srtm_list:
 
        2.1 Bind child_srtm_list to an SRTM.
-       2.2 For each STRM in the list:
+       2.2 For each SRTM in the list:
            2.2.1 Read the label from the SRTM.
            2.2.2 Append a copy of this label to diagonal_1.
-           2.2.3 if can_step the STRM, the step the head to the next sibling.
+           2.2.3 if can_step the SRTM, the step the head to the next sibling.
                  else remove SRTM from the child_srtm_list.  (This removal
                  will never happen on an infinite topology.)
 
diff --git a/developer/example/GraphCycleCFinder/#SRTM_Depth.java# b/developer/example/GraphCycleCFinder/#SRTM_Depth.java#
deleted file mode 100644
index 78de5f7..0000000
--- a/developer/example/GraphCycleCFinder/#SRTM_Depth.java#
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-SRTM_Depth is a list of neighbor SRTMs going down the leftmost side of
-a graph traversal. A leftmost traversal is one characterized by
-following leftmost not yet visited node on the most recently visited
-node's neighbor list.
-
-Depth traversal from a start node, ends when reaching a node that has
-no neighbors, or when reaching encountering a cycle.
-
-The `Node::neighbor()` function returns an SRTM for iterating over the
-node's neighbors. An SRTM is returned rather than a list, because in
-general a neighbor list is allowed to be unbounded.  Though with a
-finite graph, that can not happen. (See IndexTree for an example of an
-infinite depth and infinite breadth graph traveral.)
-
-It is possible to construct and infinite graph such that the
-`SRTM_Depth::make()` function would never return. 
-
-For a finite graph, this depth traversal will provably terminate, due
-to running out unique (non cycle) nodes to visit.  More generally, if
-graph traversal from a start node is guaranteed to reach a leaf node
-(has no neighbors), or a a cycle, within a finite number of node
-traversal steps, then `SRTM_Depth::make()` will always return.
-
-Each call to step causes the TM read head to move to the next lowest
-depth, leftmost unvisited node. This might require backtracking and
-descending again.
-
-Nodes are referenced by label.
-
-A null valued label is flagged as an error, though we still look it up
-in the graph. It is a fatal error, `exit(1)` if `lookup` returns a
-null node.
-
-A path is a list of nodes found while traversing a tree.  A road is a
-list of child_srtm found while traversing the tree.
-
-*/
-
-import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
-import com.ReasoningTechnology.Ariadne.Ariadne_Graph;
-
-
-class SRTM_Depth{
-
-  // static
-  //
-
-  PathStack make(Graph g){
-    return new SRTM_Depth(g);
-  }
-
-  // instance data
-  //
-  protected List<Ariadne_SRTM> path;
-  protected Graph graph;
-
-  // constructor
-  //
-  protected SRTM_Depth(Graph g){
-    set_topography(topo_null);
-    if(g == null) return;
-    graph = g;
-    path.add( g.start() );
-    descend();
-  }
-
-  // instance interface implementation
-  //
-
-
-  // A path is terminated by a leaf node or discovering a cycle.
-  protected boolean extend_path_to_termination(){
-
-    ArrayList<Label> = path new ArrayList<>;
-    
-
-    // Get the label for current child of the deepest in tree child_srtm
-    // The current child is the one under the read head.
-    Ariadne_SRTM<Ariadne_SRTM> child_srtm = path.get(path.size() - 1); 
-    Ariande_Label label = child_srtm.read(); 
-    if( label == null ){
-      System.out.println("SRTM_Depth::extend_to_leaf found null node");
-    }
-
-    // check if label has been visited before:
-    //
-    
-    
-    // descend from the label and put it in to 
-    Ariadne_Node node = graph.lookup(label);
-    if( node == null ){
-      System.out.println
-        (
-         "SRTM_Depth::descend error: label(\"" 
-         + label 
-         + "\") not found in graph."
-         );
-      return false;
-    }
-
-    Ariadne_SRTM_Label = node.neighbor();
-
-    if( !
-
-    Ariadne_SRTM<Ariadne_SRTM> srtm = Ariadna_SRTM_List.make(path);
-    if( !srtm.can_read() ) return;
-    do{
-      child_srtm = srtm.read();
-      if( !srtm.can_step() ) break;
-      srtm.step();
-    }while(true);
-
-    visited.push(path.
-  }
-
-  // being a good object citizen
-  //
-
-
-}
diff --git a/developer/example/GraphCycleCFinder/SRTM_Depth.java b/developer/example/GraphCycleCFinder/SRTM_Depth.java
index 474ba36..c8ccc19 100644
--- a/developer/example/GraphCycleCFinder/SRTM_Depth.java
+++ b/developer/example/GraphCycleCFinder/SRTM_Depth.java
@@ -32,83 +32,126 @@ A null valued label is flagged as an error, though we still look it up
 in the graph. It is a fatal error, `exit(1)` if `lookup` returns a
 null node.
 
+A `path` is a list of nodes (each referenced by a label).  `context_path`
+carries with it the child list for each node in the path.  The child
+list is represented as a srtm, and the head of the tape machine marks
+the child node that is no the path.
+
 */
 
+import java.util.HashMap;
+
 import com.ReasoningTechnology.Ariadne.Ariadne_SRTM;
 import com.ReasoningTechnology.Ariadne.Ariadne_Graph;
 
-
 class SRTM_Depth{
 
   // static
   //
 
-  PathStack make(Graph g){
-    return new SRTM_Depth(g);
+  SRTM_Depth make(Graph graph){
+    SRTM_Depth depth = new SRTM_Depth();
+    if(graph == null) return null;
+    depth.graph = graph;
+    depth.context_path.add( graph.start() );
+    boolean flag = complete_context_path();
+    if( flag ) return depth;
+    return null;
   }
 
   // instance data
   //
-  protected List<Ariadne_SRTM> path;
-  protected Graph graph;
+  protected Graph graph = null;
+  protected List<Ariadne_SRTM> context_path = new ArrayList<>();
+  protected Label cycle_node_label = null;
 
   // constructor
   //
-  protected SRTM_Depth(Graph g){
+  protected SRTM_Depth(){
     set_topography(topo_null);
-    if(g == null) return;
-    graph = g;
-    path.add( g.start() );
-    descend();
   }
 
   // instance interface implementation
   //
 
 
-  // A path is terminated by a leaf node or discovering a cycle.
-  protected boolean extend_path_to_termination(){
-
-    ArrayList<Label> = path new ArrayList<>;
-    
+  // A path is terminated by a leaf node or upon discovering a cycle.
+  // Return false iff can not complete the context path. This is generally a fatal error.
+  protected boolean complete_context_path(){
 
-    // Get the label for current child of the deepest in tree child_srtm
-    // The current child is the one under the read head.
-    Ariadne_SRTM<Ariadne_SRTM> child_srtm = path.get(path.size() - 1); 
-    Ariande_Label label = child_srtm.read(); 
-    if( label == null ){
-      System.out.println("SRTM_Depth::extend_to_leaf found null node");
-    }
-
-    // check if label has been visited before:
-    //
-    
-    
-    // descend from the label and put it in to 
-    Ariadne_Node node = graph.lookup(label);
-    if( node == null ){
-      System.out.println
-        (
-         "SRTM_Depth::descend error: label(\"" 
-         + label 
-         + "\") not found in graph."
-         );
+    if( context_path.isEmpty() ){
+      System.out.println("SRTM_Depth::complete_context_path empty context_path");
       return false;
     }
 
-    Ariadne_SRTM_Label = node.neighbor();
+    private final HashSet<Label> path_node_label_set = new HashSet<>();
+    boolean is_cycle_node = false;
 
-    if( !
+    // should add cycle check for anomalous case caller fed us an initial path with a cycle
+    // initialize the path_node set
+    Ariadne_SRTMI_Array<Ariadne_SRTM> context_path_srtm = Ariadne_SRTMI_Array.make(context_path);
+    Ariadne_SRTM_List<label> child_srtm = null;
+    Label path_node_label = null;
 
-    Ariadne_SRTM<Ariadne_SRTM> srtm = Ariadna_SRTM_List.make(path);
-    if( !srtm.can_read() ) return;
+    // context_path is known not to be  empty, so can_read() is true
     do{
-      child_srtm = srtm.read();
-      if( !srtm.can_step() ) break;
-      srtm.step();
+      child_srtm = context_path_srtm.read();
+      path_node_label = child_srtm.read();
+      if(path_node_label == null){
+        System.out.println("SRTM_Depth::complete_context_path null path label");
+        return false;
+      }
+      is_cycle_node = path_node_label_set.contains(path_node_label);
+      if( is_cycle_node ){
+        System.out.println
+        (
+         "SRTM_Depth::complete_context_path: cycle found in initial context_path"
+         );
+        cycle_node_label = path_node_label;
+        return false; 
+      }
+      path_node_label_set.add( path_node_label );
+      // when completing from the `start()`, this will be break out on the first try
+      if( !context_path_srtm.can_step() ) break;
+      context_path_srtm.step();
     }while(true);
 
-    visited.push(path.
+    // path descends down the left side of the unvisted portion of the tree.
+    // extend the context_path downward until leftmost is a leaf node or a cycle node
+    Ariadne_Node path_node = null;
+    boolean is_leaf_node = null;
+    do{
+      path_node = graph.lookup(path_node_label);
+      if(path_node == null){
+        System.out.println
+          (
+           "SRTM_Depth::complete_context_path node not found in graph for: label(\""
+           + path_node_label
+           + "\")"
+           );
+        return false;
+      }
+
+      // descend
+      child_srtm = path_node.neighbor();
+
+      // exit conditions
+      //
+      is_leaf_node = child_srtm == null || !child_srtm.can_read();
+      if(is_leaf_node) return true;
+      //
+      path_node_label = child_srtm.read();
+      is_cycle_node = path_node_label_set.contains(path_node_label);
+      if( is_cycle_node ){
+        // caller needs to check for cycle found before each new step
+        cycle_node_label = path_node_label;
+        return true; 
+      }
+
+      // path_node_label has now been visited
+      path_node_label_set.add(path_node_label);
+
+    }while(true);
   }
 
   // being a good object citizen
diff --git a/developer/example/SRTM/SRTMI_Array_CLI.java b/developer/example/SRTM/SRTMI_Array_CLI.java
index cbea135..3046772 100644
--- a/developer/example/SRTM/SRTMI_Array_CLI.java
+++ b/developer/example/SRTM/SRTMI_Array_CLI.java
@@ -10,7 +10,7 @@ public class SRTMI_Array_CLI {
     List<String> label_array = Arrays.asList( "A", "B", "C", "D" );
 
     // Attach SRTMI to the array
-    Ariadne_SRTMI_Array<String> srm = Ariadne_SRTMI_Array.make( label_array );
+    Ariadne_SRTMI_Array<String> srm = Ariadne_SRTMI_Array.make(label_array);
     if( srm.can_read() ){
       do{
         System.out.println( "Reading: " + srm.read() );