## Thursday, 25 June 2015

### simple logic in the MatSumSig model

Again, just simple foundational ideas. Simple logic in the MatSumSig model:
```d = a OR b OR c
[ d ] = [ BF[x1] ] [ 1 1 1 ] [ BF[x1] ] [ a ]
[ BF[x2] ] [ b ]
[ BF[x3] ] [ c ]

d = a AND b AND c
[ d ] = [ BF[x1] ] [ 1/3 1/3 1/3 ] [ BF[x1] ] [ a ]
[ BF[x2] ] [ b ]
[ BF[x3] ] [ c ]

d = a XOR b XOR c
[ d ] = [ XF[x1] ] [ 1 1 1 ] [ BF[x1] ] [ a ]
[ BF[x2] ] [ b ]
[ BF[x3] ] [ c ]

f = (a AND b AND c) OR (d AND e)
[ f ] = [ BF[x1] ] [ 1 1 ] [ BF[x1] ] [ 1/3 1/3 1/3 0   0   ] [ BF[x1] ] [ a ]
[ BF[x2] ] [ 0   0   0   1/2 1/2 ] [ BF[x2] ] [ b ]
[ BF[x3] ] [ c ]
[ BF[x4] ] [ d ]
[ BF[x5] ] [ e ]
```
where BF[x] and XF[x] are sigmoids:
```def binary_filter(x):
if x <= 0.96:
return 0
else:
return 1

def xor_filter(x):
if 0.96 <= x and x <= 1.04:
return 1
else:
return 0
```
Update: now let's do the same in BKO. A 2 element truth table:
```pattern |row-1> => 0|a> + 0|b>
pattern |row-2> => |a> + 0|b>
pattern |row-3> => 0|a> + |b>
pattern |row-4> => |a> + |b>

OR-2 |a> => |x1>
OR-2 |b> => |x1>

AND-2 |a> => 0.5|x1>
AND-2 |b> => 0.5|x1>

OR |*> #=> push-float binary-filter OR-2 binary-filter pattern |_self>
AND |*> #=> push-float binary-filter AND-2 binary-filter pattern |_self>
XOR |*> #=> push-float xor-filter OR-2 binary-filter pattern |_self>

sa: table[row,pattern,OR,AND,XOR] ket-sort starts-with |row->
+-------+----------+----+-----+-----+
| row   | pattern  | OR | AND | XOR |
+-------+----------+----+-----+-----+
| row-1 | 0 a, 0 b | 0  | 0   | 0   |
| row-2 | a, 0 b   | 1  | 0   | 1   |
| row-3 | 0 a, b   | 1  | 0   | 1   |
| row-4 | a, b     | 1  | 1   | 0   |
+-------+----------+----+-----+-----+
```
Cool, huh!

Update: let's do a 3 element truth table:
```pattern |row-1> => 0|a> + 0|b> + 0|c>
pattern |row-2> => 0|a> + 0|b> + |c>
pattern |row-3> => 0|a> + |b> + 0|c>
pattern |row-4> => 0|a> + |b> + |c>
pattern |row-5> => |a> + 0|b> + 0|c>
pattern |row-6> => |a> + 0|b> + |c>
pattern |row-7> => |a> + |b> + 0|c>
pattern |row-8> => |a> + |b> + |c>

OR-3 |a> => |x1>
OR-3 |b> => |x1>
OR-3 |c> => |x1>

AND-3 |a> => 0.333|x1>
AND-3 |b> => 0.333|x1>
AND-3 |c> => 0.333|x1>

OR |*> #=> push-float binary-filter OR-3 binary-filter pattern |_self>
AND |*> #=> push-float binary-filter AND-3 binary-filter pattern |_self>
XOR |*> #=> push-float xor-filter OR-3 binary-filter pattern |_self>

sa: table[row,pattern,OR,AND,XOR] ket-sort starts-with |row->
+-------+---------------+----+-----+-----+
| row   | pattern       | OR | AND | XOR |
+-------+---------------+----+-----+-----+
| row-1 | 0 a, 0 b, 0 c | 0  | 0   | 0   |
| row-2 | 0 a, 0 b, c   | 1  | 0   | 1   |
| row-3 | 0 a, b, 0 c   | 1  | 0   | 1   |
| row-4 | 0 a, b, c     | 1  | 0   | 0   |
| row-5 | a, 0 b, 0 c   | 1  | 0   | 1   |
| row-6 | a, 0 b, c     | 1  | 0   | 0   |
| row-7 | a, b, 0 c     | 1  | 0   | 0   |
| row-8 | a, b, c       | 1  | 1   | 0   |
+-------+---------------+----+-----+-----+
```
That is even cooler! And I hope it helps to show the mapping between the MatSumSig model, and the BKO scheme.

I guess it would also be useful to give the OR-k and AND-k matrices:
```sa: matrix[OR-2]
[ x1 ] = [  1  1  ] [ a ]
[ b ]

sa: matrix[AND-2]
[ x1 ] = [  0.5  0.5  ] [ a ]
[ b ]

sa: matrix[OR-3]
[ x1 ] = [  1  1  1  ] [ a ]
[ b ]
[ c ]

sa: matrix[AND-3]
[ x1 ] = [  0.33  0.33  0.33  ] [ a ]
[ b ]
[ c ]
```
Update: Let's do the compound example:
```f = (a AND b AND c) OR (d AND e)
[ f ] = [ BF[x1] ] [ 1 1 ] [ BF[x1] ] [ 1/3 1/3 1/3 0   0   ] [ BF[x1] ] [ x1 ]
[ BF[x2] ] [ 0   0   0   1/2 1/2 ] [ BF[x2] ] [ x2 ]
[ BF[x3] ] [ x3 ]
[ BF[x4] ] [ x4 ]
[ BF[x5] ] [ x5 ]
```
Now in BKO:
```-- define our patterns:
pattern |row-1> => 0|x1> + 0|x2> + 0|x3> + 0|x4> + 0|x5>
pattern |row-2> => |x1> + 0|x2> + 0|x3> + 0|x4> + 0|x5>
pattern |row-3> => 0|x1> + |x2> + 0|x3> + 0|x4> + 0|x5>
...

-- define our operators:
AND-3-2 |x1> => 0.333|x1>
AND-3-2 |x2> => 0.333|x1>
AND-3-2 |x3> => 0.333|x1>
AND-3-2 |x4> => 0.5|x2>
AND-3-2 |x5> => 0.5|x2>

OR-2 |x1> => |x1>
OR-2 |x2> => |x1>

f |*> #=> push-float binary-filter OR-2 binary-filter AND-3-2 binary-filter pattern |_self>
```
And the matrices:
```sa: matrix[OR-2]
[ x1 ] = [  1  1  ] [ x1 ]
[ x2 ]

sa: matrix[AND-3-2]
[ x1 ] = [  0.33  0.33  0.33  0    0    ] [ x1 ]
[ x2 ]   [  0     0     0     0.5  0.5  ] [ x2 ]
[ x3 ]
[ x4 ]
[ x5 ]
```
Update: let's be more terse with our sigmoid names.
```binary-filter => BF
xor-filter => XF
```
And then we have:
```OR |*> #=> push-float BF OR-3 BF pattern |_self>
AND |*> #=> push-float BF AND-3 BF pattern |_self>
XOR |*> #=> push-float XF OR-3 BF pattern |_self>
f |*> #=> push-float BF OR-2 BF AND-3-2 BF pattern |_self>
```
Cool. I like the compact version better.