Added a function which finds all of the 600-tetras from a vertex of the 120-cell

NOTES.md

@@ -0,0 +1,26 @@
+# NOTES
+
+
+New approach for the 5-cells:
+
+Pick a tetrahedron of an inscribed 600-cell with vertices A, B, C, D
+
+This gives pairs of vertices:
+
+AB
+AC
+AD
+BC
+BD
+CD
+
+Each of these gives rise to seven pairs of 5-cells which are on neighboring vertices
+of the 5 600-cells.
+
+Try enumerating these and inspecting them to find one or more coherent sets of four
+5-cells which lie on one tetrahedron from each of the 600-cells.
+
+(I expect there to be more than one, like how there are two ways to partition the
+120-cell vertices into 600-cells)
+
+

cellindex.js

@@ -105,12 +105,10 @@ export const LAYERS120 =  {
 };
 
 export const CELL120_CELL5 = {
-    "1": [ 258, 1, 510, 304, 431 ],
+    "1": [ 1, 93, 37, 157 ],
-    "2": [ 185, 93, 222, 295, 372 ],
 }
 
 
-
 // Schoute's partition via https://arxiv.org/abs/1010.4353
 
 export const PARTITION600 = {

explore_120

@@ -0,0 +1 @@
+

explore_120cell.js

@@ -199,7 +199,6 @@ function try_120_5_cells_fails(cell120, cells, l) {
                     console.log("overlap");
                     console.log(c);
                     return true;
- 
                 }
             }
             return false;
@@ -269,27 +268,24 @@ function node_dist(cell120, aid, bid) {
     return dist(a, b);
 }
 
+function print_row(v1, v2, p, v5) {
+    console.log(`${v1.id},${v2.id},${p},${v5[1]},${v5[2]},${v5[3]},${v5[4]},${v5[5]}`);
+}
+
+// for a pair of vertices which are on the same inscribed 600 cell,
+// this returns all 7 pairs of 5-cells which contain v1 and v2 and
+// which are also evenly spaced (ie every pair of vertices on the
+// same 600-cell  is one edge apart)
 
 
-function follow_600(cell120, all5) {
+function find_adjoining_5cells(cell120, all5, v1, v2) {
-    const v = cell120.nodes[0];
+    const DIST600 = round_dist(node_dist(cell120, v1.id, v2.id));
-    console.log("Start vertex:");
+    const v15s = all5.filter((c5) => c5[v1.label] === v1.id);
-    console.log(v);
+    const v25s = all5.filter((c5) => c5[v2.label] === v2.id);
-    const v5s = all5.filter((c5) => c5[v.label] === v.id);
+    let p = 0;
-    console.log(`Vertex ${v.id} belongs to these 5-cells:`);
+    const c5pairs = [];
-    console.log(v5s);
+    for( const v5a of v15s ) {
-    const n600s = neighbours600(cell120, v.id);
+        for( const v5b of v25s ) {
-    const n600id = n600s[0];
-    const n600 = cell120node(cell120, n600id); 
-    console.log("One 600-cell neighbour:");
-    console.log(n600);
-    const DIST600 = round_dist(node_dist(cell120, v.id, n600id));
-    const nv5s = all5.filter((c5) => c5[v.label] === n600id);
-    console.log(`Vertex ${n600id} belongs to these 5-cells:`); 
-    console.log(nv5s);
-    console.log("Distances for each pair of 5-cells from the two sets:");
-    for( const v5a of v5s ) {
-        for( const v5b of nv5s ) {
             let match = true;
             const d = {};
             for( const label in v5a ) {
@@ -299,19 +295,76 @@ function follow_600(cell120, all5) {
                 }
             }
             if( match ) {
-                console.log("--- pair ---");
+                c5pairs.push([ v5a, v5b ]);
-                console.log(v5a);
-                console.log(v5b);
             }
         }
     }
+    return c5pairs;
 }
 
 
 
+function tetras(cell120, all5, v) {
+    // given a vertex v, find all of the 600-cell tetras it's on
+
+    const n600s = neighbours600(cell120, v.id);
+    // need to find all sets of three neighbours which are neighbours: there
+    // should be 20 of these because they're faces of an icosahedron
+    console.log(v.id);
+    const tetras = new Set;
+    for( const v2id of n600s ) {
+        // find mutual neighbours of the first two
+        const n2600s = neighbours600(cell120, v2id);
+        const mutuals = n2600s.filter((nid) => {
+            return nid != v2id && nid != v.id && n600s.includes(nid)
+        });
+        for( const nm of mutuals ) {
+            const nnms = neighbours600(cell120, nm);
+            const mutuals2 = nnms.filter((nid) => {
+                return nid != nm && nid != v2id && nid != v.id && mutuals.includes(nid)
+            });
+            for( const m2 of mutuals2 ) {
+                const t = [ v.id, v2id, nm, m2 ];
+                t.sort((a, b) => a - b);
+                const tstr = t.join(',');
+                tetras.add(tstr);
+            }
+        }
+    }
+    console.log(tetras);
+}
+/*    // find mutuals which are mutuals of each other
+    const m0 = mutuals[0];
+    const mn = neighbours600(cell120, m0);
+    const mm = mn.filter((nid) => nid != m0 && mutuals.includes(nid));
+    return [ v1.id, v2id, m0, mm[0] ];
+}*/
+
+function str5cell(c5) {
+    return ["1","2","3","4","5"].map((l) => String(c5[l]).padStart(3, '0')).join('-');
+}
+
+function tetra_sets(cell120, all5, tetra) {
+    // given a tetrahedron on a 600-cell, find the sets of adjacent 5-cells on
+    // all of the pairs
+    //  this is ass-backwards. Need to find tetras on the other 4 vertices of a 5-cell
+
+    const vs = tetra.map((tid) => cell120node(cell120, tid));
+    const pairs = [[0,1], [0,2], [0, 3], [1, 2], [1, 3], [2, 3]];
+    for( const p of pairs ) {
+        const v1 = vs[p[0]];
+        const v2 = vs[p[1]];
+        const c5pairs = find_adjoining_5cells(cell120, all5, v1, v2);
+        console.log(v1.id, v2.id);
+        console.log(c5pairs.map((p) => str5cell(p[0]) + "    " + str5cell(p[1])));
+    }
+}
 
 const cell120 = POLYTOPES.cell120_inscribed();
 const all5 = gather_5cells(cell120);
 
-follow_600(cell120, all5);
+const v1 = cell120.nodes[0];
+
+tetras(cell120, all5, v1);
+tetras(cell120, all5, cell120.nodes[1]);
 

polytopes.js

@@ -473,14 +473,14 @@ export const cell120_inscribed_cell5 = () => {
 
         const links = [];
 
-	for( const p of [ 1, 2 ]) {
+/*	for( const p of [ 1, 2 ]) {
 		const nodes600 = nodes.filter((n) => n.label === p);
 		const links600 = auto_detect_edges(nodes600, 12);
 		links600.map((l) => l.label = p);
 		links.push(...links600);
 	}
 
-        for( const c5 in CELLINDEX.CELL120_CELL5 ) {
+*/        for( const c5 in CELLINDEX.CELL120_CELL5 ) {
             const nodes5 = nodes.filter((n) => CELLINDEX.CELL120_CELL5[c5].includes(n.id));
             const links5 = auto_detect_edges(nodes5, 4);
             links5.map((l) => l.label = 0);