Finite Discrete Information Systems
See also:
The
Mathematical Analysis,
SMN
related discussions.
Here we develop the concept of an FDIS, which is a particular type of Finite State Automata (FSA) interpreted as a model of a general system; this system modelling methodology, I refer to as System Matrix Notation or SMN.
In essence an FDIS is a mathematical model of both a General System and of General Realistic Computation. In its most general form SMN provides an abstract network of nodes and relations and it implements the dynamic connectivity within that network, thus it provides a computational process that is finite discrete and massively parallel. This general structure can be imbued with any meaning that one can imagine, from system models, documents, software, etc. In this discussion I primarily explore this as a network of general systems. This effectively implements an intrinsically system-theoretic model of quantum computation (which includes classical computation as a limiting case). This gives rise to a general system modelling methodology that may be applied to the analysis and creation of systems of all kinds.
In this discussion we first define a simple model of a finite state automata, then develop a model of an FDIS. Then we explore some examples and techniques for modelling or simulating systems using FDIS's. Throughout this discussion I am not defining a highly particular model but only a general class of model so virtually all of the aspects can be modified and changed and one can explore the ramifications of those variations. Thus I illustrate only the overall shape of the model and people can explore and adapt the particulars to their own particular needs. It is a very flexible modelling paradigm that can be twisted and contorted in many many ways.
In this discussion I develop a system modelling paradigm that may be used in many different contexts for modelling and simulating systems of all kinds and elsewhere this is extended to a particular type of FDIS that leads to a metaphysical paradigm. There I analyse the type of FDIS that possibly underlies the manifestation of our own physical universe and I explore the nature of such an empirical universe if it was to arise as a simulation that was computed by an FDIS, this is in the discussion on Finite Discrete Closed Information Systems or FDCIS's.
A general definition of a finite state automata consists of a set of automata states S that the automata may occupy, an initial automata state s0, a set of possible input states I, a set of possible output states O, a transformation function f that takes the automata state and the input and produces an output, a set of particular input states i0 and a set of state variables o0 that will later contain the output.
Here I will consider a slightly different definition. A finite state automata consists of a System Matrix (SM) represented by M , a State Vector (SV) represented by v and a matrix multiplication operator that produces a new SV. The system's state is not intrinsically divided into compartments such as s0, i0 and o0, all these are combined in the SV which represents the holistic state of the whole system; one may compartmentalise and assign meanings within the SV as one sees fit. The transformation function f is represented by the SM which is a transformation matrix that maps the present state into a new state. The matrix M is a square Hermitian matrix (i.e. M† = (M *)T = M). Furthermore one may have either the rows or the columns or both normalised to one, or just have arbitrary values. These four normalisation conditions define four distinct classes of well formed automata that can be created. The input and output alphabets I and O are represented by finite discrete variables that define distinct sets of potential states.
{{discuss more on input and output normalisation}}
The SM and SV are iterated to produce successive system states
that represent successive moments of existence for that system,
hence 
and
in general 
.
The matrix multiplied with the state vector effectively produces a
series of iterative equations, one for each state variable, that can
be used to completely represent the computational process, if these
are substituted into each other n times then this is
equivalent to raising the matrix to the power n.
Hence M implements all primitive interactions between sub
systems, i.e. those that occur over a single time step. The compound
SM M n is a transformation
matrix that implements all compound interactions between sub systems,
i.e. those that occur over multiple time steps. One may produce such
compound SM's by simply defining the primitive SM and then raising it
to successively higher powers. This can be achieved with an
exponential acceleration if one utilises the fact that 
and 
and
so on. In this manner we can produce matrices with powers of 1, 2, 4,
8, 16, etc. Since each of these matrices effectively allows us to
reach into the future state space of the system we may explore
any of the future states of the system using these matrices.
The use of Compound SM's is only applicable for the class of periodically closed systems, however any system can be treated as a periodically closed system to varying degrees. These are systems that take an initial input which they process internally and then produce an output. During the period of internal processing there is no further input or outside interaction of any kind, hence they are periodically closed. This is required since if one uses a compound SM that steps the system forward by n time steps, this leap through state space occurs in a single computation so no intermediate external interactions can be included in the computation.
The use of compound SM's implements a form of hyperspatial transport through the system's state space where one may leap from a present state to a future state in a manner such that all of the intervening states have been effectively traversed, with all of the causal information flowing along the correct interaction paths and being computed correctly. However the intervening states are not actually traversed because the entire computation is conducted in a single iteration and thereby a single moment of simulation time. Thus the leap occurs instantaneously and it results in the same future state that would have arisen if we had traversed the state space via multiple steps over multiple moments of time.
This represents a considerable increase of computational efficiency; one may invest time and effort into initially producing the compound SM's and these may then be used to significantly speed up the runtime efficiency of the simulation. There are some complicating factors in the use of this method but most system simulations can benefit from this to some degree.
A turing machine is an example of a finite state automata and it is also a model of general computation hence an FSA can serve as a general computational process, thus allowing for the simulation of general system models. One could develop a system model of a turing machine and implement it within a system matrix and compute it as an FSA, thus one produces a virtual machine. I wont go into that detail here but I will briefly consider the issue of input interfaces into a periodically closed process; these are simple generalised computational processes.
Say there are n pieces of data to be input into an FSA over the duration of a cycle, for example, if the FSA is to recognise words within a language and return a boolean result, the inputs would be characters in a sequence. These are formed into an n step input pipeline which is then integrated into the programming or causal structure within the matrix as though the data feeds in one element at a time. Thus the language recogniser gets one character at a time and with this it narrows down constraints like following branches in a tree, until the word is either found or not found. This is the internal algorithm or the causal programming of the FSA represented in a single matrix. The entire matrix is then raised to the power n thus feeding in and processing the entire input in a single iteration.
In this way very complex input mechanisms and causal programming can be devised within the computational space of an FSA and this can be reduced into a single iteration of a matrix equation. It is in the context of this causal programming that we later construct system models.
In this context we interpret the state vector v as a holistic system state or the state of an entire simulation universe, and the system matrix M is interpreted as the transcendent causal programming that implements the system's behaviour, or that represents the network of causal information channels that percolates the simulation universe and thereby connects every point in that universe with every other point. Hence each iteration produces a new moment of empirical existence within the simulation universe and between empirical moments every system within that universe interacts with every other system to some degree. Thus there are information flows between systems that are transcendent or prior to the empirical universe and thereby do not rely on the transport of empirical energy, that are not constrained by concepts of empirical distance and which, from an empirical perspective, seem to occur instantaneously. This accords with many of the findings of quantum physics and may explain some of the so called paradoxes therein.
Each matrix element implements the relationship between two
primitive systems within the simulation universe. It represents the
interaction channel or the causal information channel between them.
If there are N primitive systems in the simulation universe
then there are N state variables in the SV, and the SM is
an 
matrix.
All higher level or compound systems are formed out of patterns or
groupings of primitive systems, and these may form higher level
groupings and so on up to the group of all primitive systems, which
is the simulation cosmos itself represented as a single coherent
system.
{{mention succedence matrices}}
For a schematic run through the relationship between matrix mathematics and causal connectivity see here.
In its most general form the system matrix is related to the
nonion like form of a complex dyadic, which is equivalent to a
second rank tensor; but put simply it is a square matrix with complex
elements of the general form 
.
Here I i j is the input filter for
the i'th system receiving along the interaction channel from
the j'th system, Oi j is the output
filter for the j'th system transmitting along the
interaction channel to the i'th system and the 
are
unit vectors associated with the i'th and j'th systems.
The overlap of the unit vectors 
determines
the two systems intrinsic interaction potential. In most cases one
can simplify this general form.
Each system's set of input filters defines how and to whom that system is listening and the set of output filters defines how and to whom the system is speaking.
With each iteration, each matrix element is multiplied from the
right by an SV element. In the metaphysical implementation all of
these quantities are complex and may thereby modulate both the
amplitude and the phase of the data as it passes through these
filters. The state vector stores complex data that represents the
intermediate state of the system. In the most general
implementation the matrix elements are arbitrary functions and the
state vector contains arbitrary data. This data is output in
different forms along different channels where 
is
the j'th system's output to the i'th system; in this
way a system can provide different outputs along different
interaction channels to different systems. Furthermore, 
is
then the i'th system's input from the j'th system. All
N inputs to the i'th system are then formed into a
superposition of inputs that becomes the new intermediate state for
that system. In the metaphysical implementation an important function
of these filters is to phase shift the various data streams so as to
bring them into or out of alignment prior to the superposition. In
other cases these filters can also be vectors or matrices that
transform the data in transit and implement the detailed causal
connectivity between systems, or also arbitrary functions that
operate on the data.
In general, within this overall modelling methodology, any type of mathematical entity can theoretically be used in any role so long as the overall computation is coherent, there are very few absolute requirements, thus the modelling paradigm is extremely flexible.
It is often a useful requirement that all input and output filters
be normalised so that a system cannot receive more than it's total
perceptual capacity and it cannot transmit more than it's total
internal signal power. Hence for each row of M we have 
and
for each column of M we have 
.
However it can be useful to have systems that are effectively all
seeing, or systems that are all speaking. An example of
the later might be the mass media, where given only a small fragment
of information it propagates and spreads that information thus
amplifying it immensely.
There is also a related discussion on Overlap Vectors in the context of Metaphysical SMN.
Here I will illustrate some very simple models to show how the above paradigm can be used to develop working simulations. One may construct system models using four general techniques which are described below. One will notice that as one attempts to create, analyse and simulate these models by hand that they are quite complex and one may wonder, why would one choose to do it this way? The reason for the complexity is that all of the causal connectivity has been made explicit, whereas usually, much of the causal connectivity is implemented within the mind of the person who is doing the calculation or else by arbitrary computer code that connects the various calculations together into a whole. The benefit of making it all explicit is that it is far more amenable to generalised, automated implementation within a single computational methodology. One need not write arbitrary computer code to connect up the various equations and shuttle the information about, it is all explicitly contained within the one mathematical model. This allows for the modular development of an idiom of simple model components that can easily be combined and connected up to create more complex models and so on up to models that are so complex that they could not have been constructed using ad hoc methods. Then once the model has been constructed one simply cranks the handle and out comes the simulation.
Furthermore, one need not construct any of these models by hand, these initial or naïve examples are shown simply to illustrate the underlying models and how they relate to the scenarios that are being modelled. We will see later that there are automated methods for constructing these models, one can use a simple graphical interface where one can drag system icons about and connect them up and define their properties or one can use script based methods, similar to computer programming languages. Furthermore, once one has defined the transcendent structure of the model using these methods one can then specify the types of empirical behaviours that one desires from the model. Then an automated computer algorithm can derive the causal equations and produce a single optimised SMN model that possesses the required underlying transcendent structure and which exhibits the desired empirical behaviour. As the systems that we are dealing with become increasing complex these modular and automated methods will become indispensable.
This is directly analogous to the development of computer animation technology. Prior to their invention one might look at a specification of the detailed data structures and complex modelling methods that would lie deep within a 3D modelling program and that would implement its computational functionality. These specifications might describe simple examples such as how one would represent a simple sphere and cause it to move with uniform motion, just to show how the methodology works. One could easily look at such a description and think, how complex, I could just type up a bit of code and produce a sphere on my computer screen and that would be much quicker and simpler than all those abstract data structures and complex methodologies. However these methodologies are amenable to automation and may be encapsulated behind a graphical user interface and then one may produce whole motion pictures that would have otherwise been impossible by simply typing ad hoc code for all the various figures and scenes and special effects. They have all been subsumed into the one computational methodology.
The data structures and methodologies presented in rudimentary form here could be developed and encapsulated within a program or a range of programs that would allow for the development of software systems of incredible complexity and these can be used to design and analyse a vast range of systems that would otherwise have been beyond our reach due to their subtle and intricate complexity. It would allow us to eventually comprehend and create systems that have complexity equivalent to that of organic systems rather than mechanical systems.
The most direct and labour intensive method is to design a system using traditional system modelling methods and then to translate that into an SMN model by hand, this is illustrated in the following few examples to illustrate the details of the modelling methodology, and then more advanced methods for generating system models will be illustrated in further examples.
Consider a simple classical particle in one dimension. One may
apply a force to it in the positive or negative direction thus giving
it velocity and causing its position to vary. Its principle empirical
state variables are 
or 
and
the basic dynamical equations 
;
and
.
We may express the state vector as 
using ,
where m is the particles mass and T indicates transpose
since it is a column vector. The particles behaviour can be described
using the following causal equations, which are derived from the
above equations, where Δt is the simulation time step.
and 
and 
From these we can simply construct the system matrix in the following form:
where:
the inner product of the first row and the SV corresponds to the x equation,
the inner product of the second row and the SV corresponds to the v equation
and the inner product of the third row and the SV corresponds to the F equation.
The F state variable is purely a handle by which we may interact with the object and push it about, hence its value is determined externally.
One simulates the particle by computing successive iterations of
the matrix multiplication with the state vector. Each iteration
produces a new moment in time for the simulation and describes a
complete state of the particle in that moment. One may verify that if
the force is zero the velocity remains constant and the particle
moves by 
with
each iteration, so if the velocity is also zero the particle remains
stationary. If the force is applied as an initial impulse it is
initially non-zero so the velocity is perturbed but then remains
constant from then on. If the force is maintained at a non-zero value
by some external system then the velocity varies with each iteration
and the particle accelerates.
This is an extremely simple example and the SMN methodology and doesn't add much to the traditional treatment other than to combine it into a single matrix.
Also see the source code for a simple SMN software model of this system.
This is related to the second method of representing empirical values using complex computational data. This example will illustrate some of the details of this approach.
Consider a simulation space within which there are two particles, both at the origin. There is then an equal and opposite impulse force that propels them apart along the x axis with constant velocity. First we consider the empirical values required.
The velocity state variables are constant and the position state variables grow in magnitude but have opposite sign. If these are represented using the second method then each state vector element is a complex FD state variable z and the empirical value is determined by v = Re(z2).
Hence the position state variables begin with balanced representational power in the real and imaginary components thus producing zero valued empirical quantities and these then overbalance with one variable going entirely real whilst the other goes entirely imaginary. At this point the simulation has reached its representational limits and cannot proceed, but can only be reversed.
If one considers the representational power within the state vector throughout the iterations, for the F, v1 and v2 state variables there is no variation other than for the first impulse in which power is injected into the system from whence it redistributes. For the position variables x1 and x2, as one variable shifts its power to the real component the other shifts its power to the imaginary component, thus the power remains constant on the whole and only re-distributes between them. So each variable may vary its empirical value but only in relation to the other.
Thus in this context the total representational power within the state vector sets the limits of the empirical context. The movement of this power from variable to variable and from real to imaginary components implements all of the empirical dynamics that occur within the simulation. The movement of this power is constrained by overall conservation laws and this gives rise to dynamical symmetries within the simulation.
The above particle model is defined in an inertial reference frame
and cannot exhibit relativistic phenomena in moving reference frames,
such as time dilation or length contraction, however with some simple
modifications it can. Firstly, instead of using v one uses
where 
and 
and
vf is the velocity of the moving reference
frame. This particle momentum is lorentz invariant and applies
in all reference frames.
Furthermore, instead of 
we
use 
and
this implements the time dilation effect; as 
so
the simulation time step 
and
time seems to come to a standstill because with each iteration the
simulation time progresses by only an infinitesimal amount.
As for length contraction; the state variables used here are
finite and discrete FD
variables so 
where
rx is an integer index into the state
variable's information space and dx is the quantisation of
that information space. However, instead of dx one could
use 
so,
as and 
so
all lengths seem to contract.
Hence the state vector is 
and
the system matrix has the form:
where the factor
is subsumed into the FD variable. This is all just in one dimension
and in three dimensions one experiences length contraction only in
the direction of motion.
Of course, these ideas are just indications of how one might approach the problem, they are not meant to be a complete and exhaustive analysis; that is beyond the scope of this discussion.
Consider a massless idealised spring with characteristic
equation 
where
k is the spring constant that determines the response
of the spring to Δx which is a displacement of the spring
from equilibrium. Here the subscript p indicates that this
force is associated with the spring's internal potential
energy, this distinction will be useful later.
This diagram illustrates such a spring centred on the x
axis with masses m1 and m2
attached to each end. The equilibrium positions of the masses are
such that 
.
Each of these masses are modelled as a simple classical particle as
illustrated earlier.
The force Fp is calculated from the mass
positions x1 and x2
as 
so
if m1 and m2 are in
their equilibrium position the force is zero; if either or both m1
and m2 are pulled outward, thus stretching
the spring then 
so
the force is negative and the spring pulls them inwards and if either
or both m1 and m2
are pushed inwards, thus compressing the spring then 
so
the force is positive and the spring pushes them outwards.
So we have 
where
L is an explicit constant state variable so that it can
be fed into the force calculation. The rest of the system matrix is
composed of two simple classical particle models where the position
state variables contribute to the force calculation and the force Fp
then drives the particles into motion. There is now no explicit
external handle on these particles by which to perturb them
but one can manually displace their positions within the state vector
to set this model into motion.
The inter-connections between the model components are achieved simply by overlapping the rows or columns of the matrix associated with the appropriate state variables, thus the information is directed through the correct causal channels and the overall system is animated. This is possible because all model components are represented using the same underlying mathematical methodology and this allows for simple modular construction of high level systems out of lower level system components by simply combining matrices and overlapping rows and columns. Hence, in the context of a graphical system design suite, one could select from a range of components, arrange them about and connect them up by drawing lines between them, then specify the properties of the components and their inter-connections and the underlying SMN engine will represent all of this using matrices which it combines together to form the overall system, which can then immediately be simulated or executed if it is a piece of SMN software.
The resulting system matrix is:
where
the corresponding state vector is 
Here we see that a compression of the spring creates a positive Fp force which causes the m1 mass to move in the direction of negative x and the m2 mass to move in the direction of positive x thus providing a restoring force. And vice versa for a stretched spring.
Also see the source code for a simple SMN software model of this system.
All of the above examples have been classical, i.e. they rely on state variables with distinct well formed values. However SMN can model quantum systems equally well. In a quantum system model each state variable becomes a probability distribution (PD) over all possible values of that state variable so the state vector becomes a vector of PD's and the system matrix becomes a transformation matrix that operates on the PD's. Things become conceptually more complex here since we are used to thinking in terms of classical reality but the underlying computations are still quite simple.
In order for two separate state variables to interact their
separate PD's must be transformed into a single compound PD.
This can be achieved using the direct product operator 
.
For example, if we have two state variables a and b and
each may exhibit the value 0 or 1 then there are two
PD's that can be combined into a single compound PD as follows: 
This compound PD can then be operated on by a transformation matrix that produces a new compound PD that can then be resolved into separate PD's once again.
When I first developed these methods I didn't know about the existence of the direct product operator so I developed my own matrix methods with which to combine and separate the PD's. It has been a common phenomenon throughout this work that I have had to improvise in countless ways and I generally discover at a later date that those things have been developed elsewhere, although often slightly differently. Upon such a discovery I try and assimilate those standard methods into my work as much as possible however I still don't know of a standard method for separating the PD's within the context of the SMN computational pipeline and the direct product operator is subtly different from my own methods so for now I will continue to use my own methods, but others may know of more standard techniques and may wish to inform me and/or adapt things themselves.
I call them the 
operators.
The difference between the 
operators
is that the direct product is an operation on two separate vectors,
each of which is a PD and it produces a single vector that is a
compound PD, whilst the Ψ operator is a matrix that is
associated with a non-standard matrix multiplication operation
that is applied to a single vector that contains both input PD's in
series and which produces a single vector that is the compound
PD. I.e. using the above PD's (a and b) the state
vector is [ a0 , a1
, b0 , b1 ]T,
hence I say they are in series. The matrices
both have a form that depends upon the structures of the separate
PD's. Using the two PD's introduced above the Ψ matrix is:
And the matrix multiplication is quite non-standard; each row is combined with the SV but then only the non-zero matrix elements are multiplied with the corresponding vector elements and these are then multiplied together instead of being summed.
When applied to the PD's in series the result is the same as the direct product operator applied to separate PD's.
Uses
standard matrix multiplication and for the two PD's introduced above
it has the form:
so 
Now we have introduced the basic machinery of a quantum SMN model, lets explore a couple of simple examples of logic gates just to observe how the model is computed.
For the first example I could define a as the input and b as the output so since the state variables a and b are not required to be mixed for the calculation (they are separate input and output channels that don't mix) I do not need to combine them into a compound PD and I can apply a system matrix directly to the series PD's.
For the logic gate I will implement a purely quantum logical
operation that has no classical analogue; 
(the
square root of NOT); thus two of these operations in series are
equivalent to a classical NOT gate, so first lets consider the
effect of a NOT gate.
If a = 0 then the PD is [1, 0], i.e. the probability
p(a=0) = a0 = 1 and p(a=1) = a1
= 0. Thus NOT a = 1 so the resulting PD is [0, 1].
These can be thought of as unit vectors and the NOT gate
rotates them by 90o thus since the effect of two 
gates
is equivalent to a single NOT gate it rotates the unit vector
half way producing a PD with the general form 
but
if this was the case then 
so
these must actually be the real components of complex values and each
is rotated through the argand plane so we have 
.
Note that this sums to one, which is a requirement of any PD, meaning that the state variable definitely has some value although exactly which may not be uniquely defined. This is also an example of complex computational data giving rise to real valued empirical data; note that a0. a0* = ½.
This system matrix is determined by considering the various
constraints such as the fact that the input should remain unchanged,
hence the structure of the top two rows of the left two columns; the
initial state of the output is irrelevant to the calculation, hence
the right two columns; the result in the example case just described
should be reproduced, hence the bottom two elements of the first
column; and when a similar but opposite case with
[0, 1]
as the input is considered we require the bottom two elements of the
second column.
Hence we have 
where if the input PD is [1, 0] then the resulting PD
is 
and
if this is fed in as the input it results in the PD [0, 1].
Whereas if the input PD is [0, 1] then the resulting PD
is 
and
if this is fed in as the input it results in the PD [1, 0].
To illustrate another possibility, I will implement a logical operation that requires two inputs and one output. In this example both inputs need to be merged into a compound PD so that they can be considered together when producing the output. For everything to be totally explicit we require two inputs a and b and an output c thus the separated SV would have six elements and the compound SV would have 23 = 8 elements (assuming a, b and c are all binary state variables) so Ψ is an 8x6 matrix and Ψ-1 is a 6x8 matrix. However since we are doing this by hand and I would like to utilise the Ψ and Ψ-1 matrices defined above I will take a shortcut and also take the opportunity to illustrate the possibility of such a shortcut. I will reuse the inputs as outputs, thus we only need the state variables a and b and the 4x4 matrices defined above. If the reuse is done carelessly it can corrupt the overall causal connectivity between systems; (it can be a bit like crossing wires in a circuit). In this respect explicit state variables are much safer, but in certain cases it can be more efficient to simply reuse state variables so that the input and the output are represented by the same state variable.
In doing this I can actually implement two logic gates in one
since there are two available outputs. So for the first logic gate I
will implement 
and
for the second gate I will implement 
.
These are going to take the compound PD as the input SV so we need a
system matrix that will transform the compound PD into a new compound
PD that represents the output states of both logic gates.
The system matrix along with the compound SV is shown to the right:
I will explain the thinking behind the construction of this system
matrix. Consider the matrix column by column from left to right and
the compound state vector from top to bottom. Firstly, the top state
vector element represents the case where the input was [a, b] =
[0, 0], and the output should be a = 0 NAND 0 = 1
and b = 0 XOR 0 = 0 so we want the output to be
[a, b]
= [0, 1] hence a1. b0
hence the 1 in the third row of the first column. In this way
each column samples a particular input and each row in that column
produces a particular output. For the second possible input we
consider the case [a, b] = [0, 1], and the output should be a
= 0 NAND 1 = 1 and b = 0 XOR 1 = 1 so we want the
output to be a1. b1
hence the 1 in the fourth row of the second column and so on.
From start to finish the overall computation is shown below, starting from the series PD, this is transformed into the compound PD which is then operated on by the SM, which is then resolved into a series PD again.
= 
=
= 
And one can compare this final result with the truth tables to see that the a state variable represents the NAND logic operation where a = 0 only in the case where both inputs are equal to 1 and a = 1 for all other inputs. Also we see that the b state variable represents the XOR logic operation where b = 0 when both inputs are the same and b = 1 when they are different.
NAND Truth Table
|
a |
b |
a NAND b |
|---|---|---|
|
0 |
0 |
1 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
0 |
XOR Truth Table
|
a |
b |
a XOR b |
|---|---|---|
|
0 |
0 |
0 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
0 |
In describing this example I have only mentioned cases where the inputs and outputs have classical PD's in the sense that a PD is either [0, 1] or [1, 0] but the computation works equally well if one uses quantum PD's such as [0.5, 0.5] or [0.2, 0.8] or even complex values as well, so long as the total PD sums to one.
For completeness I include here the source code to an example of a NAND system implemented using SMN in Euphoria, however understanding this code is not straight forward and requires information provided later regarding the software implementation of SMN and also a detailed example of a drink machine. Here is the source code for a simple SMN software model of this system.
This is a more complex example that provides a more complete example of a quantum SMN circuit. It contains three NAND logic gates where the inputs b, c, d and e are processed by B and C and their result is then combined by A into a single output a. This example illustrates some of the data routing that occurs in a quantum SMN circuit, this requires a little extra machinery to combine separate PD's into a series format and to separate them again; this is achieved using matrix input filters. This example also illustrates another possible variation for the structure of the SM where each of the three NAND operations reuses one state variable for the output and doesn't use the other state variable at all for output so the SM can be further simplified such that it takes a four element compound PD and produces a two element compound PD. Thus we use 2x4 system matrices, which are non-square, hence non-hermitian and cannot be raised to higher powers, but in this case that doesn't matter. Indeed the overall SM is still square and hermitian and can still be raised to higher powers even though the sub SM's cannot.
All global inputs and outputs are represented explicitly here so the general structure of the matrix is:
A # # 0 0 0 0 0 : internal
0 B 0 0 # # 0 0 : internal
0 0 C 0 0 0 # # : internal
# 0 0 a 0 0 0 0 → output
0 0 0 0 b 0 0 0 ← input
0 0 0 0 0 c 0 0 ← input
0 0 0 0 0 0 d 0 ← input
0 0 0 0 0 0 0 e ← inputWhere the diagonal elements are all zeros so they are labelled for ease of reference. The actual system matrix is shown below in the form of a table for clarity:
|
A |
[10] Ψ-1 [0001]Ψ [01] [1110] [00] [00] |
[00] Ψ-1 [0001]Ψ [00] [1110] [10] [01] |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
x0 |
0 |
|
0 |
B |
0 |
0 |
[10] [01] [00] [00] |
[00] [00] [10] [01] |
0 |
0 |
0 |
b0 |
0 |
0 |
|
0 |
0 |
C |
0 |
0 |
0 |
[10] [01] [00] [00] |
[00] [00] [10] [01] |
0 |
d0 |
0 |
0 |
Ψ-1 [0001]Ψ [1110] |
0 |
0 |
a |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
a0 |
|
0 |
0 |
0 |
0 |
b |
0 |
0 |
0 |
b0 |
0 |
0 |
0 |
|
0 |
0 |
0 |
0 |
0 |
c |
0 |
0 |
c0 |
0 |
0 |
0 |
|
0 |
0 |
0 |
0 |
0 |
0 |
d |
0 |
d0 |
0 |
0 |
0 |
|
0 |
0 |
0 |
0 |
0 |
0 |
0 |
e |
e0 |
0 |
0 |
0 |
On the left is the System Matrix and the shaded columns on the right show the four successive state vectors displaying the results of the three iterations that are required to move from initial input to final output.
The left most SV being the input state vector containing four input state variable PD's.
The second and third rows of the SM contain input filters that combine two separate PD's into a single series PD, these are seen in the second SV (second shaded column) and these are the intermediate states of the B and C systems.
This second SV is then operated on by the first row of the SM where for each system B and C an output filter is applied to produce the outputs for those systems. The Ψ operator transforms the series PD into a four element compound PD, which is then transformed by the 2x4 NAND system matrix into a two element compound PD, then the Ψ-1 operator transforms this into a two element PD (in this case the Ψ-1 operator is a unit matrix that does nothing since a two element PD is equivalent to a two element compound PD, both are simply binary). This has thus produced the outputs for both B and C, which are now processed by the input filters for system A which combines these two outputs into a single series PD shown in the third SV. This is the intermediate state of the system A.
This third SV is then processed by the fourth row of the SM and the intermediate state of A is operated on by the output filter. Once again the Ψ operator transforms the series PD into a four element compound PD, which is then transformed by the 2x4 NAND system matrix into a two element compound PD, then the Ψ-1 operator transforms this into a two element PD and this has thus produced the output for system A which need not be transformed further but simply presented in the fourth SV.
To simplify things we could have started the simulation with the second state vector and only used the top left 4x3 sub matrix to perform the computation, but I showed the rest to be explicit about where the data has come from. If the whole of the above matrix was actually a sub matrix within a larger matrix then the explicit input state variables would actually be other system's outputs. In the flow of a simulation the initial input iteration is a prior output iteration of another system and the final output iteration is a later input iteration of another system so each of these is half associated with the NAND system and half associated with other systems. Hence this is really a two step process from input to output which makes sense since there are two tiers of systems through which the information must flow.
This whole system could also be pre-computed into a compound SM that performs this operation in a single iteration however in this example we wanted to step through it to see how the data is routed and transformed in detail.
For completeness I include here the source code to an example of a Two Tiered NAND system implemented using SMN in Euphoria, however understanding this code is not straight forward and requires information provided later regarding the software implementation of SMN and also a detailed example of a drink machine. Here is the source code for a simple SMN software model of this system.
In regards to the earlier analogy of 3D modelling programs, the following will illustrate how to use the system modelling methodology from a graphical users perspective. This gives a vague indication of how it might look and function in practice.
Systems can be defined as networks of interconnected systems and these can be displayed graphically, a good example of this is topic maps{{link}}. Here I have defined an empirical object as a system with three primitive sub systems.
A particle is a type of object and so is a spring, these types form an object oriented class hierarchy where particle and spring inherit from object.
A spring is an object so it has x, v and F state variables, and it has one object at either end, thus two more sets of x, v and F state variables, plus the spring has its own internal spring force Fp and an equilibrium length L. Thus there are eleven state variables required to totally represent a spring with two masses. Earlier we did it with only six state variables which is the minimum.
To illustrate how it is done I will reduce this complete model down to the simplified model illustrated earlier. This reduction can be automated.
First we remove the unnecessary state variables by simply removing their associated rows and columns from the SM and SV.
Then consider the information flows or causal connectivity between the remaining state variables. I.e. the i'th row represents the i'th system's inputs, thus if the j'th column had a non-zero element in that row then there would be a line pointing from the j'th system to the i'th system. We see that there are three force state variables which can all be combined.
In this case they are combined by simply overlapping their rows and columns so they are all the same system. This is possible because the information is not transformed along the way. If there were other transformations that were being compressed there is a more general method. One isolates the sub matrix corresponding to the relevant interaction channels and then raises this to a higher power so that the multiple step process is compressed into a single step process. In this way individual paths within a causal structure can also be selectively compressed.
I will describe this compression method in a little detail. The
causal pathway that is to be compressed cannot have any inputs along
its length, this is equivalent to it being periodically closed.
Consider the pathway that traverses 
,
one can either calculate the squared matrix which represents all two
step interactions and consider the 
interface
element. Or if the overall matrix is very large one can take the rows
and columns associated with these state variables and isolate them
out and combined them into a sub matrix which is then raised to a
higher power so that its transformation occurs in a single iteration
and the entire path from start to finish is emulated by a single
step.
{{detailed matrix mathematics run through pg 193-6 of 2005/06/22}}
Once these methods are automated one could then, for example, construct arbitrary networks of springs and simulate them. To join two springs they only need share a common mass on each of their ends and they are thereby joined by this mass, so these rows and columns can overlap. One could also build up a complex idiom of general systems of all kinds that can be combined in ways so as to produce any desired high level systems we require.
One may also use scripts to define, store and create SMN models; either in conjunction with other model construction methods or alone. These would be much like an augmented version of C++ or some other programming language; indeed since SMN is a low level implementation of general computation it can easily manifest any kind of computational process, thus any programming language could conceivable be read in by an appropriate interpreter and converted into an SMN model.
There are deep parallels between SMN and the object oriented approach...
{{I will later explore these parallels}}
Transcendent causal structures within the SM give rise to empirical behaviour or patterns of activity within the empirical context and it turns out that it is relatively simple to reverse this process. Beginning from a representation of the desired empirical behaviour one may derive the particular causal matrix that produces this behaviour. One can represent an example of a type of empirical behaviour and from this one can derive the system matrix elements required to implement this behaviour, not just in that particular instance but in general so the general principle has been abstracted out from the particulars. By this I mean that one may, for example, provide an empirical representation of a particle moving from point A to B with constant speed, but what we teach the SM is how to simulate a particle moving with constant speed. The points A and B are irrelevant particulars and the ability to move with constant speed is the general principle that has been extracted.
This method was developed by considering the application of the
linear algebraic methods of eigen analysis to system matrices. In
eigen analysis we consider the equation 
where
λ is a scalar multiplier and we solve it by considering the
equation 
.
Thus we are looking for a condition where the new vector is a simple
scalar multiple of the previous vector, which is a simple example of
an empirical behaviour represented by two successive SV's, but in SMN
the SV contains all kinds of state variables and there is no simple
scalar multiplier that applies to all of these. Thus we could
consider a more complex situation where there is a scalar multiple
for each state variable in the SV, thus 
.
Or one can do away with λ all together and simply consider
the equation 
directly
which turns out to be easier for this purpose.
Another difference with simple eigen analysis is that the matrix is not given and we wish to determine the matrix from the vectors. Thus all the matrix elements are initially undefined, however if all of them are undefined we cannot solve the situation uniquely, thus we need to determine which are the zero and non-zero elements. This is equivalent to determining the basic structure of the matrix or the causal connectivity of the system, i.e. which state variables or sub systems relate to which. We needn't define how they relate, that is what we wish to calculate, we need only define if they relate. One could use the graphical or the script based method to define the relations by simply drawing connections between them, but one need not define the exact properties of the relations since that will be derived from the desired behaviour; at this stage we are just defining the overall structure of the system.
Thus, if one can produce detailed descriptions of a system's key behaviours and one also knows the system's general structure, then that is enough information to produce an SMN model of that system that can simulate or implement that system in full detail and in any context. I will illustrate this method by deriving a simple classical particle, which was described earlier.
There are position, velocity and force state variables where force
effects both position and velocity; velocity effects itself
(persists) and position; and position effects only itself (persists).
These define the three columns of the SM from right to left
thus 
and
we then derive the values of the various elements. We begin from the
simplest scenario and work toward the most complex, in this way we
build up the various layers of causal connectivity within the system.
Hence we first consider the case of a stationary particle.
Let v0 = [1, 0, 0]T and v1 = [1, 0, 0]T thus nothing changes. Hence
thus m11 = 1 which allows a particle to maintain its position in the absence of any other influence.
Let v0 = [1, 1, 0]T and v1 = [2, 1, 0]T thus the particle moves by one unit. Hence
thus m22 = 1 which causes the velocity to maintain its value in the absence of any other influence, and m12 =1 which causes the velocity to influence the position in the desired manner.
This behavioural requirement has defined the value of the time step as Δt = 1 since m12 = Δt.
Let v0 = [0, 0, 1]T and v1 = [½, 1, 0]T thus there is an initial impulse force that perturbs the particle's position and gives it a constant velocity. Hence
thus m13 = ½ which causes the force to influence the position, and m23 = 1 which causes the force to influence the velocity.
Thus we end up with 
which
is the system matrix that corresponds to a simple classical particle,
where the values of Δt and m (particle mass) have been
implicitly determined by the empirical behaviour.
This learning process extracts out the general causal structure without regard to the particular details, i.e. it distils the underlying information pattern. This is related to metaphor, analogy, modelling, simulation, representation, perception, knowledge and learning in general.
This process may be automated and used to dynamically generate system models based upon observed empirical behaviours, therefore a perceptual system may observe phenomena and extract out the general principles, thereby internally modelling the phenomena and developing an internal representation of the system and thereby learning about the empirical system. In this way an SMN based perceptual program could intelligently observe and learn from its environment; not just the particulars, of which there are an infinite number, but the general principles; thus it may distil an understanding of its environment.
See SMN and SCSPL for the details of recent developments in this direction.
SMN can be used as a general information processor that goes beyond the limitations of linear matrices. For example, each matrix element, instead of being a numerical value that is multiplied with a state variable, could instead be a general function (either mathematical of arbitrary software) and the state variable could be any appropriate input data for that function. Thus the pairwise convergence of an SM element and an SV element, such as mi j . vj is actually a function being applied to input data and producing a resulting output.
If one raises such a matrix to a higher power the elements become sequences of these functions m1 . m2 . m3 ... and so on. When this is supplied with the input data on the right, this then implements a computational pipeline where the right most function processes the input and produces an output, which is then processed by the next function and so on until a final output is produced. When one raises a linear matrix to a higher power all the m terms, which represent the steps in a causal sequence, compact down into a single term since they are just numerical values that can be multiplied together. However when the elements are arbitrary functions, then the causal sequence compacts down into a sequence of functions that needs to be resolved at run time when the input data becomes available. Thus raising higher powered linear matrices can result in significant performance gains, whereas for non-linear matrices there isn't such a drastic increase in efficiency. Although one still benefits from the use of higher powered matrices in the form of organising and optimising the causal structure of a system, and of finding compact representations for complex non-linear systems.
When the matrix can contain arbitrary functions, this allows any form of computation to take place within an SMN context and SMN will take care of all of the information logistics and will coordinate all of the functions and data within a single underlying framework thus allowing for the development of highly complex mathematical operations or software programs. These may be built up in a modular manner using graphical or script based techniques, and the models may be visualised, analysed, simulated and tested as they are being constructed. Once they are constructed they can be effortlessly integrated with other SMN based systems and easily integrated with any other systems via standardised SMN interfaces.
In this non-linear conception of SMN it can be useful to consider a functional description of the behaviour of SMN itself. There are pairwise functions P(mi j, vj) that take an element of the SM and an element of the SV and combine them, either by multiplication or by using the state data as input to a function represented by mi j. Then there is what I call aggregate functionsA( ) which take all of the results from the pairwise functions associated with a system's inputs (a row of the SM) and combines these into a single result. For example, the aggregate function used by standard matrix multiplication is summation of all the pairwise results and the aggregate function used by the Ψ operator (above) multiplies all the pairwise results. Then there is a global function G( ) that coordinates the processing of the successive iterations.
In rough pseudo code we get:
G(M, v, t) {
for all i do{
v[i, t] = A[i](M[i], v)
}
t = t + 1
}where there is an aggregate function A[i]( ) for each row and this function takes two inputs; the i'th row of the SM and the SV.
This aggregate function is applied to each row and this constitutes one iteration of the simulation.
One could also implement non-ergodic systems by allowing the matrix elements to evolve over time, normally this is done within the SMN simulation space where there is an ergodic SMN foundation that creates a virtual non-ergodic context. However one could implement it explicitly by inserting into this global function an extra step or function just prior to the increment of the time variable. This could be called an evolution function E(M, v), that varies the values of the matrix elements depending upon the state of the SV, which represents the states of the various empirical systems. For more on the evolution function refer to comments regarding 'modFD' in this discussion and also see the schematic description of the full non-ergodic SMN algorithm. There are likely to be many other variations that produce different types of SMN implementations, I have not explored these possibilities to any depth.
The aggregate function can be roughly described in pseudo code as:
A(row, v) {
for all j do{
append_to_sequence( P(row[ j], v[ j]) )
}
process_sequence()
}The pairwise function is applied to each element of the SM row and SV, thus producing a sequence of results. Each pairwise function results in an input from a particular system and the sequence therefore represents the total input for the system associated with that row. This input can then be processed in any arbitrary way thus producing an output or intermediate state for that system.
Before exploring a detailed example of the use of SMN for the creation of software systems using arbitrary functions and arbitrary data I will take a detour and discuss a couple of issues related to the software implementation of the SMN algorithm itself. These will help one understand the details of the following software example and the related source code.
The matrices are a conceptual way of organising all the data but they are not the most efficient way of implementing SMN in software, however the software is intimately related to the mathematics. The matrices contain many zero terms that not only require representation but also require calculation, but in software we can use sparse matrix methods to avoid representing zero terms in sparse matrices (but in dense matrices direct representation is used) and we can use energy flow processing or bottom up processing to avoid unnecessary calculation of terms.
In a typical SM there can be many zero terms stored within the matrix and many null multiplications that represent closed interaction channels. In the mathematical formalism all of these zero's need to be stored and multiplied explicitly, however in general this is not very efficient for large modular systems where there are many zero terms that separate non-interacting sub systems, indeed for a highly modular system the matrix is composed almost entirely of zero terms.
Sparse matrix methods provide a formalism within which one can represent a matrix such that only non-zero terms are stored. The Sparse System Matrix data object stores some meta data such as the dimension of the matrix, then there is a list of Row objects and a list of Column objects. Each row or column object contains an index which identifies which row or column it is and it also contains a list of Elements. In a row object the elements are data objects that contain a column index and a pointer to the actual data that is effectively stored in that matrix element. In a column object the elements are data objects that contain a row index and a pointer to the actual data that is effectively stored in that matrix element. Using this configuration one may access the matrix elements either by row or column and one can easily extract whole rows or columns from the sparse matrix, which is required during the process of energy flow processing discussed next.
To see a software implementation of this refer to either of the
following:
This source code file SparseSM
includes the syntax highlighting to make it more readable, this is
for anyone who just wants to look at the code without having to
download and set-up the Euphoria program in order to get the syntax
highlighting.
This file SparseSM.e
is the straight source code for execution using Euphoria.
In the context of the mathematical implementation of SMN the entire matrix must be processed with each iteration. In regards to a simulation universe this is equivalent to the entire universe being processed for every simulation moment. But if the simulation universe was such that is was almost entirely static except for a small region of activity then the entire universe still needs to be processed with each moment in order to process the small region of activity. However in such a universe most of the states in the universe remain unchanged so throughout most of the universe one has expended effort to repeat the same calculations using the same inputs only to end up with the same result. If the inputs are unchanged one could simply retain the prior states since these are still valid present states, so one can implicitly step a static universe forward in time by doing nothing other that retaining the prior states; this is far more efficient.
But how does one know which interactions to recalculate and which to simply carry forward? This depends upon the concept of energy; energy is the flow of influence, which is the flow of information, which in a state vector shows up as discernible difference or changing state. So if a state changes in a discernible way, then all systems who have that state as an input need to be recalculated to re-sample the new state and thereby produce new outputs. If the new input results in changed outputs then downstream systems also need to be reprocessed, this leads to a chain reaction or a flow of energy through the system model. If the output is the same, even if the input has changed, the flow peters out and the system returns to a quiescent state in which the model remains unprocessed and the simulation universe is static.
Because the system model is stored within a succedence matrix one can easily determine the down stream systems for a particular system that has changed state, one simply looks for matrix elements in that systems column. All these need to be re-calculated.
To see a software implementation of this refer to either of the
following:
These files ergodicSysMSMN
(release 1) and SMN (release 2)
include the syntax highlighting to make them more readable, this is
for anyone who just wants to look at the code without having to
download and set-up the Euphoria program in order to get the syntax
highlighting.
These files ergodicSysMSMN.e
(release 1) and SMN.e (release 2) are the
straight source code for execution using Euphoria.
In this example I create a model of a drink machine using matrix elements that are functions which are fragments of Euphoria code which process the data whilst SMN provides a general context within which the data is routed from function to function. Thus SMN serves as a general information control system, that routes the data between the various functions and thereby integrates all of the various sub systems into a coherent whole. It animates the causal network and thereby produces a meta system transition.
Note: I have used “Euphoria” because it is a very fast, powerful and user friendly programming language, and it's almost free although one must pay roughly $30 US in order to be able to debug code with more than 300 or so lines. So if anyone knows of a free programming environment that is suitable I would appreciate knowing about it for future development. Furthermore, Euphoria provides a dos based text editor with syntax highlighting but I have found that the best method is to use “Code Genie” which is an excellent free text editor specifically for programming usage and I have created a syntax highlighting file that can be used to provide Euphoria syntax highlighting within it. This can be downloaded here if anyone needs it; it's not perfect but works quite adequately.
Here we will build a conceptual model of the target system, translate that into an SMN model then simulate it and observe its behaviour over time. A drink machine is a system that is simple, intuitive, has clearly defined sub systems with simple relations (since it is an engineered system) and has various inputs and outputs to interact with. This is only a very crude example used to illustrate the general operation of the method, and furthermore, this would normally be done via a graphical interface, however here we explore the intricate details of the low level implementation, thus it will seem unnecessarily complicated for such a simple model but one would not normally program in SMN by manipulating the matrices manually, just as one does not create computer animations by manipulating the underlying data structures manually. But since there is no graphical interface developed as yet and I wish to illustrate how the details work so that perhaps such an interface can be built, I will go through the low level details manually. Only those interested in SMN software development need wade into these details.
The general behaviour of a drink machine is such that it stores drinks and distributes them when a certain price is paid and a selection is made. The model we will consider here is a simplified drink machine but complex enough. It is able to run out of coins or drinks, it returns change, it has a coin return button, only the lights next to those products which are available are lit. Product availability depends upon the drink inventory and upon how much money has been entered, if the amount is less than the price the item is unavailable.
As one approaches the machine it is in a dormant state, one enters coins one at a time, the machine adds them up into a total and as the required amount is entered the lights turn on beside the drink selection buttons. If one presses a button that is lit the corresponding drink is delivered in the drink chute and the change, if any, is delivered in the change chute and the machine returns to a dormant state.
The main objects or information items in the system are coins, drinks, button selections, light activations, coin totals, drink_prices and an amount of change. A coin is an object with a value from the range { no_coin, 5c, 10c, 20, 50c, $1, $2}. A drink is an object with a value from the range {lemonade, cola, juice, water}. A button is associated with a button id which is an id number that is communicated to the process logic upon the event of a button press. A light is associated with an activation state that can be either {on, off} or {0,1} and is formed into an availability vector for all the lights. The objects coin_total, drink_prices and change are all of type coin.
The main functions of the system are accept coins, accumulate coin total, maintain a coin reservoir, determine product availability, provide and respond to a selection, maintain a drink reservoir, deliver drinks, calculate change, deliver change and return coins. Note; coin return can be implemented as a zero priced null product.
The main sub systems or parts are 'coin', 'logic', 'selection' and 'drink'. The coin sub system receives coins, maintains a coin reservoir, accumulates a total, calculates change and dispenses change. The logic sub system determines what drinks are available depending on the coin total, the drink prices and the drink inventory and also responds to selections by verifying that it is available, sending commands to dispense a particular drink and to calculate the change. The selection sub system displays a selection of choices and receives or interprets a selection event. The drink sub system dispenses the appropriate drink when prompted to by logic.
The coin sub system interacts only with the logic sub system to communicate the total and to receive change delivery requests. The selection system interacts only with the logic sub system to know which lights to illuminate and also to communicate any selections or button press events. The drinks sub system interacts only with the logic sub system to know which drinks to dispense. So the logic system is a centralised control system that takes the coin, selection and drink sub systems and integrates them into a unified whole. The SMN system is the transcendent control system that is animating the empirical primitive systems but the logic sub system is the empirical control system that is animating the empirical sub systems.
All
of the above description is represented in the above “Drink Machine
System Diagram”. This diagram illustrates the outer system boundary
and its interfaces, the four sub systems and their next level sub
systems and the information flows between these. For example, one can
see the information flows from coin_total and drink prices and
drink_reservoir to availability, this information is then used to
determine an availability vector that has a zero or one for each
possible item and this information is sent off to the button lights
and to chosen, which is the logic system that determines if a
selection is valid and if so acts upon it.
The diagram above of the drink machine describes a top level information space, each entity is a point in this space and the relations between these entities defines the topology of this top level metric space. This defines a network of information channels or a field of interaction.
Each point in this field of interaction is occupied by a system. E.g. the coin_slot system occupies a point in this field and due to the topology of this field or network of information channels, this coin_slot is influenced by information flowing from 'coins' and it influences the other systems 'coin_adder' and 'coin_reservoir'. There is no information channel directly connecting the coin_slot and the button_lights, they are joined by a chain of paths that implements the causal connection between the two, i.e. when the appropriate amount of money has passed the slot the light turns on.
Now we come to define in detail the interaction network or the Drink Machine System Matrix and associated primitive systems. First we define the existence of the primitive systems and the topology of the network that binds them together, then we consider the data that flows through this network and finally we consider what transformations or functions are required to implement the information space.
Normally the modelling process would be accomplished using a graphical modelling program that automatically stores the systems as system matrices; one would simply create a system diagram much like above and right click on each component to set its properties and then run the simulation. Right clicking on a system allows one to set its transforms and right clicking on an interaction path allows one to set its data structure and particular state. However such a program has yet to be written so here we code the SMN data objects by hand.
There are thirteen primitive systems is this particular system model and these combine according to the following system matrix.
-- 1 2 3 4 5 6 7 8 9 10 11 12 13 -- ------------------------------------------------------- --1 chosen | 0 1 0 1 0 0 0 0 0 0 0 0 1 -- | --2 available | F2 0 0 F23 1 0 0 1 0 0 0 0 0 0 -- | --3 drink reservoir | F3 F31 0 1 0 0 0 0 0 0 1 0 0 0 -- | --4 drink prices | 0 0 0 0 0 0 0 0 0 0 0 0 0 -- | --5 change calc | F51 0 0 0 0 0 1 0 0 0 0 0 0 -- | --6 coin adder | 0 0 0 0 F65 0 0 0 0 0 0 F612 0 -- | --7 coin total | F7 0 0 0 0 0 1 1 0 0 0 0 0 0 -- | --8 coin reservoir | F8 0 0 0 0 F85 0 0 0 0 0 0 1 0 -- | --9 change chute | F9 0 0 0 0 0 0 0 1 1 0 0 0 0 -- | --10 drink chute |F10 0 0 1 0 0 0 0 0 0 1 0 0 0 -- | --11 lights | 0 1 0 0 0 0 0 0 0 0 0 0 0 -- | --12 coin slot | 0 0 0 0 0 0 0 0 0 0 0 0 0 -- | --13 buttons | 0 0 0 0 0 0 0 0 0 0 0 0 0 -- |
Any non zero element indicates an interaction where a single one indicates a direct transfer of information whilst a Fxy indicates some kind of transformation between systems x and y that will be implemented as a euphoria function. However an F# at the left of a row indicates an aggregate function that will operate on the combined input produced when this row is convolved with the state vector. This matrix corresponds to the diagram above; if one looks at the change calculator, system five above, from its row one sees that it receives transformed data from chosen and also receives direct data from coin_total, with this it calculates change = total - price. From its column we see that it outputs to coin_total and to coin_reservoir; it sends a reset signal to coin_total that causes it to reset to zero and it sends the change request on to the coin_reservoir.
But there are some slight differences here in regards to the accumulators or reservoirs, for example, consider drink_reservoir, it receives input from chosen, drink_reservoir and drink_chute whereas on the diagram it only received input from chosen. It interacts with itself in this instance in order to preserve the state of the drink reservoir as a state being passed through time or being thrown and caught. It also takes input from the drink chute so that the reservoir knows when the chute has received the drink.
Indeed there are three different methods of accumulating used in this model in order to illustrate their use. Drink_reservoir uses explicit self reference to maintain its inventory within a direct feedback loop using a system transform. Coin_total uses a two step feedback loop with coin_adder and uses an interface transform. Coin_reservoir uses an internal tally, which it externalises as output but which it remembers itself within so doesn't require this as input.
The above system model also uses different processing methods, e.g. 'chosen' simply aggregates the inputs and then applies two different output transforms on it, whereas 'available' uses an aggregate function and provides this same data to two different outputs. There are also several possible instances of the use of interface transforms too but one system's input is another's output so it is often a matter of perspective, but for example, coin slot may simply contain a coin and coin adder utilises an input transform the determine the value of the coin.
There are countless ways of implementing this one model, in many cases it is arbitrary exactly which method is used, whether a particular interface is output transformed or input transformed. The modelling language is very flexible!
To fill in the details of the transforms indicated on the above matrix the following definitions are made where, as above, the transforms have either been labelled according to their matrix element index or to the row index depending on whether they were interface transforms or aggregate functions.
-- F(2,3) takes the state of the drink_reservoir and extracts
its inventory
in{inventory, dispensed_drink}
out{inventory}
-- F(3,1) extracts the button_id from chosen's input and
sends this to drink_reservoir
in{availability vector, drink
prices list, button id}
out{button_id}
-- F(5,1) extracts the price that corresponds to drink_id
from drink_prices and sends to change_calc
in{availability_vector,
drink_prices:{price,..}, button_id}
out{drink_prices[button_id]
or zero}
-- F(6,5) if change_calc's input (price) is non-zero then
reset=1
in{price, coin_total}
out{boolean reset value}
-- F(6,12) for the coin in the slot it determines the value
of the coin
in{{value}} where a coin is a sequence containing
value coin:{value}
out{value}
-- F(8,5) calculates the difference between price and
coin_total to determine required change
in{price,
coin_total}
out{coin_total - price}
-- F2 takes drink_prices, drink inventory and coin_total and
produces an availability vector
in{ inventory,
drink_prices:{price,..}, coin_total}
out{ availability vector}
which is a vector of booleans, i.e. {0,1,1,0} for example if the
second and third drinks are available
-- F3 takes a drink_id and its previous state and subtracts
one from its inventory then outputs this tally plus any required
drinks
in{ drink_id, {inventory, dispensed_drink},
drink_dispensed}
out{ inventory, dispensed_drink}
-- F7 takes {{the reset boolean and any new coin values} and
the previous total} and -- determines a new total
in{{ reset,
new_value}, coin_total}
out{ coin_total}
-- F8 takes a change_value and an input coin, it adds the
coin to its internal tally -- and subtracts the change from its
internal tally and outputs the requested change coins.
in{
change_value, new_coin}
out{ change_coins} where change coins is
a sequence of coins of particular denominations.
-- F9 takes the output of the coin_reservoir and the
chute_state and manages the chute_state
in{ { coin,...},
chute_state}
out{ change_coins}
-- F10 takes the state of the drink_reservoir and the
chute_state and manages the chute_state
in{ { inventory,
dispensed_drink}, chute_state}
out{ dispensed_drink}
From these function interface specifications we can see the full range of the model's data objects or information atoms.
All the above aggregate functions are inserted into the aggregate function vector and the interface transforms are inserted into the appropriate elements of the system matrix. All the direct transfer operators or ones in the system matrix are filled in then aspects of the state vector are built up. In Euphoria code this looks something like:
-- constructing the singular transform vector
st = {-1,F2,F3,-1,-1,-1,F7,F8,F9,F10,-1,-1,-1}
-- constructing the Metric System Matrix, element by element
sm = sparse_SM(13,13)
sm = set_SM(sm, {1,2}, 1)
sm = set_SM(sm, {1,4}, 1)
sm = set_SM(sm, {1,13}, 1)
sm = set_SM(sm, {2,3}, {{F23},1})
sm = set_SM(sm, {2,4}, 1)
sm = set_SM(sm, {2,7}, 1)
sm = set_SM(sm, {3,1}, {1,{F31}})
sm = set_SM(sm, {3,3}, 1)
sm = set_SM(sm, {3,10}, 1)
sm = set_SM(sm, {5,1}, {1,{F51}})
sm = set_SM(sm, {5,7}, 1)
sm = set_SM(sm, {6,5}, {1,{F65}})
sm = set_SM(sm, {6,12}, {{F612},1})
sm = set_SM(sm, {7,6}, 1)
sm = set_SM(sm, {7,7}, 1)
sm = set_SM(sm, {8,5}, {1,{F85}})
sm = set_SM(sm, {8,12}, 1)
sm = set_SM(sm, {9,8}, 1)
sm = set_SM(sm, {9,9}, 1)
sm = set_SM(sm, {10,3}, 1)
sm = set_SM(sm, {10,10}, 1)
sm = set_SM(sm, {11,2}, 1)
-- an inventory of 100 each of four types of drinks
inv = {{"cola",100},{"lemonade",100},{"juice",100},{"water",100}}
-- prices in cents for the four drink types
prices = {120,120,100,80}
-- constructing the final State Vector
sv = {{{0,0,0,0},prices,0},{0,0,0,0},{inv,"none"},prices,{0,0},{0,0,0},0,{},{},"none",0,{100},0}
-- note the dollar coin inserted in sv[12] (second last) which is the coin slot
-- this is an initial condition that we are starting the simulation with.
-- flagging the initial inputs for processing by the energy flow algorithm
-- we have put a coin in the coin slot so sv[12] has changed, hence
cUpdate = {12}
-- combining all of the above into a single system model
model = {st,sm,sv,cUpdate}
-- and then step the model forward in time
result = step_Model(model, nSteps)Now we have a fully defined model which can be seen (in its low level detail) at the top of the file DrinkMachine_out which was produced by the software implementation of this drink machine model, indeed much of the above description was paraphrased or taken directly from the software implementation design documents and source code.
In the related source code one can find the definitions of all the various functions and how they transform the data. This source code deals only with the construction and simulation of the model, for the source code for the SMN system itself see SMN Code.
Now we look at the behaviour of the model when simulated by stepping the model forward in time and observing its behaviour. The file DrinkMachine_out contains the output produced by the execution of the program ergodicSysMSMN_DrinkMachine.ex which leads one through a step by step sequence where one inserts a dollar coin, waits for the system to settle and the lights to come on, then one presses a drink button and waits for ones drink and change to be dispensed.
It takes a little while to get used to reading the low level models but in time one can see the behaviour of the system as the state vector elements change. Eventually all of this will be wrapped up inside a software interface so people only deal with graphical system representations but for now we need to view the models in code.
By representing the entire system model within a single unified mathematical framework, this allows for advanced system analysis and simulation techniques to be developed, such as the use of higher powered matrices to explore the future or past state space of the system. However the full range of possibilities is only likely to become known over time. There are many possible developments in the direction of a group theoretic analysis of FSA's, this is discussed in the context of FDCIS's. Once there is a fully functional software implementation of SMN this could evolve into all kinds of system analysis applications.
{{more}}
What is one? What can one do with one? How does one create one?
SMN is in essence a general information processor that can structure, organise, distribute and transform information of all kinds. This capacity is conceptualised and harnessed using the conceptual language of systems theory and could be represented as an interactive environment within which a user could visualise and interact with systems as dynamical information constructs. Within this environment they may integrate the power of SMN with their other information tools and with their wider context. It would provide a unified space within which to bring all of the elements together and wherein to develop an increasingly complex and powerful idiom of SMN systems, patterns, templates and so on which augment, extend and specialise the underlying computational potential of SMN.
One may use the organisational schema of SMN to structure complex content, such as multimedia networks or experiential landscapes or detailed documents, designs and specifications or concept maps of ideas, scenarios and entire conceptual frameworks such as scientific domains. But this is all existential information, regarding content only. Into this one may integrate causal information and invest the static model with dynamical behaviour. Thus any type of data can be represented and made to behave in any causally coherent manner, furthermore it may be processed or acted upon by any type of computational process, which can be represented within an SMN simulation space and then iterated or animated, whereby SMN handles all of the computational logistics and routes all of the data along all of the information channels, distributing it and transforming it as required, thereby simulating the virtual system.
The processes can be ergodic or non-ergodic, linear or non-linear, classical or quantum, distributed or centralised. It could be logically structured according to any coherent schema such as any computer language, any modelling method such as UML, OO, procedural programming, mathematics, SMN or system oriented methods and so on.
I have some rough high level designs, even rougher detailed designs and some simple software prototypes. These will be further developed over time.
But software development isn't my forte and I've been struggling from lack of inspiration, resources and time so hopefully there are some other developers interested in helping to create this. It's early manifiestations can be quite simple but eventually it could be like a fusion of:
3D Studio or other animation programs, but not just for the outer appearances of things; the systems can exist in realistic metaphysical spaces and interact according to detailed causal programming.
Mathematica or Matlab, providing advanced analysis and mathematical functionality with complex networks of equations able to be modelled and analysed, but also integrated with dynamical systems internally modelled or externally observed or controlled using SMN.
Rational Rose and Visual C++ or Java, but one need not write much code and one can create incredibly complex, subtle and fault tolerant systems that have been rigorously developed and tested from a system theoretic perspective. One can build up an idiom of reusable components that can be easily integrated to form complex high level systems, and one can dynamically simulate, visualise and analyse ones systems as one constructs them.
Multimedia, Web Design and general human communication (especially for Topic Maps or XTM which is a new XML based standard that allows for Conceptual Networks or Concept Maps, which are an inherently systems based format; in fact the SMN engine itself is an advanced topic map engine, which some developers may wish to look into.) A concept map isn't just a linear string of symbols that one follows, it is a landscape of ideas in relation that one may explore according to ones inclination. Within this landscape there are many paths that one may follow, some of these may be predefined in order to lead people along a particular line of reasoning or to present a particular perspective. Other paths may be only traversed by intrepid explorers, straying far from the beaten track. Furthermore it can encode a generalised representation of a domain of knowledge that is not contingent upon any particular perspective, it provides a transcendent structure for the domain and many particular perspectives can then be derived from this. In this way one may set up a model of a situation and then extract views of it from several perspectives and then analyse how they differ and how these differences can lead to misunderstandings. Or one may take multiple perspectives on the one issue and merge these together into a single network and then one may analyse the underlying scenario and understand how these perspectives arise, how they interact and how they can be reconciled.
A Universal Control System able to be adapted to any electronically controllable context, from automated factories, aircraft, traffic control, computer and general equipment operating systems and so on.
Perceptual Learning systems, Cognitive Systems and Artificial Intelligence are all conceivable within this metaphysical modelling context. It provides a metaphysically realistic space in which these systems could be developed or allowed to evolve.
Furthermore, the underlying SMN methodology could be implemented directly in silicon and it would form the basis for a new type of chip that allows for system simulation. This could be an addition to traditional computing, analogous to 3D accelerator cards, but in time it could also revolutionise the entire computer architecture.
The ultimate implementation would be using quantum computers and indeed SMN may indicate a method for the general programming of quantum computers. So far as I know, at present people have only developed specialised algorithms but not a general method for programming a quantum computer. There are significant parallels between SMN and quantum physics that may indicate a way towards this.
In its most general form SMN provides an abstract network of nodes and relations and it implements the dynamic connectivity within that network. This general structure can be imbued with any meaning that one can imagine, from system models, documents, software, etc. Who knows what ingenious uses may be found over time.
All conceivable types of systems can be modelled and analysed to any degree of resolution we desire; limited only by our ability to comprehend and represent their complexity. In this sense SMN represents a very low level enabling technology that may be extended and specialised in countless directions and will lead to countless innovations over time. If enough people get involved and their creative juices start to flow, who knows what is possible, one cannot really tell at this early stage.
I expect there will eventually be a great deal of commercial development and a lot of money made for individuals and organisations, and I am happy to collaborate with almost anyone in the development of SMN, but I hope that this paradigm flowers within the free and open source software communities and