Because we treat the integers we have axiom for integers instead of the axiom of the empty set. of the integers.

This may not seem satisfactory since it assumes the integers
already exist. However we are assuming the framework of C
`++` and they do exist in that framework. All of these
axioms are informal. If you want to do a fully formal system you
need to start with first order arithmetic or some other system
strong enough to embed a universal TM and then define the
constructs in C `++` that we use in that system. The code
for this is trivial. You only need to have an integer object as a
member of class `Functional` and return the value of that
object for member function `int_value`. To write the code
for this we need to define the class `Functional`. The full
class definition is in Figure .

Many of the member functions have already been described. We
will describe here some additional functions that are generic.
Others will member functions and the code for member functions that
are not a part of the class definition will be included where and
if they are needed. Some functions are for housekeeping or other
purposes and will not be described here. They included because this
is compiled C `++` code which is intended to be used and has
been to a limited degree tested. The source code is available at TO
BE DETERMINED.

We use `virtual` C `++` functions to make this
classes open ended. A `Functional` maps
`Functional`'s to other `Functional`'s through a
virtual function `operator()`. By deriving classes from base
class `Functional` and by redefining the virtual member
functions, such as `operator()`, we have a completely open
structure with flexibility similar to that of a `set' in set
theory. Because every instance of a `Functional` must be
implemented as an effective procedure, we need to know if a given
parameter is valid. This is determined by another virtual function
`valid_parameter` . This is the
base class for all functionals no matter what structure they
represent. As new levels of the hierarchy are defined the virtual
functions in `Functional` must be defined in derived classes
to work with all previously defined code.

If an integer is being represented then `the_limit` is
the integer being represented otherwise it is -1. Member
`union_depth` is used to take the
union of an infinite set. Virtual member function
`clone_base` is used to create a
copy of this object including all the derived classes that this
object may also be an instance of. This function is never called
directly but only by function `clone` .

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