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);
}