GAP (NConvex) - Chapter 5: Fans

Goto Chapter: Top 1 2 3 4 5 6 7 Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

5 Fans
5.1 Constructors
5.1-1 Fan
5.1-2 Fan
5.1-3 Fan
5.1-4 FansFromTriangulation
5.1-5 FanFromTriangulation
5.2 Attributes
5.2-1 RayGenerators
5.2-2 GivenRayGenerators
5.2-3 RaysInMaximalCones
5.2-4 MaximalCones
5.2-5 FVector
5.3 Properties
5.3-1 IsWellDefinedFan
5.3-2 IsComplete
5.3-3 IsPointed
5.3-4 IsSmooth
5.3-5 IsSimplicial
5.3-6 IsNormalFan
5.3-7 IsRegularFan
5.3-8 IsFanoFan
5.4 Operations on fans

### 5 Fans

#### 5.1 Constructors

##### 5.1-1 Fan

`‣ Fan`( F ) | ( operation )

Returns: a fan object

If the input F is fan then return F.

##### 5.1-2 Fan

`‣ Fan`( C ) | ( operation )

Returns: a fan object

The input is a list of list \(C\). the output is the fan defined by the cones \(\{\mathrm{Cone}_i(C_i )\}_{C_i\in C}\).

##### 5.1-3 Fan

`‣ Fan`( R, C ) | ( operation )

Returns: a fan object

The input is two lists, \(R\) that indicates the rays and \(C\) that indicates the cones. The output is the fan defined by the cones \(\{\mathrm{Cone}_i(\{ R_j, j\in C_i\} )\}_{C_i\in C}\).

Below we define the same fan in two different ways:

    gap> F1 := Fan( [ [ [ 2, 1 ], [ 1, 2 ] ], [ [ 2, 1 ], [ 1, -1 ] ],
    >              [ [ -3, 1 ], [ -1, -3 ] ] ] );
    <A fan in |R^2>
    gap> F2 := Fan( [ [ 2, 1 ], [ 1, 2 ], [ -3, 1 ], [ -1, -3 ], [ 1, -1 ] ],
    >         [ [ 1, 2 ], [ 1, 5 ], [ 3, 4 ] ] );
    <A fan in |R^2>
    gap> rays1 := RayGenerators( F1 );
    [ [ -3, 1 ], [ -1, -3 ], [ 1, -1 ], [ 1, 2 ], [ 2, 1 ] ]
    gap> rays2 := RayGenerators( F2 );
    [ [ -3, 1 ], [ -1, -3 ], [ 1, -1 ], [ 1, 2 ], [ 2, 1 ] ]
    gap> RaysInMaximalCones( F1 );
    [ [ 0, 0, 0, 1, 1 ], [ 0, 0, 1, 0, 1 ], [ 1, 1, 0, 0, 0 ] ]
    gap> RaysInMaximalCones( F2 );
    [ [ 0, 0, 0, 1, 1 ], [ 0, 0, 1, 0, 1 ], [ 1, 1, 0, 0, 0 ] ]
    gap> RaysInAllCones( F1 );
    [ [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 1 ], [ 0, 0, 0, 0, 1 ],
     [ 0, 0, 0, 1, 0 ], [ 0, 0, 1, 0, 1 ], [ 0, 0, 1, 0, 0 ],
     [ 1, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 1, 0, 0, 0, 0 ] ]
    gap> FVector( F1 );
    [ 5, 3 ]
    gap> IsComplete( F1 );
    false
    gap> IsSimplicial( F1 );
    true
    gap> IsNormalFan( F1 );
    false
    gap> IsRegularFan( F1 );
    false
    gap> P1 := Polytope( [ [ 1 ], [ -1 ] ] );
    <A polytope in |R^1>
    gap> P1 := NormalFan( P1 );
    <A complete fan in |R^1>
    gap> RayGenerators( P1 );
    [ [ -1 ], [ 1 ] ]
    gap> P3 := P1 * P1 * P1;
    <A fan in |R^3>
    gap> RayGenerators( P3 );
    [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ 0, 0, -1 ], [ 0, 0, 1 ], [ 0, 1, 0 ],
      [ 1, 0, 0 ] ]
    gap> RaysInMaximalCones( P3 );
    [ [ 0, 0, 0, 1, 1, 1 ], [ 0, 0, 1, 0, 1, 1 ], [ 0, 1, 0, 1, 0, 1 ],
      [ 0, 1, 1, 0, 0, 1 ], [ 1, 0, 0, 1, 1, 0 ], [ 1, 0, 1, 0, 1, 0 ],
      [ 1, 1, 0, 1, 0, 0 ], [ 1, 1, 1, 0, 0, 0 ] ]
    gap> RaysInAllCones( P3 );
    [ [ 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 1, 1 ], [ 0, 0, 0, 1, 1, 0 ],
      [ 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 1, 0, 1 ],
      [ 0, 0, 0, 0, 0, 1 ], [ 0, 0, 0, 0, 1, 1 ], [ 0, 0, 1, 0, 1, 1 ],
      [ 0, 0, 1, 0, 1, 0 ], [ 0, 0, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 1 ],
      [ 0, 1, 0, 1, 0, 1 ], [ 0, 1, 0, 1, 0, 0 ], [ 0, 1, 0, 0, 0, 0 ],
      [ 0, 1, 0, 0, 0, 1 ], [ 0, 1, 1, 0, 0, 1 ], [ 0, 1, 1, 0, 0, 0 ],
      [ 1, 0, 0, 1, 1, 0 ], [ 1, 0, 0, 1, 0, 0 ], [ 1, 0, 0, 0, 0, 0 ],
      [ 1, 0, 0, 0, 1, 0 ], [ 1, 0, 1, 0, 1, 0 ], [ 1, 0, 1, 0, 0, 0 ],
      [ 1, 1, 0, 1, 0, 0 ], [ 1, 1, 0, 0, 0, 0 ], [ 1, 1, 1, 0, 0, 0 ] ]
    gap> IsNormalFan( P3 );
    true
    gap> Dimension( P3 );
    3
    gap> PrimitiveCollections( P3 );
    [ [ 4, 3 ], [ 5, 2 ], [ 6, 1 ] ]

The following is an example for a fan that is complete but not normal.

    gap> rays := [ [ 1, 0, 0 ], [ -1, 0, 0 ], [ 0, 1, 0 ], [ 0, -1, 0 ],
    > [ 0, 0, 1 ], [ 0, 0, -1 ], [ 2, 1, 1 ], [ 1, 2, 1 ], [ 1, 1, 2 ],
    > [ 1, 1, 1 ] ];;
    gap> cones := [ [ 1, 3, 6 ], [ 1, 4, 6 ], [ 1, 4, 5 ], [ 2, 3, 6 ],
    > [ 2, 4, 6 ], [ 2, 3, 5 ], [ 2, 4, 5 ], [ 1, 5, 9 ], [ 3, 5, 8 ],
    > [ 1, 3, 7 ], [ 1, 7, 9 ], [ 5, 8, 9 ], [ 3, 7, 8 ], [ 7, 9, 10 ],
    > [ 8, 9, 10 ], [ 7, 8, 10 ] ];;
    gap> F := Fan( rays, cones );
    <A fan in |R^3>
    gap> IsComplete( F );
    true
    gap> IsNormalFan( F );
    false
    gap> PrimitiveCollections( F );
    [ [ 7, 1 ], [ 7, 2 ], [ 7, 3 ], [ 7, 4 ], [ 7, 5 ], [ 7, 6 ],
      [ 9, 1 ], [ 9, 2 ], [ 9, 3 ], [ 9, 6 ], [ 10, 1 ], [ 10, 2 ],
      [ 10, 3 ], [ 10, 4 ], [ 8, 1 ], [ 8, 2 ], [ 8, 3 ], [ 8, 5 ],
      [ 6, 1 ], [ 5, 2 ], [ 4, 3 ], [ 9, 10, 8 ], [ 5, 6, 4 ] ]

##### 5.1-4 FansFromTriangulation

`‣ FansFromTriangulation`( R ) | ( operation )

Returns: a list of fans

The input is a list of ray generators \(R\). Provided that the package TopcomInterface is available, this function computes the list of all fine and regular triangulations of these ray generators. It then returns the list of the associated fans of these triangulations.

##### 5.1-5 FanFromTriangulation

`‣ FanFromTriangulation`( R ) | ( operation )

Returns: a fan

The input is a list of ray generators \(R\). Provided that the package TopcomInterface is available, this function computes a fine and regular triangulation of these ray generators and returns the associated fan.

The above methods construct fans from so-called triangulations. For a given list \(R\) of lists of integers, a triangulation is a fan whose ray generators are contained in the given list \(R\).

A regular triangulation is such a fan, for which all cones are strictly convex. It is called a fine triangulation, iff all elements of \(R\) are ray generators of this fan.

Above we present two method which make this approach available in NConvex via the package TopcomInterface, which in turn rests on the program Topcom. Consequently, these methods are only available if the package TopcomInterface is available. They compute either all of the fine and regular triangulations or merely just a single such triangulation.

As an example inspired from toric geometry, let us use the ray generators of the fan of the resolved conifold (i.e. the total space of the bundle ). This space is known to allow for two different triangulations. The code below reproduces this feature.

    gap> rays := [ [ 1, 0, 1 ], [ 1, 1, 0 ], [ 0, 0, -1 ], [ 0, -1, 0 ] ];;
    gap> all_triangulations := FansFromTriangulation( rays );
    [ <A fan in |R^3>, <A fan in |R^3> ]
    gap> one_triangulation := FanFromTriangulation( rays );
    <A fan in |R^3>

#### 5.2 Attributes

##### 5.2-1 RayGenerators

`‣ RayGenerators`( F ) | ( attribute )

Returns: a list

The input is a fan F. The output is the set of all ray generators of the maximal cones in the fan.

##### 5.2-2 GivenRayGenerators

`‣ GivenRayGenerators`( F ) | ( attribute )

Returns: a list

The input is a fan F. The output is the given or defining set of ray generators of the maximal cones in the fan.

##### 5.2-3 RaysInMaximalCones

`‣ RaysInMaximalCones`( F ) | ( attribute )

Returns: a list

The input is a fan F. The output is a list of lists. which represent an incidence matrix for the correspondence of the rays and the maximal cones of the fan F. The i'th list in the result represents the i'th maximal cone of F. In such a list, the j'th entry is \(1\) if the j'th ray is in the cone, 0 otherwise.

##### 5.2-4 MaximalCones

`‣ MaximalCones`( F ) | ( attribute )

Returns: a list

The input is a fan F. The output is a list of the maximal cones of F.

##### 5.2-5 FVector

`‣ FVector`( F ) | ( attribute )

Returns: a list

Description

#### 5.3 Properties

##### 5.3-1 IsWellDefinedFan

`‣ IsWellDefinedFan`( F ) | ( property )

Returns: a true or false

It checks whether the constructed fan is well defined or not.

##### 5.3-2 IsComplete

`‣ IsComplete`( F ) | ( property )

Returns: a true or false

Checks whether the fan is complete, i.e. if its support is the whole space.

##### 5.3-3 IsPointed

`‣ IsPointed`( F ) | ( property )

Returns: a true or false

Checks whether the fan is pointed, i.e., that every cone it contains is pointed.

##### 5.3-4 IsSmooth

`‣ IsSmooth`( F ) | ( property )

Returns: a true or false

Checks if the fan is smooth, i.e. if every cone in the fan is smooth.

##### 5.3-5 IsSimplicial

`‣ IsSimplicial`( F ) | ( property )

Returns: a true or false

Checks if the fan is simplicial, i.e. if every cone in the fan is simplicial.

##### 5.3-6 IsNormalFan

`‣ IsNormalFan`( F ) | ( property )

Returns: a true or false

Checks if the fan is normal as described in (Theorem 4.7, Combinatorial convexity and algebraic geometry, Ewald, Guenter).

##### 5.3-7 IsRegularFan

`‣ IsRegularFan`( F ) | ( property )

Returns: a true or false

Synonyme to `IsNormalFan`

##### 5.3-8 IsFanoFan

`‣ IsFanoFan`( F ) | ( property )

Returns: a true or false

Checks whether the fan is a fano fan.

#### 5.4 Operations on fans

A star subdivision is a certain way of extending a fan. In toric geometry, its applications include blowups of varieties. The following examples correspond to blowups of the origin of the 2-dimensional and 3-dimensional affine space, respectively.

    gap> rays := [ [ 1,0 ], [ 0,1 ] ];;
    gap> max_cones := [ [1,2] ];;
    gap> fan_affine2 := Fan( rays, max_cones );;
    gap> fan_blowup_affine2 := StarSubdivisionOfIthMaximalCone( fan_affine2, 1 );
    <A fan in |R^2>
    gap> Length( RaysInMaximalCones( fan_blowup_affine2 ) );
    2
    gap> rays := [ [ 1,0,0 ], [ 0,1,0 ], [0,0,1] ];;
    gap> max_cones := [ [1,2,3] ];;
    gap> fan_affine3 := Fan( rays, max_cones );;
    gap> fan_blowup_affine3 := StarSubdivisionOfIthMaximalCone( fan_affine3, 1 );
    <A fan in |R^3>
    gap> Length( RaysInMaximalCones( fan_blowup_affine3 ) );
    3

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 Ind

generated by GAPDoc2HTML