The notation for an integer must, like everything else in the
hierarchy, be an instance of the class `Functional`. We get
the integer value from the notation by calling a member function,
`int_value` . If a
`Functional` is not a notation for an integer this member
returns **-1**.

Class `Functional` represents arbitrary structures.
Integers are treated as a special case with member function
`int_value`. Integers are the finite ordinals. For infinite
ordinals we need more structure and this is best handled with a
derived class `Ordinal` . To
determine if an arbitrary functional is an ordinal we will have a
member function `ordinal_value` .
This will return a null pointer if the `Functional` does not
represent an ordinal. If it does represent an ordinal it returns a
pointer to itself that can then access member functions specific to
ordinals. `Functional`s that represent integers must be
derived from an instance of class `Ordinal` and return a pointer from
`ordinal_value` .

Ordinals must be recursively well ordered. There is a member
function `order` of
`Ordinal` such that for any two ordinal notations `a`
and `b` `a->Ordinal::order(b)` returns -1, 0 or 1
if `a` is less than, equal to or greater than `b`.
Since `b` may be from an expansion of the notational
hierarchy that `a` knows nothing about the
`order` function for `a` may
return `-b->order(a)`. To know whether this is needed
there is an `Ordinal` member
function `level` that returns an
integer value representing the level in an expanded notational
hierarchy. The `order` function of
the ordinal with the largest value of `level` must be used.
The orderings defined in a particular expansion will always have a
fixed recursive ordinal as a limit. This limit does not hold for
sequences of expansions.

As mentioned before, in contrast with ZF, there are many types of limit ordinals. Limits are characterized by the type of parameter they allow. The lowest level is the integers. The next level is notations for recursive ordinals (which can be defined as those ordinals represented by structures well founded for the integers). The next levels correspond to structures definable by well foundedness on the previous level of object. We can integrate this up to any recursive ordinal. We want to be able to iterate it up to any recursive notation we can define.

home | consulting | videos | book | QM FAQ | contact |