Topic awaiting preservation: My First 8x8 Ortho (Page 1 of 1)

A little over a year ago I put away all of my notes concerning xor and
orthos. Then, about 3 weeks ago, my brain started up again and wouldn't
shut-up. I started working on it again and things just started exploding
in my brain.

A few days ago I had managed this:

0 1 3 2 4 5 7 6
3 2 1 0 6 7 4 5
1 0 2 3 5 4 6 7
2 3 0 1 7 6 5 4
4 5 6 7 2 3 1 0
6 7 5 4 1 0 3 2
7 6 4 5 0 1 2 3
5 4 7 6 3 2 0 1

4 5 7 6 2 3 0 1
5 4 6 7 3 2 1 0
0 1 3 2 6 7 5 4
1 0 2 3 7 6 4 5
6 7 4 5 0 1 2 3
7 6 5 4 1 0 3 2
3 2 0 1 5 4 7 6
2 3 1 0 4 5 6 7

That is an 8x8 ortho that I had created in 4d space. Orthos are basically
a single transversal in 4d space, so why not?

Those do look an awlful lot like xor at a glance, but they are not. Let
me perm/reduce one for ya real quick:

0 1 2 3 4 5 6 7
1 0 3 2 5 4 7 6
2 3 0 1 7 6 4 5
3 2 1 0 6 7 5 4
4 5 6 7 1 0 2 3
5 4 7 6 0 1 3 2
6 7 5 4 3 2 0 1
7 6 4 5 2 3 1 0

A lot of it does look like xor, but it is broken in a few places. I didn't
intend to break it just quite yet, but I did and I am *very* happy with it.

That is absolutely gorgeous.

I am doing it manually using Pygame. Playing a kind of board game in 4d
on a 2d screen is interesting. Once I understand the rules a little
better, it shouldn't take much to code it to where it will solve 100%
of the time.

And there is this really bizarre pattern in xor that I can't quite figure
out. Most of it is easy to see, but there are anomolies that I can't
explain. It's recursive or self-modifying or something. It is right on
the tip of my brain and it drives me crazy. I'll be at my regular job
and then start staring off into space trying to see what lies beneath.
I can already flex pretty damn hard as it is, but once I see the underlying
driving force, I will be unstoppable. I will get it, and I will shake
the pillars of Heaven yet again.

My work continues.

Cheers.

I have no idea what any of this means, but I enjoyed reading it. best of luck. Sounds like quite a riddle.

.Quotes.

Hey, Gilbert. I just wrote some stuff that takes this to a simpler level. Things have been crazy busy lately with RL.
Here is the post that should shed some light:

-----------


Since last post, my understanding has increased dramatically. Unfortunately,
been working 60hrs weeks at my regular job and things have been progressing
extremely slowly. Which is kind of a good thing because I am taking more
time to mull things over and finding traps before I even think about
code. That is, I'm finding logic bombs before they can become logic
bombs.

My first mistake was thinking in terms of swaps. Just like it sounds -
take two things and swap them. Thinking in this way isn't exactly
conducive. It kept leading to anomalies that I couldn't explain. So I
started thinking in terms of invert. Instead of taking two things and
swapping them, use XOR to invert them. When I shifted my thinking as such,
things started to make sense. New kinds of patterns started showing up
that I could explain.

Next mistake. In a few places in my notes I have scrawled the phrase,
"It's in the bits!" It is indeed in the bits, but I was looking at them
wrong. I was looking at bits in a 1d sequence. More anomalies that baffled
me. Luckily, I love re-arranging data and thinking in terms more like
dimensions. So I started looking at the bits in 2d.

Check it out:

. . . X . X X X    . . . X . X X X    X X X . X . . .    . . . X . X X X
. . . X . X X X    X X X . X . . .    . . . X . X X X    . . . X . X X X
X X X . X . . .    . . . X . X X X    . . . X . X X X    X X X . X . . .
. . . X . X X X    . . . X . X X X    . . . X . X X X    X X X . X . . .
X X X . X . . .    X X X . X . . .    X X X . X . . .    . . . X . X X X
. . . X . X X X    . . . X . X X X    . . . X . X X X    . . . X . X X X
X X X . X . . .    X X X . X . . .    X X X . X . . .    X X X . X . . .
X X X . X . . .    X X X . X . . .    X X X . X . . .    X X X . X . . .

Aren't those amazing? I love those little guys. They make it so easy to
see what I've been missing.

In each one of those squares, there are 4 X's in each row and column. I
brute-force interated it and there are 2,450 of them. But the trick isn't
just 4 X's in each row and column, but in their relationship to each other.
There has to be a very specific relationship between them: they have to
be "compatible". That compatibility takes the form of:

[0,0]=25%  [0,1]=25%
[1,0]=25%  [1,1]=25%

Once you have 6 of them that are compatible, you have orthogonal latin
squares of size=8. If you find 8 that are compatible, you have MOLS=3 of
size=8. And one of the cool things is that it doesn't matter what order
you put them in when putting them together. Once you have one set of
orthogonal latin squares, you can re-order the bit-planes and still have
valid latin squares (and MOLS). As long as the 25% relationship remains
intact, none of that other shit matters.

I have done some reading about orthos and it was either Euler or Knuth
that pointed to a structure that looks like this:

0 1  0 1
1 0  3 2

I can now explain that using bit-planes and distribution.

OMG, I haven't even touched on distribution. Thinking in terms of
distribution is another thing that has really helped me figure things
out. This goes back to the 25% thing. The 1d version is 50% and the 2d
version is 25%. Basic bits and XOR sequence in 1d:

....XXXX
..XX..XX
.X.X.X.X

Can you see it? Can you see how the 1d'ness of that leads to the 2d'ness
of the above squares? Can you see how half are the same and half are
different between any 2 lines of bits? Can you see how this leads to 25%?

....XXXX
..XX..XX

50% = same
50% = different

[..]=25% [X.]=25%
[.X]=25% [XX]=25%

------------

....XXXX
.X.X.X.X

50% = same
50% = different

[..]=25% [X.]=25%
[.X]=25% [XX]=25%

------------

..XX..XX
.X.X.X.X

50% = same
50% = different

[..]=25% [X.]=25%
[.X]=25% [XX]=25%

Yeah, it really is like that. Pretty wicked easy, yes? And that is the
start of the underlying dynamics of all of this.

Man, I love this stuff.

(Edited by warjournal on 08-16-2020 16:43)

I worked *only* 9 hrs today, so taking a few minutes to do what I *truly*
enjoy.

Take 6 bit-planes of size=8 and all 6 must have the same 25% relationship
between all of them. To me, this feels very correct and right on par. But,
just to see, quickly cobbled some old code just to double-check.

It took some code that interates over all possible permutations and outputs
the ones that are orthogonal. Then I put the bit-planes over each other
using bit-shifts. The important line looks like this:

nv = b0[row][col] | (b3[row][col]<<3)

Then I ran that through my base(64) sequence of symbols (because 6 bits
is 64 or 0-63). Then I counted up the unique symbols. Here is a small
sample of what I got:

u f Q B a r 6 N
n W J 2 j y F U
g x 8 P s d K 5
Z o 1 G - k T C
4 L c t O 9 w h
D S l + H 0 p Y
M 7 q b A R e v
V E z i 3 I X m
64

m X A R i z M 7
v e 3 I b q V E
Y p O 9 + l 4 L
h w H 0 t c D S
C T s d G 1 g x
5 K - k P 8 Z o
U F a r 2 J u f
N 6 j y B Q n W
64

W n A R i z 6 N
f u 3 I b q F U
o Z O 9 + l K 5
x g H 0 t c T C
S D s d G 1 w h
L 4 - k P 8 p Y
E V a r 2 J e v
7 M j y B Q X m
64

Each one has 64 unique symbols in base(64). This shows that (maybe not so
clearly) that all of the bit-planes have the exact same 25% relationship
between all of them. This shows that (maybe not so clearly) that you can
order the bit-planes in any way that you want and still get valid output.
Same relationship, any order.

Ugh! Too many emotions to deal with right now.

But I would like to thank the Doc for keeping the lights on. Still giving
me a voice for the things that I truly do enjoy playing with.

Omg, after approx 4 yrs I have generalized orthogonal latin squares (and
MOLS) of size=n^2. Shaking the pillars of Heaven doesn't get much better
than that.

OMG I'm wrong about something!
I don't know what, but this just got fun again.