Logical Equivalence between SMN and SCSPL:
the Full Non-Ergodic SMN Algorithm

I have recently mapped out in detail a parallel between IST (my own work) and CTMU (originated by Christopher Langan). Although they are related but seemingly disparate conceptual frameworks, they are nevertheless two different conceptualisations of the same underlying phenomenon. I will explain...

Any piece of mathematics or theory or software is simply an algorithmic representation of an underlying information process that can be represented and conceptualised in many different ways. Thus there are many different algorithmic representations of the underlying process that are all logically equivalent. There are also many conceptual frameworks within which one may make sense of the underlying process (e.g. classical/quantum physics, analytical/process philosophy and so on).

I discovered the equivalence by simply implementing the mathematics of system matrix notation (SMN) in software and then working on optimising and stream-lining it within that context. There is now a relatively solid software implementation of the mathematics of SMN and I have been working on optimising its algorithmic efficiency; not looking at it as a piece of mathematics but instead as an abstract algorithm. Due to this the algorithmic structure of the code has been evolving (whilst preserving its logical equivalence with SMN) and has converged onto something that is logically equivalent to a self-configuring self-processing language (SCSPL) operating within a self-excited circuit. Thus the process of refinement eventually gave rise to an algorithm that implements an SCSPL based approach. In fact I would propose that SMN is the optimum mathematical representation and SCSPL is the optimum software implementation.

This change in conceptual focus and algorithmic approach has effectively transformed the mathematics of SMN into a software implementation that operates as an SCSPL based iterative process. Thus SMN and SCSPL are logically equivalent approaches, hence SMN gives rise to both a mathematical definition in terms of a system theoretic metaphysics (IST) and an algorithmic definition in terms of a SCSPL based metaphysics (CTMU).

## General Principles of SMN

The algorithmic use of matrices, vectors and operators employed in system matrix notation (SMN) operates within the conceptual framework of system theory where the SVElements are primitive system states and the SM defines the causal connectivity that forms the underlying network of interaction paths that binds sub systems into super systems. The diagrams below indicate the manner of the connection between matrix mathematics and causal connectivity. Here are the initial matrix and vector, the matrix elements (grey circles) contain function ids (dark dots) and the vector elements (dark circles) contain arbitrary existential data. The following images illustrate the initial stages of the process of matrix multiplication in order to indicate the nature of the underlying causal network that is produced. See the key below for more detail on the symbols used. The matrix is multiplied with the state vector via a process operating one row at a time. Here we see the top row of the matrix being rotated and aligned with the vector, then the functions are applied to the corresponding data. Each element of the matrix row represents an input channel for a particular system. It's input functions receive and process the available data. These results are normally then summed into a single datum and assigned to the corresponding element of the result vector however this part is not illustrated here. This result is the system's state and is represented in the state vector. As each row is processed, drawing upon the entire cosmic state, each state element is re-computed and the next moment in time is thus computed. With each iteration each moment evolves into the next and the virtual universe is animated into existence. The part we are interested in here is... Say, instead of applying the functions to the data we just took a reference to that data so that it can be retrieved when required. This reference (green dot) is then stored in the matrix element along with the function id. This change is also necessary for the implementation of higher powered matrices. The bottom row is similarly processed thus producing... ... this matrix, which need no longer be multiplied because the causal connectivity is encoded by the references. Hence the matrix is simply a data object who's rows are function definition statements that utilise the vector as a common information space. Thus when higher powered matrices are implemented we will have nested functions operating on functions which ultimately draw upon the SV data. Hence the SMN logic manages all of the logistics of the information transfers.

This indicates that matrix mathematics is an information process that is logically equivalent to a set of iterative processes operating on a shared information space. Each process is defined by a row of the matrix, which is a type of function definition statement that defines the procedural structure of the process. This connects up with the perspective and general approach of the cognitive theoretic model of the universe (CTMU), in particular the use of a self-configuring self-processing language (SCSPL) within a self-excited circuit. This is logically equivalent to the mathematics of SMN.

## System Matrix Rows and Function Definition Statements...

The standard linear matrix mathematics is equivalent to a linear function definition language (FDL).
The matrix row [a,b,c] multiplied by the state vector [x,y,z] gives (a.x + b.y + c.z) thus the row is an FDS for functions of that form.

Thus a linear matrix is equivalent to an FDL for functions of the form:

```    svElem = a.x + b.y + c.z
```
Using in-element operators is equivalent to an FDL for functions of the form:
```    svElem = a(x) + b(y) + c(z)
```
Then also using row operators is equivalent to an FDL for functions of the form:
```    SV[r] = rowOp( a(x), b(y), c(z) )
```
And using input/output operators is equivalent to an FDL for functions of the form:
```    SV[r] = rowOp( a_in( a_out(x) ), b_in( b_out(y) ), c_in (c_out(z) ) )
```
Or using operator sequences is equivalent to an FDL for functions of the form:
```    SV[r] = rowOp( a_1( a_2(a_2( ... a_n(x))) ), b_1( ... b_n(y)), c_1( ... c_n(z)) )

where each element of the OpSpec has the form {op_1, {op_2, {... , {op_n, {svRef}}}}}

so SV[r] = rowOp( OpSpec_1( ... OpSpec_n(svRef) ), ... )
```
Note that the function rowOp( OpSpec_1( ... Opspec_n(svRef) ), ... ) is equivalent to rowOp( FD[r][Opsec_], SV )

Allowing the SM to be modified is equivalent to an FDL for functions of the form:
```    FD[r] = modFD(FD[r], SV[r])
SV[r] = rowOp( FD[r][Opsec_], SV ) )
```

Below is a snippet of pseudo code that illustrates the kernel of the algorithm

```for t = 1 to steps do -- for each simulation moment
for r= 1 to length(FD) do -- for each FDS
FDS = FD[r]
newSV[r] = call_func( FDS[rowOp_], resolve(FDS[OpSpec_]) ) -- compute new SV element (existential state)
FD[r] = call_func( FDS[modFD_], ( FDS, SV[r] ) ) -- compute new function definition statement (FDS)
end for
SV = newSV
end for
```

The function 'resolve' takes a function definition statement and instantiates it by drawing in any required data from the state vector and applying this as input to the functional structure defined by the OpSpec. This produces a result that is combined with other results by rowOp to form the new state of the corresponding SV element. The function modFD takes in the current FDS and the corresponding SV element or system state. From this information it computes the new FDS that will perform the system's perception and response operations in the next simulation moment.

Below is a schematic of the optimised algorithm:  In the new algorithmic implementation there is still a state vector (SV) but the system matrix SM has taken on a new role. By extracting and collecting the row-ordered data from a sparse SM we thereby construct a sequence called the FD, which contains function definition statements (FDS's). The SV and FD are simply abstract data objects that are utilised by the algorithm to structure the data, there is no longer any explicit matrix multiplication. Each element of the SV contains some existential data that represents the state of a particular circuit element within the self-excited circuit. Furthermore, each FDS in the FD represents a statement within a function definition language (FDL) that defines the exact form of the computational operation that will draw in all required data and produce a new representational state (SVElement).

The FD is in one sense a data object that can be modified at run time, but it is also in another sense a set of function definitions that when instantiated can operate on data, hence the functions can dynamically evolve. When such operations are inserted into a computational loop that drives an ongoing iterative process, this then constitutes an SCSPL engine.

New values for the SVElements (existential states) and FDS's (FDL statements) are generated with each iteration. In the current software implementations the operations defined within the FDS's only operate on the SV but the plan has been to eventually extended this to the FD (or the SM) as well. Hence each computational operation that is an instantiation of an FD statement operates on the whole data (FD,SV) and each such operation produces a new SVElement and a new FD statement that are assigned to a particular SVElement and FDS.

These instantiated FD operations share a common information space of existential states (SV); this then constitutes an SCSPL operating within a self-excited circuit, which constitutes a virtual-reality generative process that gives rise to a simulation universe.

Conceptually, in each moment within the simulated universe every element of the self-excited circuit can potentially observe the existential state of the whole circuit (SV), it can respond to this observation by altering its state (SVElement) and it can also reconfigure the process whereby it performs the operations of observation and response (FDS). Thus the circuit as a whole perceives and responds to itself, and its state of existence (cosmic state or SV) evolves. Furthermore the algorithmic process by which it perceives and responds is distributed amongst the elements and encoded as data (FDS) thus it too may evolve over time as each circuit element reconfigures itself and thus the circuit as a whole reconfigures itself.

I am dealing with mathematical and software representations of both a system theoretic and an SCSPL based metaphysics. The programs released to date (2006/02/11) have been based on a relatively direct implementation of the mathematics so they are more system theoretic oriented. However ParticleDraw (updated 2006/02/15) is an example of an SCSPL implementation. This program has been optimised as a software algorithm and has thus diverged from the matrix mathematics (whilst retaining exact logical equivalence) and it has converge onto a more SCSPL oriented approach. The new SMN v6.0 high level design describes a total remake of the whole program partly due to the rammifications of the underlying algorithmic shift.

This new approach stores the causal model as both SM and FD. It simulates the model using the FD and it manipulates the model using the SM. This provides an optimum of efficiency due to algorithmic stream-lining whilst retaining all of the flexibility and creative potential of a virtual-reality generative process due to the logical equivalence with SMN. Furthermore, all of the mathematical techniques that derive from SMN are still equally applicable, thus the system can not only be optimally computationally simulated using the SCSPL approach but it can also be optimally mathematically analysed and constructed using the SMN approach. See this brief discussion on SMN modeling for more information on this aspect.

# Full Non-Ergodic SMN implementation

The above algorithm made use of the function modFD to modify each FDS in the FD, however that was an ad-hoc implementation. A fully SMN implementation is described below. This schematic illustrates the complete SMN computing 'machinery' required to simulate a single quantum binary system or two classical systems. This can be scaled up to handle any number of systems, however this simple case is used to illustrate the general principles.

Below I describe how this computational machinery functions in order to coordinate all of the required information flows.

The standard SM and SV can be seen in the bottom right corner however the SM has been slightly modified. Instead of the matrix elements holding the SMElement values directly, the matrix elements are refferences into the SMV. Thus as the SMV elements evolve so does the SM.

A quick run through: the SMM implements the causal logic whereby the SMV evolves, hence the SM evolves. Then the SM implements the causal logic whereby the SV evolves.

Hence the SV evolves in time and the simulated universe is animated. The behaviour of the systems is implemented by the SM, and due to the SMV's evolution the system's behaviour evolves in time. Hence the simulated universe is a fully non-ergodic existential context.

In Detail This illustrates the SMM operating on the SMV and the SV and thereby generating a new SMV. The SMV is then conceptually formed into the SM, in practice this can be implemented by the SMElements refferencing into the SMV. The SM then operates on the SV thus producing a new existential moment.

This can all be achieved in a single matrix multiplication iteration... The matrix M is multiplied with the vector V thus producing a new vector V. During this process the SMM operates on V and produces a new SMV and the SM uses the current SMV to operate on the SV thus producing a new SV. Thus after a single iteration there is a new SMV and new SV.

Hence,   Vt+1 = M . Vt

This new matrix / vector iteration can be implemented using an FD as discussed previously. This would retain the logical equivalence with the above SMN matrix mechanics but also take advantage of the algorithmic optimisation involved in the SCSPL approach.

Note: by allowing SMElements to refference their values from the state vector one can easily implement conditional statements such as “If ... then ...”. This allows for general programming using SMN matrix methods.