Unscrambling the cube

Not open for further replies.
This is a distance table for the group (of pairwise adjacent operators), that forms the 2-generator set, which is all permutations of any pair, so a row or column of B is not permuted (this implies a function like invert(permute,combine), say):

                                  Number of vertices
				   at distance r           

                        r                             log B(r) / log(r)
                        0              1                   −
                        1              4                   −
                        2             10              2.32193
                        3             24              2.46497
                        4             58               2.6427
                        5            130              2.84243
                        6            271              3.02772
                        7            526              3.19162
                        8            980              3.33333
                        9            1750             3.46023
                       10            2731             3.57449
                       11            3905              3.6604
                       12            5229             3.72191
                       13            5848             3.76469
                       14            4792             3.77948
                       15            2375              3.7576
                       16            508              3.70136
                       17             18              3.62837

           Table 1: The number of vertices at distance r from the origin

There are 18 nodes which are a distance of 17 from the identity (N = 1); these 18 must each have at least one generator, which is a word like A.B. There is a set of words that will generate sufficient (or all) of the 18 nodes at r = 17, these will also have a distance from each other which is a function of the word length.

In fact here is a paper that analyzes this group of extreme nodes (antipodes). You can see what their opinion is of the logarithmic function expressed as a ratio in Table 1.

Note that the algebraic freedom to select any pair in the subgroup (which together form an adjacent pair) is a function that depends strictly on H_color.
Note also that the first transition from r = 0 to r = 1 for the subgroup yields 4 nodes at the same distance.

There are 2 directions and 2 "digits" X,Y that explain this, since 2x2 = 2+2 by way of 4 being a perfect square--hence the first "interval" is a perfect 4th (think about what a 5th, 7th, etc, is represented by, then consider that there are 12 edges on a cube equivalent to 12 points on a sliced geodesic ball, which is the same as the number of spheres in the packing problem that Newton and one of his contemporaries never resolved or "Kepler's Spheres". Kepler believed the ratios of planetary orbits to the orbits of their moons was a harmonic equation that was a kind of music...)

There is a monotonicity, which is the appearance of prime factors larger than 2 or 3 in the subtotals T, indexed by n and an inner "mechanical" m, both natural numbers with countably infinite range, domain R the reals. The 4-color/2-color identity is the open "box" B with four sides colored. There are exactly two ways to leave two faces (A and B) black, one of which also leaves a dihedral element of the full group (of combined elements) completely black, this reduces the diameter of the Cayley graph, but not n or m. The twist and flip operators (which are compositions or combinations of more fundamental functions, that act on sets of elements, the 2-ary swap() and 1-ary invert() operations on words with "color indices"), leave this element unchanged after acting on it (any actions "from the left" are the same as "from the right" if the order is swapped around, or if they're inverted, the element is "at infinity" as far as B is concerned, the machine simply outputs "bb" for this element, which is at the apex--of the cone over the simplex)
Last edited:
noodler said:
Let's revisit the sequence problem:

S1 = 18, 243, 3240, 43234, ...
S2 = 9. 54, 321, 1847, ...
S3 = 6, 27, 120, 534, ...

Assume the first term for each S is actually just a "start" function, like booting up a computer system.

This one has 6 i/o kinds of processors initially, which are S3 -- this means it can "talk to itself" along 3 i/o channels, each 1/2 of the channel verifies it is ready to send/receive; S2 is a group of 3 of these also forking (device ready if you will, back to the kernel), and S3 is actually a copy of the state of S2+S3, on a dual-processor kind of system.

So that, if the smaller device is a kind of channel-with-blocking, and a fork/exec paradigm applies, the larger is a monolithic realization of the kernel of a system that given enough parallel (recursive) processes and fork-exec headroom, each of the following "bins" which are the next 3+ terms, will be filled at one step, n.

Then a single exhaustive enumeration of all steps, by iterating over n, and descending/ascending back-and-forth alternately between n-1 and n+1 to fill the place for n, occupied by the subtotals listed as f and q. This is what T is about, the number of processes the system needs to fork so they can all exec the required forward or backward step, from n.

The next step goes 27, 54, 243. The first two of these, are actually made up of "carried or borrowed" terms from further ahead. In fact this lookahead gets as wide as 6, in a single iteration of n, from 1 to 14, if and only if the enumeration (algorithm) visits enough nodes "in place" that it needs to do this. The width of the carry-borrow register T_w, varies with both the depth of each parallel recursion (in principle, at least), and the width of n, the number of places.
With more cubes, you could have a pipeline, with each at a different width/breadth in the enumeration.

Obviously the application of the "full metric" which comes with the square() function, gets to the extreme more quickly, so is more efficient. The remaining "gap" that the shorter single-step approach leaves behind, is like a phase difference, for the overall system (or for each of p cubes in a pipeline, simulating a parallel computation of |G| the full width/depth).

If the gap between n = 11 and n = 14 is a characteristic of "periodicity" then if it is a phase-difference, there is a gauge theory for this, that we can write in terms of twist(), and flip(). Since the latter acts only on dihedral elements of G, it reveals that invert() and swap() act in the same way, when one of these has a "b-side".
Oh yeah, it's a yellow submarine, alright.
Last edited:
Conjecture: UNIX was designed originally because its authors saw a need for a more general OS, MULTICS was a good idea, but the hardware of the time wasn't really up to it.

The other reason, I once heard, is because they wanted to play Zork.

But the idea I have, is that UNIX was/is a more general theory of what a computer should be. This is the same domain as what Erno Rubik did to the Platonic solids.

Definitions: the face metric is the number of positions a face can be in. A "face" corresponds to an X, where X is a member of a conventional face-labeling which identifies the color of each face. We do not concern ourselves at this stage as to the definition of color, rather assuming that a set of distinct "pre-calculated" colors is available. In fact we can adopt a "standard" which is the Ideal basis, as manufactured (quark-style) by toymakers.

This corresponds to an ideal set of color relations. In actuality, identical color is the identity of the basis of synchronization of abstract "processes" which are actions of subgroups (of abstract algebraic functions) on sets of elements. There is a full "outer" group of actions on all the elements, including those that alternate views of the cube itself (the faces group of elements of C which project color to the apex, which is the number of cone cells in your retinas that do not respond to any input, or abstractly are "blocked" or "sending a string of zeros", we imagine a DC voltage level--the action potential--attached to some kind of switch).

Seeing a colored sticker is equivalent to seeing a number on a calculator display--the pop function = apply(color,x). Then we immediately have apply(push,(color(x))), by default.

Turing claimed that, in order to see a symbol it has to have been written by either some kind of automatic, deterministic machine, or by a more general kind which can be configured (programmed) to write the symbol. In Rubik's puzzle domain (and the mathematical extensions in 4 and 5 dimensions), colored elements are the symbols, that is, geometric relations are black and white, the colors additional to these give the geometry an algebraic form.

The metrics depend on the number of colors used, on how many elements at a time, and so, on how the cube has been sectioned. In fact to see anything other than geometry you need to start coloring the sections (the sliced cube is geometric but the theory of "words" is not). This is a weak connection to the theory of waves, in a wavefunction, type of thing (pun intended here).

The 1/4 transitive action of the minimally active configured-space (i.e. N is =1), is because you need to deploy it on at least two adjacent pivots. These both act centrally, to more or less "launch" a fraction of themselves into an orbital (twisted) state.

Each of two generators acts on a fraction of the "coordinates" UR, say. Each has a "potential at equilibrium" U,U', and R,R', so that the inner dynamic has a term: 1/4(U+U'+R+R'), as outlined in the previous link, this can be rewritten: 1/4(Px,Py), and extended to the 3-generator group as 1/4(Px+Py+Pz).

When two of the external facets are equal in color, this is in the same domain as confirming that two frequencies are equal; exactly the same domain, in fact.
If the speed of "color" is the same in all the versions (if the 4 and 5 dimensional computer models use the same laws of physics and calculation), then there is no reason you can't build a network of elements, all communicating by sending and receiving set frequencies over an agreed bandwidth and scale.

Oh, wait, you could just make gazillions of 'em, and assume that they are communicating in color, if they have colored stickers on them. The links would then be all the human brains comparing one or more examples, synchronously, or using a computer algorithm to sort random samples for instance.
This is the strong link to Einstein's special theory, in which synchronization of clocks replaces (but not really) synchronization of (visible) frequency.


Unt zo, the general theory is connected via the following proposition: EFE is essentially a theory based on iterations of coordinate transformations, into and out of the frequency domain, to determine gravitational effects (a word, with n digits, which is alpha and omega) in terms of space and time (sections or areas, and wavelengths), Platonic solids are "ideal solids" in that they prove a proposition about causality, and slicing them deeply only introduces a deeper proof--that figuring and moving various parts of a regular Platonic solid after slicing it so they transform geometrically can be scaled to a very large (universal Platonic form) or very small object.

The computer models project these onto a screen which has 2n dimensions. The 2-generator group exists when there are two faces colored, then N goes to 2. This leaves two of the group of eight trihedral "corner cubies" black, and they aren't included in the group of generators, so can be bandaged (blocked). To make sure you could actually glue or tape them together so they not only meet up but are joined--which is then a kind of fundamental Boolean proposition, and this bandage is a lambda for the calculus...

On the brute force enumeration of the Pocket Cube: each of the f and p values as n changes, has a maximum. This is the greatest recursive depth a parallel processor system would need to allocate, at each point. This is then modeled by that many cube-cells all having a different permutation, given the same (n-1)th or (n+1)th configuration. So here the system borrows from ahead, and from behind. At the start, it must borrow ahead, because the enumeration proceeds in both directions--there is no carry at n = 0. At the end it must borrow from behind, or in other words, the difference of 3n is exhausted by the f-group at n = 11, the q-group has to fill its last 3 places from somewhere, which is all the q still "in f", the QTM hasn't reached at this point; the series "spirals inward", I believe, along a series of "rays" that connect the last 3 terms for q, to the f-group, it must look something like triangles in scale perspective according to some logarithmic ratio, so they all lie on a triangle (or along the edge of a Mobius strip, perhaps). Q is the character that "makes it so. number 1..."

Recursive depth would correspond to transporting something around a Mobius strip along both edges simultaneously - say the strip can section itself spontaneously into the required number of loops, you can prove this in principle by cutting around a paper strip close to an edge, maintaining a small but finite distance from it. So here, the "flippance" of a strip corresponds to invert(x), and the "twistivity" corresponds to twist(x,y), for points x or y (a squarable set, since the edges of a region of the strip define a square or rectangle as long as both are straight)


Note that in the image of a strip, U and R correspond to the centerline and the real number line respectively (the symbols are overloaded)...
Last edited:
I'm going to get seriously incoherent at this stage:

Here is a table that is the result of an iteration, with recursion, for the Pocket Cube.
The horizontal values, n, are steps in the face-metric, and the vertical values, m, are steps in the quarter-metric, for turns or moves over all elements.

 	0	1	2	3	4	5	6	7	8	9	10	11	Total
QTM 0	1												1
    1		6											6
    2		3	24										27
    3			24	96									120
    4			6	144	384								534
    5				72	768	1,416							2,256
    6				9	564	3,608	4,788						8,969
    7					126	3,600	15,072	14,260					33,058
    8					5	1,248	18,996	57,120	36,780				114,149
    9						120	9,480	85,548	195,400	69,960			360,508
    10							1,728	55,548	341,604	487,724	43,984		930,588
    11							72	14,016	238,920	841,500	256,248	96	1,350,852
----------------------------------------------------------------------------------------------------------------- <- edge of 11x11 square
    12								1,032	56,440	455,588	268,532	944	782,536
    13								12	928	32,968	54,876	1,496	90,280
    14										8	160	108	276
         1      9      54     321     1,847    9,992   50,136  227,536 870,072 1,887,748 623,800 2,644  (=3,674,160)

The sets are ordered by the functions q(m) and f(n), say. Each "bin" T(m,n) is partially ordered, or if you selected a random sample from any place indexed by m and n, they would all be similar somehow, as geometric figures like triangles can be similar.

Note that: the largest bins and subtotals respectively where m and n intersect, are where a randomly permuted set of samples (as free variables) would be expected to be found. So locating a given Pocket Cube which is in scrambled form, properly in the table so it has functions q(m) and f(n) to identify it, is in the classical probability domain.

So a question that comes up straight away is: how many colored stickers are required to separate the samples from each other, and how many does the form at (0,0) have, compared to any at (14,11)?
Last edited:
An "interesting" detail: the cycle order of arbitrary length sequences of the forms UR and U'R (algorithms that permute the elements of the cube puzzle), varies periodically. The fundamental order of a cycle will permute the elements so they all return to the positions+orientations they had at the start--such a cycle restores or preserves the identity.

The order of UR is 105 and of U'R is 63 (you can verify this using Cube Explorer or similar software). That is, if you repeat the string UR 105 times, it returns to the start of the algorithm and leaves the elements unchanged. The order of UR is the same as the order of RU.

For the other string, which is in the cross subgroup, 63 repeats generate the same "return to sender" algorithm. Note that U'R, UR', R'U and RU' have the same cycle order.
Note also that 105 - 63 = 42. This means that the symmetry looks like: order(UR) => 7(12 + 3), order(U'R) => 7(12 - 3). Likewise, the R and U can be viewed as abstract nodes that meet along edges (which are the real edges of the puzzle), or as abstract edges that join nodes, the edges R and U are then the arcs between nodes generated by rotations. Then an operator U is either a node with edges, an object class: _o_, or an edge between nodes, class: o_o.

An operator has the freedom to "direct" itself to join an edge to another node, as in: _oU_ + _Ro_ -> _oURo_, or: o_U_ + _R_o -> o_UR_o. The positioning of the letters is just a convention that attempts to encapsulate the process of adding a node to a graph. There should be stricter rules about this:

Rules of graph construction (non-universal version)

1. An empty graph has no nodes.
2. A node "meets" a graph when it "pops" into existence, or, you dump a register (like a particle into a vacuum, say).
3. A graph "joins" nodes with edges, these are lying around (i.e. edges are like a child process of parent nodes).
4. Edges are added between nodes that meet each other.
5, Edges join nodes, and nodes meet edges.
Last edited:
Ok, I think I'm getting a handle finally on the twist group. The orders of UR and U'R are known, and that both algorithmic forms can be rewritten--the rules are rules of inversion. UR and RU (also U'R' and R'U') have the same symmetry (are isomorphic) as do U'R and UR'.

When these are combined there are more ways to alternate the inversion rules over the algorithm's structure. URU'R has cycle order 5, in 4 letters. If you take the inverse directly this is: R'UR'U'. If you alternate the number of inverted ops you have a braid group on 4 letters. This is something like plaiting several strands together--because there are 4 letters taken pairwise with inversion included, you can weave the inversions through the algorithm, and this explores (as in, using Cube Explorer or similar) the structure of the group's order relations.

Since URU'R is order 5 this means repeating it 5 times returns all elements to their initial positions and orientations. If you repeat it 2 times it still has order 5. In fact any multiple of 5 has order 5, even a very large multiple. Any iteration count which isn't a multiple of 5 will repeat 5 times, so this algorithm is involutional. I believe this subgroup of the 2g group of the full set of generators is the M_5 component (a subset of M_4) that twists the corners.

I have a 3x3x3 puzzle which at the moment has a single layer permuted. This has 3 twists in the same sense (anticlockwise) and no flips, but 2 of the edge components are translated by +1 and -1 in respect of how the entire subgroup of components needs to rotate to be congruent mod colors.

Alternating the prime symbols, in an algorithm with the general form XYX'Y so it becomes XY'X'Y, for instance, will alter the cycle order (and you get prime orders: 2,3,7 and multiples). This can be alternated again by introducing a third generator, adjacent to the first two. The first rewrite here can be, for instance: XY'Z'X, which is the subgroup that generates a 7-component "figure" that looks like a "Y" when you look directly at the center (which is the corner component with three "legs" along the edges). With at least one alternate letter, and the alternation of inversion over the order of these letters you generate another braid group.

My conjecture about this algorithmic form is that it is a general way to permute the remaining elements (none are excluded, as in the 2g group), and develop a solution strategy. Of course, software can give you a solution after you enter a permuted state into it, but this is only one solution, you really want something general that you can modify. My general solution is in the family of F2L, then using the constraint that, to preserve a part of the first two layers, I have to keep the "up" face oriented upwards, and use only the QTM on the "side faces". I have an out because the D-layer stays in the FTM.

So I have: U blocked, F,R,B,L in the QTM and D in the FTM. If I include U or ignore orientations I can freely choose which part of the structure of XY'Z'X is the D-layer, and permute the remainder freely in this manner. Likewise if I restrict it, I can permute the remainder and eventually eliminate the number of pivots (operators) used, so the sequence of restrictions applied goes from a single excluded or eliminated pivot (U), and 5 free, to only one free (D). Then trivially, as they say, I am one move from the solution...

So the message is that one of these:

is in one of the locations in the table above. It's in the "solved" state, but that could be because it was in any one of the other states and someone solved it. The table shows that there is a hierarchy, and that transitioning through this means being in position either at the (n-1)th or (n+1)th place with m fixed, or the (m-1)th or (m+1)th place with n fixed.

The puzzle itself is a "dumb" device that can be used to locate a position in the table, in terms of applying the set of operations that transform the device's appearance. The way the "locator" transforms is the information that locates it in the table. Restricting the operations to a minimal action--no double moves allowed--makes the number of steps exactly three more than when double moves are allowed.

The puzzle itself is the finite part of a finite automaton, and the table is a chart of where the full and restricted transitions intersect each other.

Kenneth Krohn and John Rhodes announced at a conference in 1962 a method for decomposing a (deterministic) finite automaton into "simple" components that are themselves finite automata. This joint work, which has implications for philosophy, merited the award of two PhDs: to Krohn by Harvard and to Rhodes by MIT. Simpler proofs and generalizations of the theorem to infinite structures have been published since then (see Chapter 4 of [Steinberg & Rhodes, 2009] for an overview).

Krohn and Rhodes found a general decomposition for finite automata. In doing their research, though, the authors discovered and proved an unexpected major result in finite semigroup theory, revealing a deep connection between finite automata and semigroups. Presently work by Egri-Nagy and Nehaniv is going ahead to further automate the holonomy version of the Krohn-Rhodes decomposition extended with the related decomposition for finite groups (so-called Frobenius-Lagrange coordinates) using the computer algebra system GAP.

Applications outside of the semigroup and monoid theories are presently becoming computationally feasible. They include computations in biology and biochemical systems (e.g. Egri-Nagy & Nehaniv 2008]), artificial intelligence, finite-state physics, psychology, and game theory (see e.g. [Rhodes 2009]).

...the idea of hierarchical coordinate systems giving understanding computationally has not been much studied nor applied. Now such tools are available open-source [Egri-Nagy and Nehaniv, 2004, Egri-Nagy and Nehaniv, 2008] for transformation semigroups, complemented by our work reported here for groups giving fine detail on coordinatizing the groups involved.
The mathematical significance of these coordinate systems is immediate, but as they capture one of the basic aspects of our cognitive capabilities, namely, hierarchical representation, they might also play significant role in Artificial Intelligence.

If you don't know what a wreath product is, or a semigroup, just pick up a Rubik's cube. The pocket cube's wreath product looks like: S8 ≀ C3 ≀ S7 ≀ C3 ≀ S6 ≀ C3 ≀ S5 ≀ C3 ≀ S4 ≀ C3 ≀ S3 ≀ C3 ≀ C2 ≀ C3. Each Sn is a symmetry group and each Cn is a cycle group. S8 is the symmetry group that represents the choice made at the start of the coordinatization procedure, and there are 8 components (see above) with the same symmetry.

The "intelligence" is obviously because the elements can be discriminated, and the discriminant is a function of color contrast. The automaton has two kinds of input: the contrast of color, and tactile feedback. The second can confirm that transitions are possible (without looking), and the first confirms that the transitions are a path-integral.

The path of least action is a solution, if you start at a random location, that always moves toward the solved state. If a random walk moves away from the solution then the path integral formula has to account for it, in the total "entropy of solution", and a maximal entropy random walk will visit all of the positions in the table, enumerating all the allowed states for the wreath product and its semigroup.
Last edited:
Here is how I would explain this to a kid who knows how to solve, or do tricks with a Rubik's Cube or similar kind of mechanical puzzle.

Start with a scrambled and a blank puzzle plus some stickers (which are isomorphic to the ones on the scrambled version), start stickering the blank by using any colored sticker on one of the elements. The sticker "elements" connect the colored version to the blank one. The facets are like slots for the colored stickers--hence the notion that the puzzles are like components with slots (for coordinates, x,y,z), which is what a tensor is.

The next step, after connecting the blank "space" with the fully-colored one, is to match the colors, then apply another sticker to the blank. The next step therefore depends on the context: do you match the same color or a different color, and in what context?
If you stay with the same color as in the first step, there are 3 other facets of the scrambled version that match. As soon as you copy one of these to the blank version, you "kill" part of the wreath.
You match an element of S8 to one in C3, now if you re-orient both copies of the "puzzle", by matching them up physically (i.e. under rotation) the first part of the wreath product vanishes, and you "fall through" to S7 and select another element, match it with one from C3 killing that level and adding colors to the blank.
So that S8 ≀ C3 -> 1, S7 ≀ C3 -> 1, ...

In parallel, however, adding stickers to the blank one at a time, under "matching" constraints, builds the wreath product in reverse: C3 ≀ C2 ≀ C3 -> C3 ≀ C2 ≀ C3 ≀ S3 ...

Ed: should have mentioned that the procedure only applies to the components with 3 facets (or slots). The components with one less slot are in a different wreath product, whose "outer" symmetry is S12.
Last edited:
Well, figuratively speaking, the model is evolving...

The Mendelian approach:

The table above can be considered a genealogy of classes of "species" which are all hybrids of "the twist group". This is true because "flippance" is zero at N = 2 (there are 2N-2 slices per face group).

So at m = n = 0 there is a single common ancestor (Eve), and the first generation has 6 haploids: X,X',Y,Y',Z,Z', and 3 diploids which are autosomes: XX,YY,ZZ.

Where m = n in the rest of the table, successive generations are related by common descent of a single 'turn', or the diagonal from (0,0) to (11,11) is where the FTM and QTM intersect, the first generation is where they also diverge from (1,1) to (2,1). Note the second generation is the only place in the family tree where successive divergent "species" have equal numbers, 24 at (2,2) and at (3,2), and that the number of hybrids increases along the diagonal by a factor of 4, for the first few generations.

Obviously the hybridization gets more complex as n increases and species "evolve", by combination and recombination, into chains. A chain of "descent" exists from the zeroth to the 11th generation, and within the 11th to the 14th family. The algorithm says that the minimum length is 11 steps from the ancestor, using the FTM which includes the QTM.
(The induced metric is the easy part).

Cube evolution goes next to N = 3 and "edge relations" appear. At N = 4 you have two ways to permute 2x2x2 subgroups since you can focus on the center slots, or operations on them and ignore the remainder (remove the labels or switch off the gene). What I need is a growth formula for a population which is limited, say by the medium it's evolving in.

Ahhh.... dear noodler.....

This seems all very interesting and everything, but... have you thought about maybe going outside and breath some fresh air? There's a beautiful world out there you are missing, buddy...

Also... maybe you should consider using your intellectual capabilities to solve more practical problems, such as helping develop a fusion reactor...

Finally... try getting a fuck buddy or somethin'... great method of releasing stress and recharging... ;)
Well, I have thought about how playing games of cards in a Casino is more interesting than playing cards at home, and sometimes you can win money too. But that depends on your grasp of combinatorial problems, statistics, poverty etc.

I should stress that this exercise is really only a part time occupation, I mean, I watch TV now and then so life isn't totally empty...
Well, I have thought about how playing games of cards in a Casino is more interesting than playing cards at home, and sometimes you can win money too. But that depends on your grasp of combinatorial problems, statistics, poverty etc.

I should stress that this exercise is really only a part time occupation, I mean, I watch TV now and then so life isn't totally empty...

Perhaps rather than suggesting you should go outside, you could think of what you are looking at as a Picture within a frame. Although you are mesmirised by the "cube" thats sat upon a pictorial desk, it's a part of a foreground, whats in greater detail is what lies beyond the window painted as beautiful scenery.

The scenery can of course be complex, if not more complex, afterall there might be mechanisms generating any wonder of outcomes.

I guess what I'm saying is while the cube might be a focus for you, can you ratify that this enigma of mathematical complexity that you've got yourself bogged down with, actually has any form of benefitial outcome?

(i.e. Are you going to feed starving children with your reasoning?)

Just so you don't miss my point. Put the cube down if you can't find reason, don't waste any talents you might have on something thats "on a road to nowhere".
Relax, people.

Any benefit to myself of spotting some kind of pattern, especially when gambling, is my business, if this is all too boring or seems a bit too focused on Rubik's puzzles, it's because they're good examples.

So are decks of cards, and so is anything with an exponential generating function. The question I suppose is, why do people win when they gamble, and can losses be minimised?
Here the published table shows that the signal-space is actually lossless, so why can't anyone just memorise all > 3.6 million "cards in the deck"?

Garrett Lisi doesn't talk about tesseracts, or tesselations on the sphere.

This doc echoes the mendelian model, but in the hypercube or 8-cell. It kind of says that mutations (transpositions, gene-splicing etc) are a tesselation--you either get a weave of some kind, or a structure that falls apart. In real biology, the most common form of a genome is circular DNA in a single chromosome, if, that is, bacteria are the most common biological species.


Biology is complicated, there are all these metabolic cycles, enzymes and co-enzymes zipping around an aqueous solution, but inside a compartment that controls pH, by metabolizing--algorithmically, life or at least biochemistry is an infinitely recursive process...

/puff..:m:. Yes, Watson, but what of iterated evolution, my good man?
Not open for further replies.