# User:Devon McCormick/Trees

Here's an exposition of one method for representing trees in J.

## Parent Index Vector

The tree is a vector of integers where each element is the index of the parent node but with _1 for the root's parent. This is handy for modeling directory trees and it works well for that.

Say we have a directory tree like this:

```C:
|__n0
|   |_n00
|   |_n01
|
|__n1
|__n10
|   |__n100
|__n11
|   |__n110
|   |__n111
|   |__n112
|__n12
```

We typically separate the tree structure from the corresponding vector of nodes which, in this case, are the directory or file names.

For example, we can translate the above tree as follows using breadth-first ordering:

```   nmsb=. 'C:';'n0';'n1';'n00';'n01';'n10';'n11';'n12';'n100';'n110';'n111';'n112'
trb=. _1    0    0    1     1     2      2     2     5      6      6      6
```

We can also translate it using depth-first ordering:

```   nmsd=. 'C:';'n0';'n00';'n01';'n1';'n10';'n100';'n11';'n110';'n111';'n112';'n12'
trd=.  _1   0    1     1     0    4     5      4     7      7      7      4
```

Whichever we choose is not functionally significant: all the following code works the same on either version. This representation of trees is good for looking up an item and locating its parent, or joining sub-trees into a larger tree. By "good", we mean simple to code and fast-running.

Here are some basic verbs with examples of using them.

```   whChild=: [: I. [ e. ]     NB.* whChild: where are children of x in tree y
whRoot=: [:I. _1=]         NB.* whRoot: where roots are in tree y
nextLevel=: [ whChild ]    NB.* nextLevel: indexes of descendants of x in tree y
whParent=: _1-.~]{[        NB.* whParent: index of parent; _1 means no parent.
whLeaves=: [: I. [: -. ] e.~ [: i.#     NB.* whLeaves: indexes into tree of leaf nodes.

trb whChild whRoot trb     NB. Indexes of children of root
1 2
trd whChild whRoot trd     NB. Indexes of children of root on depth-first version
1 4
```

Though the numbers differ, they refer to the same items in each case:

```   nmsb{~trb whChild whRoot trb NB. Children of root using breadth-first
+--+--+
|n0|n1|
+--+--+
nmsd{~trd whChild whRoot trd NB. Depth-first
+--+--+
|n0|n1|
+--+--+
```

Here we see how to generalize moving to levels further down the tree using the power conjunction " ^: ".

```   trb nextLevel whRoot trb                NB. Next level down from root
1 2
trb nextLevel trb nextLevel whRoot trb  NB. two levels down
3 4 5 6 7
trb nextLevel^:2 ] whRoot trb           NB. two levels down
3 4 5 6 7
```

#### Grafting

Now let's graft a new tree onto an existing one:

```   newnms=. 'new0';'new01';'new02';'new010';'new011';'new020';'new021'
newtree=. _1     0       0       1        1        2        2
#&>newtree;<newnms    NB. Sanity check
7 7

graftRoot=: 3 : 0
'ot jn nt'=. y        NB. old tree;join-node;new tree
ot,(_1=nt)}(nt+#ot),:jn
)

graftRoot trb;(nmsb i. <'n0');newtree     NB. Graft new branches to "n0" node
_1 0 0 1 1 2 2 2 5 6 6 6 1 12 12 13 13 14 14
#newtr2=. graftRoot trb;(nmsb i. <'n0');newtree
19
#newnms2=. nmsb,newnms
19
trb nextLevel^:1 ] whRoot trb
1 2
newnms2{~newtr2 nextLevel^:1 ] whRoot newtr2
+--+--+
|n0|n1|
+--+--+
newnms2{~newtr2 nextLevel^:2 ] whRoot newtr2
+---+---+---+---+---+----+
|n00|n01|n10|n11|n12|new0|
+---+---+---+---+---+----+
newnms2{~newtr2 nextLevel^:3 ] whRoot newtr2
+----+----+----+----+-----+-----+
|n100|n110|n111|n112|new01|new02|
+----+----+----+----+-----+-----+
newnms2{~newtr2 nextLevel^:4 ] whRoot newtr2
+------+------+------+------+
|new010|new011|new020|new021|
+------+------+------+------+
newnms2{~newtr2 nextLevel^:5 ] whRoot newtr2  NB. No fifth level
```

We can also display a high-level image of the grafted result.

### Validity Checking

This representation of trees allows multiple root nodes - which is called a "forest" - and can represent closed loops, which are invalid as trees. Since invalid representations are possible, it may behoove us to check if a given tree is valid. We can do this in the following way.

```NB.* verifyTree: check that tree has >:1 root, no cycles, no unreachable nodes:
NB. 0 for bad node, 1 for good one.
verifyTree=: 3 : 0
cc=. 0\$~#y                 NB. Cycle counter
nli=. whRoot y             NB. Next level indexes: start at root(s)
cc=. (1+nli{cc) nli}cc     NB. Count # visits to node
while. (0<#nli) *. 1=>./cc do.
nli=. y nextLevel nli
cc=. (1+nli{cc) nli}cc NB. Count # visits to node
end.
cc *. -.(_1=y) *. 1<+/_1= y    NB. Dis-allow forests
NB.EG (1 0;0 0;1 0 0) -: verifyTree &.> _1 1; 0 1; _1 2 1  NB. bad ones
NB.EG (1 1 1;1 1 1 1) -: verifyTree &.> _1 0 1; _1 0 _1 2  NB. good ones
NB.EG (0 0;0 1 0 1) -: verifyTree &.> _1 _1; _1 0 _1 2     NB. bad ones, multi-root
)
```

The "EG" comments at the end give examples of use and the results expected: each phrase should return a single "1" indicating the results match the outputs. The three initial bad trees fail verification (indicated by zeros corresponding to bad nodes) because the first one is cyclical because it has a node that is its own parent, the second one is cyclical and has no root, and the third has a cycle between 1 and 2.

Notice that we choose to treat multi-rooted trees as invalid only with the final condition. This is an arbitrary choice. Similarly, our exclusion of cycles is arbitrary as well. We could just as well allow forests or cycles if we wanted to generalize beyond trees to graphs of some kind. However, this "parent index" scheme would allow for only a limited subset of graphs, so is not a good choice to represent more general graphs.

### Grafting, Pruning, and Displaying

We use the "tree" routine to display trees to illustrate the changes we can make by pruning and grafting nodes from one part of a tree to another.

To convert initial tree to the following, first split off the "n0" branch:

```   'trb0 nms0 trb1 nms1'=. ;0 1 pruneB &.><(nmsb i. <'n0');trb;<nmsb
trb0                       NB. Tree without pruned branch
_1 0 1 1 1 2 3 3 3
nms0
+--+--+---+---+---+----+----+----+----+
|C:|n1|n10|n11|n12|n100|n110|n111|n112|
+--+--+---+---+---+----+----+----+----+
trb1                       NB. Pruned branch
_1 0 0
nms1
+--+---+---+
|n0|n00|n01|
+--+---+---+
nms=. nms0,nms1                                NB. All names for new combined tree
tr=. graftRoot trb0;(nms0 i. <'n100');trb1     NB. Tree with pruned branch grafted to "n100" node.
```

Pruned branch re-attached in different place:

```   tree }.nms,.~tr{nms
+-------------------------------------------+
|                                     ┌─ n00|  NB. We see the "n0" node moved from
|             ┌─ n10 ─── n100 ─── n0 ─┴─ n01|  NB. the root to node "n100".
|             │       ┌─ n110               |
|─ C: ─── n1 ─┼─ n11 ─┼─ n111               |
|             │       └─ n112               |
|             └─ n12                        |
+-------------------------------------------+
```

Original tree from above:

```   tree }.nmsb,.~trb{nmsb
+----------------------------+
|             ┌─ n00         |
|      ┌─ n0 ─┴─ n01         |
|      │      ┌─ n10 ─── n100|
|─ C: ─┤      │       ┌─ n110|
|      └─ n1 ─┼─ n11 ─┼─ n111|
|             │       └─ n112|
|             └─ n12         |
+----------------------------+
```

## Using "Tree Display"

There's an existing utility to display a tree in a printable format. To use this utility, we must convert our "parent index" form to one in which edges are listed as point pairs. One way to do this is shown as follows.

```   trb=. _1 0 0 1 1 2 2 2 5 6 6 6
|:]t1b=. }.(i.#trb),.~trb      NB. Assume root is at start (hence }.)
0 0 1 1 2 2 2 5 6  6  6
1 2 3 4 5 6 7 8 9 10 11

tree t1b
+----------------------+
|           +- 3       |
|     +- 1 -+- 4       |
|     |     +- 5 --- 8 |
|- 0 -+     |     +- 9 |
|     +- 2 -+- 6 -+- 10|
|           |     +- 11|
|           +- 7       |
+----------------------+

9!:6
+++++++++|-           NB. Simple ASCII characters for box-drawing
11{.16}.a.
┌┬┐├┼┤└┴┘│─
EW=. {:BOXC=. 11{.16}.a.        NB. Box-drawing characters: globals used by "tree"

trd=. _1 0 1 1 0 4 5 4 7 7 7 4  NB. Depth-first version of tree
|:]t1d=. }.(i.#trd),.~trd
0 1 1 0 4 5 4 7 7  7  4
1 2 3 4 5 6 7 8 9 10 11

tree t1d
┌──────────────────────┐
│           ┌─ 2       │
│     ┌─ 1 ─┴─ 3       │
│     │     ┌─ 5 ─── 6 │
│─ 0 ─┤     │     ┌─ 8 │
│     └─ 4 ─┼─ 7 ─┼─ 9 │
│           │     └─ 10│
│           └─ 11      │
└──────────────────────┘
```

That this latter representation, based on the depth-first ordered tree, is the same as the former one can be see if we insert the node names to illuminate the correspondence between the indexes of the two tree representations.

```   nmsd=. 'C:';'n0';'n00';'n01';'n1';'n10';'n100';'n11';'n110';'n111';'n112';'n12'
nmsb=. 'C:';'n0';'n1';'n00';'n01';'n10';'n11';'n12';'n100';'n110';'n111';'n112'

tree (}.trd{nmsd),.}.nmsd   NB. depth-first
┌────────────────────────────┐
│             ┌─ n00         │
│      ┌─ n0 ─┴─ n01         │
│      │      ┌─ n10 ─── n100│
│─ C: ─┤      │       ┌─ n110│
│      └─ n1 ─┼─ n11 ─┼─ n111│
│             │       └─ n112│
│             └─ n12         │
└────────────────────────────┘
tree (}.trb{nmsb),.}.nmsb    NB. Do the same with the breadth-first version.
┌────────────────────────────┐
│             ┌─ n00         │
│      ┌─ n0 ─┴─ n01         │
│      │      ┌─ n10 ─── n100│
│─ C: ─┤      │       ┌─ n110│
│      └─ n1 ─┼─ n11 ─┼─ n111│
│             │       └─ n112│
│             └─ n12         │
└────────────────────────────┘

```

We can do this to see our grafted tree example from above.

```   tree (}.newtr2{newnms2),.}.newnms2
┌─────────────────────────────────────────┐
│             ┌─ n00                      │
│             ├─ n01                      │
│      ┌─ n0 ─┤                  ┌─ new010│
│      │      │        ┌─ new01 ─┴─ new011│
│      │      └─ new0 ─┤         ┌─ new020│
│─ C: ─┤               └─ new02 ─┴─ new021│
│      │      ┌─ n10 ──── n100            │
│      │      │        ┌─ n110            │
│      └─ n1 ─┼─ n11 ──┼─ n111            │
│             │        └─ n112            │
│             └─ n12                      │
└─────────────────────────────────────────┘
```

## Code

The code so far is here. This file also includes a copy of the display tree code mentioned above for "one-stop-shopping".