Expression

And : &, Or : |, Not : -

((-1&((8&(((-5|-5)&0)&-3))&-1))|(7|((7|((((-9|9)&(4&1))|((-5|(-9|3))|(((((-1&(8|
(-2|(-8&7))))|(7|6))|-5)&4)|(((4|-2)&(0|6))|9))))&((-0|(2&(-4|(2|4))))&(8|(9&-3)
))))|((-4|(8&(((9&-8)|4)|((-8&(-8&8))|(9&(-1&-2))))))&8))))

Binary Expression Tree

The Build Tree algorithm built the following binary expression tree from 
the original expression.

The root of the tree is at the left edge at the bottom of this section.

The children of a node appear somewhere above and below it and are indented four
spaces more than their parent.

                    Literal 8
                And
                                                Literal 2
                                            Not
                                        And
                                                Literal 1
                                            Not
                                    And
                                        Literal 9
                                Or
                                            Literal 8
                                        And
                                                Literal 8
                                            Not
                                    And
                                            Literal 8
                                        Not
                            Or
                                    Literal 4
                                Or
                                            Literal 8
                                        Not
                                    And
                                        Literal 9
                        And
                            Literal 8
                    Or
                            Literal 4
                        Not
            Or
                                        Literal 3
                                    Not
                                And
                                    Literal 9
                            Or
                                Literal 8
                        And
                                            Literal 4
                                        Or
                                            Literal 2
                                    Or
                                            Literal 4
                                        Not
                                And
                                    Literal 2
                            Or
                                    Literal 0
                                Not
                    And
                                        Literal 9
                                    Or
                                                Literal 6
                                            Or
                                                Literal 0
                                        And
                                                    Literal 2
                                                Not
                                            Or
                                                Literal 4
                                Or
                                        Literal 4
                                    And
                                                Literal 5
                                            Not
                                        Or
                                                    Literal 6
                                                Or
                                                    Literal 7
                                            Or
                                                                Literal 7
                                                            And
                                                                    Literal 8
                                                                Not
                                                        Or
                                                                Literal 2
                                                            Not
                                                    Or
                                                        Literal 8
                                                And
                                                        Literal 1
                                                    Not
                            Or
                                        Literal 3
                                    Or
                                            Literal 9
                                        Not
                                Or
                                        Literal 5
                                    Not
                        Or
                                    Literal 1
                                And
                                    Literal 4
                            And
                                    Literal 9
                                Or
                                        Literal 9
                                    Not
                Or
                    Literal 7
        Or
            Literal 7
    Or
                    Literal 1
                Not
            And
                            Literal 3
                        Not
                    And
                            Literal 0
                        And
                                    Literal 5
                                Not
                            Or
                                    Literal 5
                                Not
                And
                    Literal 8
        And
                Literal 1
            Not
Root

Binary Constraint Tree

The Propagate Truth Value algorithm was applied to the binary expression tree
with the value of True being propagated from the root, resulting in the following 
binary constraint tree.

At each literal node, the literal is constrained to the truth value following 
the arrow.

                    Literal 8 -> true
                And
                                            Literal 2 -> false
                                        And
                                            Literal 1 -> false
                                    And
                                        Literal 9 -> true
                                Or
                                            Literal 8 -> true
                                        And
                                            Literal 8 -> false
                                    And
                                        Literal 8 -> false
                            Or
                                    Literal 4 -> true
                                Or
                                        Literal 8 -> false
                                    And
                                        Literal 9 -> true
                        And
                            Literal 8 -> true
                    Or
                        Literal 4 -> false
            Or
                                    Literal 3 -> false
                                And
                                    Literal 9 -> true
                            Or
                                Literal 8 -> true
                        And
                                            Literal 4 -> true
                                        Or
                                            Literal 2 -> true
                                    Or
                                        Literal 4 -> false
                                And
                                    Literal 2 -> true
                            Or
                                Literal 0 -> false
                    And
                                        Literal 9 -> true
                                    Or
                                                Literal 6 -> true
                                            Or
                                                Literal 0 -> true
                                        And
                                                Literal 2 -> false
                                            Or
                                                Literal 4 -> true
                                Or
                                        Literal 4 -> true
                                    And
                                            Literal 5 -> false
                                        Or
                                                    Literal 6 -> true
                                                Or
                                                    Literal 7 -> true
                                            Or
                                                                Literal 7 -> true
                                                            And
                                                                Literal 8 -> false
                                                        Or
                                                            Literal 2 -> false
                                                    Or
                                                        Literal 8 -> true
                                                And
                                                    Literal 1 -> false
                            Or
                                        Literal 3 -> true
                                    Or
                                        Literal 9 -> false
                                Or
                                    Literal 5 -> false
                        Or
                                    Literal 1 -> true
                                And
                                    Literal 4 -> true
                            And
                                    Literal 9 -> true
                                Or
                                    Literal 9 -> false
                Or
                    Literal 7 -> true
        Or
            Literal 7 -> true
    Or
                Literal 1 -> false
            And
                        Literal 3 -> false
                    And
                            Literal 0 -> true
                        And
                                Literal 5 -> false
                            Or
                                Literal 5 -> false
                And
                    Literal 8 -> true
        And
            Literal 1 -> false
Root

Constraint Tree

The Gather Junctors algorithm was applied to the binary constraint tree,
resulting in the following constraint tree.

The address in memory of each node is shown to the left for reference.

The root of the tree is the uppermost And node.

Each And node is associated with its guard set that contains its constraints, 
shown within { }

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -1, -3, +8 }
00A22430                    Or
00A223D0                        And { -5 }
00A224F0                        And { -5 }
00A226D0                And { +7 }
00A22850                And { +7 }
00A22970                And { }
00A229D0                    Or
00A22A30                        And { +1, +4 }
00A22B50                            Or
00A22AF0                                And { -9 }
00A22BB0                                And { +9 }
00A22E50                        And { -5 }
00A22FD0                        And { -9 }
00A23090                        And { +3 }
00A23150                        And { +4 }
00A231B0                            Or
00A23330                                And { -1 }
00A23450                                    Or
00A233F0                                        And { +8 }
00A23570                                        And { -2 }
00A23750                                        And { +7, -8 }
00A234B0                                And { +7 }
00A23810                                And { +6 }
00A23870                                And { -5 }
00A239F0                        And { }
00A23AB0                            Or
00A23A50                                And { +4 }
00A23B70                                And { -2 }
00A23C90                            Or
00A23C30                                And { +0 }
00A23CF0                                And { +6 }
00A23BD0                        And { +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { -4 }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

The Reduce to Elegance algorithm is applied to the constraint tree in order to
reduce it to Elegant Normal Form.

After each group of changes in the constraint tree, a snapshot of the constraint
tree will be displayed. I've colored some important messages in the output in blue,
colored nodes at or near the points of application in blue, and used red to highlight 
some relevant constraints.

A close study of this example will reveal that the algorithm can be improved.
It can and will be.

The remainder of this run is the output of the Reduce to Elegance algorithm

ReduceToElegance()
   about to call AndReduceToElegance
AndReduceToElegance( 00A21E90,  dominant: { },  command: { } )
   major cycle of reduction
      current node = 00A21E90
InconsistentHandle( 00A21E90, dominant: { }, handle: { } )
   handle is consistent
      child = 00A21F50
         calling OrReduceToElegance
OrReduceToElegance( 00A21F50, dominant: { }, command: { } )
   child = 00A22070
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A22070,  dominant: { },  command: { +7 } )
   major cycle of reduction
      current node = 00A22070
InconsistentHandle( 00A22070, dominant: { }, handle: { } )
   handle is consistent
      child = 00A22430
         calling OrReduceToElegance
OrReduceToElegance( 00A22430, dominant: { +0, -1, -3, +8 }, command: { +7 } )
   child = 00A223D0
      local command set = { -5, +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A223D0,  dominant: { +0, -1, -3, +8 },  command: { -5, +7 } )
   deleting current node 00A223D0 due to one-constraint subsumption
      AndReduceToElegance returned kersDelete
         there is more than one child
ReleaseTree( 00A223D0 )

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -1, -3, +8 }
00A22430                    Or
00A224F0                        And { -5 }
00A226D0                And { +7 }
00A22850                And { +7 }
00A22970                And { }
00A229D0                    Or
00A22A30                        And { +1, +4 }
00A22B50                            Or
00A22AF0                                And { -9 }
00A22BB0                                And { +9 }
00A22E50                        And { -5 }
00A22FD0                        And { -9 }
00A23090                        And { +3 }
00A23150                        And { +4 }
00A231B0                            Or
00A23330                                And { -1 }
00A23450                                    Or
00A233F0                                        And { +8 }
00A23570                                        And { -2 }
00A23750                                        And { +7, -8 }
00A234B0                                And { +7 }
00A23810                                And { +6 }
00A23870                                And { -5 }
00A239F0                        And { }
00A23AB0                            Or
00A23A50                                And { +4 }
00A23B70                                And { -2 }
00A23C90                            Or
00A23C30                                And { +0 }
00A23CF0                                And { +6 }
00A23BD0                        And { +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { -4 }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

   child = 00A224F0
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A224F0,  dominant: { +0, -1, -3, +8 },  command: { +7 } )
   major cycle of reduction
      current node = 00A224F0
InconsistentHandle( 00A224F0, dominant: { +0, -1, -3, +8 }, handle: { } )
   handle is consistent
OrCut( 00A224F0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         promote constraints { -5 }
         OrReduceToElegance returned kersPromoteConstraints

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22430                    Or
00A224F0                        And { }
00A226D0                And { +7 }
00A22850                And { +7 }
00A22970                And { }
00A229D0                    Or
00A22A30                        And { +1, +4 }
00A22B50                            Or
00A22AF0                                And { -9 }
00A22BB0                                And { +9 }
00A22E50                        And { -5 }
00A22FD0                        And { -9 }
00A23090                        And { +3 }
00A23150                        And { +4 }
00A231B0                            Or
00A23330                                And { -1 }
00A23450                                    Or
00A233F0                                        And { +8 }
00A23570                                        And { -2 }
00A23750                                        And { +7, -8 }
00A234B0                                And { +7 }
00A23810                                And { +6 }
00A23870                                And { -5 }
00A239F0                        And { }
00A23AB0                            Or
00A23A50                                And { +4 }
00A23B70                                And { -2 }
00A23C90                            Or
00A23C30                                And { +0 }
00A23CF0                                And { +6 }
00A23BD0                        And { +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { -4 }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

AndCut( 00A22430 )
   child = 00A224F0
      child = 00A22430
         calling OrReduceToElegance
OrReduceToElegance( 00A22430, dominant: { +0, -1, -3, +8 }, command: { +7 } )
   child = 00A224F0
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A224F0,  dominant: { +0, -1, -3, +8 },  command: { +7 } )
   disconnecting current node 00A224F0 due to zero-constraint subsumption
        AndReduceToElegance returned kersDisconnect
         OrReduceToElegance returned kersDisconnect
ReleaseTree( 00A22430 )
ReleaseTree( 00A224F0 )
         erasing child = 00A22430

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A226D0                And { +7 }
00A22850                And { +7 }
00A22970                And { }
00A229D0                    Or
00A22A30                        And { +1, +4 }
00A22B50                            Or
00A22AF0                                And { -9 }
00A22BB0                                And { +9 }
00A22E50                        And { -5 }
00A22FD0                        And { -9 }
00A23090                        And { +3 }
00A23150                        And { +4 }
00A231B0                            Or
00A23330                                And { -1 }
00A23450                                    Or
00A233F0                                        And { +8 }
00A23570                                        And { -2 }
00A23750                                        And { +7, -8 }
00A234B0                                And { +7 }
00A23810                                And { +6 }
00A23870                                And { -5 }
00A239F0                        And { }
00A23AB0                            Or
00A23A50                                And { +4 }
00A23B70                                And { -2 }
00A23C90                            Or
00A23C30                                And { +0 }
00A23CF0                                And { +6 }
00A23BD0                        And { +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { -4 }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

        AndReduceToElegance returned kersKeep
   child = 00A226D0
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A226D0,  dominant: { },  command: { +7 } )
   deleting current node 00A226D0 due to one-constraint subsumption
      AndReduceToElegance returned kersDelete
         there is more than one child
ReleaseTree( 00A226D0 )

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A229D0                    Or
00A22A30                        And { +1, +4 }
00A22B50                            Or
00A22AF0                                And { -9 }
00A22BB0                                And { +9 }
00A22E50                        And { -5 }
00A22FD0                        And { -9 }
00A23090                        And { +3 }
00A23150                        And { +4 }
00A231B0                            Or
00A23330                                And { -1 }
00A23450                                    Or
00A233F0                                        And { +8 }
00A23570                                        And { -2 }
00A23750                                        And { +7, -8 }
00A234B0                                And { +7 }
00A23810                                And { +6 }
00A23870                                And { -5 }
00A239F0                        And { }
00A23AB0                            Or
00A23A50                                And { +4 }
00A23B70                                And { -2 }
00A23C90                            Or
00A23C30                                And { +0 }
00A23CF0                                And { +6 }
00A23BD0                        And { +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { -4 }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

   child = 00A22850
      local command set = { }
      calling AndReduceToElegance
AndReduceToElegance( 00A22850,  dominant: { },  command: { } )
   major cycle of reduction
      current node = 00A22850
InconsistentHandle( 00A22850, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A22850 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A22970
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A22970,  dominant: { },  command: { +7 } )
   major cycle of reduction
      current node = 00A22970
InconsistentHandle( 00A22970, dominant: { }, handle: { } )
   handle is consistent
      child = 00A229D0
         calling OrReduceToElegance
OrReduceToElegance( 00A229D0, dominant: { }, command: { +7 } )
   child = 00A22A30
      local command set = { +3, -5, +7, +9, -9 }
      requesting disconnect due to inconsistent command set
         OrReduceToElegance returned kersDisconnect
ReleaseTree( 00A229D0 )
ReleaseTree( 00A22A30 )
ReleaseTree( 00A22B50 )
ReleaseTree( 00A22AF0 )
ReleaseTree( 00A22BB0 )
ReleaseTree( 00A22E50 )
ReleaseTree( 00A22FD0 )
ReleaseTree( 00A23090 )
ReleaseTree( 00A23150 )
ReleaseTree( 00A231B0 )
ReleaseTree( 00A23330 )
ReleaseTree( 00A23450 )
ReleaseTree( 00A233F0 )
ReleaseTree( 00A23570 )
ReleaseTree( 00A23750 )
ReleaseTree( 00A234B0 )
ReleaseTree( 00A23810 )
ReleaseTree( 00A23870 )
ReleaseTree( 00A239F0 )
ReleaseTree( 00A23AB0 )
ReleaseTree( 00A23A50 )
ReleaseTree( 00A23B70 )
ReleaseTree( 00A23C90 )
ReleaseTree( 00A23C30 )
ReleaseTree( 00A23CF0 )
ReleaseTree( 00A23BD0 )
         erasing child = 00A229D0

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { -4 }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

      child = 00A23DB0
         calling OrReduceToElegance
OrReduceToElegance( 00A23DB0, dominant: { }, command: { +7 } )
   child = 00A23D50
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23D50,  dominant: { },  command: { +7 } )
   major cycle of reduction
      current node = 00A23D50
InconsistentHandle( 00A23D50, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23D50 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A23ED0
      local command set = { -0, +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23ED0,  dominant: { },  command: { -0, +7 } )
   major cycle of reduction
      current node = 00A23ED0
InconsistentHandle( 00A23ED0, dominant: { }, handle: { } )
   handle is consistent
      child = 00A24050
         calling OrReduceToElegance
OrReduceToElegance( 00A24050, dominant: { +2 }, command: { -0, +7 } )
   child = 00A23FF0
      local command set = { -0, +2, +4, +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23FF0,  dominant: { +2 },  command: { -0, +2, +4, +7 } )
   subtracted some opposing command constraints

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24050                            Or
00A23FF0                                And { }
00A24110                                And { +2 }
00A241D0                                And { +4 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

   disconnecting current node 00A23FF0 due to zero-constraint subsumption
        AndReduceToElegance returned kersDisconnect
         OrReduceToElegance returned kersDisconnect
ReleaseTree( 00A24050 )
ReleaseTree( 00A23FF0 )
ReleaseTree( 00A24110 )
ReleaseTree( 00A241D0 )
         erasing child = 00A24050

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { +8 }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

        AndReduceToElegance returned kersKeepNewTerminalUnit
            starting with the first child again
   child = 00A23D50
      local command set = { +2, +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23D50,  dominant: { },  command: { +2, +7 } )
   major cycle of reduction
      current node = 00A23D50
InconsistentHandle( 00A23D50, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23D50 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A23ED0
      local command set = { -0, +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23ED0,  dominant: { },  command: { -0, +7 } )
   major cycle of reduction
      current node = 00A23ED0
InconsistentHandle( 00A23ED0, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23ED0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         there are no common constraints to promote
         OrReduceToElegance returned kersKeep
AndCut( 00A23DB0 )
   child = 00A23D50
   child = 00A23ED0
            no need to rereduce child
      child = 00A240B0
         calling OrReduceToElegance
OrReduceToElegance( 00A240B0, dominant: { }, command: { +7 } )
   child = 00A23F30
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23F30,  dominant: { },  command: { +7 } )
   major cycle of reduction
      current node = 00A23F30
InconsistentHandle( 00A23F30, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23F30 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A242F0
      local command set = { +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A242F0,  dominant: { },  command: { +7, +8 } )
   major cycle of reduction
      current node = 00A242F0
InconsistentHandle( 00A242F0, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A242F0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         there are no common constraints to promote
         OrReduceToElegance returned kersKeep
AndCut( 00A240B0 )
   child = 00A23F30
   child = 00A242F0
            no need to rereduce child
OrCut( 00A22970 )
   child = 00A23DB0
   child = 00A240B0
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A24590
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A24590,  dominant: { },  command: { +7 } )
   major cycle of reduction
      current node = 00A24590
InconsistentHandle( 00A24590, dominant: { }, handle: { } )
   handle is consistent
      child = 00A24410
         calling OrReduceToElegance
OrReduceToElegance( 00A24410, dominant: { +8 }, command: { +7 } )
   child = 00A227F0
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A227F0,  dominant: { +8 },  command: { +7 } )
   major cycle of reduction
      current node = 00A227F0
InconsistentHandle( 00A227F0, dominant: { +8 }, handle: { } )
   handle is consistent
OrCut( 00A227F0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A24530
      local command set = { -4, +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A24530,  dominant: { +8 },  command: { -4, +7 } )
   removed some redundant constraints

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { }
00A245F0                            Or
00A24710                                And { -8, +9 }
00A24830                                And { +4 }
00A24A10                                And { +8, -8 }
00A24CB0                                And { -1, -2, +9 }

   major cycle of reduction
      current node = 00A24530
InconsistentHandle( 00A24530, dominant: { +8 }, handle: { } )
   handle is consistent
      child = 00A245F0
         calling OrReduceToElegance
OrReduceToElegance( 00A245F0, dominant: { +8 }, command: { -4, +7 } )
   child = 00A24710
      local command set = { +4, -4, +7 }
      requesting disconnect due to inconsistent command set
         OrReduceToElegance returned kersDisconnect
ReleaseTree( 00A245F0 )
ReleaseTree( 00A24710 )
ReleaseTree( 00A24830 )
ReleaseTree( 00A24A10 )
ReleaseTree( 00A24CB0 )
         erasing child = 00A245F0

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }
00A24410                    Or
00A227F0                        And { -4 }
00A24530                        And { }

        discovered zero-constraint subsumption at 00A227F0 [message was missing]
        AndReduceToElegance returned kersDisconnect
            OrReduceToElegance returned kersDisconnect
ReleaseTree( 00A24410 )
ReleaseTree( 00A227F0 )
ReleaseTree( 00A24530 )
         erasing child = 00A24410

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22070                And { +0, -0, -1, -3, -5, +8 }
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }

        AndReduceToElegance returned kersKeepNewTerminalUnit
            starting with the first child again
   child = 00A22070
      local command set = { +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A22070,  dominant: { },  command: { +7, +8 } )
   deleting current node 00A22070 due to one-constraint subsumption
      AndReduceToElegance returned kersDelete
         there is more than one child
ReleaseTree( 00A22070 )

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A23F30                        And { +8 }
00A242F0                        And { -3, +9 }
00A24590                And { +8 }

   child = 00A22850
      local command set = { +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A22850,  dominant: { },  command: { +8 } )
   major cycle of reduction
      current node = 00A22850
InconsistentHandle( 00A22850, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A22850 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A22970
      local command set = { +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A22970,  dominant: { },  command: { +7, +8 } )
   major cycle of reduction
      current node = 00A22970
InconsistentHandle( 00A22970, dominant: { }, handle: { } )
   handle is consistent
      child = 00A23DB0
         calling OrReduceToElegance
OrReduceToElegance( 00A23DB0, dominant: { }, command: { +7, +8 } )
   child = 00A23D50
      local command set = { +2, +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23D50,  dominant: { },  command: { +2, +7, +8 } )
   major cycle of reduction
      current node = 00A23D50
InconsistentHandle( 00A23D50, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23D50 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A23ED0
      local command set = { -0, +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23ED0,  dominant: { },  command: { -0, +7, +8 } )
   major cycle of reduction
      current node = 00A23ED0
InconsistentHandle( 00A23ED0, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23ED0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         there are no common constraints to promote
         OrReduceToElegance returned kersKeep
AndCut( 00A23DB0 )
   child = 00A23D50
   child = 00A23ED0
            no need to rereduce child
      child = 00A240B0
         calling OrReduceToElegance
OrReduceToElegance( 00A240B0, dominant: { }, command: { +7, +8 } )
   child = 00A23F30
      local command set = { +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23F30,  dominant: { },  command: { +7, +8 } )
   deleting current node 00A23F30 due to one-constraint subsumption
      AndReduceToElegance returned kersDelete
         there is more than one child
ReleaseTree( 00A23F30 )

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22850                And { +7 }
00A22970                And { }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A242F0                        And { -3, +9 }
00A24590                And { +8 }

   child = 00A242F0
      local command set = { +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A242F0,  dominant: { },  command: { +7, +8 } )
   major cycle of reduction
      current node = 00A242F0
InconsistentHandle( 00A242F0, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A242F0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         promote constraints { -3, +9 }
         OrReduceToElegance returned kersPromoteConstraints

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22850                And { +7 }
00A22970                And { -3, +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A240B0                    Or
00A242F0                        And { }
00A24590                And { +8 }

AndCut( 00A240B0 )
   child = 00A242F0
      child = 00A23DB0
         calling OrReduceToElegance
OrReduceToElegance( 00A23DB0, dominant: { }, command: { +7, +8 } )
   child = 00A23D50
      local command set = { +2, +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23D50,  dominant: { },  command: { +2, +7, +8 } )
   major cycle of reduction
      current node = 00A23D50
InconsistentHandle( 00A23D50, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23D50 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A23ED0
      local command set = { -0, +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23ED0,  dominant: { },  command: { -0, +7, +8 } )
   major cycle of reduction
      current node = 00A23ED0
InconsistentHandle( 00A23ED0, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A23ED0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         there are no common constraints to promote
         OrReduceToElegance returned kersKeep
AndCut( 00A23DB0 )
   child = 00A23D50
   child = 00A23ED0
            no need to rereduce child
      child = 00A240B0
         calling OrReduceToElegance
OrReduceToElegance( 00A240B0, dominant: { }, command: { +7, +8 } )
   child = 00A242F0
      local command set = { +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A242F0,  dominant: { },  command: { +7, +8 } )
   disconnecting current node 00A242F0 due to zero-constraint subsumption
        AndReduceToElegance returned kersDisconnect
         OrReduceToElegance returned kersDisconnect
ReleaseTree( 00A240B0 )
ReleaseTree( 00A242F0 )
         erasing child = 00A240B0

Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22850                And { +7 }
00A22970                And { -3, +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24590                And { +8 }

OrCut( 00A22970 )
   child = 00A23DB0
      current node = 00A22970
InconsistentHandle( 00A22970, dominant: { }, handle: { } )
   handle is consistent
      child = 00A23DB0
         calling OrReduceToElegance
OrReduceToElegance( 00A23DB0, dominant: { -3, +9 }, command: { +7, +8 } )
   child = 00A23D50
      local command set = { +2, +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23D50,  dominant: { -3, +9 },  command: { +2, +7, +8 } )
   major cycle of reduction
      current node = 00A23D50
InconsistentHandle( 00A23D50, dominant: { -3, +9 }, handle: { } )
   handle is consistent
OrCut( 00A23D50 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A23ED0
      local command set = { -0, +7, +8 }
      calling AndReduceToElegance
AndReduceToElegance( 00A23ED0,  dominant: { -3, +9 },  command: { -0, +7, +8 } )
   major cycle of reduction
      current node = 00A23ED0
InconsistentHandle( 00A23ED0, dominant: { -3, +9 }, handle: { } )
   handle is consistent
OrCut( 00A23ED0 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         there are no common constraints to promote
         OrReduceToElegance returned kersKeep
AndCut( 00A23DB0 )
   child = 00A23D50
   child = 00A23ED0
            no need to rereduce child
OrCut( 00A22970 )
   child = 00A23DB0
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
   child = 00A24590
      local command set = { +7 }
      calling AndReduceToElegance
AndReduceToElegance( 00A24590,  dominant: { },  command: { +7 } )
   major cycle of reduction
      current node = 00A24590
InconsistentHandle( 00A24590, dominant: { }, handle: { } )
   handle is consistent
OrCut( 00A24590 )
   end of major cycle of reduction - AndReduceToElegance
        AndReduceToElegance returned kersKeep
      checking for promotability of constraints
         there are no common constraints to promote
         OrReduceToElegance returned kersKeep
AndCut( 00A21F50 )
   child = 00A22850
   child = 00A22970
   child = 00A24590
            no need to rereduce child
OrCut( 00A21E90 )
   child = 00A21F50
   end of major cycle of reduction - AndReduceToElegance
   AndReduceToElegance returned kersKeep

Elegant Constraint Tree

00A21E90        And { }
00A21F50            Or
00A22850                And { +7 }
00A22970                And { -3, +9 }
00A23DB0                    Or
00A23D50                        And { -0 }
00A23ED0                        And { +2 }
00A24590                And { +8 }

Since the elegant constraint tree retains some constraints but
does not contain any opposing constraints, we know that it is both 
Satisfiable and Falsifiable.