Finished Chapter 4

chap_4/e4_1.dfy

@@ -0,0 +1,96 @@
+datatype BYTree = BlueLeaf | YellowLeaf | Node(left: BYTree, right: BYTree)
+
+function ReverseColors(t: BYTree): BYTree {
+    match t
+    case BlueLeaf => YellowLeaf
+    case YellowLeaf => BlueLeaf 
+    case Node(left, right) => BYTree.Node(ReverseColors(left), ReverseColors(right))
+}
+
+method TestReverseColors() {
+    var a := BYTree.Node(BlueLeaf, BYTree.Node(BlueLeaf, YellowLeaf));
+    var b := BYTree.Node(YellowLeaf, BYTree.Node(YellowLeaf, BlueLeaf));
+    assert ReverseColors(a) == b;
+    assert ReverseColors(b) == a;
+
+    var c := BYTree.Node(BYTree.Node(YellowLeaf, BlueLeaf), BlueLeaf);
+    var d := BYTree.Node(BYTree.Node(BlueLeaf, YellowLeaf), YellowLeaf);
+    assert ReverseColors(c) == d;
+    assert ReverseColors(d) == c;
+
+    var e := BlueLeaf;
+    assert ReverseColors(e) != e;
+}
+
+function Oceanize(t: BYTree): BYTree {
+    match t
+        case BlueLeaf | YellowLeaf => BlueLeaf
+        case Node(left, right) => BYTree.Node(Oceanize(left), Oceanize(right))
+}
+
+method testOceanize() {
+    var a := BYTree.Node(BlueLeaf, YellowLeaf);
+    var b := BYTree.Node(BlueLeaf, BlueLeaf);
+    assert Oceanize(a) == b; 
+}
+
+function LeftDepth(t: BYTree): nat {
+    if t.BlueLeaf? || t.YellowLeaf? then 1
+    else 1 + LeftDepth(t.left)
+}
+
+predicate HasLeftTreeMatch(t: BYTree, u: BYTree) {
+    match t
+    case Node(left, right) => left == u // || HasLeftTree(left, u) || HasLeftTree(right, u)
+    case BlueLeaf => false
+    case YellowLeaf => false
+}
+
+predicate HasLeftTreeCon(t: BYTree, u: BYTree) {
+    if t.BlueLeaf? then false
+    else if t.YellowLeaf? then false
+    else t.left == u
+}
+
+predicate HLT(t: BYTree, u: BYTree) {
+    HasLeftTreeMatch(t, u) && HasLeftTreeCon(t, u)
+}
+
+method testHasLeftTree() {
+    var a := BYTree.Node(BlueLeaf, YellowLeaf);
+    var b := BlueLeaf;
+    var c := BYTree.Node(a, b);
+
+    assert HLT(a, b);
+    assert !HLT(b, a);
+    assert HLT(c, a);
+    assert !HLT(c, b);
+}
+
+datatype Color = Blue | Yellow | Green | Red
+
+datatype ColoredTree = Leaf(Color) | Node(ColoredTree, ColoredTree)
+
+predicate IsSwedishColoredTree(t: ColoredTree) {
+    match t {
+    case Leaf(Color) => 
+        match Color {
+        case Blue => true
+        case Yellow => true
+        case Green => false
+        case Red => false
+        }
+    case Node(left, right) => IsSwedishColoredTree(left) && IsSwedishColoredTree(right)
+    }
+}
+
+method testIsSwedischColoredTree() {
+    var a := ColoredTree.Node(Leaf(Blue), Leaf(Green));
+    assert !IsSwedishColoredTree(a);
+
+    var b := ColoredTree.Node(Leaf(Blue), Leaf(Yellow));
+    assert IsSwedishColoredTree(b);
+}
+
+
+