# SplittingTree(V, C)¶

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 for 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 means 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
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?: % -> Boolean

from Aggregate

empty: () -> %

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.

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)

max: % -> SplittingNode(V, C) if SplittingNode(V, C) has OrderedSet

from HomogeneousAggregate SplittingNode(V, C)

max: ((SplittingNode(V, C), SplittingNode(V, C)) -> Boolean, %) -> 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)

min: % -> SplittingNode(V, C) if SplittingNode(V, C) has OrderedSet

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!(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)

Aggregate

BasicType

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

finiteAggregate

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

SetCategory

shallowlyMutable