## Need for it

My exact thoughts were:

It would be cool to have a font which is fully symmetric. Every symbol having Left-Right symmetry and Up-Down symmetry. You would still have to read left to right like you would do, but if you take care of that, the symbols look the same in the Mirror world or inverted mirror world.

## Segment display

I will be only using 7-Segment and 16-Segment digits to show here.

I am only using segment display to make my life easy and since the symmetries we are interested are line symmetries. LR symmetry is by horizontal line and UD symmetry is by vertical line. Segment display’s segments play well with these axes of symmetries.

### Seven Segment

As the name implies, each digit consists of 7 individual segments which are lighted accordingly to convey the digit.

The [0-9] digits look like this:

Each individual element separately controlled. So, we can start naming each of them starting from the topmost and going in an clockwise fashion as A, B, C, D, E, F, G.

For simplicity sake, we can express the same as “ABCDEFG”.

The following shows the mapping between our naming and the segment in the 7-segment display.

There are in total $$2^7$$ posibilities.

#### LR Symmetry

Comparing the original digit with a Left-Right inverted one, we can identify segments which should match to give a symmetric digit.

Starting off with original as “ABCDEFG”,

LR symmetry makes it “AFEDCBG”

Equating both to preserve symmetry “A=+D+=G”, where “+=” are used as placeholders for segments.

Thereby, enforcing constraints and bringing total number of free parameters to $$5$$ which leads to $$2^5$$ possibilities.

#### UD Symmetry

Doing similar thing for UD symmetry case,

Starting off with original as “ABCDEFG”,

UD symmetry makes it “DCBAFEG”,

Equating both to preserve symmetry “+%%+==G”, where “+=%” are used as placeholders for segments.

Thereby, enforcing constraints and bringing total number of free parameters to $$4$$ which leads to $$2^4$$ possibilities.

#### Full Symmetry

Enforcing LR and UD symmetries at the same time, brings out, “+==+==G”, where “+,=” are used as placeholders for segments.

In the fully symmetric case, number of free parameters is $$3$$ which only yields $$2^3$$ possibilities, which isn’t even enough to cover the alphabets.

You can do base 8 counting though.

### Sixteen Segment

This segment display has 16 segments.

The [0-9] digits look like this:

#### Repeating for sixteen-segments

Here, our naming convention would “ABCDEFGHIJKLMNOP”.

The following shows the mapping between our naming and the segment in the 16-segment display.

There are in total $$2^7$$ posibilities.

For a $$16$$ segment digit, we have $$2^{16}=65536$$ possibilities.

#### LR Symmetry

LR symmetry brings the number of free parameters to $$9$$ emitting $$2^9 = 512$$ possibilities.

Due to the sheer size of the set, I won’t be showing them here.

#### UD Symmetry

UD symmetry also brings the number of free parameters to $$9$$ emitting $$2^9 = 512$$ possibilities.

Due to the sheer size of the set, I won’t be showing them here.

#### Full Symmetry

Applying LR and UD symmetry constriants brings the number of free parameters to $$5$$ giving only $$2^5 = 32$$ possibilities.

The generating signature is: “CCAACCAADDEEBBBB” where “ABCDE” are placeholders for .

## Ending notes

### Segment display

I made use of this JS for displaying segmented displays. The edited JS script can be found here.

### rexgen

I used rexgen to generate the bits. I could have written a pythonic-or-C function to generate combinations but I was just lazy.

A sample code to generate full symmetry bits for $$7$$-segment is:

rexgen '()()\2\1\2\2'


### Insufficient

Even in the case of $$16$$ segments, the full symmetry charset cardinality is only $$32$$. So, you can cover the alphabet set or the digit set but not both simultaneously.

If you cover all the alphabets, you would only have $$6$$ remaining in the set so you can have like base6 digits.

### Mapping

Let’s say we only want to map alphabets in $$16$$-segment full symmetry case.

How would we do a one-to-one mapping? This is more of a design question than a scientific question now. I am not going to do this now.

Maybe when I am in the mood, I’d. Or, maybe, anyone can define their own mapping which can be their own encryption.