# SplittingTree(V, C)ΒΆ

- V: Join(SetCategory, Aggregate)
- C: Join(SetCategory, Aggregate)

This domain exports a modest implementation of splitting trees. Splitting trees are needed when the evaluation of some quantity under some hypothesis requires to split the hypothesis into sub-cases. For instance by adding some new hypothesis on one hand and its negation on another hand. The computations are terminated is a splitting tree `a`

when `status(value(a))`

is `true`

. Thus, if for the splitting tree `a`

the flag `status(value(a))`

is `true`

, then `status(value(d))`

is `true`

for any subtree `d`

of `a`

. This property of splitting trees is called the termination condition. If no vertex in a splitting tree `a`

is equal to another, `a`

is said to satisfy the no-duplicates condition. The splitting tree `a`

will satisfy this condition if nodes are added to `a`

by mean of `splitNodeOf!`

and if `construct`

is only used to create the root of `a`

with no children.

- #: % -> NonNegativeInteger
- from Aggregate
- =: (%, %) -> Boolean
- from BasicType
- ~=: (%, %) -> Boolean
- from BasicType
- any?: (SplittingNode(V, C) -> Boolean, %) -> Boolean
- from HomogeneousAggregate SplittingNode(V, C)
- child?: (%, %) -> Boolean
- from RecursiveAggregate SplittingNode(V, C)
- children: % -> List %
- from RecursiveAggregate SplittingNode(V, C)
- coerce: % -> OutputForm
- from CoercibleTo OutputForm

- conditions: % -> List C
`conditions(a)`

returns the list of the conditions of the leaves of a

- construct: (V, C, List %) -> %
`construct(v, t, la)`

creates a splitting tree with value (i.e. root vertex) given by`[v, t]\$S`

and with`la`

as children list.

- construct: (V, C, List SplittingNode(V, C)) -> %
`construct(v, t, ls)`

creates a splitting tree with value (i.e. root vertex) given by`[v, t]\$S`

and with children list given by`[[s]\$\% for s in ls]`

.

- construct: (V, C, V, List C) -> %
`construct(v1, t, v2, lt)`

creates a splitting tree with value (i.e. root vertex) given by`[v, t]\$S`

and with children list given by`[[[v, t]\$S]\$\% for s in ls]`

.

- construct: SplittingNode(V, C) -> %
`construct(s)`

creates a splitting tree with value (i.e. root vertex) given by`s`

and no children. Thus, if the status of`s`

is`false`

,`[s]`

represents the starting point of the evaluation`value(s)`

under the hypothesis`condition(s)`

.- copy: % -> %
- from Aggregate
- count: (SplittingNode(V, C) -> Boolean, %) -> NonNegativeInteger
- from HomogeneousAggregate SplittingNode(V, C)
- count: (SplittingNode(V, C), %) -> NonNegativeInteger
- from HomogeneousAggregate SplittingNode(V, C)
- cyclic?: % -> Boolean
- from RecursiveAggregate SplittingNode(V, C)
- distance: (%, %) -> Integer
- from RecursiveAggregate SplittingNode(V, C)
- elt: (%, value) -> SplittingNode(V, C)
- from RecursiveAggregate SplittingNode(V, C)
- empty: () -> %
- from Aggregate
- empty?: % -> Boolean
- from Aggregate
- eq?: (%, %) -> Boolean
- from Aggregate
- eval: (%, Equation SplittingNode(V, C)) -> % if SplittingNode(V, C) has Evalable SplittingNode(V, C)
- from Evalable SplittingNode(V, C)
- eval: (%, List Equation SplittingNode(V, C)) -> % if SplittingNode(V, C) has Evalable SplittingNode(V, C)
- from Evalable SplittingNode(V, C)
- eval: (%, List SplittingNode(V, C), List SplittingNode(V, C)) -> % if SplittingNode(V, C) has Evalable SplittingNode(V, C)
- from InnerEvalable(SplittingNode(V, C), SplittingNode(V, C))
- eval: (%, SplittingNode(V, C), SplittingNode(V, C)) -> % if SplittingNode(V, C) has Evalable SplittingNode(V, C)
- from InnerEvalable(SplittingNode(V, C), SplittingNode(V, C))
- every?: (SplittingNode(V, C) -> Boolean, %) -> Boolean
- from HomogeneousAggregate SplittingNode(V, C)

- extractSplittingLeaf: % -> Union(%, failed)
`extractSplittingLeaf(a)`

returns the left most leaf (as a tree) whose status is`false`

if any, else “failed” is returned.- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory
- latex: % -> String
- from SetCategory
- leaf?: % -> Boolean
- from RecursiveAggregate SplittingNode(V, C)
- leaves: % -> List SplittingNode(V, C)
- from RecursiveAggregate SplittingNode(V, C)
- less?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- map!: (SplittingNode(V, C) -> SplittingNode(V, C), %) -> %
- from HomogeneousAggregate SplittingNode(V, C)
- map: (SplittingNode(V, C) -> SplittingNode(V, C), %) -> %
- from HomogeneousAggregate SplittingNode(V, C)
- member?: (SplittingNode(V, C), %) -> Boolean
- from HomogeneousAggregate SplittingNode(V, C)
- members: % -> List SplittingNode(V, C)
- from HomogeneousAggregate SplittingNode(V, C)
- more?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- node?: (%, %) -> Boolean
- from RecursiveAggregate SplittingNode(V, C)

- nodeOf?: (SplittingNode(V, C), %) -> Boolean
`nodeOf?(s, a)`

returns`true`

iff some node of`a`

is equal to`s`

- nodes: % -> List %
- from RecursiveAggregate SplittingNode(V, C)
- parts: % -> List SplittingNode(V, C)
- from HomogeneousAggregate SplittingNode(V, C)

- remove!: (SplittingNode(V, C), %) -> %
`remove!(s, a)`

replaces a by remove(`s`

, a)

- remove: (SplittingNode(V, C), %) -> %
`remove(s, a)`

returns the splitting tree obtained from a by removing every sub-tree`b`

such that`value(b)`

and`s`

have the same value, condition and status.

- result: % -> List Record(val: V, tower: C)
`result(a)`

where`ls`

is the leaves list of`a`

returns`[[value(s), condition(s)]\$VT for s in ls]`

if the computations are terminated in`a`

else an error is produced.- sample: %
- from Aggregate
- setchildren!: (%, List %) -> %
- from RecursiveAggregate SplittingNode(V, C)
- setelt!: (%, value, SplittingNode(V, C)) -> SplittingNode(V, C)
- from RecursiveAggregate SplittingNode(V, C)
- setvalue!: (%, SplittingNode(V, C)) -> SplittingNode(V, C)
- from RecursiveAggregate SplittingNode(V, C)
- size?: (%, NonNegativeInteger) -> Boolean
- from Aggregate

- splitNodeOf!: (%, %, List SplittingNode(V, C)) -> %
`splitNodeOf!(l, a, ls)`

returns`a`

where the children list of`l`

has been set to`[[s]\$\% for s in ls | not nodeOf?(s, a)]`

. Thus, if`l`

is not a node of`a`

, this latter splitting tree is unchanged.

- splitNodeOf!: (%, %, List SplittingNode(V, C), (C, C) -> Boolean) -> %
`splitNodeOf!(l, a, ls, sub?)`

returns`a`

where the children list of`l`

has been set to`[[s]\$\% for s in ls | not subNodeOf?(s, a, sub?)]`

. Thus, if`l`

is not a node of`a`

, this latter splitting tree is unchanged.

- subNodeOf?: (SplittingNode(V, C), %, (C, C) -> Boolean) -> Boolean
`subNodeOf?(s, a, sub?)`

returns`true`

iff for some node`n`

in`a`

we have`s = n`

or`status(n)`

and`subNode?(s, n, sub?)`

.

- updateStatus!: % -> %
`updateStatus!(a)`

returns a where the status of the vertices are updated to satisfy the “termination condition”.- value: % -> SplittingNode(V, C)
- from RecursiveAggregate SplittingNode(V, C)

Evalable SplittingNode(V, C) if SplittingNode(V, C) has Evalable SplittingNode(V, C)

HomogeneousAggregate SplittingNode(V, C)

InnerEvalable(SplittingNode(V, C), SplittingNode(V, C)) if SplittingNode(V, C) has Evalable SplittingNode(V, C)