Add path-copying figure

201-persist/path-copying.asy

+DefaultHead=TeXHead;
+
+real factor = 0.4;
+
+object OldNode(string l, pair p){
+    label(l,p*factor);
+    return draw("", ellipse, p*factor, xmargin=3mm,FillDraw(white,black));
+}
+
+object NewNode(string l, pair p){
+    label(l,p*factor);
+    return draw("", ellipse, p*factor, xmargin=3mm,FillDraw(white,black+linewidth(0.5mm)));
+}
+
+object a = OldNode("A",(0cm,0cm));
+object b = OldNode("B",(-4cm,-5cm));
+object c = OldNode("C",(4cm,-5cm));
+object d = OldNode("D",(-2cm,-10cm));
+object e = OldNode("E",(2cm,-10cm));
+object f = OldNode("F",(6cm,-10cm));
+
+object a2 = NewNode("A",(-5cm,0cm));
+object b2 = NewNode("B",(-7cm,-5cm));
+object g = NewNode("G",(-9cm,-10cm));
+
+pair left(object p){
+    return point(p,dir(-120));
+}
+
+pair right(object p){
+    return point(p,dir(-60));
+}
+
+pair top(object p){
+    return point(p,dir(90));
+}
+
+draw(left(a)--top(b),black,Arrow());
+draw(right(a)--top(c),black,Arrow());
+draw(left(a2)--top(b2),dashed,Arrow());
+draw(right(a2)--top(c),dashed,Arrow());
+
+draw(right(b)--top(d),black,Arrow());
+draw(left(b2)--top(g),dashed,Arrow());
+draw(right(b2)--top(d),dashed,Arrow());
+
+draw(left(c)--top(e),black,Arrow());
+draw(right(c)--top(f),black,Arrow());

201-persist/persist.tex

@@ -65,7 +65,8 @@ With reasonable variants of binary search trees, achieved time complexity in a t
 The downside of this method is the increased space complexity. 
 There is no apparent construction that would not increase memory complexity by copying the paths.
 
-%TODO: Figure
+\figure[path-copying]{path-copying.pdf}{}{Path copying}
+% TODO: Annotate
 
 This outlined method is not exclusive to binary search trees. 
 It may be used to obtain functional variants of more variants of pointer data structures, of which binary search trees are a prime example.
@@ -80,12 +81,12 @@ When semi-persistence is sufficient, upon arriving at a vertex asking for the st
 We start with the default values and apply all changes that happened earlier than $A$ in chronological order overwriting if there are multiple changes for the same field or pointer. 
 This process yields the correct state of the vertex for version $A$. 
 
-There are several different options for protocol of changes. 
-In fact, it might be easier to just copy all of the other fields the vertex possesses as well if one of them changes.
+There are several options for protocol of changes. 
+In fact, it might be easier to just copy all other fields the vertex possesses as well if one of them changes.
 One change will therefore hold new values for all fields and pointers of the vertex. 
 By embedding some data structure into a fat node, identification of the correct fields may be faster.
 
-For full-persistence we also need to resolve the issue of how to effectively determining which changes should be applied. 
+For full-persistence we also need to resolve the issue of how to effectively determine which changes should be applied. 
 It will be addressed later through introduction of total ordering of all versions.
 
 Looking at the memory consumption, it appears clear that the amount consumed stems from the total number of changes done by the balancing algorithm across all operations.