I think the theoretical basis of the wave structure is sufficient to start building the mathematical structure. Of course, the theoretical aspects evolve.
First, the wave group theory should be constructed mathematically to construct the layer-by-layer structure of wave statistical mechanics. It was said that V space is defined by scalars and vectors. Classes (in OOP) are a collection of vectors represented in the form of something similar to a matrix. Then Scalars will initiate those vectors (functions). So the multiplication of a “scalar” and a “matrix” constructs an instance of some class. For this purpose, scalars should be defined as such:
R_1:[int_1,int_2,…,int_n, float_1, float_2, ….,float_n,…]
R_2:[int_1,int_2,…,int_n, float_1, float_2, ….,float_n,…]
.
.
R_m:[int_1,int_2,…,int_n, float_1, float_2, ….,float_n,…]
So this is a table with m rows and each row consists of n copies of all possible data types (i.e. n integers, n floats, etc). n and m are large numbers. Each row initiates a function in a class (as explained before each function is a sequence of several base vectors/functions). So for example, if a functions get an integer and a float as input then the row associated with that will be:
[I_1,0,0,…..,F_1,0,0,….], where I_1 is some integer and F_1 is some float.
To initiate a function (i.e. a sequence of base vectors), all base vectors should be multiplied by a scalar. In other words:
V = V_1 +V_2+ …V_n. Here V refers to a function constructed by the sequence of n base vectors: V_1, V_2, …
Then V*S (where S is some scalar) equals:
S_1*V_1 + S_2*V_2 + ….+ V_n*S_n = V*S; S_1+S_2+….= S
The addition of scalars will be defined later, first, the addition of vectors should be defined. The sequence/addition of base vectors means that the output of V_1 should be fed into V_2 as input, then the output of V_2 initiates V_3 and so on. This requires that all scalars are of the same size (n*m; note that if square tables are required, all scalars can be n*n tables; n>m).
However, there is an issue. The previous setting implies that all V_i base vectors should be initiated in the same way, and the output of V_i (for any i) should match the input of V_j (for any j). This can be solved if V_i comes with a default initializer (d_init).
Consider the previous example, V*S = S_1*V_1 + S_2*V_2 + ….
S_1 initializes V_1, and S_2 is the output of V_1 that should initialize V_2. If the format of S_2 doesn’t match d_init_2, Then S_2 should be set to zero, and as a result, S_2=0 removes V_2 from the sequence (note that even if V_i doesn’t require any input, by construction it should get some arbitrary input to differentiate it from S_i=0)
S_1*V_1 + S_2*V_2 = S_1*V_1
This implies that the output of V_1 specifies the equivalency set of zero. This constructs a new type of algebra where (A+B)+C != A+(B+C). Also the identity element zero is an equivalency set which is specified by the output of the previous base vector in the sequence.
This provides a mathematical tool to construct different layers. By this construction irrelevant base vectors to some function will be in the zero zone (null space), so they will not be available in that layer.
UPDATE 1:
This is an example of a scalar:
R_1:[(int_1), NULL ,…,NULL, (float_1), (float_2), NULL, …]
R_2:[(int_1), (int_2), NULL, …, (float_1), (float_2), NULL …]
.
.
R_m:[NULL, … , (float_1), NULL , …. ]
Each value, such as int_1, is denoted as (int_1)
Then (int_1) + (int_2) := (int_1, int_2)
For example:
S_1=
[(int_1), NULL ]
N
U
L
L
[ NULL ]
and S_2=
[(int_2), NULL ]
N
U
L
L
[ NULL ]
Then S_1 + S_2 =
[(int_1, int_2) , NULL ]
N
U
L
L
[ NULL ]
UPDATE 2:
Because the null space is based on the input and output (i/o) of V_i, then the format of i/o can be constructed more suitably. So instead of (int_1,int_2,…..), pattern-based structures will be constructed.