Letter Folding

The 3D models provide a natural structure using folding to generate a truth table across the letters. [unfinished]

3D Systems

The Ezekiel's Bones project at Paleo.In explains the 3D model system that underlies the 2D shapes of the drawn Paleo Letters.

That 3D system as 4 different model series that map to various stories in scripture.

The Joseph series, also called the Silo and Well series, takes the letters of the alphabet and successively folds them together. That folding process produces the 3D models that assemble both into a silo and into a well.

That series shows the single starting point 3D object from which the entire alphabet develops.

The 3D folding model can be expressed as a truth table, about like what would be used in digital electrical engineering. This article follows the same folding pattern as used in the 3D system, but generates the bit pattern that selects from those models.

The summary table at the bottom of this article is important because it shows in a pattern of 6 bits or 64 specific rows or cases.

The DNA codon table contains 64 cases too so there is structural match between the Paleo Alphabet and the DNA.

To make this easier to follow I've broken this down into steps that match the fold points in the 3D system. Notes accompany each step.

Step 1

The following shows the alphabet in order, without punctuation.

In the 3D system the punctuation has an independent folding path. The fold point is at the 1/2 way point. This folding design is something any child learning the alphabet would be taught.

Step 2

In this step, the previous table has been augmented with a 2nd and 3rd row. The second row shows the left and right sides of the alphabet, designated with L for the 11 left side letters and R for the 11 right side letters.

Also on this table, the numbers 0 and 1 are shown with the L and R letters. The left will be assigned a base 2 digit of 0, and the right will be assigned a base 2 digit of 1. These 0 and 1 values will be used in tables that follow to produce a binary table that maps out the alphabet.

Binary tables, as we are developing here for the alphabet can be thought of as a tree, where each column represents a decision point on a journey.

The following tables shows what will become the most significant digit in the final table at the bottom of this article.

Step 3

In this step the previous table is flipped on it side.

This is so we can watch the numeric values of 0 and 1 in successive versions of the table.

Step 4

In this table another bit is introduced. This new bit marks another round of left/right folding.

The challenge here is that each half of the table has only 11 letters. In the 3D system that middle letter folds on itself.

That case is marked with an X instead of an L or R.

In this truth table the X represents a "don't care." This 3rd state of binary logic is important many engineering problems. That X will be expanded in the next step below.

Step 5

In this step the Xs are removed. This is done by duplicating the row, and leaving a 0/L and a 1/R instead.

This is the first step in growing the list so all 0/1 bit combinations point at unique letters.

Step 6

In this step each block of L or R is folded again into L and R sides.

This adds another bit.

There are no X cases this time around because each L and R block in the table above is an even length. The new bit introduced here identifies an exact half of those 6 unit long blocks.

Step 7

In the step another digit is added. This digit is used to break the blocks above into L and R sides.

In this case each L or R block above is 3 rows long. This is not evenly divisible and so the middle row in these triples is marked as an X.

In the matched 3D system the rows marked below with an X fold onto themselves.

Step 8

In this step each row with an X is replaced with 2 rows, an L and an R row.

This removes the don't care. But, for certain letters, it duplicates those letters in the far right column.

Step 9

In the table above, each of the L and R sides is now 2 letters long. Each of these 2 letter sides must itself be folded again. Because each L/R set above is even length, this step here does not generate any don't care, or X, cases.

So far these 5 digits select from 32 cases but together select one of the 22 letters. Conceptually, it only takes 5 bits to uniquely select one of 32 cases, and the 22 letters of the alphabet fit within 32 cases. So the following table appears to be complete.

Step 10

The 3D system has 1 more final object above those needed to select between the 32 cases as in the table in step 9 above.

This final object is NOT choosing between, or folding, the letters. This final object chooses between letters and punctuation.

The object is not exactly folding, either. All sides on the 6 sides of this final object are exactly alike. They included dots and lines. Instead of folding, the operation is joining or clicking, objects in the punctuation tree and the objects in the letter tree.

For the purposes of the following truth table another bit is going to be introduced. B5. This will be a Don't Care in every position. It does not select letters, it selects if this is a letter or a punction.

The step here introduces this bit as all dont cares.

Think of each row as being folded, and since it is only 1 tall it is an odd number. So like in earlier steps a don't care is being folded into each row.

Step 11

Just like in earlier steps, each row with an X must now be expanded into 2 rows. As normal, a row with a 0 and a row with a 1.

In this step the total number of rows is brought up to 64, the same number of rows in a codon table from the DNA.

Note also that each letter in this table has either 2 or 4 rows. This is similar to the codon table where nearly every entry is either 2 or 4 codons shared.

What we have NOT done yet is merge the punctuation back onto this table. Some of the following letters are false, they are showing up as in the table, but in reality they should be punction. That problem will be addressed below.

Step 12

This step is just a clean up step. Each line in the table is given a base 10 number that matches the base 2 number in the bits. The L/R column is removed. In all bits, all columns, L = 0 and R = 1.

This is a summary of a 6 bit truth table for the letters of the alphabet.

What is still missing is assigning punctuation to some of the rows. That problem is tackled below.