Merge branch 'pr-249' into devel

* pr-249:
  Minor adjustment in new extended method for CoxRing
  Added examples on new constructor to the docu
  Added convenient methods for construction of toric varieties
  Added tests to exemplify the new ways in which a Cox ring can be created
  Extended method CoxRing of toric varieties

Author: mohamed-barakat

ToricVarieties/doc/Doc.autodoc

@@ -29,6 +29,9 @@ Sebastian Gutsche
 @Subsection A smooth, complete toric variety which is not projective
 @InsertSystem nonprojective
 
+@Subsection Convenient construction of toric varieties
+@InsertSystem ConvenientConstructors
+
 @Chapter Toric subvarieties
 
 @Chapter Affine toric varieties

ToricVarieties/examples/examplesmanual/P1P1.g

@@ -52,28 +52,67 @@ IsSmooth( P1 );
 #! true
 Dimension( P1 );
 #! 1
+CoxRing( P1, "q" );
+#! Q[q_1,q_2]
+#! (weights: [ 1, 1 ])
 P1xP1 := P1*P1;
 #! <A projective smooth toric variety of dimension 2 which is a product 
 #! of 2 toric varieties>
 ByASmallerPresentation( ClassGroup( P1xP1 ) );
 #! <A free left module of rank 2 on free generators>
-CoxRing( P1xP1 );
-#! Q[x_1,x_2,x_3,x_4]
+CoxRing( P1xP1, "x1,y1,y2,x2" );
+#! Q[x1,y1,y2,x2]
 #! (weights: [ ( 0, 1 ), ( 1, 0 ), ( 1, 0 ), ( 0, 1 ) ])
 Display( SRIdeal( P1xP1 ) );
-#! x_1*x_4,
-#! x_2*x_3 
+#! x1*x2,
+#! y1*y2
 #! 
 #! A (left) ideal generated by the 2 entries of the above matrix
 #! 
 #! (graded, degrees of generators: [ ( 0, 2 ), ( 2, 0 ) ])
 Display( IrrelevantIdeal( P1xP1 ) );
-#! x_1*x_2,
-#! x_1*x_3,
-#! x_2*x_4,
-#! x_3*x_4 
+#! x1*y1,
+#! x1*y2,
+#! y1*x2,
+#! y2*x2
 #! 
 #! A (left) ideal generated by the 4 entries of the above matrix
 #! 
 #! (graded, degrees of generators: [ ( 1, 1 ), ( 1, 1 ), ( 1, 1 ), ( 1, 1 ) ])
 #! @EndExample
+
+
+
+#! @System ConvenientConstructors
+
+#! @Example
+rays := [ [1,0],[-1,0],[0,1],[0,-1] ];
+#! [ [ 1, 0 ], [ -1, 0 ], [ 0, 1 ], [ 0, -1 ] ]
+cones := [ [1,3],[1,4],[2,3],[2,4] ];
+#! [ [1,3],[1,4],[2,3],[2,4] ]
+weights := [ [1,0],[1,0],[0,1],[0,1] ];
+#! [ [1,0],[1,0],[0,1],[0,1] ]
+weights2 := [ [1,1],[1,1],[1,2],[1,2] ];
+#! [ [1,1],[1,1],[1,2],[1,2] ]
+tor1 := ToricVariety( rays, cones, weights, "x1,x2,y1,y2" );
+#! <A toric variety of dimension 2>
+CoxRing( tor1 );
+#! Q[x2,y2,y1,x1]
+#! (weights: [ ( 1, 0 ), ( 0, 1 ), ( 0, 1 ), ( 1, 0 ) ])
+tor2:= ToricVariety( rays, cones, weights, "q" );
+#! <A toric variety of dimension 2>
+CoxRing( tor2 );
+#! Q[q_2,q_4,q_3,q_1]
+#! (weights: [ ( 1, 0 ), ( 0, 1 ), ( 0, 1 ), ( 1, 0 ) ])
+tor3:= ToricVariety( rays, cones, weights );
+#! <A toric variety of dimension 2>
+CoxRing( tor3 );
+#! Q[x_2,x_4,x_3,x_1]
+#! (weights: [ ( 1, 0 ), ( 0, 1 ), ( 0, 1 ), ( 1, 0 ) ])
+tor4:= ToricVariety( rays, cones, weights2, "x1,x2,z1,z2" );
+#! <A toric variety of dimension 2>
+CoxRing( tor4 );
+#! Q[x2,z2,z1,x1]
+#! (weights: [ ( 1, 1 ), ( 1, 2 ), ( 1, 2 ), ( 1, 1 ) ])
+
+#! @EndExample

ToricVarieties/gap/ToricVarieties.gd

@@ -343,12 +343,15 @@ DeclareOperation( "CharacterToRationalFunction",
                   [ IsList, IsToricVariety ] );
 
 #! @Description
-#!  Computes the Cox ring of the variety <A>vari</A>. <A>vars</A> needs to be a string containing one variable,
-#!  which will be numbered by the method. 
+#!  Computes the Cox ring of the variety <A>vari</A>. <A>vars</A> needs to be a string. We allow for two
+#! different formats. Either, it is a string which does not contain ",". Then this string will be index and
+#! the resulting strings are then used as names for the variables of the Cox ring. Alternatively, one can also
+#! use a string containing ",". In this case, a "," is considered as separator and one can provide individual
+#! names for all variables of the Cox ring.
 #! @Returns a ring
 #! @Arguments vari, vars
 DeclareOperation( "CoxRing",
-                  [ IsToricVariety, IsString ] );
+                  [ IsToricVariety, IsList ] );
 
 #! @Description
 #!  Returns a list of the currently defined Divisors of the toric variety.
@@ -424,9 +427,25 @@ DeclareOperation( "ToricVariety",
                   [ IsConvexObject ] );
 
 #! @Description
-#!  Creates a toric variety out of the convex object <A>conv</A>. In addition it takes a list of integers.
-#!  Those are used to set the degrees of the variables in the Cox ring of the variety.
+#! Creates a toric variety from a list <A>rays</A> of ray generators and cones <A>cones</A>.
+#! Beyond the functionality of the other methods, this constructor allows to assign specific 
+#! gradings to the homogeneous variables of the Cox ring.
+#! With respect to the order in which the rays appear in the list <A>rays</A>, we assign gradings
+#! as provided by the third argument <A>degree_list</A> . The latter is a list of integers.
 #! @Returns a variety
-#! @Arguments conv
+#! @Arguments rays, cones, degree_list
+DeclareOperation( "ToricVariety",
+                  [ IsList, IsList, IsList ] );
+
+#! @Description
+#! Creates a toric variety from a list <A>rays</A> of ray generators and cones <A>cones</A>.
+#! Beyond the functionality of the other methods, this constructor allows to assign specific
+#! gradings and homogeneous variable names to the ray generators of this toric variety.
+#! With respect to the order in which the rays appear in the list <A>rays</A>, we assign gradings
+#! and variable names as provided by the third and fourth argument. These are the list of gradings
+#! <A>degree_list</A> and the list of variables names <A>var_list</A>. The former is a list of
+#! integers and the latter a list of strings.
+#! @Returns a variety
+#! @Arguments rays, cones, degree_list, var_list
 DeclareOperation( "ToricVariety",
-                  [ IsConvexObject, IsList ] );
+                  [ IsList, IsList, IsList, IsList ] );

ToricVarieties/gap/ToricVarieties.gi

@@ -566,17 +566,32 @@ RedispatchOnCondition( CoxRing, true, [ IsToricVariety, IsString ], [ HasNoTorus
 ##
 InstallMethod( CoxRing,
                "for convex toric varieties.",
-               [ IsToricVariety and HasNoTorusfactor, IsString ],
+               [ IsToricVariety and HasNoTorusfactor, IsList ],
 
-  function( variety, variable )
-    local raylist, indeterminates, ring, class_list;
+  function( variety, variable_names )
+    local var_list, raylist, indeterminates, ring, class_list;
 
+    # test for valid input
+    if not IsString( variable_names ) then
+        Error( "the variable names must be specified as a string" );
+    fi;
+
+    # identify the individual names and the ray generators
+    var_list := SplitString( variable_names, "," );
     raylist := RayGenerators( FanOfVariety( variety ) );
 
-    indeterminates := List( [ 1 .. Length( raylist ) ], i -> JoinStringsWithSeparator( [ variable, i ], "_" ) );
+    # check for valid input and, if provided, form list of final variable names
+    if ( Length( var_list ) <> 1 and Length( var_list ) <> Length( raylist ) ) then
+        Error( "either one variable name, or a variable name for each ray generator must be specified" );
+    fi;
+
+    if Length( var_list ) = 1 then
+        indeterminates := List( [ 1 .. Length( raylist ) ], i -> JoinStringsWithSeparator( [ var_list[ 1 ], i ], "_" ) );
+        indeterminates := JoinStringsWithSeparator( indeterminates, "," );
+    else
+        indeterminates := var_list;
+    fi;
 
-    indeterminates := JoinStringsWithSeparator( indeterminates, "," );
-    
     ring := GradedRing( DefaultGradedFieldForToricVarieties() * indeterminates );
 
     SetDegreeGroup( ring, ClassGroup( variety ) );
@@ -1439,40 +1454,108 @@ end );
 
 ##
 InstallMethod( ToricVariety,
-               " for homalg fans and a list of weights for the variables in the Cox ring",
-               [ IsFan, IsList ],
-  function( fan, degrees )
-    local variety, matrix1, matrix2, map;
+               " for lists of rays, cones and weights for the variables in the Cox ring",
+               [ IsList, IsList, IsList ],
+  function( rays, cones, degrees )
+    local vars;
+
+    # install standard list of variable names
+    vars := JoinStringsWithSeparator(
+                 List( [ 1 .. Length( rays ) ],
+                        i -> JoinStringsWithSeparator( [ TORIC_VARIETIES.CoxRingIndet, i ], "_" ) ), "," );
+
+    # and return result from method below
+    return ToricVariety( rays, cones, degrees, vars );
+
+end );
+
+##
+InstallMethod( ToricVariety,
+               " for lists of rays, cones, gradings and variable names",
+               [ IsList, IsList, IsList, IsList ],
+  function( rays, cones, gradings, indeterminates )
+    local fan, var_names_buffer, var_names, variety, rays_in_fan, shuffled_gradings, shuffled_var_names, i, pos, matrix1, matrix2, map;
 
+    # construct the fan and test that it is pointed
+    fan := Fan( rays, cones );
     if not IsPointed( fan ) then
 
         Error( "input fan must only contain strictly convex cones\n" );
 
     fi;
 
+    # check that gradings are of correct lengths
+    if not Length( gradings ) = Length( rays ) then
+
+        Error( "For each ray generators a grading has to be provided" );
+        return false;
+
+    fi;
+
+    # test if the var_names have been given as correct input
+    if not IsString( indeterminates ) then
+        Error( "the variables names have to be provided as string" );
+    fi;
+
+    # next seperate them by ","
+    var_names_buffer := SplitString( indeterminates, "," );
+    if ( Length( var_names_buffer ) <> 1 and Length( var_names_buffer ) <> Length( rays ) ) then
+        Error( "either one variable name, or a variable name for each ray generator must be specified" );
+    fi;
+    if Length( var_names_buffer ) = 1 then
+        var_names := List( [ 1 .. Length( rays ) ],
+                                i -> JoinStringsWithSeparator( [ var_names_buffer[ 1 ], i ], "_" ) );
+    else
+        var_names := var_names_buffer;
+    fi;
+
     variety := rec( WeilDivisors := WeakPointerObj( [ ] ) );
 
     ObjectifyWithAttributes(
                              variety, TheTypeFanToricVariety,
                              FanOfVariety, fan
                             );
 
-    # check for valid input
-    matrix1 := Involution( HomalgMatrix( RayGenerators( fan ), HOMALG_MATRICES.ZZ ) );
-    matrix2 := HomalgMatrix( degrees, HOMALG_MATRICES.ZZ );
-    if not IsZero( matrix1 * matrix2 ) then
+    # The ray generators in fan = Fan( rays, cones ) are shuffled w.r.t. the provided inputlist rays.
+    # Let us therefore determine the permutation matrix
+    rays_in_fan := RayGenerators( FanOfVariety( variety ) );
+    shuffled_gradings := [];
+    shuffled_var_names := [];
+    for i in [ 1 .. Length( rays_in_fan ) ] do
+        pos := Position( rays, rays_in_fan[ i ] );
+        shuffled_gradings[ i ] := gradings[ pos ];
+        shuffled_var_names[ i ] := var_names[ pos ];
+    od;
 
-      Error( "corrupted input - the given weights must form (a) cokernel of the ray generators of the given fan" );
+    # if vari does not have a torus factor, then the gradings are set by the cokernel
+    # of the matrix, in which the rays are the rows (Cox-Schenk-Little, theorem 4.1.3)
+    # we proceed under this assumption thus
+    if HasTorusfactor( variety ) then
+        Error( Concatenation( "The method of setting the gradings by hand is currently supported ",
+                              "only for toric variety without torus factor" ) );
+        return false;
+    fi;
+
+    # now check, that the provided gradings are valid
+    matrix1 := HomalgMatrix( rays_in_fan, HOMALG_MATRICES.ZZ );
+    matrix2 := HomalgMatrix( shuffled_gradings, HOMALG_MATRICES.ZZ );
+    if not IsZero( Involution( matrix2 ) * matrix1 ) then
+
+      Error( "corrupted input - the given gradings must form (a) cokernel of the ray generators of the given fan" );
 
     fi;
 
-    # compute the map from the Weil divisors to the class group according to the given degrees
-    map := HomalgMap( degrees,
+    # now use this information to set the map from WeilDivisors to the class group
+    map := HomalgMap( shuffled_gradings,
                       TorusInvariantDivisorGroup( variety ),
-                      Length( degrees[ 1 ] ) * HOMALG_MATRICES.ZZ
+                      Length( shuffled_gradings[ 1 ] ) * HOMALG_MATRICES.ZZ
                      );
     SetMapFromWeilDivisorsToClassGroup( variety, map );
 
+    # finally install the Cox ring with the prescribed names
+    # this here needs to join the shuffled_var_names by "," Banane
+    CoxRing( variety, JoinStringsWithSeparator( shuffled_var_names, "," ) );
+
     # and return the variety
     return variety;