/usr/share/axiom-20140801/input/paffexample.input

)set break resume
)spool paffexample.output
)set message auto off
)clear all

-- This example compute the genus of the projective plane curve defined by
-- by
--
--       5    2 3      4
--      X  + Y Z  + Y Z  = 0
--
-- over the field GF(2).

-- First we define the field GF(2).

--S 1 of 20
K:=PF 2  
--R 
--R
--R   (1)  PrimeField(2)
--R                                                                 Type: Domain
--E 1

-- Next, we define the polynomial ring over which
-- the polynomial is defined. 
-- You have the choice for the name of 
-- the three variables (always three !!) but  
-- the domain  DMP must be used. 
-- DMP  is an AXIOM domain and stands for DistributedMultivariatePolymnomial.

--S 2 of 20
R:=DMP([X,Y,Z],K)
--R 
--R
--R   (2)  DistributedMultivariatePolynomial([X,Y,Z],PrimeField(2))
--R                                                                 Type: Domain
--E 2

-- Then we tell to the package PAFF over which field the computation 
-- must be done. Also, you must give the same list of variables which 
-- is used to defined the polynomial.
-- BLQT Stand for BlowUpWithQuadTrans which specified the method
-- used for blowing-up (there will be another one 
-- using similar technics to Hamburger-Nother expansions).

--S 3 of 20
P:=PAFF(K,[X,Y,Z],BLQT)
--R 
--R
--R   (3)
--R   PackageForAlgebraicFunctionField(PrimeField(2),[X,Y,Z],BlowUpWithQuadTrans)
--R                                                                 Type: Domain
--E 3

-- We defined now the polynomial of the curve.

--S 4 of 20
C:R:=X**5 + Y**2*Z**3+Y*Z**4
--R 
--R
--R         5    2 3      4
--R   (4)  X  + Y Z  + Y Z
--R               Type: DistributedMultivariatePolynomial([X,Y,Z],PrimeField(2))
--E 4

-- We give it to the package PAFF(K,[X,Y,Z]) which was assigned to the
-- variable "P"

--S 5 of 20
setCurve(C)$P
--R 
--R
--R         5    2 3      4
--R   (5)  X  + Y Z  + Y Z
--R               Type: DistributedMultivariatePolynomial([X,Y,Z],PrimeField(2))
--E 5

-- To compute the genus of the curve, simply do 

--S 6 of 20
genus()$P
--R 
--R
--R   (6)  2
--R                                                     Type: NonNegativeInteger
--E 6

-- To compute the genus, the package use the genus formula 
-- given by the blowin-up theory. That means that the singular points
-- has been computed. 

--S 7 of 20
singularPoints()$P
--R 
--R
--R                1
--R   (7)  [(0:1:0) ]
--R                                   Type: List(ProjectivePlane(PrimeField(2)))
--E 7

-- The results of singularPoints()$P is the list of all
-- the singular points of the curve in the projective plane.
--
--
-- The Brill-Noether algorithm use the notion of "adjunction divisor".
-- To compute it simply do "adjunctionDivisor()$P"
-- You should obtained something like
--
--            1
--       8 %I1
--
-- This is a divisor of the function field of the curve, consisting
-- of 8 times the place %I1 which is of degree 1 (the exponant).
-- The place %I1 is a place above a singular point (the unique one 
-- for this example). This mean that the "desingularization tree" 
-- has been computed. See next step.

--S 8 of 20
adjunctionDivisor()$P
--R 
--R
--R             1
--R   (8)  8 %I1
--R                                         Type: Divisor(Places(PrimeField(2)))
--E 8

-- To compute the "desingularization tree" simply do:
-- desingTree()$P
--
-- For this example, you should obtained from desingTree()$P
--
--        ["UU.."]
--
-- This a list of desingularization tree for each singular point.
-- Here there is only one, which is "UU..".  
-- To interpret the result, you have to do some manual drawing.
-- The letter U means "Up", and a . (dot) means "down".
-- 
--
--
--              o
--              |  
--           ^  |  |
--           |  |  | .
--         U |  |  | 
--           |  |  v
--              |
--              |
--              o
--              |  
--           ^  |  |
--           |  |  | .
--         U |  |  |
--           |  |  v
--              |
--              |
--              o
--         

--S 9 of 20
desingTree()$P
--R 
--R
--R   (9)  ["UU.."]
--R  Type: List(DesingTree(InfClsPt(PrimeField(2),[X,Y,Z],BlowUpWithQuadTrans)))
--E 9

-- To see more information about the desingularization trees,
-- issue the command, fullDesTree()$P, and recall the command 
-- desingTree()$P. Here you have a bit more information about
-- the infinitly near points in the desingularization trees.
-- For this example, the result corresponds to the following
--
--         %I1  o  multiplicity = 1
--              |  
--              |
--              |
--              |
--              |
--              |
--              |
--         %I0  o  multiplicity = 2
--              |  
--              |
--              |
--              |
--              |
--              |
--              |
--         %P0  o  multiplicity = 3
--         

--S 10 of 20
fullDesTree()$P
--R 
--R                                                                   Type: Void
--E 10

--S 11 of 20
desingTree()$P
--R 
--R
--R   (11)  [[name= %P0,mult= 3]([name= %I0,mult= 2]([name= %I1,mult= 1]))]
--R  Type: List(DesingTree(InfClsPt(PrimeField(2),[X,Y,Z],BlowUpWithQuadTrans)))
--E 11

-- To see everything about desingularization trees, issue
-- the following

--S 12 of 20
fullInfClsPt()$P
--R 
--R                                                                   Type: Void
--E 12

--S 13 of 20
desingTree()$P
--R 
--R
--R   (13)
--R   [
--R                       1                                 5    4    3
--R     [dominate= (0:1:0) , name= %P0, mult= 3, defCurve= X  + Y  + Y ,
--R                       1                                              1
--R      localPoint= (0:0) , chart= [exCoord= 0,affNeigh= 2], expD= 3 %I1 ]
--R                          1                                 2      4    3
--R        [dominate= (0:1:0) , name= %I0, mult= 2, defCurve= X  + X Y  + Y ,
--R                          1                                              1
--R         localPoint= (0:0) , chart= [exCoord= 1,affNeigh= 2], expD= 2 %I1 ]
--R                             1                                 2      3
--R           [dominate= (0:1:0) , name= %I1, mult= 1, defCurve= X  + X Y  + Y,
--R                             1                                            1
--R            localPoint= (0:0) , chart= [exCoord= 2,affNeigh= 2], expD= %I1 ]
--R     ]
--R  Type: List(DesingTree(InfClsPt(PrimeField(2),[X,Y,Z],BlowUpWithQuadTrans)))
--E 13

-- You can ask for all the place of degree 1

--S 14 of 20
placesOfDegree(1)$P
--R 
--R
--R                 1        1    1
--R   (14)  [[0:1:1] ,[0:0:1] ,%I1 ]
--R                                            Type: List(Places(PrimeField(2)))
--E 14

-- With those places, you can create divisors 

--S 15 of 20
listOfDiv:=placesOfDegree(1)$P :: List DIV PLACES PF 2
--R 
--R
--R                 1        1    1
--R   (15)  [[0:1:1] ,[0:0:1] ,%I1 ]
--R                                   Type: List(Divisor(Places(PrimeField(2))))
--E 15

-- You can add the divisors.

--S 16 of 20
D:=reduce(+, listOfDiv)
--R 
--R
--R                1          1      1
--R   (16)  [0:1:1]  + [0:0:1]  + %I1
--R                                         Type: Divisor(Places(PrimeField(2)))
--E 16

-- You can multiply the divisor by an integer

--S 17 of 20
D10 := 10 * D
--R 
--R
--R                   1             1         1
--R   (17)  10 [0:1:1]  + 10 [0:0:1]  + 10 %I1
--R                                         Type: Divisor(Places(PrimeField(2)))
--E 17

-- You can ask for the degree of the divisor

--S 18 of 20
degree D10
--R 
--R
--R   (18)  30
--R                                                        Type: PositiveInteger
--E 18

-- You can compute the basis of the vector space L(D10).
-- The results is an Axiom Record. The first selector "num"
-- corresponds to the numerators of the elements of the basis,
-- and the second selector "den" is the common denominator.

--S 19 of 20
baseOfLofD:= lBasis(D10)$P
--R 
--R   Trying to interpolate with forms of degree:
--R   8
--R   Denominator found
--R   Intersection Divisor of Denominator found
--R
--R   (19)
--R   [
--R     num =
--R         8   5 3   6 2     7     4 3     5 2   2 6   2 3 3   2 4 2   2 5
--R       [Z , Y Z , Y Z , X Z , X Y Z , X Y Z , X Z , X Y Z , X Y Z , X Y Z,
--R         3 5   3 2 3   3 3 2   3 4    4 4   4   3   4 2 2   4 3    4 4   5 3
--R        X Z , X Y Z , X Y Z , X Y Z, X Z , X Y Z , X Y Z , X Y Z, X Y , X Z ,
--R         5   2   5 2    5 3   6 2   6      6 2   7    7    8
--R        X Y Z , X Y Z, X Y , X Z , X Y Z, X Y , X Z, X Y, X ]
--R     ,
--R          5 2     5   2
--R    den= X Y Z + X Y Z ]
--IType: Record(num: List DistributedMultivariatePolynomial(...
--E 19

-- Of course, the number of element in the list of numerator
-- is the dimension of the vector space L(D10). According to the 
-- Riemann-Roch Theorem, since 
-- 
--  deg D10 >= 2 g - 1
-- 
-- we should have 
--
-- dim L(D10) = deg D10 - g + 1

--S 20 of 20
((# baseOfLofD.num) = degree D10 - genus()$P + 1 ) :: Boolean
--R 
--R
--R   (20)  true
--R                                                                Type: Boolean
--E 20

)spool
)lisp (bye)
axiom-test 20140801-6 / usr / share / axiom-20140801 / input / paffexample.input
