Number of CRF polychora

[quickfur]

Nice puzzle. Not sure I know the answer... but there's something about these constructions where you have an initial polytope P, layered on top of a phi-scaled P, and then some other vertex layers to close things up. In that sense, they are all generalizations of teddi (as triangle || phi*triangle || dual triangle).

Am I close?

[Klitzing]

Nice puzzle. Not sure I know the answer... but there's something about these constructions where you have an initial polytope P, layered on top of a phi-scaled P, and then some other vertex layers to close things up. In that sense, they are all generalizations of teddi (as triangle || phi*triangle || dual triangle).

Am I close?

Well teddi is obviously contained both in the 3||teddi and the tetrahedral ursachoron. But it is mibdi, which is contained in the 3-mibdi-laced-wedge. Sure, mibdi as such is just an ike diminishing as teddi is. So they surely are related somehow by the pentagon logic xfo&#x. - But beyond?

In fact those 3 have a much closer relationship than you assumed so far. ...

--- rk

[Klitzing]

As there were no further trials  
here finally the answer comes :

Code: Select all

                                      o3o           o3o                   o3o           o3o   
                                                                                              
                                                                                              
x3o                         +     x3o                   x3o     =     x3o                   x3o
                                                                                              
           f3o                               f3o                                 f3o           
    o3x           o3x                               o3x                   o3x           o3x   
                                                                                              
                                                                                              
  {3} || teddi              +       tetrahedral ursachoron      =       3-mibdi-laced-wedge   


Nice find, ain't it?

--- rk

[quickfur]

So you're saying that 3-mibdi-laced-wedge is just a stacking of tetrahedral ursachoron with {3} || teddi? Haha... and I was under the (wrong) impression that it was elementary! (I.e. can't be decomposed into smaller CRFs).

Now, I wonder if we would get something interesting if we started with an x5o3x ursachoron (don't remember what's the final name we agreed on for this), and stacked it with {6} || x5o3x? Would it be CRF? Can it be made CRF? Will it have nice symmetries?

[ndl]

If you would give the tetra-ursachoron four of those augments (3||teddi) what would it look like? Would it have pentagonal diprisms? I assume it would be non-convex.

[username5243]

I'm actually not sure - neither tet-ursachoron nor 3||teddi seems to have dichoral angles listed on Klitzing's site as of yet. Anyone up for deriving the relevant angles?

[quickfur]

The dichoral angle between two adjacent teddies in the octahedral ursachoron is 112.4555°.

I can't seem to find my 3||teddi model...

[ndl]

I've got all the vertices here:

Code: Select all

1.00000000000000000  0.70710678118654752  0.00000000000000000  0.00000000000000000
-1.00000000000000000  0.70710678118654752  0.00000000000000000  0.00000000000000000
0.00000000000000000 -0.70710678118654752  1.00000000000000000  0.00000000000000000
0.00000000000000000 -0.70710678118654752 -1.00000000000000000  0.00000000000000000
0.00000000000000000  1.85122958682191612  0.61803398874989485  1.14412280563536860
0.00000000000000000  1.85122958682191612 -0.61803398874989485  1.14412280563536860
1.00000000000000000  0.43701602444882107  1.61803398874989485  1.14412280563536860
-1.00000000000000000  0.43701602444882107  1.61803398874989485  1.14412280563536860
1.00000000000000000  0.43701602444882107 -1.61803398874989485  1.14412280563536860
-1.00000000000000000  0.43701602444882107 -1.61803398874989485  1.14412280563536860
1.61803398874989485 -0.43701602444882107  1.00000000000000000  1.14412280563536860
1.61803398874989485 -0.43701602444882107 -1.00000000000000000  1.14412280563536860
-1.61803398874989485 -0.43701602444882107  1.00000000000000000  1.14412280563536860
-1.61803398874989485 -0.43701602444882107 -1.00000000000000000  1.14412280563536860
0.61803398874989485 -1.85122958682191612  0.00000000000000000  1.14412280563536860
-0.61803398874989485 -1.85122958682191612  0.00000000000000000  1.14412280563536860
1.61803398874989485  1.14412280563536860  0.00000000000000000  1.85122958682191612
-1.61803398874989485  1.14412280563536860  0.00000000000000000  1.85122958682191612
0.00000000000000000 -1.14412280563536860  1.61803398874989485  1.85122958682191612
0.00000000000000000 -1.14412280563536860 -1.61803398874989485  1.85122958682191612
0.00000000000000000  1.41421356237309505  0.00000000000000000  2.99535239245728471
1.00000000000000000  0.00000000000000000  1.00000000000000000  2.99535239245728471
1.00000000000000000  0.00000000000000000 -1.00000000000000000  2.99535239245728471
-1.00000000000000000  0.00000000000000000  1.00000000000000000  2.99535239245728471
-1.00000000000000000  0.00000000000000000 -1.00000000000000000  2.99535239245728471
0.00000000000000000 -1.41421356237309505  0.00000000000000000  2.99535239245728471


Convex hull in Stella gives me some offending tets rising from each edge of lowest tet in rosette form with inner edge being only 1/phi. Those are not going to be pentagonal dipyramids after all just regular peppies with no way to fit anything in those holes to make it convex.

aug ursa.JPG (61.65 KiB) Viewed 70663 times

[quickfur]

If you're looking for a CRF that contains pentagonal dipyramids, there's the various augmented 5,10-duoprisms. The 5,10-duoprism admits augmentations with 5-prism pyramids, and since the dichoral angle between the 5-prism and the pentagonal pyramid is exactly 18°, placing two augments on adjacent 5-prisms will result in the pentagonal pyramids of the respective augments lying on the same hyperplane, so they will merge into pentagonal dipyramids. You can have all 10 pentagonal prisms augmented, which produces a CRF with 10 pentagonal dipyramid cells. (The ring of decagonal prisms is also augmentable with 10-prism||5-gon at the same time, so you can have an omniaugmented 5,10-duoprism that contains pentagonal dipyramids and pentagonal cupolae.)

[mr_e_man]

As it turns out, the 10,10-duoprism actually has 11,921,273 augmentations (that's 11.9 million!), which is several times more than the previous count. The reason for this is that the bug in the previous version of the program failed to account for the fact that the rings of the duoprism cannot be rotated independently of each other: a rotation in one ring causes a gyration in the other, and vice versa. Furthermore, some augmentations are chiral, so they contribute 2 to the count rather than just 1 -- they cannot be transformed to each other via rotations only; they require a reflection. There's also a slight reduction in the count because the previous version didn't check the full rotational symmetry of the duoprism, so some combinations were duplicated.

I would not double-count the chiral ones. A left-handed thing is isomorphic to a right-handed thing, in my view.

So would the count be something like 6 million? Aren't "most" augmentations chiral?


Also, can anyone explain or confirm the huge numbers in Mrrl's linked post?

And furthermore, one doesn't have to stick with the 24 apices of the snub 24-cell alone. One could, for example, diminish the 600-cell at an apex that lies between two of the snub 24-cell's icosahedra, leading to a different kind of diminishing. Adding in these other possibilities greatly expand the number of diminishings of the 600-cell (I think mrrl estimated the number to be close to a million).

No, these were closer to 2^100 but rectified 600-cell (using only one type of diminishing) beats them - there are proven 2^156 different CRFS with estimations up to 2^500

Here I'm more interested in lower bounds than upper bounds. An obvious upper bound for the rectified 600-cell is 2^720.

[quickfur]

As it turns out, the 10,10-duoprism actually has 11,921,273 augmentations (that's 11.9 million!), which is several times more than the previous count. The reason for this is that the bug in the previous version of the program failed to account for the fact that the rings of the duoprism cannot be rotated independently of each other: a rotation in one ring causes a gyration in the other, and vice versa. Furthermore, some augmentations are chiral, so they contribute 2 to the count rather than just 1 -- they cannot be transformed to each other via rotations only; they require a reflection. There's also a slight reduction in the count because the previous version didn't check the full rotational symmetry of the duoprism, so some combinations were duplicated.

I would not double-count the chiral ones. A left-handed thing is isomorphic to a right-handed thing, in my view.

So would the count be something like 6 million? Aren't "most" augmentations chiral?

No, I'd say the majority of them are not chiral. I doubt it would be as low as 6 million. My wild guess is that it would still be 10 million or above.

Also, can anyone explain or confirm the huge numbers in Mrrl's linked post?

I believe he calculated a (rather crude) upper bound, just by computing an exponential.

And furthermore, one doesn't have to stick with the 24 apices of the snub 24-cell alone. One could, for example, diminish the 600-cell at an apex that lies between two of the snub 24-cell's icosahedra, leading to a different kind of diminishing. Adding in these other possibilities greatly expand the number of diminishings of the 600-cell (I think mrrl estimated the number to be close to a million).

No, these were closer to 2^100 but rectified 600-cell (using only one type of diminishing) beats them - there are proven 2^156 different CRFS with estimations up to 2^500

Here I'm more interested in lower bounds than upper bounds. An obvious upper bound for the rectified 600-cell is 2^720.

A lower bound would be Blind's count of non-adjacent 600-cell diminishings, which is 314 million. This number takes into account all the 600-cell's symmetries, but does not take into account CRF adjacent diminishings. So it is a gross underestimate, considering that the 600-cell can be diminished down to very thin CRF wedges (the 600-cell lunae that I discovered) -- everything in between has to be counted in order to have the full number. The number of combinations is exponential, and I wouldn't be surprised if the final number is significantly more than 314 million.

But certainly, this is nowhere near Mrrl's astronomical 2^100, which is a 31-digit number. I think his estimate did not account for the symmetries of the 600-cell and/or did not adequately recompense for them.

[quickfur]

[...]
Furthermore, some augmentations are chiral, so they contribute 2 to the count rather than just 1 -- they cannot be transformed to each other via rotations only; they require a reflection.
[...]

I would not double-count the chiral ones. A left-handed thing is isomorphic to a right-handed thing, in my view.

So would the count be something like 6 million? Aren't "most" augmentations chiral?

No, I'd say the majority of them are not chiral. I doubt it would be as low as 6 million. My wild guess is that it would still be 10 million or above.
[...]

Actually, I just checked my code again: it does not double count chiral augmentations. I think what I meant when I wrote what was quoted above, is that I corrected the counts because previously it double-counted chiral augmentations, and now it takes chirality into account. So the 11.9 million count actually does not count chiral augmentations twice. If you were to count mirror images separately the final total would be higher.

[mr_e_man]

But certainly, this is nowhere near Mrrl's astronomical 2^100, which is a 31-digit number. I think his estimate did not account for the symmetries of the 600-cell and/or did not adequately recompense for them.

Well, the symmetry group's size is 14400, so each thing Mrrl counted would have at most 14400 isomorphs he also counted; this would give a lower bound of 2^100 / 14400 ≈ 2^86.

(I like to use 2^10 ≈ 10^3 to convert between binary and decimal. For example, 2^100 = (2^10)^10 ≈ (10^3)^10 = 10^30, which indeed has 31 digits.)


How could we count the triangle-free subsets of the 600-cell's vertices? That would give a lower bound better than 314 million.

Stated differntly, whenever your potential diminishing of the hexacosachoron includes at least a subset of 3 to be cut off vertices, then these ought not form a unit edged triangle.

[quickfur]

But certainly, this is nowhere near Mrrl's astronomical 2^100, which is a 31-digit number. I think his estimate did not account for the symmetries of the 600-cell and/or did not adequately recompense for them.

Well, the symmetry group's size is 14400, so each thing Mrrl counted would have at most 14400 isomorphs he also counted; this would give a lower bound of 2^100 / 14400 ≈ 2^86.

(I like to use 2^10 ≈ 10^3 to convert between binary and decimal. For example, 2^100 = (2^10)^10 ≈ (10^3)^10 = 10^30, which indeed has 31 digits.)

I don't know where Mrrl came up with the 2^100 figure; it seems disproportionately large. I wonder if the idea was the take the number of vertices in a 600-cell, which is 120, and subtract some of them to approximately account for not having triangles diminished, which if we assume we subtract 20 vertices, then we have 100 vertices which may either be diminished or not, giving us 2^100. The problem with this rough estimate is that it likely contains a large number of non-CRF subsets, but how many of them are there is unclear from the construction. So it doesn't really tell us very much.

How could we count the triangle-free subsets of the 600-cell's vertices? That would give a lower bound better than 314 million.

Stated differntly, whenever your potential diminishing of the hexacosachoron includes at least a subset of 3 to be cut off vertices, then these ought not form a unit edged triangle.

Unfortunately it's not quite this simple. The 600-cell wedges, for example, do cut away subsets that contain triangles, yet they still remain CRF. So even if we could figure out how many triangle-free subsets there are, it's still only a lower bound, possibly a rather loose one, considering how many more subsets you can have if you include triangles, even if some of those have to be excluded to maintain CRF-ness. It's not a trivial problem.

[quickfur]

[...]
Actually, I just checked my code again: it does not double count chiral augmentations. I think what I meant when I wrote what was quoted above, is that I corrected the counts because previously it double-counted chiral augmentations, and now it takes chirality into account. So the 11.9 million count actually does not count chiral augmentations twice. If you were to count mirror images separately the final total would be higher.

I just re-ran my program with chirality checks disabled. It found 23 million augmentations of duoprisms. Almost all of the 23 million are from the 10,10-duoprism -- so apparently you're right, most of it is chiral!

[mr_e_man]

The pentagons in x5o3x3o correspond to the vertices in o5o3x3o, or the edges in o5o3o3x. There's a total of 720.

Consider the 120 pentagons in x5o3x3o corresponding to the vertices in o5o3x3o which are deleted to get spidrox. Any of these pentagons (with their magnabicupolic rings) can be deleted, or gyrated, or left alone. This gives us at least 3^120 / 14400 ≈ 10^53 different CRFs!

[quickfur]

The pentagons in x5o3x3o correspond to the vertices in o5o3x3o, or the edges in o5o3o3x. There's a total of 720.

Consider the 120 pentagons in x5o3x3o corresponding to the vertices in o5o3x3o which are deleted to get spidrox. Any of these pentagons (with their magnabicupolic rings) can be deleted, or gyrated, or left alone. This gives us at least 3^120 / 14400 ≈ 10^53 different CRFs!

[mr_e_man]

Hold on...

But that's only the tip of the iceberg. Something horrible happens when we get to the 10,10-duoprism: the pentagonal magnabicupolic ring augments are, again, very shallow, so both rings can be independently augmented. Furthermore, each augment has two distinct orientations, which greatly increases the number of combinations (now each prism has 3 possible states: unaugmented, ortho-augmented, and gyro-augmented). It's not quite 3^n, because some gyrations are isomorphic to others under the duoprism's symmetry group, but nevertheless, there is an absolutely humongous number of combinations here. Add to this the fact that the intra-ring angles are shallow enough for for adjacent decagonal prisms to be simultaneously augmented and still remain convex, and we have (up to) 3^10 * 3^10 combinations, divided by the size of the symmetry group of the 10,10-duoprism. Of course, the symmetry group is pretty big, but not very big compared to the sheer number of combinations. The final count of 10,10-duoprism CRF augmentations, if my program is correct, is 1,365,377, up to isomorphism(!!) (and not counting the unaugmented 10,10-duoprism).

Alright, I've fixed the bug in my program (hopefully that's the last of 'em...).

[...]

As it turns out, the 10,10-duoprism actually has 11,921,273 augmentations (that's 11.9 million!), which is several times more than the previous count. The reason for this is that the bug in the previous version of the program failed to account for the fact that the rings of the duoprism cannot be rotated independently of each other: a rotation in one ring causes a gyration in the other, and vice versa. Furthermore, some augmentations are chiral, so they contribute 2 to the count rather than just 1 -- they cannot be transformed to each other via rotations only; they require a reflection. There's also a slight reduction in the count because the previous version didn't check the full rotational symmetry of the duoprism, so some combinations were duplicated.

The 10,10-duoprism's symmetry group's size is 800 (as each ring has 20 symmetries, and the two rings can be swapped, which gives 20 * 20 * 2).

It should be expected that "most" augmentations have no symmetry at all; it's easy to break symmetry. For such an augmentation, all 800 isomorphs would be unequal to each other, thus contributing 800 to the count of 3^10 * 3^10 . So the true count should be very close to 3^20 / 800 ≈ 4.36 million.

But both 1.3 million and 11.9 million are not close to that. Maybe there's another bug in your program?

At least 4.3 million is a lower bound for the 10,10-duoprism.

[quickfur]

Hold on...

[...]
As it turns out, the 10,10-duoprism actually has 11,921,273 augmentations (that's 11.9 million!), which is several times more than the previous count. The reason for this is that the bug in the previous version of the program failed to account for the fact that the rings of the duoprism cannot be rotated independently of each other: a rotation in one ring causes a gyration in the other, and vice versa. Furthermore, some augmentations are chiral, so they contribute 2 to the count rather than just 1 -- they cannot be transformed to each other via rotations only; they require a reflection. There's also a slight reduction in the count because the previous version didn't check the full rotational symmetry of the duoprism, so some combinations were duplicated.

The 10,10-duoprism's symmetry group's size is 800 (as each ring has 20 symmetries, and the two rings can be swapped, which gives 20 * 20 * 2).

Are you sure you got the symmetry group order right? Take one of the prism cells in one of the rings. You can rotate it around the ring in 10 distinct positions. You can also rotate it in-place in 10 orientations. And reflect it across 10 different planes around its vertical axis, as well as reflect it across the horizontal plane. And rotate it by 90° onto the second ring. I'm not very good with computing the order of symmetry groups, but it would appear to me that this should give us 10*10*10*2*2 = 4000. Did I screw up somewhere?

It should be expected that "most" augmentations have no symmetry at all; it's easy to break symmetry. For such an augmentation, all 800 isomorphs would be unequal to each other, thus contributing 800 to the count of 3^10 * 3^10 . So the true count should be very close to 3^20 / 800 ≈ 4.36 million.

Don't forget that for the 10,10-duoprism, the augments are orientable (meaning they can be in one of two positions that, when other augments are present, represents two distinct augmentations). As the number of augments increase, the number of distinct orientations increase approximately exponentially, until the number of augments nears the saturation point.

But both 1.3 million and 11.9 million are not close to that. Maybe there's another bug in your program?

At least 4.3 million is a lower bound for the 10,10-duoprism.

I doubt there's another bug, though I have not disproved the possibility. Basically the way the program works is as follows:

(1) represent an augmentation as two arrays, corresponding to the two duoprism rings, with 0 meaning no augment in that position, 1 meaning one augment, 2 meaning one rotated augment (if that particular ring has augments that can be distinctly rotated).

(2) Generate (on-the-fly) all possible such pairs of arrays.

(3) For each generated array pair, compute its canonical representation. A canonical representation is the lexicographically-least array pair obtained by transforming the given array pair by the equivalent of the duoprism's symmetries. If an array pair is not equal to its canonical representation, discard it. (In practice, for performance reasons, we can discard a pair as soon as one of its transformations is lexicographically less than itself -- since that implies that it cannot be canonical.)

(4) Count all remaining pairs, which must be canonical representations.

In step (3), the following transformations are applied (in all combinations):

(a) Rotate each array up to n positions where n is the size of the corresponding ring;

(b) If a ring contains orientable augments, flip the orientations of the augments (and rotate the other ring appropriately). (In the implementation, this is done along with (a) because the two are equivalent under a swapping of rings.)

(c) Reverse the order of elements in the array (corresponding to a reflection).

(d) If it's an n,n-duoprism, swap the two arrays (corresponding to a 90° rotation that exchanges the rings). (For m,n-duoprisms where m≠n, there is no such symmetry so we don't perform the swap.) In the implementation, we simply standardize on the first ring being lexicographically less, so if m=n and ring1 > ring2, we discard the pair immediately.

[quickfur]

[...]
Don't forget that for the 10,10-duoprism, the augments are orientable (meaning they can be in one of two positions that, when other augments are present, represents two distinct augmentations). As the number of augments increase, the number of distinct orientations increase approximately exponentially, until the number of augments nears the saturation point.
[...]

To be absolutely clear, in this case the augment is 5-gon||10-gon, which can be fitted onto one of the duoprism's cells in two different orientations. When there's only 1 augment, this doesn't make a difference. But when there are two augments on the same ring, they can either be in the same orientation, or in anti orientation to each other (i.e., rotated by 72° relative to each other). Furthermore, when two augments are on two different rings, two square pyramids (one from each ring) can share a face, or square pyramid and a triangular prism (one from each ring) can share a face, or two triangular prisms (one from each ring) can share a face. So that's 3 topologically-distinct augmentations. When there are 2 augments on the first ring and one on the second, we have about 5-6 different augmentations.

As the number of augments increase, the number of combinations of orientations obviously compound rapidly. I suspect this is where the missing count from your estimate is coming from.

[mr_e_man]

Are you sure you got the symmetry group order right? Take one of the prism cells in one of the rings. You can rotate it around the ring in 10 distinct positions. You can also rotate it in-place in 10 orientations. And reflect it across 10 different planes around its vertical axis, as well as reflect it across the horizontal plane. And rotate it by 90° onto the second ring. I'm not very good with computing the order of symmetry groups, but it would appear to me that this should give us 10*10*10*2*2 = 4000. Did I screw up somewhere?

Let's look at the 10-gon alone. There are 10 rotations (by multiples of 36°) and 10 reflections (5 lines passing through opposite vertices, and 5 lines bisecting opposite edges) for a total of 10+10=20 symmetries. In general, a p-gon has 2p symmetries.
You can't rotate and reflect independently. A composition of two reflections is a rotation, and a composition of a rotation and a reflection is a reflection.
So your count should have 10+10 in place of 10*10, which does give 800.

Wikipedia supports this. (See the "Symmetry" parts of the two tables on the right.) And I was hoping Bowers would as well, but he didn't get around to polygonal duoprisms yet.

It should be expected that "most" augmentations have no symmetry at all; it's easy to break symmetry. For such an augmentation, all 800 isomorphs would be unequal to each other, thus contributing 800 to the count of 3^10 * 3^10 . So the true count should be very close to 3^20 / 800 ≈ 4.36 million.

Don't forget that for the 10,10-duoprism, the augments are orientable (meaning they can be in one of two positions that, when other augments are present, represents two distinct augmentations). As the number of augments increase, the number of distinct orientations increase approximately exponentially, until the number of augments nears the saturation point.

The orientation is accounted for by the base being 3 instead of 2.

But maybe there is a "bug" in my line of reasoning.

[mr_e_man]

In step (3), the following transformations are applied (in all combinations):

(a) Rotate each array up to n positions where n is the size of the corresponding ring;

(b) If a ring contains orientable augments, flip the orientations of the augments (and rotate the other ring appropriately). (In the implementation, this is done along with (a) because the two are equivalent under a swapping of rings.)

I hope that parenthetic part means you're not doing (a) independently. A rotation in (a), by an odd number of positions, must be accompanied by a gyration (1 <-> 2) in the opposite ring (if applicable).

(c) Reverse the order of elements in the array (corresponding to a reflection).

That's definitely a problem!
A reflection can effectively gyrate the augments.

For an odd-sided polygon in 2D, any mirror line passes through a vertex and the opposite edge. But odd-sided prisms can't be gyratably augmented, so this is irrelevant.

For an even-sided polygon in 2D, some mirror lines pass through two opposite vertices, and other mirror lines bisect two opposite edges. The former (and not the latter) reflections, extended to 4D and acting on a prism of that polygon, would change the augment's orientation.

Reversing the order of augments in one ring means reflecting over a polygon in that ring, or reflecting over a line (/plane) passing through a vertex (/vertical edge) of a polygon (/prism) in the other ring. This would change the augment's orientation.

Thus, (c) must be accompanied by a gyration (1 <-> 2) in the opposite ring (if applicable).

(d) If it's an n,n-duoprism, swap the two arrays (corresponding to a 90° rotation that exchanges the rings). (For m,n-duoprisms where m≠n, there is no such symmetry so we don't perform the swap.) In the implementation, we simply standardize on the first ring being lexicographically less, so if m=n and ring1 > ring2, we discard the pair immediately.

This looks fine, though I think it's actually a 180° rotation.

[quickfur]

In step (3), the following transformations are applied (in all combinations):

(a) Rotate each array up to n positions where n is the size of the corresponding ring;

(b) If a ring contains orientable augments, flip the orientations of the augments (and rotate the other ring appropriately). (In the implementation, this is done along with (a) because the two are equivalent under a swapping of rings.)

I hope that parenthetic part means you're not doing (a) independently. A rotation in (a), by an odd number of positions, must be accompanied by a gyration (1 <-> 2) in the opposite ring (if applicable).

Yes, this case is accounted for. (a) and (b) are done together, obviously, since rotation in one ring equals gyration in the other, and vice versa.

(c) Reverse the order of elements in the array (corresponding to a reflection).

That's definitely a problem!
A reflection can effectively gyrate the augments.

Sorry, I didn't describe it accurately enough. A reversal is done to both rings simultaneously, since reversing one ring without reversing the other may create a non-isomorphic augmentation. Reversing both produces the mirror image of the polytope.

In any case, any mistake in this area would undercount the number of augmentations (it would find more lexicographically-smaller transformations than there actually are, so more combinations would be discarded).

[...]

(d) If it's an n,n-duoprism, swap the two arrays (corresponding to a 90° rotation that exchanges the rings). (For m,n-duoprisms where m≠n, there is no such symmetry so we don't perform the swap.) In the implementation, we simply standardize on the first ring being lexicographically less, so if m=n and ring1 > ring2, we discard the pair immediately.

This looks fine, though I think it's actually a 180° rotation.

Why would it be 180°? The 2-planes of each ring are linearly-independent and therefore must be at 90° to each other. Swapping them in effect is equal to rotating the polytope such that each ring moves into the plane of the other, i.e., a 90° rotation.

[mr_e_man]

[...]

(d) If it's an n,n-duoprism, swap the two arrays (corresponding to a 90° rotation that exchanges the rings). (For m,n-duoprisms where m≠n, there is no such symmetry so we don't perform the swap.) In the implementation, we simply standardize on the first ring being lexicographically less, so if m=n and ring1 > ring2, we discard the pair immediately.

This looks fine, though I think it's actually a 180° rotation.

Why would it be 180°? The 2-planes of each ring are linearly-independent and therefore must be at 90° to each other. Swapping them in effect is equal to rotating the polytope such that each ring moves into the plane of the other, i.e., a 90° rotation.

The transformation is (x,y,z,w) -> (z,w,x,y), i.e. a reflection x <-> z and a reflection y <-> w. The composition of two orthogonal reflections is a 180° rotation. In general, the composition of two reflections along vectors with an angle θ between them is equivalent to a rotation by 2θ in the plane of those vectors.

You could also look at the vertex figure, which is a tetrahedron with two opposite 144° edges and four 90° edges. The relevant transformation is a 180° rotation around an axis passing through two opposite 90° edges, which swaps the two 144° edges. There is no 90° rotation symmetry of the tetrahedron.

(c) Reverse the order of elements in the array (corresponding to a reflection).

That's definitely a problem!
A reflection can effectively gyrate the augments.

Sorry, I didn't describe it accurately enough. A reversal is done to both rings simultaneously, since reversing one ring without reversing the other may create a non-isomorphic augmentation. Reversing both produces the mirror image of the polytope.

Reversing both gives a 180° rotation, not a reflection.
In the vertex figure, the axis of rotation passes through the two 144° edges of the tetrahedron.

(c) should reverse one ring, and gyrate the other, to make the mirror image.

So (a) applies n rotations to ring 1, and m rotations to ring 2 (both possibly with gyrations in the other ring);
(c) applies a reflection to ring 1, and (separately) a reflection to ring 2 (both possibly with gyrations in the other ring);
and (d) swaps the two rings, if possible.
These are all independent (kind of; I guess it's a semidirect product). So there's a total of n*m*2*2(*2 if n=m) transformations being applied, as there should be.

[mr_e_man]

Okay, I've manually verified some of the results in your list, up to the 4,8-duoprism (ignoring 4,4).

But for the 4,8-duoprism, I found 152 different augmentations (counting the uniform duoprism), not 123+1.

And for the 5,6-duoprism, I found 66 different augmentations, not 64+1.
Specifically, I got 13 with no augments on the 'hips' (hexagonal prisms), 20 with one hip augment, 20 with two hip augments in the same orientation, and 13 with two hip augments in opposite orientations.

However, the gyratable augments are a bit confusing.

[quickfur]

Haha, apparently I need to look into this again. Probably should build actual models of the generated augmentations to verify by hand.

[mr_e_man]

Here's an implementation of your algorithm, with part (3)(c) fixed, in Python.

It's specialized for the 10,10-duoprism. It assumes that both rings can be augmented independently, and that adjacent augments are possible. I haven't considered the more general cases.

Instead of encoding the augments as 0,1,2, I encoded them as 0,1,2,3, keeping pyramids and magnabicupolic rings separate.
Also, I packaged the augmentation information for each ring into a single integer instead of an array.
I had fun doing everything with bitwise operations.

The reflections are done at the outer levels of iteration, and the rotations at the inner levels, because it's more expensive to reverse the bits in a number than to rotate them.

Code: Select all

# Keep in mind the operator precedence:
# arithmetic operations (+ - * //) are evaluated first, then
# bit shifts (<< >>), then other bitwise operations (& | ^).

# no augment = 00, pyramid augment = 01,
# ortho augment = 10, gyro augment = 11 (binary)

all_bits = (1 << 2*10) - 1
even_bits = all_bits // 3
odd_bits = even_bits << 1

def pyramids(x):
    return x & even_bits & ~(x & odd_bits)>>1

def rotate(x, num_places, total_places):
    return x >> 2*num_places | (
        (x & ((1<<2*num_places)-1)) << 2*(total_places - num_places))

def gyrate(x):
    return (x & odd_bits) | ((x & even_bits) ^ (x & odd_bits)>>1)

def reverse(x, total_places):
    y = 0
    for i in range(total_places):
        y |= (x>>2*i & 3) << 2*(total_places - 1 - i)
    return y

count = 0
ring1 = 0
while ring1 < 1<<2*10:
    ring2 = 0
    while ring2 < 1<<2*10:

        rings1and2 = ring1 << 2*10 | ring2
        is_least = True
        i = 0
        while is_least and i < 2:
            ring1_i = reverse(ring1, 10) if i else ring1
            ring2_i = gyrate(ring2) if i else ring2
            j = 0
            while is_least and j < 2:
                ring2_ij = reverse(ring2_i, 10) if j else ring2_i
                ring1_ij = gyrate(ring1_i) if j else ring1_i
                k = 0
                while is_least and k < 10:
                    ring1_ijk = rotate(ring1_ij, k, 10)
                    ring2_ijk = gyrate(ring2_ij) if k & 1 else ring2_ij
                    l = 0
                    while is_least and l < 10:
                        ring2_ijkl = rotate(ring2_ijk, l, 10)
                        ring1_ijkl = gyrate(ring1_ijk) if l & 1 else ring1_ijk
                        new_rings1and2 = ring1_ijkl << 2*10 | ring2_ijkl
                        new_rings2and1 = ring2_ijkl << 2*10 | ring1_ijkl
                        is_least &= rings1and2 <= new_rings1and2
                        is_least &= rings1and2 <= new_rings2and1
                        l += 1
                    k += 1
                j += 1
            i += 1
        count += is_least

        ring2 += 1
        ring2 += pyramids(ring2)
    ring1 += 1
    # Pyramid augments aren't allowed on the 10,10-duoprism; skip over these.
    ring1 += pyramids(ring1)

print(count)


It took several hours for this to run. I guess it would be faster with a lower-level language.

4924629 is the final count of 10,10-duoprism augmentations. (It includes the un-augmented duoprism.) Compare this to my estimate: 3^20 / 800 =
4358481 (rounding up). They are fairly close!

[quickfur]

Here's an implementation of your algorithm, with part (3)(c) fixed, in Python.

It's specialized for the 10,10-duoprism. It assumes that both rings can be augmented independently, and that adjacent augments are possible. I haven't considered the more general cases.

Instead of encoding the augments as 0,1,2, I encoded them as 0,1,2,3, keeping pyramids and magnabicupolic rings separate.

Wait, I thought the 10,10-duoprism only takes magnabicupolic rings as augments?

Also, I packaged the augmentation information for each ring into a single integer instead of an array.
I had fun doing everything with bitwise operations.

The reflections are done at the outer levels of iteration, and the rotations at the inner levels, because it's more expensive to reverse the bits in a number than to rotate them.

Are you natively compiling the Python code? 'cos if not, the difference between between reversing bits and rotating them would probably be unnoticeable.

Code: Select all

# Keep in mind the operator precedence:
# arithmetic operations (+ - * //) are evaluated first, then
# bit shifts (<< >>), then other bitwise operations (& | ^).

# no augment = 00, pyramid augment = 01,
# ortho augment = 10, gyro augment = 11 (binary)

all_bits = (1 << 2*10) - 1
even_bits = all_bits // 3
odd_bits = even_bits << 1

def pyramids(x):
    return x & even_bits & ~(x & odd_bits)>>1

def rotate(x, num_places, total_places):
    return x >> 2*num_places | (
        (x & ((1<<2*num_places)-1)) << 2*(total_places - num_places))

def gyrate(x):
    return (x & odd_bits) | ((x & even_bits) ^ (x & odd_bits)>>1)

def reverse(x, total_places):
    y = 0
    for i in range(total_places):
        y |= (x>>2*i & 3) << 2*(total_places - 1 - i)
    return y

count = 0
ring1 = 0
while ring1 < 1<<2*10:
    ring2 = 0
    while ring2 < 1<<2*10:

        rings1and2 = ring1 << 2*10 | ring2
        is_least = True
        i = 0
        while is_least and i < 2:
            ring1_i = reverse(ring1, 10) if i else ring1
            ring2_i = gyrate(ring2) if i else ring2
            j = 0
            while is_least and j < 2:
                ring2_ij = reverse(ring2_i, 10) if j else ring2_i
                ring1_ij = gyrate(ring1_i) if j else ring1_i
                k = 0
                while is_least and k < 10:
                    ring1_ijk = rotate(ring1_ij, k, 10)
                    ring2_ijk = gyrate(ring2_ij) if k & 1 else ring2_ij
                    l = 0
                    while is_least and l < 10:
                        ring2_ijkl = rotate(ring2_ijk, l, 10)
                        ring1_ijkl = gyrate(ring1_ijk) if l & 1 else ring1_ijk
                        new_rings1and2 = ring1_ijkl << 2*10 | ring2_ijkl
                        new_rings2and1 = ring2_ijkl << 2*10 | ring1_ijkl
                        is_least &= rings1and2 <= new_rings1and2
                        is_least &= rings1and2 <= new_rings2and1
                        l += 1
                    k += 1
                j += 1
            i += 1
        count += is_least

        ring2 += 1
        ring2 += pyramids(ring2)
    ring1 += 1
    # Pyramid augments aren't allowed on the 10,10-duoprism; skip over these.
    ring1 += pyramids(ring1)

print(count)


It took several hours for this to run. I guess it would be faster with a lower-level language.

I'll have to look more carefully into your code later, busy right now. All those bit operations are hard to read. I would've preferred a more straightforward, obvious implementation for a first stab, which would be easier to verify, and only if necessary, a more optimized implementation afterwards.

4924629 is the final count of 10,10-duoprism augmentations. (It includes the un-augmented duoprism.) Compare this to my estimate: 3^20 / 800 =
4358481 (rounding up). They are fairly close!

Would you be interested to do this for all the other duoprisms too? I really want to compare independently-derived results for better confidence that we didn't screw up somewhere, like I apparently did.

[mr_e_man]

Here's an implementation of your algorithm, with part (3)(c) fixed, in Python.

It's specialized for the 10,10-duoprism. It assumes that both rings can be augmented independently, and that adjacent augments are possible. I haven't considered the more general cases.

Instead of encoding the augments as 0,1,2, I encoded them as 0,1,2,3, keeping pyramids and magnabicupolic rings separate.

Wait, I thought the 10,10-duoprism only takes magnabicupolic rings as augments?

Of course. But this way makes the bitwise operations easier, and allows for generalizing to other duoprisms.

Also, I packaged the augmentation information for each ring into a single integer instead of an array.
I had fun doing everything with bitwise operations.

The reflections are done at the outer levels of iteration, and the rotations at the inner levels, because it's more expensive to reverse the bits in a number than to rotate them.

Are you natively compiling the Python code? 'cos if not, the difference between between reversing bits and rotating them would probably be unnoticeable.

No, I'm just using IDLE.

To compare the two methods, I made the program stop when the count reached 20000. Reversing at the outer levels, it took about 13 seconds. Reversing at the inner levels, it took about 30 seconds. I also did this with the 'is_least' loop test disabled (so both methods are applying the same full set of transformations, not stopping when a lesser isomorph is found); getting to 2000 took 22 seconds and 53 seconds, respectively.
Notice that the 'reverse' function has a loop in it, and 'rotate' does not.

I'll have to look more carefully into your code later, busy right now. All those bit operations are hard to read. I would've preferred a more straightforward, obvious implementation for a first stab, which would be easier to verify, and only if necessary, a more optimized implementation afterwards.

Right. I know readability is important....

Well, I think you could easily modify your own program (reverse one ring, gyrate the other), and hopefully get the same results as mine.

[mr_e_man]

(c) Reverse the order of elements in the array (corresponding to a reflection).

That's definitely a problem!
A reflection can effectively gyrate the augments.

Sorry, I didn't describe it accurately enough. A reversal is done to both rings simultaneously, since reversing one ring without reversing the other may create a non-isomorphic augmentation. Reversing both produces the mirror image of the polytope.

Reversing both gives a 180° rotation, not a reflection.
In the vertex figure, the axis of rotation passes through the two 144° edges of the tetrahedron.

Actually, it's not a 180° rotation either. Reversing both rings is not a symmetry at all!

Consider the augmentation [1,1,1,1,1,1,1,1,1,1], [1,0,0,0,0,0,0,0,0,0], where the first ring is fully augmented with magnabicupolic rings in the same orientation, and the second ring has one augment, connecting to the triangular prisms in the first ring. Reversing both gives [1,1,1,1,1,1,1,1,1,1], [0,0,0,0,0,0,0,0,0,1], where the augment in the second ring connects to the square pyramids in the first ring. Thus, the transformed augmentation is not isomorphic to the original augmentation.

Instead, that 180° rotation symmetry I mentioned reverses both rings, and gyrates both rings. This would give [2,2,2,2,2,2,2,2,2,2], [0,0,0,0,0,0,0,0,0,2], where the augment in the second ring again connects to the triangular prisms in the first ring.

So you were including a false symmetry, and omitting a true symmetry. This could increase the count in some cases, and decrease the count in other cases.