From 4bbc3f1de4bd48873b9c2c9bf3ab815fc7239934 Mon Sep 17 00:00:00 2001
From: Thomas Walker Lynch <eknp9n@reasoningtechnology.com>
Date: Fri, 24 Jan 2025 11:12:48 +0000
Subject: [PATCH] =?utf8?q?apr=C3=A9s?=
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

---
 developer/deprecated/Ariadne_SRTM.java        | 16 +++---
 developer/deprecated/temp.java                | 18 +++----
 "developer/document\360\237\226\211/bugs.txt" | 22 ++++----
 .../CountingNumber/CountingNumber.java        |  4 +-
 .../CountingNumber/CountingNumber_0_CLI.java  |  6 +--
 .../GraphCycleCFinder/TM_SR_ND_Depth.java     | 32 ++++++------
 developer/example/GraphIndexTree/Graph.java   |  4 +-
 developer/example/GraphIndexTree/Label.java   |  6 +--
 developer/example/GraphIndexTree/Node.java    |  4 +-
 .../GraphIndexTree/TM_SR_ND_Child.java        | 14 +++---
 .../GraphIndexTree/TM_SR_ND_Diagonal.java     | 24 ++++-----
 .../GraphIndexTree/TM_SR_ND_Diagonal_CLI.java | 10 ++--
 .../four_down_four_across_CLI.java            |  8 +--
 .../example/TM_SR_ND/TM_SR_ND_Array_CLI.java  | 10 ++--
 .../example/TM_SR_ND/TM_SR_ND_List_CLI.java   | 10 ++--
 .../example/TM_SR_ND/TM_SR_ND_Print_CLI.java  | 10 ++--
 .../example/TM_SR_ND/TM_SR_ND_Set_CLI.java    |  8 +--
 .../#Ariadne_SiblingContext.java#"            | 50 -------------------
 .../Ariadne_ContextPath_FD.java"              | 12 ++---
 .../javac\360\237\226\211/Ariadne_Graph.java" |  2 +-
 .../Ariadne_Graph_FD.java"                    | 18 +++----
 .../javac\360\237\226\211/Ariadne_Node.java"  |  4 +-
 .../Ariadne_Node_FD.java"                     |  6 +--
 .../Ariadne_SiblingContext.java"              | 50 +++----------------
 .../Ariadne_SiblingContext_NX.java"           | 32 ++++++++++++
 .../Ariadne_TM_SR_NX.java"                    | 40 +++++++--------
 .../Ariadne_TM_SR_NX_Array.java"              | 14 +++---
 .../Ariadne_TM_SR_NX_List.java"               | 20 ++++----
 .../Ariadne_TM_SR_NX_Set.java"                | 14 +++---
 29 files changed, 210 insertions(+), 258 deletions(-)
 delete mode 100644 "developer/javac\360\237\226\211/#Ariadne_SiblingContext.java#"
 create mode 100644 "developer/javac\360\237\226\211/Ariadne_SiblingContext_NX.java"
 rename "developer/javac\360\237\226\211/Ariadne_TM_SR_ND.java" => "developer/javac\360\237\226\211/Ariadne_TM_SR_NX.java" (87%)
 rename "developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Array.java" => "developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Array.java" (86%)
 rename "developer/javac\360\237\226\211/Ariadne_TM_SR_ND_List.java" => "developer/javac\360\237\226\211/Ariadne_TM_SR_NX_List.java" (85%)
 rename "developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Set.java" => "developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Set.java" (86%)

diff --git a/developer/deprecated/Ariadne_SRTM.java b/developer/deprecated/Ariadne_SRTM.java
index 5d1771a..ac126b6 100644
--- a/developer/deprecated/Ariadne_SRTM.java
+++ b/developer/deprecated/Ariadne_SRTM.java
@@ -1,7 +1,7 @@
 /*
   Step Right Tape Machine
 
-  Depending how the undefined methods here are defined, the TM_SR_ND can
+  Depending how the undefined methods here are defined, the TM_SR_NX can
   equally be a finite iterator, a generator, or an infinite stream.
 
   This is for single-threaded execution. The multi-threaded model
@@ -9,7 +9,7 @@
 */
 package com.ReasoningTechnology.Ariadne;
 
-public class Ariadne_TM_SR_ND{
+public class Ariadne_TM_SR_NX{
 
   // static
   //
@@ -22,8 +22,8 @@ public class Ariadne_TM_SR_ND{
     ,INFINITE
   }
 
-  public static Ariadne_TM_SR_ND make(){
-    return new Ariadne_TM_SR_ND();
+  public static Ariadne_TM_SR_NX make(){
+    return new Ariadne_TM_SR_NX();
   }
 
   // instance data
@@ -35,7 +35,7 @@ public class Ariadne_TM_SR_ND{
   // constructor(s)
   //
 
-  protected Ariadne_TM_SR_ND(){
+  protected Ariadne_TM_SR_NX(){
     set_topology( not_mounted );
   }
 
@@ -87,16 +87,16 @@ public class Ariadne_TM_SR_ND{
       return false;
     }
     @Override public Object read(){
-      throw new UnsupportedOperationException("Ariadne_TM_SR_ND::NotMounted::read.");
+      throw new UnsupportedOperationException("Ariadne_TM_SR_NX::NotMounted::read.");
     }
     @Override public boolean can_step(){
       return false;
     }
     @Override public void step(){
-      throw new UnsupportedOperationException("Ariadne_TM_SR_ND::NotMounted::step.");
+      throw new UnsupportedOperationException("Ariadne_TM_SR_NX::NotMounted::step.");
     }
     @Override public Topology topology(){
-      throw new UnsupportedOperationException("Ariadne_TM_SR_ND::NotMounted::topology.");
+      throw new UnsupportedOperationException("Ariadne_TM_SR_NX::NotMounted::topology.");
     }
   }
 
diff --git a/developer/deprecated/temp.java b/developer/deprecated/temp.java
index c3f1529..4526452 100644
--- a/developer/deprecated/temp.java
+++ b/developer/deprecated/temp.java
@@ -1,6 +1,6 @@
 Aeloria
 /*
-  IndexTree_TM_SR_ND_Diagonal
+  IndexTree_TM_SR_NX_Diagonal
 
   An index tree is infinite.
 
@@ -14,15 +14,15 @@ Aeloria
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.List;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
 import com.ReasoningTechnology.Ariadne.IndexTree_Node;
 
-public class IndexTree_TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND_Label {
+public class IndexTree_TM_SR_NX_Diagonal extends Ariadne_TM_SR_NX_Label {
 
   // Static
 
-  public static IndexTree_TM_SR_ND_Diagonal make(){
-    return new IndexTree_TM_SR_ND_Diagonal();
+  public static IndexTree_TM_SR_NX_Diagonal make(){
+    return new IndexTree_TM_SR_NX_Diagonal();
   }
 
   // Instance Data
@@ -30,15 +30,15 @@ public class IndexTree_TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND_Label {
   private final List<Ariadne_Label> list_of__unopened_node;
   private final List<List<Ariadne_Label>> list_of__opened_incomplete_child_list;
   private final List<Ariadne_Label> read_list;
-  private final Ariadne_TM_SR_ND_Label breadth_srm;
+  private final Ariadne_TM_SR_NX_Label breadth_srm;
 
   // Constructor
 
-  protected IndexTree_TM_SR_ND_Diagonal(){
+  protected IndexTree_TM_SR_NX_Diagonal(){
     list_of__unopened_node = new ArrayList<>();
     list_of__opened_incomplete_child_list = new ArrayList<>();
     read_list = new ArrayList<>();
-    breadth_srm = Ariadne_TM_SR_ND_Label.make();
+    breadth_srm = Ariadne_TM_SR_NX_Label.make();
     enqueue_root();
   }Aeloria
 
@@ -76,7 +76,7 @@ public class IndexTree_TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND_Label {
       // Retrieve the node using lookup
       IndexTree_Node node = node( label );
 
-      // Mount a new breadth-first TM_SR_ND for children
+      // Mount a new breadth-first TM_SR_NX for children
       breadth_srm.mount( node.neighbor() );
 
       if( breadth_srm.can_read() ){
diff --git "a/developer/document\360\237\226\211/bugs.txt" "b/developer/document\360\237\226\211/bugs.txt"
index 7734610..b4971df 100644
--- "a/developer/document\360\237\226\211/bugs.txt"
+++ "b/developer/document\360\237\226\211/bugs.txt"
@@ -41,11 +41,11 @@
 
     However the compiler does not consider:
 
-      `Ariadne_TM_SR_ND<Label>`
+      `Ariadne_TM_SR_NX<Label>`
 
     To be a type of 
 
-      `Ariadne_TM_SR_ND<Ariadne_Label>`
+      `Ariadne_TM_SR_NX<Ariadne_Label>`
 
     This is awkward because `Graph::start` returns a TM of labels,
     where the labels are derived from `Ariadne_Label`
@@ -55,21 +55,21 @@
   Java is inconsistent in its interpretation of generic types. For example
   it considers these to be different types:
 
-    Ariadne_TM_SR_ND<T>
-    Ariadne_TM_SR_ND_Array<T> // extends Ariadne_TM_SR_ND<T>
+    Ariadne_TM_SR_NX<T>
+    Ariadne_TM_SR_NX_Array<T> // extends Ariadne_TM_SR_NX<T>
 
    Hence, the result from a factory for the child:
 
-    Ariadne_TM_SR_ND_Array<T> x make(){...}
+    Ariadne_TM_SR_NX_Array<T> x make(){...}
 
    Cannot be assigned to a variable declared of the parent type, 
-     Ariadne_TM_SR_ND<T>
+     Ariadne_TM_SR_NX<T>
 
    Yet it will not allow overloading of 
 
-     Ariadne_TM_SR_ND<T> make(..){
+     Ariadne_TM_SR_NX<T> make(..){
      }
-     Ariadne_TM_SR_ND_Array<T> make(..){
+     Ariadne_TM_SR_NX_Array<T> make(..){
      }
     
    If the programmer puts a caste on the factory output when assigning
@@ -82,4 +82,8 @@
      The crux of the issue is Java's type erasure combined with its strict generic type checks:
 
      Java enforces that overloaded methods can't differ only by their return type because, after type erasure, they would have identical signatures.
-     At the same time, assigning a subclass instance (Ariadne_TM_SR_ND_Array<T>) to a variable of the parent type (Ariadne_TM_SR_ND<T>) causes type ambiguity with generics.   
+     At the same time, assigning a subclass instance (Ariadne_TM_SR_NX_Array<T>) to a variable of the parent type (Ariadne_TM_SR_NX<T>) causes type ambiguity with generics.   
+
+2025-01-24T10:54:26Z[]
+    global substitute in this file _ND -> _NX
+
diff --git a/developer/example/CountingNumber/CountingNumber.java b/developer/example/CountingNumber/CountingNumber.java
index 9b017fe..df26d12 100644
--- a/developer/example/CountingNumber/CountingNumber.java
+++ b/developer/example/CountingNumber/CountingNumber.java
@@ -1,7 +1,7 @@
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
 import java.math.BigInteger;
 
-public class CountingNumber extends Ariadne_TM_SR_ND<BigInteger>{
+public class CountingNumber extends Ariadne_TM_SR_NX<BigInteger>{
 
   // Static
   //
diff --git a/developer/example/CountingNumber/CountingNumber_0_CLI.java b/developer/example/CountingNumber/CountingNumber_0_CLI.java
index 9611026..30eb96e 100644
--- a/developer/example/CountingNumber/CountingNumber_0_CLI.java
+++ b/developer/example/CountingNumber/CountingNumber_0_CLI.java
@@ -1,4 +1,4 @@
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
 import java.math.BigInteger;
 
 public class CountingNumber_0_CLI{
@@ -8,14 +8,14 @@ public class CountingNumber_0_CLI{
 
     if( !n.can_read() ) return;
 
-    if( n.topology() == Ariadne_TM_SR_ND.Topology.SEGMENT ){
+    if( n.topology() == Ariadne_TM_SR_NX.Topology.SEGMENT ){
       do{
         System.out.println("Current Number: " + n.read());
         if( !n.can_step() ) break;
         n.step();
       }while( true );
 
-    }else if( n.topology() == Ariadne_TM_SR_ND.Topology.INFINITE ){
+    }else if( n.topology() == Ariadne_TM_SR_NX.Topology.INFINITE ){
       int count = 0;
       do{
         System.out.println("Current Number: " + n.read());
diff --git a/developer/example/GraphCycleCFinder/TM_SR_ND_Depth.java b/developer/example/GraphCycleCFinder/TM_SR_ND_Depth.java
index 4c4549a..ca02b2b 100644
--- a/developer/example/GraphCycleCFinder/TM_SR_ND_Depth.java
+++ b/developer/example/GraphCycleCFinder/TM_SR_ND_Depth.java
@@ -14,25 +14,25 @@ import java.util.HashSet;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
 import com.ReasoningTechnology.Ariadne.Ariadne_Graph;
 import com.ReasoningTechnology.Ariadne.Ariadne_Node;
 import com.ReasoningTechnology.Ariadne.Ariadne_Label;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_Array;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_Array;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_List;
 
-class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
+class TM_SR_NX_Depth extends Ariadne_TM_SR_NX<Label>{
 
   // ----------------------------------------
   // static
   //
 
-  TM_SR_ND_Depth make(Ariadne_Graph graph){
+  TM_SR_NX_Depth make(Ariadne_Graph graph){
     if(graph == null) return null;
-    TM_SR_ND_Depth depth = new TM_SR_ND_Depth();
+    TM_SR_NX_Depth depth = new TM_SR_NX_Depth();
     depth.graph = graph;
     depth.context_path.add( graph.start() );
-    depth.context_path_tm = Ariadne_TM_SR_ND_Array.make(context_path);
+    depth.context_path_tm = Ariadne_TM_SR_NX_Array.make(context_path);
     initialize i = initialize.f(depth.context_path_tm ,depth.path_member_set);
     if( !i.success() ) return null;
     first_in_path_cycle_node_label = i.first_in_path_cycle_node_label;
@@ -44,8 +44,8 @@ class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
   //
 
   protected Graph graph = null;
-  protected List<Ariadne_TM_SR_ND<Label>> context_path = new ArrayList<>();
-  protected Ariadne_TM_SR_ND_Array<Ariadne_TM_SR_ND> context_path_tm = null;
+  protected List<Ariadne_TM_SR_NX<Label>> context_path = new ArrayList<>();
+  protected Ariadne_TM_SR_NX_Array<Ariadne_TM_SR_NX> context_path_tm = null;
   protected Label first_in_path_cycle_node_label = null;
 
   // Used for cycle detection.
@@ -55,7 +55,7 @@ class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
   // constructor
   //
 
-  protected TM_SR_ND_Depth(){
+  protected TM_SR_NX_Depth(){
     set_topology(topo_null);
   }
 
@@ -79,20 +79,20 @@ class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
     protected void g(context_path_tm ,path_member_set){
 
       if( context_path.isEmpty() ){
-        System.out.println("TM_SR_ND_Depth::initialize required context_path is empty.");
+        System.out.println("TM_SR_NX_Depth::initialize required context_path is empty.");
         success = false;
         return;
       }
 
       boolean is_cycle_node = false;
-      Ariadne_TM_SR_ND sibling_tm = null;
+      Ariadne_TM_SR_NX sibling_tm = null;
       Ariadne_Label path_node_label = null;
 
       do{
         sibling_tm = context_path_tm.read();
         path_node_label = sibling_tm.read();
         if(path_node_label == null){
-          System.out.println("TM_SR_ND_Depth::complete_context_path hit null path label on path");
+          System.out.println("TM_SR_NX_Depth::complete_context_path hit null path label on path");
           success = false;
           return;
         }
@@ -110,7 +110,7 @@ class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
       if( is_cycle_node && context_path_tm.can_step() ){
         System.out.println
           (
-           "TM_SR_ND_Depth::initialize_path_member_set: cycle found in initial context_path."
+           "TM_SR_NX_Depth::initialize_path_member_set: cycle found in initial context_path."
            );
         first_in_path_cycle_node_label = path_node_label;
         success = false;
@@ -136,7 +136,7 @@ class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
     boolean is_cycle_node = false;
     Ariadne_Node path_node = null;
     boolean is_leaf_node = false;
-    Ariadne_TM_SR_ND sibling_tm = null;
+    Ariadne_TM_SR_NX sibling_tm = null;
     Ariadne_Label path_node_label = null;
 
     sibling_tm = context_path_tm.read();
@@ -147,7 +147,7 @@ class TM_SR_ND_Depth extends Ariadne_TM_SR_ND<Label>{
       if(path_node == null){
         System.out.println
           (
-           "TM_SR_ND_Depth::complete_context_path internal algorithm error, node on path not found in graph for: label(\""
+           "TM_SR_NX_Depth::complete_context_path internal algorithm error, node on path not found in graph for: label(\""
            + path_node_label
            + "\")"
            );
diff --git a/developer/example/GraphIndexTree/Graph.java b/developer/example/GraphIndexTree/Graph.java
index 110a36f..d2f4cfb 100644
--- a/developer/example/GraphIndexTree/Graph.java
+++ b/developer/example/GraphIndexTree/Graph.java
@@ -11,9 +11,9 @@ public class Graph extends Ariadne_Graph<Label ,Node>{
   protected Graph(){
   }
 
-  @Override public TM_SR_ND_Child start(){
+  @Override public TM_SR_NX_Child start(){
     Label root_label = Label.root();
-    return TM_SR_ND_Child.make(root_label);
+    return TM_SR_NX_Child.make(root_label);
   }
 
   // no override, this graph does not lookup Ariadne_Label, only Label
diff --git a/developer/example/GraphIndexTree/Label.java b/developer/example/GraphIndexTree/Label.java
index 75b17ec..7a40dbe 100644
--- a/developer/example/GraphIndexTree/Label.java
+++ b/developer/example/GraphIndexTree/Label.java
@@ -5,7 +5,7 @@ import java.math.BigInteger;
 import java.util.Arrays;
 
 import com.ReasoningTechnology.Ariadne.Ariadne_Label;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_List;
 
 
 public class Label implements Ariadne_Label{
@@ -74,8 +74,8 @@ public class Label implements Ariadne_Label{
 
     StringBuilder formatted = new StringBuilder("Label([");
 
-    // Use precise loop with TM_SR_ND_List to iterate
-    Ariadne_TM_SR_ND_List<BigInteger> value_srtm = Ariadne_TM_SR_ND_List.make(Arrays.asList(value));
+    // Use precise loop with TM_SR_NX_List to iterate
+    Ariadne_TM_SR_NX_List<BigInteger> value_srtm = Ariadne_TM_SR_NX_List.make(Arrays.asList(value));
     if(value_srtm.can_read()){
       do{
         formatted.append(value_srtm.read().toString());
diff --git a/developer/example/GraphIndexTree/Node.java b/developer/example/GraphIndexTree/Node.java
index 192786f..cd7fd11 100644
--- a/developer/example/GraphIndexTree/Node.java
+++ b/developer/example/GraphIndexTree/Node.java
@@ -15,8 +15,8 @@ public class Node extends Ariadne_Node<Label>{
     first_child_label.inc_down();
   }
 
-  @Override public TM_SR_ND_Child neighbor(){
-    return TM_SR_ND_Child.make(first_child_label);
+  @Override public TM_SR_NX_Child neighbor(){
+    return TM_SR_NX_Child.make(first_child_label);
   }
 
 }
diff --git a/developer/example/GraphIndexTree/TM_SR_ND_Child.java b/developer/example/GraphIndexTree/TM_SR_ND_Child.java
index 027d6a4..0dc9af9 100644
--- a/developer/example/GraphIndexTree/TM_SR_ND_Child.java
+++ b/developer/example/GraphIndexTree/TM_SR_ND_Child.java
@@ -1,22 +1,22 @@
 /*
-TM_SR_ND_Child represents in the abstract the infinite child list of an
+TM_SR_NX_Child represents in the abstract the infinite child list of an
 IndexTree node.  Index tree node labels are paths through the tree, so
 labels can be computed.
 
-TM_SR_ND_Child is made from the leftmost child label. Then step() takes
+TM_SR_NX_Child is made from the leftmost child label. Then step() takes
 the current label and computes from it the right neighbor sibling
 node's label.
 
 */
 
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
 
-public class TM_SR_ND_Child extends Ariadne_TM_SR_ND<Label>{
+public class TM_SR_NX_Child extends Ariadne_TM_SR_NX<Label>{
 
   // Static
   //
-  public static TM_SR_ND_Child make(Label leftmost_child_label){
-    return new TM_SR_ND_Child(leftmost_child_label);
+  public static TM_SR_NX_Child make(Label leftmost_child_label){
+    return new TM_SR_NX_Child(leftmost_child_label);
   }
 
   // Instance data
@@ -25,7 +25,7 @@ public class TM_SR_ND_Child extends Ariadne_TM_SR_ND<Label>{
 
   // Constructor(s)
   //
-  protected TM_SR_ND_Child(Label leftmost_child_label){
+  protected TM_SR_NX_Child(Label leftmost_child_label){
     this.label = leftmost_child_label != null ? leftmost_child_label.copy() : null;
 
     if(label == null){
diff --git a/developer/example/GraphIndexTree/TM_SR_ND_Diagonal.java b/developer/example/GraphIndexTree/TM_SR_ND_Diagonal.java
index 4492f20..4754db2 100644
--- a/developer/example/GraphIndexTree/TM_SR_ND_Diagonal.java
+++ b/developer/example/GraphIndexTree/TM_SR_ND_Diagonal.java
@@ -20,28 +20,28 @@ import java.util.ArrayList;
 import java.util.List;
 
 import com.ReasoningTechnology.Ariadne.Ariadne_Test;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_List;
 
-public class TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND<List<Label>> {
+public class TM_SR_NX_Diagonal extends Ariadne_TM_SR_NX<List<Label>> {
 
   // Static
   //
 
-  public static TM_SR_ND_Diagonal make(Label start_node) {
-    return new TM_SR_ND_Diagonal(start_node);
+  public static TM_SR_NX_Diagonal make(Label start_node) {
+    return new TM_SR_NX_Diagonal(start_node);
   }
 
   // Instance data
   //
 
   private List<Label> diagonal = new ArrayList<>();
-  private final List<TM_SR_ND_Child> child_srtm_list = new ArrayList<>();
+  private final List<TM_SR_NX_Child> child_srtm_list = new ArrayList<>();
 
   // Constructor(s)
   //
 
-  protected TM_SR_ND_Diagonal(Label start_node) {
+  protected TM_SR_NX_Diagonal(Label start_node) {
     if (start_node == null) {
       set_topology(topo_null);
       return;
@@ -74,7 +74,7 @@ public class TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND<List<Label>> {
       List<Label> diagonal_1 = new ArrayList<>();
 
       // inc_down from each node on diagonal_0 -> entry on child_srtm list
-      Ariadne_TM_SR_ND_List<Label> diagonal_srtm = Ariadne_TM_SR_ND_List.make(diagonal);
+      Ariadne_TM_SR_NX_List<Label> diagonal_srtm = Ariadne_TM_SR_NX_List.make(diagonal);
       if( diagonal_srtm.can_read() ){
         do{
           Node node = Node.make(diagonal_srtm.read());
@@ -85,10 +85,10 @@ public class TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND<List<Label>> {
       }
 
       // add to diagonal_1 from each on entry on the child_srtm list
-      Ariadne_TM_SR_ND_List<TM_SR_ND_Child> child_srtm_srtm = Ariadne_TM_SR_ND_List.make(child_srtm_list);
+      Ariadne_TM_SR_NX_List<TM_SR_NX_Child> child_srtm_srtm = Ariadne_TM_SR_NX_List.make(child_srtm_list);
       if( child_srtm_srtm.can_read() ){
         do{
-          TM_SR_ND_Child child_srtm = child_srtm_srtm.read();
+          TM_SR_NX_Child child_srtm = child_srtm_srtm.read();
           Label label = child_srtm.read();
           diagonal_1.add(label.copy());
           child_srtm.step();
@@ -111,8 +111,8 @@ public class TM_SR_ND_Diagonal extends Ariadne_TM_SR_ND<List<Label>> {
   //
   
   @Override public String toString() {
-    StringBuilder formatted = new StringBuilder("TM_SR_ND_Diagonal(");
-    Ariadne_TM_SR_ND_List<Label> diagonal_srtm = Ariadne_TM_SR_ND_List.make(diagonal);
+    StringBuilder formatted = new StringBuilder("TM_SR_NX_Diagonal(");
+    Ariadne_TM_SR_NX_List<Label> diagonal_srtm = Ariadne_TM_SR_NX_List.make(diagonal);
 
     if (diagonal_srtm.can_read()) {
       do {
diff --git a/developer/example/GraphIndexTree/TM_SR_ND_Diagonal_CLI.java b/developer/example/GraphIndexTree/TM_SR_ND_Diagonal_CLI.java
index bdc9c39..a120ff3 100644
--- a/developer/example/GraphIndexTree/TM_SR_ND_Diagonal_CLI.java
+++ b/developer/example/GraphIndexTree/TM_SR_ND_Diagonal_CLI.java
@@ -1,13 +1,13 @@
 import java.util.List;
 
-public class TM_SR_ND_Diagonal_CLI{
+public class TM_SR_NX_Diagonal_CLI{
 
   public static void main(String[] args){
-    System.out.println("Starting IndexTree TM_SR_ND Example");
+    System.out.println("Starting IndexTree TM_SR_NX Example");
 
-    // Instantiate the IndexTree Diagonal TM_SR_ND
+    // Instantiate the IndexTree Diagonal TM_SR_NX
     Graph g = Graph.make();
-    TM_SR_ND_Child start_srtm = g.start();
+    TM_SR_NX_Child start_srtm = g.start();
     if( !start_srtm.can_read() ){
       System.out.println("Graph provides no start nodes. Thought you might want to know.");
       return;
@@ -16,7 +16,7 @@ public class TM_SR_ND_Diagonal_CLI{
     do{
       Label start_label = start_srtm.read();
       System.out.println("Graph diagonalization starting from: " + start_label);
-      TM_SR_ND_Diagonal srtm = TM_SR_ND_Diagonal.make(start_label);
+      TM_SR_NX_Diagonal srtm = TM_SR_NX_Diagonal.make(start_label);
       int step_count = 0;
       if( srtm.can_read() ){
         do{
diff --git a/developer/example/GraphIndexTree/four_down_four_across_CLI.java b/developer/example/GraphIndexTree/four_down_four_across_CLI.java
index 7fad79f..855a498 100644
--- a/developer/example/GraphIndexTree/four_down_four_across_CLI.java
+++ b/developer/example/GraphIndexTree/four_down_four_across_CLI.java
@@ -1,5 +1,5 @@
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_List;
 
 public class four_down_four_across_CLI{
 
@@ -9,10 +9,10 @@ public class four_down_four_across_CLI{
 
     // Initialize graph and start at root
     Graph graph = Graph.make();
-    TM_SR_ND_Child start = graph.start();
+    TM_SR_NX_Child start = graph.start();
     Label label = start.read();
     Node node;
-    TM_SR_ND_Child child_srm;
+    TM_SR_NX_Child child_srm;
 
     System.out.println("starting at: " + start.read());
 
diff --git a/developer/example/TM_SR_ND/TM_SR_ND_Array_CLI.java b/developer/example/TM_SR_ND/TM_SR_ND_Array_CLI.java
index bda904d..63a5d5b 100644
--- a/developer/example/TM_SR_ND/TM_SR_ND_Array_CLI.java
+++ b/developer/example/TM_SR_ND/TM_SR_ND_Array_CLI.java
@@ -1,16 +1,16 @@
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_Array;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_Array;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class TM_SR_ND_Array_CLI {
+public class TM_SR_NX_Array_CLI {
   public static void main( String[] args ){
     // Create an Array
     List<String> label_array = Arrays.asList( "A", "B", "C", "D" );
 
-    // Attach TM_SR_ND to the array
-    Ariadne_TM_SR_ND_Array<String> srm = Ariadne_TM_SR_ND_Array.make(label_array);
+    // Attach TM_SR_NX to the array
+    Ariadne_TM_SR_NX_Array<String> srm = Ariadne_TM_SR_NX_Array.make(label_array);
     if( srm.can_read() ){
       do{
         System.out.println( "Reading: " + srm.read() );  
diff --git a/developer/example/TM_SR_ND/TM_SR_ND_List_CLI.java b/developer/example/TM_SR_ND/TM_SR_ND_List_CLI.java
index 8852f37..1fcdcda 100644
--- a/developer/example/TM_SR_ND/TM_SR_ND_List_CLI.java
+++ b/developer/example/TM_SR_ND/TM_SR_ND_List_CLI.java
@@ -1,9 +1,9 @@
 import java.util.LinkedList;
 
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_List;
 
-public class TM_SR_ND_List_CLI {
+public class TM_SR_NX_List_CLI {
   public static void main( String[] args ){
     // Create a linked list
     LinkedList<String> label_list = new LinkedList<>();
@@ -11,8 +11,8 @@ public class TM_SR_ND_List_CLI {
     label_list.add( "B" );
     label_list.add( "C" );
 
-    // Attach TM_SR_ND to the linked list and traverse
-    Ariadne_TM_SR_ND_List<String> srm = Ariadne_TM_SR_ND_List.make(label_list);
+    // Attach TM_SR_NX to the linked list and traverse
+    Ariadne_TM_SR_NX_List<String> srm = Ariadne_TM_SR_NX_List.make(label_list);
     if( srm.can_read() ){
       do{
         System.out.println( "Reading: " + srm.read() );  
diff --git a/developer/example/TM_SR_ND/TM_SR_ND_Print_CLI.java b/developer/example/TM_SR_ND/TM_SR_ND_Print_CLI.java
index abe13e8..d9eda1e 100644
--- a/developer/example/TM_SR_ND/TM_SR_ND_Print_CLI.java
+++ b/developer/example/TM_SR_ND/TM_SR_ND_Print_CLI.java
@@ -1,19 +1,19 @@
 /*
-Example of the TM_SR_ND's toString function.
+Example of the TM_SR_NX's toString function.
 
 */
 
 import java.util.Arrays;
 import java.util.List;
 
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND;
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_List;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_List;
 
-public class TM_SR_ND_Print_CLI{
+public class TM_SR_NX_Print_CLI{
 
   public static void main(String[] args){
     List<Object> data = Arrays.asList(42 ,null ,"" ,"World" ,1000);
-    Ariadne_TM_SR_ND tm = Ariadne_TM_SR_ND_List.make(data);
+    Ariadne_TM_SR_NX tm = Ariadne_TM_SR_NX_List.make(data);
     System.out.println( tm.toString() );
     tm.step();
     System.out.println( tm.to_string_annotated() );
diff --git a/developer/example/TM_SR_ND/TM_SR_ND_Set_CLI.java b/developer/example/TM_SR_ND/TM_SR_ND_Set_CLI.java
index 7083403..6726210 100644
--- a/developer/example/TM_SR_ND/TM_SR_ND_Set_CLI.java
+++ b/developer/example/TM_SR_ND/TM_SR_ND_Set_CLI.java
@@ -1,9 +1,9 @@
-import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_ND_Set;
+import com.ReasoningTechnology.Ariadne.Ariadne_TM_SR_NX_Set;
 
 import java.util.HashSet;
 import java.util.Set;
 
-public class TM_SR_ND_Set_CLI {
+public class TM_SR_NX_Set_CLI {
   public static void main( String[] args ){
     // Create a Set
     Set<String> label_set = new HashSet<>();
@@ -11,8 +11,8 @@ public class TM_SR_ND_Set_CLI {
     label_set.add("B");
     label_set.add("C");
 
-    // Attach TM_SR_ND to the set and traverse
-    Ariadne_TM_SR_ND_Set<String> srm = Ariadne_TM_SR_ND_Set.make(label_set);
+    // Attach TM_SR_NX to the set and traverse
+    Ariadne_TM_SR_NX_Set<String> srm = Ariadne_TM_SR_NX_Set.make(label_set);
     if( srm.can_read() ){
       do{
         System.out.println( "Reading: " + srm.read() );
diff --git "a/developer/javac\360\237\226\211/#Ariadne_SiblingContext.java#" "b/developer/javac\360\237\226\211/#Ariadne_SiblingContext.java#"
deleted file mode 100644
index cfd9466..0000000
--- "a/developer/javac\360\237\226\211/#Ariadne_SiblingContext.java#"
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.ReasoningTechnology.Ariadne;
-
-import java.math.BigInteger;
-
-// LT == Label Type
-public abstract class 
-  Ariadne_SiblingContext<LT extends Ariadne_Label>
-  extends Ariadne_TM_SR_ND<LT>
-{
-
-  // Static
-  //
-
-  public static <T extends Ariadne_Label> Ariadne_SiblingContext<T> make(){
-    throw new UnsupportedOperationException("Ariadne_SiblingContext::make not implemented.");
-  }
-
-  // Instance Data
-  //
-
-  // Constructors
-  //
-
-  protected Ariadne_SiblingContext(){
-    super();
-  }
-
-  // Instance Interface
-  //
-
-
-  @Override public boolean can_rewind(){
-    return false;
-  }
-
-  @Override public void rewind(){
-    throw new UnsupportedOperationException("Ariadne_SiblingContext::rewind not implemented.");
-  }
-
-  @Override public void append_rightmost(LT x){
-    throw new UnsupportedOperationException("Ariadne_SiblingContext::append_rightmost not implemented.");
-  }
-
-  // Topology for sibling context
-  //
-
-  @Override public Topology topology(){
-    return current_topology.topology();
-  }
-}
diff --git "a/developer/javac\360\237\226\211/Ariadne_ContextPath_FD.java" "b/developer/javac\360\237\226\211/Ariadne_ContextPath_FD.java"
index bfc88b2..c0fac46 100644
--- "a/developer/javac\360\237\226\211/Ariadne_ContextPath_FD.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_ContextPath_FD.java"
@@ -5,7 +5,7 @@ import java.util.HashSet;
 import java.util.List;
 
 // LT == Label Type
-public class Ariadne_ContextPath_FD< Ariadne_TM_SR_ND<LT> >{
+public class Ariadne_ContextPath_FD< Ariadne_TM_SR_NX<LT> >{
 
   //----------------------------------------
   // static
@@ -15,7 +15,7 @@ public class Ariadne_ContextPath_FD< Ariadne_TM_SR_ND<LT> >{
   //----------------------------------------
   // Instance data
 
-  private final List< Ariadne_TM_SR_ND<LT> > context_path_list;
+  private final List< Ariadne_TM_SR_NX<LT> > context_path_list;
   private final HashSet<LT> path_member_set;
   private Ariand_Label cycle_node_label;;
 
@@ -42,7 +42,7 @@ public class Ariadne_ContextPath_FD< Ariadne_TM_SR_ND<LT> >{
    * @param tm The traversal state to add.
    * @return true if successfully added, false if it introduces a cycle.
    */
-  public boolean push(Ariadne_TM_SR_ND<LT> tm){
+  public boolean push(Ariadne_TM_SR_NX<LT> tm){
     if( tm == null || !tm.can_read() ){
       return false;
     }
@@ -63,12 +63,12 @@ public class Ariadne_ContextPath_FD< Ariadne_TM_SR_ND<LT> >{
    *
    * @return The removed traversal state, or null if the path is empty.
    */
-  public Ariadne_TM_SR_ND<LT> pop(){
+  public Ariadne_TM_SR_NX<LT> pop(){
     if( context_path_list.isEmpty() ){
       return null;
     }
 
-    Ariadne_TM_SR_ND<LT> last = context_path_list.remove( context_path_list.size() - 1 );
+    Ariadne_TM_SR_NX<LT> last = context_path_list.remove( context_path_list.size() - 1 );
     path_member_set.remove( last.read() );
     return last;
   }
@@ -110,7 +110,7 @@ public class Ariadne_ContextPath_FD< Ariadne_TM_SR_ND<LT> >{
   public String toString(){
     StringBuilder output = new StringBuilder("Ariadne_ContextPath(");
     @SuppressWarnings("unchecked")
-      Ariadne_TM_SR_ND<Ariadne_TM_SR_ND<LT>> tm = Ariadne_TM_SR_ND_Array.make(context_path_list);
+      Ariadne_TM_SR_NX<Ariadne_TM_SR_NX<LT>> tm = Ariadne_TM_SR_NX_Array.make(context_path_list);
     if( tm.can_read() ){
       do{
 
diff --git "a/developer/javac\360\237\226\211/Ariadne_Graph.java" "b/developer/javac\360\237\226\211/Ariadne_Graph.java"
index cc62a19..a4bcee7 100644
--- "a/developer/javac\360\237\226\211/Ariadne_Graph.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_Graph.java"
@@ -67,7 +67,7 @@ public class Ariadne_Graph<LT extends Ariadne_Label, NT extends Ariadne_Node<LT>
     throw new UnsupportedOperationException("Ariadne_Graph::is_wellformed.");
   }
 
-  public Ariadne_TM_SR_ND<LT> start() {
+  public Ariadne_TM_SR_NX<LT> start() {
     throw new UnsupportedOperationException("Ariadne_Graph::start.");
   }
 
diff --git "a/developer/javac\360\237\226\211/Ariadne_Graph_FD.java" "b/developer/javac\360\237\226\211/Ariadne_Graph_FD.java"
index ce5d8da..28783df 100644
--- "a/developer/javac\360\237\226\211/Ariadne_Graph_FD.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_Graph_FD.java"
@@ -51,7 +51,7 @@ public class Ariadne_Graph_FD<LT extends Ariadne_Label ,NT extends Ariadne_Node<
     // Nodes are distinct due to the use of the HashMap
 
     // Check that start nodes are in the graph
-    Ariadne_TM_SR_ND_Array<LT> tm = Ariadne_TM_SR_ND_Array.make(start_list);
+    Ariadne_TM_SR_NX_Array<LT> tm = Ariadne_TM_SR_NX_Array.make(start_list);
     if( tm.can_read() ){
       do{
         start_flag = this.node( tm.read() ) != null;
@@ -64,8 +64,8 @@ public class Ariadne_Graph_FD<LT extends Ariadne_Label ,NT extends Ariadne_Node<
     return distinct_flag && start_flag;
   }
 
-  @Override public Ariadne_TM_SR_ND<LT> start(){
-    return Ariadne_TM_SR_ND_Array.make(start_list);
+  @Override public Ariadne_TM_SR_NX<LT> start(){
+    return Ariadne_TM_SR_NX_Array.make(start_list);
   }
 
   // Lookup a node on the graph by label
@@ -74,8 +74,8 @@ public class Ariadne_Graph_FD<LT extends Ariadne_Label ,NT extends Ariadne_Node<
   }
 
   // A tm of all nodes
-  public Ariadne_TM_SR_ND<NT> node(){
-    return Ariadne_TM_SR_ND_Array.make( new ArrayList<>(node_db.values()) );
+  public Ariadne_TM_SR_NX<NT> node(){
+    return Ariadne_TM_SR_NX_Array.make( new ArrayList<>(node_db.values()) );
   }
 
   // Lookup an edge by two labels. For a directed graph, label0 is the origin node label.
@@ -84,8 +84,8 @@ public class Ariadne_Graph_FD<LT extends Ariadne_Label ,NT extends Ariadne_Node<
   }
 
   // A tm of all edges
-  public Ariadne_TM_SR_ND<Ariadne_Edge<LT>> edge(){
-    return Ariadne_TM_SR_ND_Array.make( new ArrayList<>(edge_db.values()) );
+  public Ariadne_TM_SR_NX<Ariadne_Edge<LT>> edge(){
+    return Ariadne_TM_SR_NX_Array.make( new ArrayList<>(edge_db.values()) );
   }
 
   // Object interface
@@ -96,7 +96,7 @@ public class Ariadne_Graph_FD<LT extends Ariadne_Label ,NT extends Ariadne_Node<
     output.append("Graph_FD( ");
 
     {
-      Ariadne_TM_SR_ND<NT> tm = this.node();
+      Ariadne_TM_SR_NX<NT> tm = this.node();
       if( !tm.can_read() ){
         output.append( "Node_list()" );
       }else{
@@ -107,7 +107,7 @@ public class Ariadne_Graph_FD<LT extends Ariadne_Label ,NT extends Ariadne_Node<
     }
 
     {
-      Ariadne_TM_SR_ND<Ariadne_Edge<LT>> tm = this.edge();
+      Ariadne_TM_SR_NX<Ariadne_Edge<LT>> tm = this.edge();
       if( !tm.can_read() ){
         output.append( "Edge_list()" );
       }else{
diff --git "a/developer/javac\360\237\226\211/Ariadne_Node.java" "b/developer/javac\360\237\226\211/Ariadne_Node.java"
index 229f0bb..7cd8bac 100644
--- "a/developer/javac\360\237\226\211/Ariadne_Node.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_Node.java"
@@ -42,7 +42,7 @@ public class Ariadne_Node<LT extends Ariadne_Label> extends HashMap<String ,Obje
     return this.label;
   }
 
-  public Ariadne_TM_SR_ND<LT> neighbor(){
+  public Ariadne_TM_SR_NX<LT> neighbor(){
     throw new UnsupportedOperationException("Ariadne_Node::neighbor not implemented in the base class.");
   }
 
@@ -78,7 +78,7 @@ public class Ariadne_Node<LT extends Ariadne_Label> extends HashMap<String ,Obje
 
     // Marks representation
     if( !mark_set.isEmpty() ){
-      Ariadne_TM_SR_ND_Set srm = Ariadne_TM_SR_ND_Set.make(mark_set);
+      Ariadne_TM_SR_NX_Set srm = Ariadne_TM_SR_NX_Set.make(mark_set);
       output.append( " Mark(" );
 
       do{
diff --git "a/developer/javac\360\237\226\211/Ariadne_Node_FD.java" "b/developer/javac\360\237\226\211/Ariadne_Node_FD.java"
index 484bcea..4decffc 100644
--- "a/developer/javac\360\237\226\211/Ariadne_Node_FD.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_Node_FD.java"
@@ -40,15 +40,15 @@ public class Ariadne_Node_FD<LT extends Ariadne_Label> extends Ariadne_Node<LT>{
   // Instance interface
   //
   
-  @Override public Ariadne_TM_SR_ND<LT> neighbor(){
-    return Ariadne_TM_SR_ND_Set.make(neighbor_set);
+  @Override public Ariadne_TM_SR_NX<LT> neighbor(){
+    return Ariadne_TM_SR_NX_Set.make(neighbor_set);
   }
 
   // Good citizen
   //
 
   @Override public String toString(){
-    Ariadne_TM_SR_ND_Set<LT> tm = Ariadne_TM_SR_ND_Set.make(neighbor_set);
+    Ariadne_TM_SR_NX_Set<LT> tm = Ariadne_TM_SR_NX_Set.make(neighbor_set);
     boolean has_label = label() != null;
     boolean has_neighbor = tm.can_read();
 
diff --git "a/developer/javac\360\237\226\211/Ariadne_SiblingContext.java" "b/developer/javac\360\237\226\211/Ariadne_SiblingContext.java"
index 6886827..122b5a5 100644
--- "a/developer/javac\360\237\226\211/Ariadne_SiblingContext.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_SiblingContext.java"
@@ -1,3 +1,7 @@
+/*
+Currently SiblingContext is an alias for Ariadne_TM_SR_NX<LT>.
+
+*/
 package com.ReasoningTechnology.Ariadne;
 
 import java.math.BigInteger;
@@ -5,62 +9,24 @@ import java.math.BigInteger;
 // LT == Label Type
 public abstract class 
   Ariadne_SiblingContext<LT extends Ariadne_Label>
-  extends Ariadne_TM_SR_ND<LT>
+  extends Ariadne_TM_SR_NX<LT>
 {
 
-  // Static
+  // static
   //
 
   public static <T extends Ariadne_Label> Ariadne_SiblingContext<T> make(){
     throw new UnsupportedOperationException("Ariadne_SiblingContext::make not implemented.");
   }
 
-  // Instance Data
+  // instance data
   //
 
-  // Constructors
+  // constructor(s)
   //
 
   protected Ariadne_SiblingContext(){
     super();
   }
 
-  // Instance Interface
-  //
-
-  @Override public boolean can_read(){
-    return current_topology.can_read();
-  }
-
-  @Override public LT read(){
-    return current_topology.read();
-  }
-
-  @Override public boolean can_step(){
-    return current_topology.can_step();
-  }
-
-  @Override public void step(){
-    increment();
-    current_topology.step();
-  }
-
-  @Override public boolean can_rewind(){
-    return false;
-  }
-
-  @Override public void rewind(){
-    throw new UnsupportedOperationException("Ariadne_SiblingContext::rewind not implemented.");
-  }
-
-  @Override public void append_rightmost(LT x){
-    throw new UnsupportedOperationException("Ariadne_SiblingContext::append_rightmost not implemented.");
-  }
-
-  // Topology for sibling context
-  //
-
-  @Override public Topology topology(){
-    return current_topology.topology();
-  }
 }
diff --git "a/developer/javac\360\237\226\211/Ariadne_SiblingContext_NX.java" "b/developer/javac\360\237\226\211/Ariadne_SiblingContext_NX.java"
new file mode 100644
index 0000000..c7c73b0
--- /dev/null
+++ "b/developer/javac\360\237\226\211/Ariadne_SiblingContext_NX.java"
@@ -0,0 +1,32 @@
+/*
+Currently SiblingContext is an alias for Ariadne_TM_SR_NX<LT>.
+
+*/
+package com.ReasoningTechnology.Ariadne;
+
+import java.math.BigInteger;
+
+// LT == Label Type
+public abstract class 
+  Ariadne_SiblingContext<LT extends Ariadne_Label>
+  extends Ariadne_TM_SR_NX_Array<LT>
+{
+
+  // static
+  //
+
+  public static <T extends Ariadne_Label> Ariadne_SiblingContext<T> make(){
+    throw new UnsupportedOperationException("Ariadne_SiblingContext::make not implemented.");
+  }
+
+  // instance data
+  //
+
+  // constructor(s)
+  //
+
+  protected Ariadne_SiblingContext(){
+    super();
+  }
+
+}
diff --git "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND.java" "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX.java"
similarity index 87%
rename from "developer/javac\360\237\226\211/Ariadne_TM_SR_ND.java"
rename to "developer/javac\360\237\226\211/Ariadne_TM_SR_NX.java"
index 5bd2f02..6d61bfa 100644
--- "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX.java"
@@ -1,8 +1,8 @@
 /*
-A step right only, non-destructive tape operations, tape machine, TM_SR_ND. This
+A step right only, non-destructive tape operations, tape machine, TM_SR_NX. This
 machine has explicit tracking of the head address.
 
-BigInteger is used so that it will be possible to bind TM_SR_ND machine extensions
+BigInteger is used so that it will be possible to bind TM_SR_NX machine extensions
 to file system objects.
 
 */
@@ -11,7 +11,7 @@ package com.ReasoningTechnology.Ariadne;
 import java.math.BigInteger;
 
 // RT == read type
-public class Ariadne_TM_SR_ND<RT>{
+public class Ariadne_TM_SR_NX<RT>{
 
   // static
   //
@@ -26,8 +26,8 @@ public class Ariadne_TM_SR_ND<RT>{
     ,INFINITE
   }
 
-  public static Ariadne_TM_SR_ND make(){
-    return new Ariadne_TM_SR_ND();
+  public static Ariadne_TM_SR_NX make(){
+    return new Ariadne_TM_SR_NX();
   }
 
   // instance data
@@ -41,9 +41,9 @@ public class Ariadne_TM_SR_ND<RT>{
   // constructor(s)
   //
 
-  public Ariadne_TM_SR_ND(){
+  public Ariadne_TM_SR_NX(){
     id = id_well++;
-    test = Ariadne_Test.make("Ariadne_TM_SR_ND::" + id + "::");
+    test = Ariadne_Test.make("Ariadne_TM_SR_NX::" + id + "::");
     test.switch_test(false);
     set_topology( not_mounted );
     this.index = BigInteger.ZERO;
@@ -64,7 +64,7 @@ public class Ariadne_TM_SR_ND<RT>{
     index = index.add(BigInteger.ONE);
   }
 
-  public boolean head_on_same_cell(Ariadne_TM_SR_ND<RT> tm){
+  public boolean head_on_same_cell(Ariadne_TM_SR_NX<RT> tm){
     boolean p = this.index.equals(tm.index);
     if( test.is_on() ){
       test.print("head_on_same_cell this id/index: " + this.id() + "/" + this.index );
@@ -74,14 +74,14 @@ public class Ariadne_TM_SR_ND<RT>{
     return p;
   }
 
-  protected void entangle(Ariadne_TM_SR_ND<RT> copy){
+  protected void entangle(Ariadne_TM_SR_NX<RT> copy){
     copy.current_topology = this.current_topology;
     // Nuance here, BigInteger is immutable, so operation on the original
     // index, and the copy index, will be independent, which is what we want.
     copy.index = this.index; 
   }
-  public Ariadne_TM_SR_ND<RT> entangle(){
-    throw new UnsupportedOperationException("Ariadne_TM_SR_ND::entangle not implemented.");
+  public Ariadne_TM_SR_NX<RT> entangle(){
+    throw new UnsupportedOperationException("Ariadne_TM_SR_NX::entangle not implemented.");
   }
 
   public boolean is_mounted(){
@@ -108,7 +108,7 @@ public class Ariadne_TM_SR_ND<RT>{
   // any of the entangled machine writes the tape. Hence, append has a similar
   // affect as other writes.
   public void append_rightmost(RT x){
-    throw new UnsupportedOperationException("Ariadne_TM_SR_ND::entangle not implemented.");
+    throw new UnsupportedOperationException("Ariadne_TM_SR_NX::entangle not implemented.");
   }
 
   // stateful interface
@@ -171,16 +171,16 @@ public class Ariadne_TM_SR_ND<RT>{
       return false;
     }
     @Override public RT read(){
-      throw new UnsupportedOperationException("Ariadne_TM_SR_ND::NotMounted::read.");
+      throw new UnsupportedOperationException("Ariadne_TM_SR_NX::NotMounted::read.");
     }
     @Override public boolean can_step(){
       return false;
     }
     @Override public void step(){
-      throw new UnsupportedOperationException("Ariadne_TM_SR_ND::NotMounted::step.");
+      throw new UnsupportedOperationException("Ariadne_TM_SR_NX::NotMounted::step.");
     }
     @Override public Topology topology(){
-      throw new UnsupportedOperationException("Ariadne_TM_SR_ND::NotMounted::topology.");
+      throw new UnsupportedOperationException("Ariadne_TM_SR_NX::NotMounted::topology.");
     }
   }
   protected final TopoIface<RT> not_mounted = new NotMountedTopo();
@@ -216,18 +216,18 @@ public class Ariadne_TM_SR_ND<RT>{
 
     test.print("::to_string_annotated");
 
-    if(!is_mounted()) return "TM_SR_ND(NotMounted)";
-    if(!can_read()) return "TM_SR_ND(Null)";
+    if(!is_mounted()) return "TM_SR_NX(NotMounted)";
+    if(!can_read()) return "TM_SR_NX(Null)";
 
     // output takes two lines, starting from the left column on each
     StringBuilder data_channel = new StringBuilder("\n");
     StringBuilder control_channel = new StringBuilder("");
     
-    data_channel.append( "TM_SR_ND(" ).append( topology().name()).append("(" );
+    data_channel.append( "TM_SR_NX(" ).append( topology().name()).append("(" );
     control_channel.append( " ".repeat(data_channel.length()-1) );
 
     String element = null;
-    Ariadne_TM_SR_ND<RT> copy = this.entangle();
+    Ariadne_TM_SR_NX<RT> copy = this.entangle();
     if( copy.can_rewind() ) copy.rewind();
 
     Object o = null;
@@ -283,7 +283,7 @@ public class Ariadne_TM_SR_ND<RT>{
   // RT code format style comma separated list
   @Override public String toString(){
 
-    Ariadne_TM_SR_ND<RT> tm = this.entangle();
+    Ariadne_TM_SR_NX<RT> tm = this.entangle();
     if( tm.can_rewind() ) tm.rewind();
 
     if( !tm.can_read() ) return "";
diff --git "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Array.java" "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Array.java"
similarity index 86%
rename from "developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Array.java"
rename to "developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Array.java"
index 7105eef..465e581 100644
--- "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Array.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Array.java"
@@ -4,13 +4,13 @@ import java.math.BigInteger;
 import java.util.List;
 
 // RT == read type
-public class Ariadne_TM_SR_ND_Array<RT> extends Ariadne_TM_SR_ND<RT>{
+public class Ariadne_TM_SR_NX_Array<RT> extends Ariadne_TM_SR_NX<RT>{
 
   // Static methods
   //
   
-  public static <T> Ariadne_TM_SR_ND_Array<T> make(List<T> array){
-    return new Ariadne_TM_SR_ND_Array<>(array);
+  public static <T> Ariadne_TM_SR_NX_Array<T> make(List<T> array){
+    return new Ariadne_TM_SR_NX_Array<>(array);
   }
 
   // Instance data
@@ -21,7 +21,7 @@ public class Ariadne_TM_SR_ND_Array<RT> extends Ariadne_TM_SR_ND<RT>{
   // Constructor(s)
   //
   
-  protected Ariadne_TM_SR_ND_Array(List<RT> array){
+  protected Ariadne_TM_SR_NX_Array(List<RT> array){
     super();
     this.array = array;
 
@@ -43,11 +43,11 @@ public class Ariadne_TM_SR_ND_Array<RT> extends Ariadne_TM_SR_ND<RT>{
 
   // Children of this can call super.entangle(copy) to perform the parent part of the entanglement.
   // This calls super to perform its parent portion of the entanglement.
-  protected void entangle(Ariadne_TM_SR_ND_Array<RT> copy){
+  protected void entangle(Ariadne_TM_SR_NX_Array<RT> copy){
     super.entangle(copy);
   }
-  @Override public Ariadne_TM_SR_ND_Array<RT> entangle(){
-    Ariadne_TM_SR_ND_Array<RT> copy = Ariadne_TM_SR_ND_Array.make(this.array);
+  @Override public Ariadne_TM_SR_NX_Array<RT> entangle(){
+    Ariadne_TM_SR_NX_Array<RT> copy = Ariadne_TM_SR_NX_Array.make(this.array);
     entangle(copy);
 
     switch (this.current_topology.topology()) {
diff --git "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND_List.java" "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX_List.java"
similarity index 85%
rename from "developer/javac\360\237\226\211/Ariadne_TM_SR_ND_List.java"
rename to "developer/javac\360\237\226\211/Ariadne_TM_SR_NX_List.java"
index be6de33..44f1e07 100644
--- "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND_List.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX_List.java"
@@ -1,7 +1,7 @@
 /*
-  By convention an TM_SR_ND is named after the type of values found in the tape cells.
-  However, in this case the name reflects the type that that TM_SR_ND is made from.
-  The type of values found in the TM_SR_ND cells is abstracted as "T".
+  By convention an TM_SR_NX is named after the type of values found in the tape cells.
+  However, in this case the name reflects the type that that TM_SR_NX is made from.
+  The type of values found in the TM_SR_NX cells is abstracted as "T".
 
   This implementation uses Java's ListIterator, which lacks a direct
   method to read the current cell value, rather it yields the next
@@ -11,13 +11,13 @@ package com.ReasoningTechnology.Ariadne;
 import java.util.List;
 import java.util.ListIterator;
 
-public class Ariadne_TM_SR_ND_List<RT> extends Ariadne_TM_SR_ND<RT>{
+public class Ariadne_TM_SR_NX_List<RT> extends Ariadne_TM_SR_NX<RT>{
 
   // Static methods
   //
 
-  public static <T> Ariadne_TM_SR_ND_List<T> make(List<T> list) {
-    return new Ariadne_TM_SR_ND_List<>(list);
+  public static <T> Ariadne_TM_SR_NX_List<T> make(List<T> list) {
+    return new Ariadne_TM_SR_NX_List<>(list);
   }
 
   // instance data
@@ -30,7 +30,7 @@ public class Ariadne_TM_SR_ND_List<RT> extends Ariadne_TM_SR_ND<RT>{
   // constructor(s)
   //
 
-  protected Ariadne_TM_SR_ND_List(List<RT> list){
+  protected Ariadne_TM_SR_NX_List(List<RT> list){
     this.list = list;
 
     if( list == null || list.isEmpty() ){
@@ -55,14 +55,14 @@ public class Ariadne_TM_SR_ND_List<RT> extends Ariadne_TM_SR_ND<RT>{
 
   // Children of this can call entangle(copy) to perform the parent part of the entanglement.
   // This calls super to perform its parent portion of the entanglement.
-  protected void entangle(Ariadne_TM_SR_ND_List<RT> copy){
+  protected void entangle(Ariadne_TM_SR_NX_List<RT> copy){
     super.entangle(copy);
     copy.read_value = this.read_value;
     copy.iterator = this.list.listIterator(this.iterator.nextIndex());
   }
 
-  @Override public Ariadne_TM_SR_ND_List<RT> entangle(){
-    Ariadne_TM_SR_ND_List<RT> copy = Ariadne_TM_SR_ND_List.make(this.list);
+  @Override public Ariadne_TM_SR_NX_List<RT> entangle(){
+    Ariadne_TM_SR_NX_List<RT> copy = Ariadne_TM_SR_NX_List.make(this.list);
     entangle(copy);
 
     // Set the appropriate topology in the copy based on the current topology
diff --git "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Set.java" "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Set.java"
similarity index 86%
rename from "developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Set.java"
rename to "developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Set.java"
index b585710..ecd08a4 100644
--- "a/developer/javac\360\237\226\211/Ariadne_TM_SR_ND_Set.java"
+++ "b/developer/javac\360\237\226\211/Ariadne_TM_SR_NX_Set.java"
@@ -3,11 +3,11 @@ package com.ReasoningTechnology.Ariadne;
 import java.util.Set;
 import java.util.Iterator;
 
-public class Ariadne_TM_SR_ND_Set<RT> extends Ariadne_TM_SR_ND<RT>{
+public class Ariadne_TM_SR_NX_Set<RT> extends Ariadne_TM_SR_NX<RT>{
 
   // Static methods
-  public static <RT> Ariadne_TM_SR_ND_Set<RT> make(Set<RT> set){
-    return new Ariadne_TM_SR_ND_Set<>(set);
+  public static <RT> Ariadne_TM_SR_NX_Set<RT> make(Set<RT> set){
+    return new Ariadne_TM_SR_NX_Set<>(set);
   }
 
   // Instance data
@@ -19,7 +19,7 @@ public class Ariadne_TM_SR_ND_Set<RT> extends Ariadne_TM_SR_ND<RT>{
   protected final TopoIface<RT> topo_rightmost = new RightmostTopo();
 
   // Constructor
-  protected Ariadne_TM_SR_ND_Set(Set<RT> set){
+  protected Ariadne_TM_SR_NX_Set(Set<RT> set){
     this.set = set;
     if (set == null || set.isEmpty()){
       this.iterator = null;
@@ -43,14 +43,14 @@ public class Ariadne_TM_SR_ND_Set<RT> extends Ariadne_TM_SR_ND<RT>{
     set_topology(set.size() == 1 ? topo_rightmost : topo_segment);
   }
 
-  protected void entangle(Ariadne_TM_SR_ND_Set<RT> copy){
+  protected void entangle(Ariadne_TM_SR_NX_Set<RT> copy){
     super.entangle(copy);
     copy.iterator = this.set.iterator();
     copy.read_value = this.read_value;
   }
 
-  @Override public Ariadne_TM_SR_ND_Set<RT> entangle(){
-    Ariadne_TM_SR_ND_Set<RT> copy = Ariadne_TM_SR_ND_Set.make(this.set);
+  @Override public Ariadne_TM_SR_NX_Set<RT> entangle(){
+    Ariadne_TM_SR_NX_Set<RT> copy = Ariadne_TM_SR_NX_Set.make(this.set);
     entangle(copy);
     switch (this.current_topology.topology()){
       case NULL:
-- 
2.20.1