From: Thomas Walker Lynch <eknp9n@reasoningtechnology.com>
Date: Tue, 14 Jan 2025 15:14:24 +0000 (+0000)
Subject: strm typos -> srtm
X-Git-Url: https://git.reasoningtechnology.com/home/twl/Documents/subuser/test_env.py?a=commitdiff_plain;h=37a7d2350a6734d12b853432c0ab6db922258108;p=Ariadne

strm typos -> srtm
---

diff --git a/developer/deprecated/DirectedGraph.java b/developer/deprecated/DirectedGraph.java
new file mode 100644
index 0000000..c8b2420
--- /dev/null
+++ b/developer/deprecated/DirectedGraph.java
@@ -0,0 +1,234 @@
+package com.ReasoningTechnology.Ariadne;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+import java.util.ArrayList;
+
+public class Ariadne_GraphDirectedAcyclic extends Ariadne_Graph{
+
+  // test messaging
+  //
+    private static boolean test = false;
+    public static void test_switch(boolean test){
+      if(Ariadne_Graph.test && !test){
+        test_print("Ariadne_Graph:: test messages off");
+      }
+      if(!Ariadne_Graph.test && test){
+        test_print("Ariadne_Graph:: test messages on");
+      }
+    }
+    private static void test_print(String message){
+      if(test){
+        System.out.println(message);
+      }
+    }
+
+  // class data
+  //
+
+    // marks this class might put on a node
+    public static Ariadne_TokenSet node_marks = new Ariadne_TokenSet(){{
+      add(new Ariadne_Token("empty_root_label_list"));
+      add(new Ariadne_Token("cycle_exists"));
+      add(new Ariadne_Token("undefined_node_exists"));
+      add(new Ariadne_Token("bad_descent_termination"));
+      add(new Ariadne_Token("max_depth_reached"));
+    }};
+
+    // graph descend method return values
+    private static Ariadne_TokenSet graph_descend_set = new Ariadne_TokenSet(){{
+      add(new Ariadne_Token("empty_path_stack"));
+      add(new Ariadne_Token("cycle_found"));
+      add(new Ariadne_Token("undefined_node"));
+      add(new Ariadne_Token("leaf"));
+      add(new Ariadne_Token("max_depth_reached"));
+    }};
+
+
+  // instance data
+
+  // constructors
+  //
+    public Ariadne_GraphDirectedAcyclic(){
+      super(new HashMap<>(), null);
+    }
+
+    public Ariadne_GraphDirectedAcyclic(Map<Ariadne_Label, Ariadne_Node> node_map, Ariadne_DefinitionList recognizer_f_list, Ariadne_LabelList root_node_list, int max_depth, boolean verbose){
+      super(node_map, recognizer_f_list);
+      Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list, max_depth, verbose);
+    }
+
+    public Ariadne_GraphDirectedAcyclic(Map<Ariadne_Label, Ariadne_Node> node_map, Ariadne_DefinitionList recognizer_f_list, Ariadne_LabelList root_node_list){
+      super(node_map, recognizer_f_list);
+      Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list);
+    }
+
+  // interface functions
+  //
+    private List<Integer> path_find_cycle(Ariadne_LabelList path){
+      if(path.size() <= 1) return null;
+
+      int rightmost_index = path.size() - 1;
+      Ariadne_Label rightmost_node_label = path.get(rightmost_index);
+
+      int cycle_leftmost_index = path.indexOf(rightmost_node_label);
+      Boolean has_cycle = cycle_leftmost_index < rightmost_index;
+      if(!has_cycle) return null;
+
+      List<Integer> result = new ArrayList<>();
+      result.add(cycle_leftmost_index);
+      result.add(rightmost_index);
+      return result;
+    }
+
+    private boolean graph_descend_cycle_case(Ariadne_LabelList left_path, List<Ariadne_LabelList> path_stack, boolean verbose){
+
+      List<Integer> cycle_index_interval = path_find_cycle(left_path);
+      if(cycle_index_interval == null){
+        return false;
+      }
+
+      int cycle_i0 = cycle_index_interval.get(0);
+      int cycle_n = cycle_index_interval.get(1);
+
+      if(verbose) Ariadne_Util.print_list(
+        "Found cycle:", 
+        left_path.subList(cycle_i0, cycle_n + 1)
+      );
+
+      Ariadne_LabelList undefined_node_list = new Ariadne_LabelList();
+      for (int i = cycle_i0; i <= cycle_n; i++){
+        Ariadne_Label node_label = left_path.get(i);
+        Ariadne_Node node = super.lookup(node_label);
+        if(node != null){
+          node.mark(new Ariadne_Token("cycle_member"));
+        } else{
+          undefined_node_list.add(node_label);
+        }
+      }
+
+      if(verbose) Ariadne_Util.print_list(
+        "Each undefined node could not be marked as a cycle member:", 
+        undefined_node_list
+      );
+
+      path_stack.subList(cycle_i0 + 1, cycle_n + 1).clear();
+
+      return true;
+    }
+
+    private Ariadne_TokenSet graph_descend(List<Ariadne_LabelList> path_stack, int max_depth, boolean verbose){
+      Ariadne_TokenSet ret_value = new Ariadne_TokenSet();
+
+      if(path_stack.isEmpty()){
+        ret_value.add(new Ariadne_Token("empty_path_stack"));
+        return ret_value;
+      }
+
+      Ariadne_LabelList left_path = new Ariadne_LabelList();
+      for (Ariadne_LabelList neighbor_list : path_stack){
+        left_path.add(neighbor_list.get(0));
+      }
+
+      do{
+
+        if(graph_descend_cycle_case(left_path, path_stack, verbose)){
+          ret_value.add(new Ariadne_Token("cycle_found"));
+          return ret_value;
+        }
+
+        Ariadne_Label it_node_label = path_stack.get(path_stack.size() - 1).get(0);
+        Ariadne_Node it_node = super.lookup(it_node_label);
+        if(it_node == null){
+          ret_value.add(new Ariadne_Token("undefined_node"));
+          return ret_value;
+        }
+
+        Ariadne_LabelList neighbor_list = it_node.neighbor_LabelList();
+        if(neighbor_list.isEmpty()){
+          ret_value.add(new Ariadne_Token("leaf"));
+          return ret_value;
+        }
+
+        path_stack.add(new Ariadne_LabelList(neighbor_list));
+        Ariadne_Label it_next_label = neighbor_list.get(0);
+        left_path.add(it_next_label);
+
+        if(max_depth > 0){
+          max_depth--;
+          if(max_depth == 0){
+            if(verbose){
+              Ariadne_Util.print_list("GraphDirectedAcyclic.GraphDescend:: max_depth reached, ending descent:", path_stack);
+            }
+            ret_value.add(new Ariadne_Token("max_depth_reached"));
+            return ret_value;
+          }
+        }
+
+      } while (true);
+    }
+
+
+  public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList, int max_depth, boolean verbose){
+    Ariadne_TokenSet ret_value = new Ariadne_TokenSet();
+    boolean exists_malformed = false;
+    Ariadne_TokenSet result;
+
+    if(root_node_LabelList.isEmpty()){
+      ret_value.add(new Ariadne_Token("empty_root_label_list"));
+      return ret_value;
+    }
+
+    List<Ariadne_LabelList> path_stack = new ArrayList<>();
+    path_stack.add(new Ariadne_LabelList(root_node_LabelList));
+
+    do{
+      result = graph_descend(path_stack, max_depth, verbose);
+      if(result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("cycle_exists"));
+      if(result.contains(new Ariadne_Token("undefined_node"))) ret_value.add(new Ariadne_Token("undefined_node_exists"));
+      if(result.contains(new Ariadne_Token("max_depth_reached"))) ret_value.add(new Ariadne_Token("max_depth_reached"));
+      if(!result.contains(new Ariadne_Token("leaf")) && !result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("bad_descent_termination"));
+
+      Ariadne_LabelList top_list = path_stack.get(path_stack.size() - 1);
+      top_list.remove(0);
+      if(top_list.isEmpty()) path_stack.remove(path_stack.size() - 1);
+
+    } while (!path_stack.isEmpty());
+
+    if(verbose){
+      if(ret_value.contains("bad_descent_termination")){
+        System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: terminated with unexpected condition.");
+      }
+      if(ret_value.contains("cycle_exists")){
+        System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: One or more cycles detected.");
+      }
+      if(ret_value.contains("undefined_node_exists")){
+        System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: Undefined nodes exist.");
+      }
+    }
+
+    return ret_value;
+  }
+
+  public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList){
+    return graph_mark_cycles(root_node_LabelList, this.debug ? 40 : -1, this.debug);
+  }
+
+  @Override
+  public Ariadne_Node lookup(Ariadne_Label node_label, boolean verbose){
+    Ariadne_Node node = super.lookup(node_label, verbose);
+    if(node != null && node.has_mark(new Ariadne_Token("cycle_member"))){
+      if(verbose){
+        System.out.println("GraphDirectedAcyclic.lookup:: Node is part of a cycle, not returned: " + node_label);
+      }
+      return null;
+    }
+    return node;
+  }
+
+  public Ariadne_Node lookup(Ariadne_Label node_label){
+    return lookup(node_label, this.debug);
+  }
+
+}
diff --git a/developer/example/GraphCycleCFinder/#SRTM_Depth.java# b/developer/example/GraphCycleCFinder/#SRTM_Depth.java#
new file mode 100644
index 0000000..78de5f7
--- /dev/null
+++ b/developer/example/GraphCycleCFinder/#SRTM_Depth.java#
@@ -0,0 +1,121 @@
+/*
+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/#temp.java# b/developer/example/GraphCycleCFinder/#temp.java#
new file mode 100644
index 0000000..74e0a62
--- /dev/null
+++ b/developer/example/GraphCycleCFinder/#temp.java#
@@ -0,0 +1,118 @@
+package com.ReasoningTechnology.Ariadne;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SRTM_Depth extends Ariadne_SRTM {
+
+  // Static method to create a depth traversal SRTM
+  public static SRTM_Depth make(Ariadne_Graph graph){
+    SRTM_Depth depth = new SRTM_Depth();
+    depth.path.add(graph.start());
+    depth.descent();
+    return depth;
+  }
+
+  // Instance data
+  private final List<Ariadne_SRTM> path;
+
+  private final TopoIface topo_null = new TopoNull();
+  private final TopoIface topo_segment = new TopoSegment();
+
+  // Constructor
+  protected SRTM_Depth(){
+    this.path = new ArrayList<>();
+    set_topology(topo_null);
+  }
+
+  // Descends to the leftmost unvisited node
+  protected void descent(){
+    while( true ){
+      Ariadne_SRTM current = path.get(path.size() - 1);
+      if( !current.can_read() ){
+        backtrack();
+        if( path.isEmpty() ) return; // No more nodes to traverse
+        continue;
+      }
+
+      Ariadne_SRTM neighbors = current.read(); // Get neighbor SRTM
+      if( neighbors == null || !neighbors.can_read() ){
+        backtrack();
+        if( path.isEmpty() ) return;
+        continue;
+      }
+
+      path.add(neighbors);
+      set_topology(topo_segment);
+    }
+  }
+
+  // Backtracks to the previous node
+  protected void backtrack(){
+    while( !path.isEmpty() ){
+      Ariadne_SRTM last = path.get(path.size() - 1);
+      last.step();
+      if( last.can_step() ){
+        return;
+      }
+      path.remove(path.size() - 1);
+    }
+    set_topology(topo_null);
+  }
+
+  // Steps to the next node in the traversal
+  @Override
+  public void step(){
+    descent();
+  }
+
+  // Reads the current node
+  @Override
+  public Ariadne_SRTM read(){
+    return path.isEmpty() ? null : path.get(path.size() - 1);
+  }
+
+  // Checks if traversal can continue
+  @Override
+  public boolean can_read(){
+    return current_topology.can_read();
+  }
+
+  // Topology: Null
+  private class TopoNull implements TopoIface{
+    @Override public boolean can_read(){
+      return false;
+    }
+    @Override public Object read(){
+      throw new UnsupportedOperationException("Cannot read from NULL topology.");
+    }
+    @Override public boolean can_step(){
+      return false;
+    }
+    @Override public void step(){
+      throw new UnsupportedOperationException("Cannot step from NULL topology.");
+    }
+    @Override public Topology topology(){
+      return Topology.NULL;
+    }
+  }
+
+  // Topology: Segment
+  private class TopoSegment implements TopoIface{
+    @Override public boolean can_read(){
+      return true;
+    }
+    @Override public Object read(){
+      return path.get(path.size() - 1);
+    }
+    @Override public boolean can_step(){
+      return !path.isEmpty();
+    }
+    @Override public void step(){
+      descent();
+    }
+    @Override public Topology topology(){
+      return Topology.SEGMENT;
+    }
+  }
+}
diff --git a/developer/example/GraphCycleCFinder/DirectedGraph.java b/developer/example/GraphCycleCFinder/DirectedGraph.java
deleted file mode 100644
index c8b2420..0000000
--- a/developer/example/GraphCycleCFinder/DirectedGraph.java
+++ /dev/null
@@ -1,234 +0,0 @@
-package com.ReasoningTechnology.Ariadne;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.List;
-import java.util.ArrayList;
-
-public class Ariadne_GraphDirectedAcyclic extends Ariadne_Graph{
-
-  // test messaging
-  //
-    private static boolean test = false;
-    public static void test_switch(boolean test){
-      if(Ariadne_Graph.test && !test){
-        test_print("Ariadne_Graph:: test messages off");
-      }
-      if(!Ariadne_Graph.test && test){
-        test_print("Ariadne_Graph:: test messages on");
-      }
-    }
-    private static void test_print(String message){
-      if(test){
-        System.out.println(message);
-      }
-    }
-
-  // class data
-  //
-
-    // marks this class might put on a node
-    public static Ariadne_TokenSet node_marks = new Ariadne_TokenSet(){{
-      add(new Ariadne_Token("empty_root_label_list"));
-      add(new Ariadne_Token("cycle_exists"));
-      add(new Ariadne_Token("undefined_node_exists"));
-      add(new Ariadne_Token("bad_descent_termination"));
-      add(new Ariadne_Token("max_depth_reached"));
-    }};
-
-    // graph descend method return values
-    private static Ariadne_TokenSet graph_descend_set = new Ariadne_TokenSet(){{
-      add(new Ariadne_Token("empty_path_stack"));
-      add(new Ariadne_Token("cycle_found"));
-      add(new Ariadne_Token("undefined_node"));
-      add(new Ariadne_Token("leaf"));
-      add(new Ariadne_Token("max_depth_reached"));
-    }};
-
-
-  // instance data
-
-  // constructors
-  //
-    public Ariadne_GraphDirectedAcyclic(){
-      super(new HashMap<>(), null);
-    }
-
-    public Ariadne_GraphDirectedAcyclic(Map<Ariadne_Label, Ariadne_Node> node_map, Ariadne_DefinitionList recognizer_f_list, Ariadne_LabelList root_node_list, int max_depth, boolean verbose){
-      super(node_map, recognizer_f_list);
-      Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list, max_depth, verbose);
-    }
-
-    public Ariadne_GraphDirectedAcyclic(Map<Ariadne_Label, Ariadne_Node> node_map, Ariadne_DefinitionList recognizer_f_list, Ariadne_LabelList root_node_list){
-      super(node_map, recognizer_f_list);
-      Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list);
-    }
-
-  // interface functions
-  //
-    private List<Integer> path_find_cycle(Ariadne_LabelList path){
-      if(path.size() <= 1) return null;
-
-      int rightmost_index = path.size() - 1;
-      Ariadne_Label rightmost_node_label = path.get(rightmost_index);
-
-      int cycle_leftmost_index = path.indexOf(rightmost_node_label);
-      Boolean has_cycle = cycle_leftmost_index < rightmost_index;
-      if(!has_cycle) return null;
-
-      List<Integer> result = new ArrayList<>();
-      result.add(cycle_leftmost_index);
-      result.add(rightmost_index);
-      return result;
-    }
-
-    private boolean graph_descend_cycle_case(Ariadne_LabelList left_path, List<Ariadne_LabelList> path_stack, boolean verbose){
-
-      List<Integer> cycle_index_interval = path_find_cycle(left_path);
-      if(cycle_index_interval == null){
-        return false;
-      }
-
-      int cycle_i0 = cycle_index_interval.get(0);
-      int cycle_n = cycle_index_interval.get(1);
-
-      if(verbose) Ariadne_Util.print_list(
-        "Found cycle:", 
-        left_path.subList(cycle_i0, cycle_n + 1)
-      );
-
-      Ariadne_LabelList undefined_node_list = new Ariadne_LabelList();
-      for (int i = cycle_i0; i <= cycle_n; i++){
-        Ariadne_Label node_label = left_path.get(i);
-        Ariadne_Node node = super.lookup(node_label);
-        if(node != null){
-          node.mark(new Ariadne_Token("cycle_member"));
-        } else{
-          undefined_node_list.add(node_label);
-        }
-      }
-
-      if(verbose) Ariadne_Util.print_list(
-        "Each undefined node could not be marked as a cycle member:", 
-        undefined_node_list
-      );
-
-      path_stack.subList(cycle_i0 + 1, cycle_n + 1).clear();
-
-      return true;
-    }
-
-    private Ariadne_TokenSet graph_descend(List<Ariadne_LabelList> path_stack, int max_depth, boolean verbose){
-      Ariadne_TokenSet ret_value = new Ariadne_TokenSet();
-
-      if(path_stack.isEmpty()){
-        ret_value.add(new Ariadne_Token("empty_path_stack"));
-        return ret_value;
-      }
-
-      Ariadne_LabelList left_path = new Ariadne_LabelList();
-      for (Ariadne_LabelList neighbor_list : path_stack){
-        left_path.add(neighbor_list.get(0));
-      }
-
-      do{
-
-        if(graph_descend_cycle_case(left_path, path_stack, verbose)){
-          ret_value.add(new Ariadne_Token("cycle_found"));
-          return ret_value;
-        }
-
-        Ariadne_Label it_node_label = path_stack.get(path_stack.size() - 1).get(0);
-        Ariadne_Node it_node = super.lookup(it_node_label);
-        if(it_node == null){
-          ret_value.add(new Ariadne_Token("undefined_node"));
-          return ret_value;
-        }
-
-        Ariadne_LabelList neighbor_list = it_node.neighbor_LabelList();
-        if(neighbor_list.isEmpty()){
-          ret_value.add(new Ariadne_Token("leaf"));
-          return ret_value;
-        }
-
-        path_stack.add(new Ariadne_LabelList(neighbor_list));
-        Ariadne_Label it_next_label = neighbor_list.get(0);
-        left_path.add(it_next_label);
-
-        if(max_depth > 0){
-          max_depth--;
-          if(max_depth == 0){
-            if(verbose){
-              Ariadne_Util.print_list("GraphDirectedAcyclic.GraphDescend:: max_depth reached, ending descent:", path_stack);
-            }
-            ret_value.add(new Ariadne_Token("max_depth_reached"));
-            return ret_value;
-          }
-        }
-
-      } while (true);
-    }
-
-
-  public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList, int max_depth, boolean verbose){
-    Ariadne_TokenSet ret_value = new Ariadne_TokenSet();
-    boolean exists_malformed = false;
-    Ariadne_TokenSet result;
-
-    if(root_node_LabelList.isEmpty()){
-      ret_value.add(new Ariadne_Token("empty_root_label_list"));
-      return ret_value;
-    }
-
-    List<Ariadne_LabelList> path_stack = new ArrayList<>();
-    path_stack.add(new Ariadne_LabelList(root_node_LabelList));
-
-    do{
-      result = graph_descend(path_stack, max_depth, verbose);
-      if(result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("cycle_exists"));
-      if(result.contains(new Ariadne_Token("undefined_node"))) ret_value.add(new Ariadne_Token("undefined_node_exists"));
-      if(result.contains(new Ariadne_Token("max_depth_reached"))) ret_value.add(new Ariadne_Token("max_depth_reached"));
-      if(!result.contains(new Ariadne_Token("leaf")) && !result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("bad_descent_termination"));
-
-      Ariadne_LabelList top_list = path_stack.get(path_stack.size() - 1);
-      top_list.remove(0);
-      if(top_list.isEmpty()) path_stack.remove(path_stack.size() - 1);
-
-    } while (!path_stack.isEmpty());
-
-    if(verbose){
-      if(ret_value.contains("bad_descent_termination")){
-        System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: terminated with unexpected condition.");
-      }
-      if(ret_value.contains("cycle_exists")){
-        System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: One or more cycles detected.");
-      }
-      if(ret_value.contains("undefined_node_exists")){
-        System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: Undefined nodes exist.");
-      }
-    }
-
-    return ret_value;
-  }
-
-  public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList){
-    return graph_mark_cycles(root_node_LabelList, this.debug ? 40 : -1, this.debug);
-  }
-
-  @Override
-  public Ariadne_Node lookup(Ariadne_Label node_label, boolean verbose){
-    Ariadne_Node node = super.lookup(node_label, verbose);
-    if(node != null && node.has_mark(new Ariadne_Token("cycle_member"))){
-      if(verbose){
-        System.out.println("GraphDirectedAcyclic.lookup:: Node is part of a cycle, not returned: " + node_label);
-      }
-      return null;
-    }
-    return node;
-  }
-
-  public Ariadne_Node lookup(Ariadne_Label node_label){
-    return lookup(node_label, this.debug);
-  }
-
-}
diff --git a/developer/example/GraphCycleCFinder/SRTM_Depth.java b/developer/example/GraphCycleCFinder/SRTM_Depth.java
new file mode 100644
index 0000000..474ba36
--- /dev/null
+++ b/developer/example/GraphCycleCFinder/SRTM_Depth.java
@@ -0,0 +1,118 @@
+/*
+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.
+
+*/
+
+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/GraphIndexTree/SRTM_Child.java b/developer/example/GraphIndexTree/SRTM_Child.java
index 2d86c7e..929b908 100644
--- a/developer/example/GraphIndexTree/SRTM_Child.java
+++ b/developer/example/GraphIndexTree/SRTM_Child.java
@@ -17,8 +17,8 @@ public class SRTM_Child extends Ariadne_SRTM_Label{
   // Static
   //
 
-  public static SRTM_Child make( Label first_child_label ){
-    return new SRTM_Child( first_child_label );
+  public static SRTM_Child make( Label leftmost_child_label ){
+    return new SRTM_Child( leftmost_child_label );
   }
 
   // Instance data
diff --git a/developer/example/GraphIndexTree/SRTM_Diagonal.java b/developer/example/GraphIndexTree/SRTM_Diagonal.java
index f023789..32c3d72 100644
--- a/developer/example/GraphIndexTree/SRTM_Diagonal.java
+++ b/developer/example/GraphIndexTree/SRTM_Diagonal.java
@@ -6,7 +6,7 @@ can do this. This guarantee also applies to a pruned IndexTree.
 This implementation is nearly ready, to be included in the Ariadne
 library for generalized diagonal traversal. I have abstracted out all
 references to the IndexTree. It still needs to remove child lists that
-have been completely reversed from the child_strm_list.  This was not
+have been completely reversed from the child_srtm_list.  This was not
 needed for the IndexTree because it is infinite, so they will never be
 completely traversed. Also needed, is to stop when a node does not
 have a child list. Again, this is not needed here because the
@@ -117,7 +117,7 @@ public class SRTM_Diagonal extends Ariadne_SRTM{
 
         List<Label> diagonal_1 = new ArrayList<>();
 
-        // inc_down from each node on diagonal_0 -> entry on child_strm list
+        // inc_down from each node on diagonal_0 -> entry on child_srtm list
         Ariadne_SRTM_List<Label> diagonal_srtm = Ariadne_SRTM_List.make(diagonal);
         if( diagonal_srtm.can_read() ){
           do{
@@ -128,7 +128,7 @@ public class SRTM_Diagonal extends Ariadne_SRTM{
           }while(true);
         }
 
-        // add to diagonal_1 from each on entry on the child_strm list
+        // add to diagonal_1 from each on entry on the child_srtm list
         Ariadne_SRTM_List<SRTM_Child> child_srtm_srtm = Ariadne_SRTM_List.make(child_srtm_list);
         if( child_srtm_srtm.can_read() ){
           do{
diff --git "a/developer/javac\360\237\226\211/Ariadne_Label.java" "b/developer/javac\360\237\226\211/Ariadne_Label.java"
index 138e5e5..41c3598 100644
--- "a/developer/javac\360\237\226\211/Ariadne_Label.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_Label.java"
@@ -7,4 +7,5 @@ public interface Ariadne_Label{
   boolean is_null();
   Ariadne_Label copy();
   @Override String toString();
+  @Override public boolean equals(Object o);
 }