String fullTitle = 'Neuro-symbolic integration';
int postNumber = 16143503;
String image = '1713947036054248.png';
String date = '04/24/24(Wed)04:23:56';
String comment = 'How-to:
>Decompose the input pattern into the atomic primitives of that information medium.
>Then reconstruct this pattern one layer at a time in a deterministic fashion
>Then you can pick a node and just walk the data right out of the network as a 1 to 1 mapping of the input represented by that node
>Applying the perceptron or other neural models to the nodes allows for neural-network behavior in the distributed symbol net.
Cat:
>[C][a][t] <- decomposed primitives
>[Ca][at] <- abtracted
>[Cat] <-abstracted with no more sub-symbols to combine, the 'treetop' symbol/node.
Another example with a 2D object:
Atomic primitives
>[aa] [ba] [ca]
>[ab] bb] [cb]
>[ac] bc] [cc]
First tier of abstraction
>[aa ba] [ba ca]
>[ab bb] [bb cb]
>[ab bb][ bb cb]
>[ac bc][ bc cc]
Second tier, the treetop tier
>[aa ba ca]
>[ab bb cb]
>[ac bc cc]
Only the interface nodes at the primitive level need bound to the primitive.
Let's assign a unique ID to each node.
>0[C] 1[a] 2[t]
>3[Ca] 4[at]
>5[Cat]
Now we can keep the integrity of the distributed symbols by tracking the relationships of the nodes at the local level.
We do this by simply tracking which nodes, and in what order, make up the sub-symbols composing a node.
So instead of saying '3[Ca]' we track what lower connections actually make it up, ie, '3[0[C], 1[a]]'.
>0[C] 1[a] 2[t]
>3[0[C], 1[a]] 4[1[a], 2[t]]
>5[3[Ca], 4[at]]
Now, we are tracking the relationships of the lower nodes, however, we only need to track the ID's of the immediate lower nodes. So '3[0[C], 1[a]]' becomes '3[0, 1]'.
>0[C] 1[a] 2[t]
>3[0, 1] 4[1, 2]
>5[3, 4]';
'>>16143503
To retrieve a symbol you can simply walk down the tree on the 1th leg, and for each step walk all the way down on the 0th leg until you retrieve the primitive, then go down the next step on the 1th leg. I'll show, easier than explaining.
>5[3, 4]
So we need to walk all the way down on leg [0]:
>5[3, 4]
>5[0] == 3
>3[0, 1]
>3[0] == 0
>0[C]
>output += 'C'
Then we go back up to node 5 and step down on the [1] leg and repeat for the next primitive:
>5[3, 4]
>5[1] == 4
>4[1, 2]
Find primitive:
>4[1, 2]
>4[0] == 1
>1[a]
>output += 'a'
Step down:
>4[1, 2]
>4[1] == 2
>2[t]
>output += 't'
>output == 'Cat'';
'>>16143505
It is important to note that all symbols only appear once in the network, this allows for composibility.
Example:
Encoding 'ABRACADABRA'
> T(0) 0[A] 1[B] 2[R] 0[A] 3[C] 0[A] 4[D] 0[A] 1[B] 2[R] 0[A]
> T(1) 5[AB] 6[BR] 7[RA] 8[AC] 9[CA] 10[AD] 11[DA] 5[AB] 6[BR] 7[RA]
> T(2) 12[ABR] 13[BRA] 14[RAC] 15[ACA] 16[CAD] 17[ADA] 18[DAB] 12[ABR] 13[BRA]
> T(3) 19[ABRA] 20[BRAC] 21[RACA] 22[ACAD] 23[CADA] 24[ADAB] 25[DABR] 19[ABRA]
> T(4) 26[ABRAC] 27[BRACA] 28[RACAD] 29[ACADA] 30[CADAB] 31[ADABR] 32[DABRA]
> T(5) 33[ABRACA] 34[BRACAD] 35[RACADA] 36[ACADAB] 37[CADABR] 38[ADABRA]
> T(6) 39[ABRACAD] 40[BRACADA] 41[RACADAB] 42[ACADABR] 43[CADABRA]
> T(7) 44[ABRACADA] 45[BRACADAB] 46[RACADABR] 47[ACADABRA]
> T(8) 48[ABRACADAB] 49[BRACADABR] 50[RACADABRA]
> T(9) 51[ABRACADABR] 52[BRACADABRA]
>T(10) 53[ABRACADABRA]
> T(0) 0[A] 1[B] 2[R] 0[A] 3[C] 0[A] 4[D] 0[A] 1[B] 2[R] 0[A]
> T(1) 5[0, 1] 6[1, 2] 7[2, 0] 8[0, 3] 9[3, 0] 10[0, 4] 11[4, 0] 5[0, 1] 6[1, 2] 7[2, 0]
> T(2) 12[5, 6] 13[6, 7] 14[7, 8] 15[8, 9] 16[9, 10] 17[10, 11] 18[11, 5] 12[5, 6] 13[6, 7]
> T(3) 19[12, 13] 20[13, 14] 21[14, 15] 22[15, 16] 23[16, 17] 24[17, 18] 25[18, 12] 19[12, 13]
> T(4) 26[19, 20] 27[20, 21] 28[21, 22] 29[22, 23] 30[23, 24] 31[24, 25] 32[25, 19]
> T(5) 33[26, 27] 34[27, 28] 35[28, 29] 36[29, 30] 37[30, 31] 38[31, 32]
> T(6) 39[33, 34] 40[34, 35] 41[35, 36] 42[36, 37] 43[37, 38]
> T(7) 44[39, 40] 45[40, 41] 46[41, 42] 47[42, 43]
> T(8) 48[44, 45] 49[45, 46] 50[46, 47]
> T(9) 51[48, 49] 52[49, 50]
>T(10) 53[51, 52]';
}