N-bit meta-logic (n times cpu speed, n times ram usage)

So, I know its a wild theory at this point, without practical implementation, but lets run through the binary logic, the 4 bit logic, and as i referred to earlier on this blog, n bot logic, a bot being a 2^n bit logic.

The assumption is that it doubles ram usage while improving the speed according to its bot/2 value, so let's say 2^2=4bot is twice the speed at double the ram. 2^4=16 times the speed, at 16 times the memory cost.

Let's try to discover how to write the meta-logic to this. I just follow my own steps at first.

Note: I have a feeling this could be implemented as a software patch.

Discovering the algorithm

I'm looking back at my post on 4 bit propositional logic here: https://mtk2times2.blogspot.com/2022/12/4-bit-propositional-logic.html

About & in n bot logic:

First we write down all permutations of 2 bots. Those being:

2&0=0

2&1=0

2&2=2

2&3=3&2

3&2=2&3

So, for 8 bot logic, we would have to write the combinations of:

n&m

But what about the results? 
2&3=3&2 means according to its metalogic, that: n&m=m,n3,n2,n

Where n1 is n+1 and n2=n1+1

With m being higher than n3, n2 being higher than n1, and n1 being higher than n. Just the next number.

Then,

We write down all the permutations of the other numbers. That's how we get our & operator for n bot logic.

Inclusive or | in n-bot logic

Looking back upon the 4bit post, it looks like it follows the same pattern as above. First write down all permutations.

For m|n with m being higher than n, the answer is n|m.

For n|0 the answer is n.

For m|n where n is lower than m, the answer is the same logic as to the n-bot & operator, it being: write down n to m with | in between.

Exclusive or as denoted by /

It follows the same logic as inclusive or, just that n/n =0.

not or !

!n=a|b|c, where a and b and c are the bits of the n-bot, and a!=n, b!=n, c!=n etc. So you take n out of the definiton, and replace it with it being exclusive or a, b, c. Or alse d, e, f in higher n-bot logics, etc.

If then

This is the tricky part I guess, but it follows a meta-logic.

Let's see.

This follows the rule of: Eclude from your answer n, and write in order of going higher, with the | operator.

Now,

I have a suspicion you have to implement the lower order n-bot logics for higher n-bot logics to work. Can this be done inside a kernel, throttling cpu by ram usage?