"rerootable" purely functional tree data structure - clojure

Question

I recently purchased Inferring Phylogenies by Joseph Felsenstein, which is a great book about mathematical and computational methods for inferring phylogenetic trees, and have been playing around with implementing some of the algorithms it describes.
Specifically I'm interested in doing so using in a functional setting with persistent data structures, as a lot of the methods involve walking through a space of possible trees and it would be nice to cheaply remember the history of where we've been via structural sharing (a lá what aphyr does with "worlds" in this blog post), easily cache previously computed values for subtrees, etc.
The problem with this is that a lot of the methods involve "rerooting" trees, which I cannot figure out how to do cheaply in a purely functional way. Basically I need some way of capturing the idea that each of the following (using clojure notation, representing trees as vectors):
[:a [:b [:c :d]]]
[:b [:a [:c :d]]]
[:a [:b [:d :c]]]
[:b [:a [:d :c]]]
[[:a :b] [:c :d]]
[[:c :d] [:a :b]]
[:c [:d [:a :b]]]
[:d [:c [:a :b]]]
[:c [:d [:b :a]]]
[:d [:c [:b :a]]]
represent the same data and only differ in where the root is placed; they each represent the unrooted tree:
a b
\ /
|
/ \
c d
I'd like to be able to navigate into one of these trees with a zipper and then call a function reroot, which will return a new tree that's zipped up in such a way that the root is at the current loc.
In the book Felsenstein describes a data structure for a cheaply rerootable tree, which looks something like the following hastily made diagram
in which the circles are structs and the arrows are pointers. The rings of structs are internal nodes on the tree, and once we have a reference to one, we can move the root there by doing some pointer swapping. Unfortunately this is a mutating operation and requires mutual references, both of which are impossible in a purely functional setting.
I feel like there should be a way to do what I want using zippers, but I've been playing around with clojure.core/zip for a while and getting nowhere.
Does anyone know of an implementation of something like this or have suggestions for things I should read / papers I should look at / ideas for how to do this?
Thanks!

Answer 1

The jvm doesn't actually give us access to pointers as such that we can directly manipulate. But we do have a few options for representing a doubly linked structure.
This looks a lot like a graph, and for sparse graphs like this, a classic representation is the adjacency list. An advantage of adjacency lists is that they dereference by name rather than relying on pointer / object identity, and as such we can express arbitrary circular or self referential paths in the structure without any need for mutation.
naming your nodes alphabetically left to right / top to bottom:
{:a [:c]
:b [:d]
:c [:a :d :e]
:d [:b :c :e]
:e [:c :d :g]
:f [:h]
:g [:e :h :i]
:h [:f :g :i]
:i [:g :h]}
elements in the network are looked up by name, and arrows coming out from that element are represented by a vector as the associated value. Traversal can be implemented as a recursive function looking up the node to step to at each iteration. The "root" is just the element used to start your traversal (:i in your graph).
Various kinds of insertion / splitting rearrangement can be done with conj, update-in, assoc, etc. since the hash-map literal is a regular clojure persistent data structure.

Answer 2

An unrooted tree is a graph with the following characteristics:
It is symmetric/undirected - it is its own inverse.
It is strongly connected - you can get everywhere from anywhere.
The only way to get back to where you came from is to retrace your
steps.
The standard way to represent a graph is as a map giving the set of neighbors for each node. This is what the standard clojure graph library does, though its operations are obscured behind a largely redundant defstruct.
For your example, the map is
{:I #{:a :b :c :d}, :a #{:I}, :b #{:I}, :c #{:I}, :d #{:I}}
This is an undirected graph when it is its own inverse, where
(defn inverse [g]
(apply merge-with clojure.set/union
(for [[x xs] g, y xs] {y #{x}})))
You don't need to do anything to root it anywhere. As #noisesmith says, the root is just the node you start enumerating from. Judging by the diagram, this is equally true of Felsenstein's data structure.
If, as the diagram suggests, only your internal nodes are multiply connected, you could save some space by mapping directly from each external node to its unique neighbour . Your example would become
{:I #{:a :b :c :d}, :a :I, :b :I, :c :I, :d :I}
perhaps better expressed as two maps:
{:internals {:I #{:a :b :c :d}}, :externals {:a :I, :b :I, :c :I, :d :I}}