97 lines
2.5 KiB
Plaintext
97 lines
2.5 KiB
Plaintext
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);
|
|
}
|
|
|
|
|
|
|