From 37a7d2350a6734d12b853432c0ab6db922258108 Mon Sep 17 00:00:00 2001
From: Thomas Walker Lynch <eknp9n@reasoningtechnology.com>
Date: Tue, 14 Jan 2025 15:14:24 +0000
Subject: [PATCH] strm typos -> srtm

---
 .../DirectedGraph.java                        |   0
 .../GraphCycleCFinder/#SRTM_Depth.java#       | 121 ++++++++++++++++++
 .../example/GraphCycleCFinder/#temp.java#     | 118 +++++++++++++++++
 .../example/GraphCycleCFinder/SRTM_Depth.java | 118 +++++++++++++++++
 .../example/GraphIndexTree/SRTM_Child.java    |   4 +-
 .../example/GraphIndexTree/SRTM_Diagonal.java |   6 +-
 .../javac\360\237\226\211/Ariadne_Label.java" |   1 +
 7 files changed, 363 insertions(+), 5 deletions(-)
 rename developer/{example/GraphCycleCFinder => deprecated}/DirectedGraph.java (100%)
 create mode 100644 developer/example/GraphCycleCFinder/#SRTM_Depth.java#
 create mode 100644 developer/example/GraphCycleCFinder/#temp.java#
 create mode 100644 developer/example/GraphCycleCFinder/SRTM_Depth.java

diff --git a/developer/example/GraphCycleCFinder/DirectedGraph.java b/developer/deprecated/DirectedGraph.java
similarity index 100%
rename from developer/example/GraphCycleCFinder/DirectedGraph.java
rename to developer/deprecated/DirectedGraph.java
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/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);
 }
-- 
2.20.1