tropicalCayceyMenger introduced; all other CM subroutines unexported

Author: Anton Leykin

Rigidity/CayleyMenger-docs.m2

@@ -1,32 +1,40 @@
 doc ///
 Node
   Key 
-    getAllTrees
-    (getAllTrees,ZZ)
-    (getAllTrees,List)
+    tropicalCayleyMenger
+    (tropicalCayleyMenger,ZZ)
+    (tropicalCayleyMenger,List)
   Headline 
-    Get all Cayley-Menger trees on n vertices
+    Get maximal cones of the tropicalization of Cayley-Menger variety
   Usage
-    L = getAllTrees n
-    L = getAllTrees variableNames
+    L = tropicalCayleyMenger n
+    L = tropicalCayleyMenger G
   Inputs
     n : ZZ 
       a positive integer
-    variableNames : List
-      the list of variables to use
+    G : List
+      the list of pairs of integers representing the edges of a graph on vertices 1 to n
   Outputs
     L :
-      a list of polynomials, each representing a rooted tree leaves given by the argument list
+      a list of @TO Cone@s 
   Description
     Text
-      This function generates all rooted trees on n leaves, 
-      represented as polynomials in which each monomial corresponds 
-      to a clade (a subset of leaves descending from a common internal node). 
-      The leaves are labeled by variables x_1 to x_n (or the ones provided explicitly).
+      This function generates all maximal cones of the tropicalization of the Cayley-Menger variety on n vertices. 
     Example
-      getAllTrees 3
-      QQ[a,b,c]
-      getAllTrees {a,b,c}   
+      T = tropicalCayleyMenger 4;
+      #T
+      C = first T;
+      rays C
+      linSpace C
+    Text 
+      If a graph G is provided, it generates the maximal cones of the tropicalization of the Cayley-Menger variety restricted to the edges of G.
+    Example
+      G = {{1,2},{2,3},{3,4},{1,4}};
+      T = tropicalCayleyMenger G;
+      #T
+      C = last T;
+      rays C
+      linSpace C  
   SeeAlso
-    maximalTreePairs 
+    "Working with cones"
 ///

Rigidity/CayleyMenger-tests.m2

@@ -1,42 +1,47 @@
 TEST ///
+restart
+needsPackage "Rigidity"
 n=4;
+T = tropicalCayleyMenger n;
+assert(#T == 75);
 G={{1,2},{2,3},{3,4},{1,4}};
-
-GIndices=edgeListToIndices(G,n);
-maximalPairs = maximalTreePairs(n);
-assert (#maximalPairs == 75)
-maximalCones = apply(maximalPairs,
-    p->apply(raysOfTreePairCone(p_0,p_1),v->v_GIndices));
-assert(toString max maximalPairs == "{x_1*x_2*x_3*x_4+x_1*x_2*x_3+x_1*x_2, x_1*x_2*x_3*x_4+x_1*x_3+x_2*x_4}")
+T = tropicalCayleyMenger G;
+assert(#T == 75 and numrows rays first T == 4);
+assert(
+    (
+    rays last T - matrix {{0, 0}, {-1, 0}, {0, 0}, {0, -1}}
+    )% linSpace first T == 0
+)
+assert(#(T/dim//uniique)==1)
 ///
 
+
 TEST ///
 permutationOfDoubleIndices = (p,G) -> apply(G, l->position(G,l' -> sort p_l' == l))
 checkInvariance = perm -> (
     n := #perm;
-    G := subsets(1..n,2);
-    GIndices := edgeListToIndices(G,n);
-    maximalPairs := maximalTreePairs(n);
-    maximalCones = apply(maximalPairs,
-	p->apply(raysOfTreePairCone(p_0,p_1),v->v_GIndices));
-    lookupSet = maximalCones/toCompare//set;
-    p := permutationOfDoubleIndices(perm,apply(G,p->p-{1,1})); -- need to decrease indices by 1
-    wrong := select(#maximalCones, i->(
-	    c := maximalCones#i;
-	    c' := c/(r->r_p);
-	    not member(toCompare c', lookupSet)
-	    ));
+    G := subsets(n,2);
+    -- maxPairs := maximalTreePairs n;
+    maximalCones := tropicalCayleyMenger n;
+    p := permutationOfDoubleIndices(perm,G); 
+    pSet = maximalCones/(c->coneFromVData((rays c)^p,(linSpace c)^p));
+    wrong := select(
+        apply(5, i->random(#maximalCones)), --take a few random cones to check
+        i->(
+	        c := maximalCones#i;
+            c' := coneFromVData((rays c)^p,(linSpace c)^p);
+            position(maximalCones, c -> c' == c) === null
+            ));
     wrong
     )
-
 perm = {3,0,1,2}
-toCompare = set; -- comparison as sets holds for n=4
+setRandomSeed 1234;
 wrong = checkInvariance perm
 assert isEmpty wrong
 
--* FAILS!!!
+
+-* this takes longer to run 
 perm = {4,0,1,2,3}
-toCompare = c -> mingens image transpose matrix(QQ,c);
 wrong = checkInvariance perm
 assert isEmpty wrong
 *-

Rigidity/CayleyMenger.m2

@@ -1,9 +1,5 @@
 export {
-    "getAllTrees",
-    "raysOfTreePairCone",
-    "raysOfUltrametricCone",
-    "maximalTreePairs",
-    "edgeListToIndices"
+    "tropicalCayleyMenger"
     }
 
 getAllTrees = method();
@@ -139,12 +135,12 @@ raysOfUltrametricCone=method();
 --which is spanned by the all-ones vector
 raysOfUltrametricCone(RingElement):=List=>T->(
     coordinates := subsets(gens ring T, 2);
-    toReturn := for m in terms T list(
-    	for c in coordinates list(
-	    if m%c_0==0 and m%c_1==0 then -1 else 0
-	)
+    raysMatrix := matrix for m in terms T list(
+	for c in coordinates list
+	if m%c_0==0 and m%c_1==0 then -1 else 0	    
     );
-    return toReturn;
+    linealityMatrix := matrix {toList(#coordinates:1)};
+    return coneFromVData(transpose raysMatrix, transpose linealityMatrix);
 )
 
 raysOfTreePairCone=method();
@@ -154,7 +150,7 @@ raysOfTreePairCone=method();
 --Does this modulo the lineality space, which is spanned
 --by the all-ones vector
 raysOfTreePairCone(RingElement,RingElement):=List=>(T1,T2)->(
-    T := T1+T2-product(gens ring T1);
+    T := T1 + T2; 
     return raysOfUltrametricCone(T);
 )
 
@@ -163,9 +159,24 @@ edgeListToIndices=method();
 --and returns the positions where they appear in the lexicographic order.
 --Assumes each edge is in increasing order
 edgeListToIndices(List,ZZ):=List=>(G,n)->(
-    allEdges := flatten for i from 1 to n-1 list for j from i+1 to n list {i,j};
-    for e in G list(
-    	position(allEdges,f->f==e)
-    )
+    allEdges := subsets(1..n,2);
+    for e in G list position(allEdges,f->f==e)
+)
+
+--Takes either an integer n or a graph G (as a list of edges)
+tropicalCayleyMenger = method()
+--If an integer n is given, returns the list of maximal Cones 
+tropicalCayleyMenger ZZ := List => n -> 
+    apply(maximalTreePairs n, p->raysOfTreePairCone(p_0,p_1))
+tropicalCayleyMenger List := List => G -> (
+    n := max flatten G;
+    T := tropicalCayleyMenger n;
+    GIndices := edgeListToIndices(G,n);
+    T' := apply(T, p->coneFromVData(
+        (rays p)^GIndices,
+        (linealitySpace p)^GIndices
+        ));
+    maxDim := T'/dim//max;
+    select(T', p->dim p == maxDim)
 )