Changeset ae0203 in git


Ignore:
Timestamp:
Feb 17, 2004, 5:03:20 PM (20 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
d8932ed574a04a0801bb1e297ae05eb469cee24c
Parents:
01d285f972c12952121927cfa7c3fff6ede9d3b5
Message:
*hannes: from 2-0


git-svn-id: file:///usr/local/Singular/svn/trunk@7044 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/brnoeth.lib

    r01d285 rae0203  
    1 version="$Id: brnoeth.lib,v 1.12 2001-08-27 14:47:46 Singular Exp $";
    2 category="Miscellaneous";
     1version="$Id: brnoeth.lib,v 1.13 2004-02-17 16:03:20 Singular Exp $";
     2category="Coding theory";
    33info="
    44LIBRARY:   brnoeth.lib  Brill-Noether Algorithm, Weierstrass-SG and AG-codes
    … …  
    1111 The computation of Weierstrass semigroups is also implemented.@*
    1212 The procedures are intended only for plane (singular) curves defined over
    13  a prime field of positive charateristic.@*
     13 a prime field of positive characteristic.@*
    1414 For more information about the library see the end of the file brnoeth.lib.
    1515
    1616MAIN PROCEDURES:
    1717 Adj_div(f);            computes the conductor of a curve
    18  NSplaces(h,A);         computes non-singular places up to given degree
     18 NSplaces(h,A);         computes non-singular places with given degrees
    1919 BrillNoether(D,C);     computes a vector space basis of the linear system L(D)
    2020 Weierstrass(P,m,C);    computes the Weierstrass semigroup of C at P up to m
    … …  
    514514  // checks wether I is contained in J and returns a boolean
    515515  // remark : J is assumed to be given by a standard basis
    516   int s=size(I);
     516  int s=ncols(I);
    517517  int i;
    518518  for (i=1;i<=s;i=i+1)
    … …  
    840840        }
    841841        kill(FF2);
    842 //        list Fp;
    843 //        ideal facs=factorize(x^(q-1)-1,1);
    844 //        for (i=1;i<=q-1;i=i+1)
    845 //        {
    846 //          Fq[i]=number(subst(facs[i],x,0));
    847 //        }
    848842        for (i=1;i<=q-1;i=i+1)
    849843        {
    850 //          b=Fq[i];
    851844          b=FF1[i];
    852845          if (subst(mpol,x,b)==0)
    … …  
    11551148  int i,j,k;
    11561149  int m,n;
    1157   list L@HNE=essdevelop(CHI);
     1150//  list L@HNE=essdevelop(CHI);
     1151  list L@HNE=ratdevelop(CHI);
    11581152  export(L@HNE);
    11591153  int n_branches=size(L@HNE);
    … …  
    11981192        }
    11991193      }
     1194////////
     1195check=0;
     1196////////
    12001197      if (size(update_CURVE[5])>0)
    12011198      {
    … …  
    13121309      {
    13131310        ext_0=dgs[i];
     1311////////
     1312check=0;
     1313////////
    13141314        if (size(update_CURVE[5])>=ext_0)
    13151315        {
    … …  
    14641464        }
    14651465      }
     1466////////
     1467check=0;
     1468////////
    14661469      if (size(update_CURVE[5])>=ext2)
    14671470      {
    … …  
    16041607        // local ring exists
    16051608        ext_0=ext1*dgs[i];
     1609////////
     1610check=0;
     1611////////
    16061612        if (size(update_CURVE[5])>=ext_0)
    16071613        {
    … …  
    21522158///////////////////////////////////////////////////////////////////////////////
    21532159
    2154 proc NSplaces (int h,list CURVE)
    2155 "USAGE:   NSplaces( h, CURVE ), where h is an integer and CURVE is a list
    2156 RETURN:   list L with updated data of CURVE after computing all
    2157           points up to degree H+h (H the maximum degree of the previously
    2158           computed places): @*
     2160proc NSplaces (intvec h,list CURVE)
     2161"USAGE:   NSplaces( h, CURVE ), where h is an intvec and CURVE is a list
     2162RETURN:   list L with updated data of CURVE after computing all non-singular
     2163          affine closed places whose degrees are in the intvec h: @*
    21592164   @format
    21602165   in L[1][1]: (affine ring) lists Aff_Points(d) with affine non-singular
    2161                points of degree d (if non-empty)
     2166               (closed) points of degree d (if non-empty),
    21622167   in L[3]:    the newly computed closed places are added,
    21632168   in L[5]:    local rings created/updated to store (repres. of) new places.
    … …  
    21712176"
    21722177{
    2173   // computes all the non-singular closed places with degree up to a certain
    2174   // bound; this bound is the maximum degree of an existing singular place or
    2175   // non-singular place at infinity plus an increment h>=0 which is given as
    2176   // input
     2178  // computes all the non-singular affine (closed) places with fixed degrees
    21772179  // creates lists of points and the corresponding places
    21782180  // list CURVE must be the output of the procedure "Adj_div"
    2179   // warning : if h<0 then it will be replaced by h=0
     2181  // notice : if h==0 then nothing is done
     2182  // warning : non-positive entries are forgotten
     2183  if (h==0)
     2184  {
     2185    return(CURVE);
     2186  }
    21802187  intvec opgt=option(get);
    21812188  option(redSB);
    21822189  def Base_R=basering;
    21832190  def aff_r=CURVE[1][1];
    2184   int M=size(CURVE[5]);
    2185   if (h>0)
    2186   {
    2187     M=M+h;
    2188   }
     2191  int M=size(h);
    21892192  list update_CURVE=CURVE;
    2190   int i,j,s;
     2193  int i,j,l,s;
    21912194  setring aff_r;
    21922195  intvec pP=1,0,0;
    21932196  for (i=1;i<=M;i=i+1)
    21942197  {
    2195     dbprint(printlevel+1,"Computing non-singular affine places of degree "
    2196                            +string(i)+" ... ");
    2197     if (defined(Aff_Points(i))==0)
    2198     {
    2199       list Aff_Points(i)=closed_points_deg(CHI,i,Aff_SLocus);
    2200       s=size(Aff_Points(i));
    2201       if (s>0)
    2202       {
    2203         export(Aff_Points(i));
    2204         pP[2]=i;
    2205         for (j=1;j<=s;j=j+1)
    2206         {
    2207           pP[3]=j;
    2208           update_CURVE=place(pP,0,update_CURVE);
     2198    l=h[i];
     2199    if (l>0)
     2200    {
     2201      dbprint(printlevel+1,"Computing non-singular affine places of degree "
     2202                             +string(l)+" ... ");
     2203      if (defined(Aff_Points(l))==0)
     2204      {
     2205        list Aff_Points(l)=closed_points_deg(CHI,l,Aff_SLocus);
     2206        s=size(Aff_Points(l));
     2207        if (s>0)
     2208        {
     2209          export(Aff_Points(l));
     2210          pP[2]=l;
     2211          for (j=1;j<=s;j=j+1)
     2212          {
     2213            pP[3]=j;
     2214            update_CURVE=place(pP,0,update_CURVE);
     2215          }
    22092216        }
    22102217      }
    … …  
    22242231  // The list of computed places:
    22252232  C[3];
    2226   // create places up to degree 1+3
    2227   list L=NSplaces(3,C);
     2233  // create places up to degree 4
     2234  list L=NSplaces(1..4,C);
    22282235  // The list of computed places is now:
    22292236  L[3];
    … …  
    33693376  ring s=2,(x,y),lp;
    33703377  list C=Adj_div(x3y+y3+x);
    3371   C=NSplaces(3,C);
     3378  C=NSplaces(1..4,C);
    33723379  // the first 3 Places in C[3] are of degree 1.
    33733380  // we define the rational divisor G = 4*C[3][1]+4*C[3][3] (of degree 8):
    … …  
    36243631  ring s=2,(x,y),lp;
    36253632  list C=Adj_div(x3y+y3+x);
    3626   C=NSplaces(3,C);
     3633  C=NSplaces(1..4,C);
    36273634  def R=C[1][2];
    36283635  setring R;
    … …  
    37933800    if ( (s mod i) == 0 )
    37943801    {
    3795       def auxR=EC[5][i][1];
    3796       setring auxR;
    3797       auxIV[i]=size(POINTS);
    3798       setring BRing;
    3799       kill(auxR);
     3802      if (typeof(EC[5][i])=="list")
     3803      {
     3804        def auxR=EC[5][i][1];
     3805        setring auxR;
     3806        auxIV[i]=size(POINTS);
     3807        setring BRing;
     3808        kill(auxR);
     3809      }
     3810      else
     3811      {
     3812        auxIV[i]=0;
     3813      }
    38003814    }
    38013815    else
    … …  
    38133827      {
    38143828        l=iw[2];
    3815         // check that this place(s) are not in sup(D)
     3829        // check that this place(s) is/are not in sup(D)
    38163830        if (d==1)
    38173831        {
    … …  
    39123926  ring s=2,(x,y),lp;
    39133927  list HC=Adj_div(x3+y2+y);
    3914   HC=NSplaces(1,HC);
     3928  HC=NSplaces(1..2,HC);
    39153929  HC=extcurve(2,HC);
    39163930  def ER=HC[1][4];
    … …  
    39593973  ring s=2,(x,y),lp;
    39603974  list HC=Adj_div(x3+y2+y);
    3961   HC=NSplaces(1,HC);
     3975  HC=NSplaces(1..2,HC);
    39623976  HC=extcurve(2,HC);
    39633977  def ER=HC[1][4];
    … …  
    39914005   @format
    39924006   L[1][5]: ring p,(x,y,t),ls,
    3993    L[2][3]: int  (the number of places over the base field).
     4007   L[2][3]: int  (the number of computed places over the base field).
    39944008   @end format
    39954009          In both cases, in the ring L[1][5] lists with the data for all the
    3996           rational places (after a field extension of degree d) are
     4010          computed rational places (after a field extension of degree d) are
    39974011          created (see @ref{Adj_div}):
    39984012   @format
    39994013   lists POINTS, LOC_EQS, BRANCHES, PARAMETRIZATIONS.
    40004014   @end format
    4001 NOTE:     The list CURVE should be the output of @code{NSplaces} and has
    4002           to contain (at least) all places up to degree d. @*
     4015NOTE:     The list CURVE should be the output of @code{NSplaces},
     4016          and must contain (at least) one place of degree d. @*
     4017          You actually need all the places with degree dividing d.
     4018          Otherwise, not all the places are computed, but only part of them. @*
    40034019          This procedure must be executed before constructing AG codes,
    40044020          even if no extension is needed. The ring L[1][4] must be active
    … …  
    40474063  else
    40484064  {
    4049     if (size(CURVE[5])>=d)
    4050     {
    4051       int i,j,k;
    4052       if (typeof(CURVE[5][d])=="list")
    4053       {
    4054         def S(d)=CURVE[5][d][1];
    4055         setring S(d);
    4056       }
    4057       else
    4058       {
    4059         ring S(d)=char(basering),t,ls;
    4060         list POINTS=list();
    4061       }
    4062       string smin=string(minpoly);
    4063       setring BR;
    4064       ring RatPl=(char(basering),a),(x,y,t),ls;
    4065       execute("minpoly="+smin+";");
    4066       list POINTS=imap(S(d),POINTS);
    4067       list LOC_EQS=imap(S(d),LOC_EQS);
    4068       list BRANCHES=imap(S(d),BRANCHES);
    4069       list PARAMETRIZATIONS=imap(S(d),PARAMETRIZATIONS);
    4070       kill(S(d));
    4071       int s=size(POINTS);
    4072       int counter=0;
    4073       int piv=0;
    4074       for (j=1;j<=s;j=j+1)
    4075       {
     4065    // exclude the case when no place of degree d was previously computed/found
     4066    int dd=size(CURVE[5]);
     4067    if (dd<d)
     4068    {
     4069      ERROR("you did not compute/find any place of degree "+string(d));
     4070    }
     4071    if (typeof(CURVE[5][d])<>"list")
     4072    {
     4073      ERROR("you did not compute/find any place of degree "+string(d));
     4074    }
     4075
     4076    // Define the ring "RatPl" :
     4077    def S(d)=CURVE[5][d][1];
     4078    setring S(d);
     4079    string smin=string(minpoly);
     4080    setring BR;
     4081    ring RatPl=(char(basering),a),(x,y,t),ls;
     4082    execute("minpoly="+smin+";");
     4083
     4084    // import data from local ring S(d)
     4085    list POINTS=imap(S(d),POINTS);
     4086    list LOC_EQS=imap(S(d),LOC_EQS);
     4087    list BRANCHES=imap(S(d),BRANCHES);
     4088    list PARAMETRIZATIONS=imap(S(d),PARAMETRIZATIONS);
     4089    kill(S(d));
     4090
     4091    // conjugate data from S(d)
     4092    int s=size(POINTS);
     4093    int counter=0;
     4094    int piv=0;
     4095    int i,j,k;
     4096    for (j=1;j<=s;j=j+1)
     4097    {
     4098      counter=counter+1;
     4099      piv=counter;
     4100      for (k=1;k<d;k=k+1)
     4101      {
     4102        POINTS=insert(POINTS,Frobenius(POINTS[piv],1),counter);
     4103        LOC_EQS=insert(LOC_EQS,Frobenius(LOC_EQS[piv],1),counter);
     4104        BRANCHES=insert(BRANCHES,conj_b(BRANCHES[piv],1),counter);
     4105        PARAMETRIZATIONS=insert(PARAMETRIZATIONS,Frobenius(
     4106                                  PARAMETRIZATIONS[piv],1),counter);
    40764107        counter=counter+1;
    40774108        piv=counter;
    4078         for (k=1;k<d;k=k+1)
    4079         {
    4080           POINTS=insert(POINTS,Frobenius(POINTS[piv],1),counter);
    4081           LOC_EQS=insert(LOC_EQS,Frobenius(LOC_EQS[piv],1),counter);
    4082           BRANCHES=insert(BRANCHES,conj_b(BRANCHES[piv],1),counter);
    4083           PARAMETRIZATIONS=insert(PARAMETRIZATIONS,Frobenius(
    4084                                              PARAMETRIZATIONS[piv],1),counter);
    4085           counter=counter+1;
    4086           piv=counter;
    4087         }
    4088       }
    4089       string olda;
    4090       poly paux;
    4091       intvec iv,iw;
    4092       int ii,jj,kk,m,n;
    4093       for (i=d-1;i>=2;i=i-1)
    4094       {
    4095         if ( (d mod i)==0 )
    4096         {
    4097           if (typeof(CURVE[5][i])=="list")
    4098           {
    4099             def S(i)=CURVE[5][i][1];
    4100           }
    4101           else
    4102           {
    4103             ring S(i)=char(basering),t,ls;
    4104             list POINTS=list();
    4105             setring BR;
    4106            }
     4109      }
     4110    }
     4111
     4112    // now the same thing for smaller base fields
     4113    string olda;
     4114    poly paux;
     4115    intvec iv,iw;
     4116    int ii,jj,kk,m,n;
     4117    for (i=d-1;i>=2;i=i-1)
     4118    {
     4119      if ( (d mod i)==0 )
     4120      {
     4121        if (typeof(CURVE[5][i])=="list")
     4122        {
     4123          def S(i)=CURVE[5][i][1];
     4124          // embedd S(i) inside basering == RatPl " ==S(d) "
    41074125          olda=subfield(S(i));
    41084126          setring S(i);
    41094127          s=size(POINTS);
    41104128          setring RatPl;
     4129          // import data from S(i)
    41114130          for (j=s;j>=1;j=j-1)
    41124131          {
    … …  
    41144133            POINTS=insert(POINTS,list(),0);
    41154134            POINTS[1][1]=number(importdatum(S(i),"POINTS["+string(j)
    4116                                                             +"][1]",olda));
     4135                                                          +"][1]",olda));
    41174136            POINTS[1][2]=number(importdatum(S(i),"POINTS["+string(j)
    4118                                                             +"][2]",olda));
     4137                                                          +"][2]",olda));
    41194138            POINTS[1][3]=number(importdatum(S(i),"POINTS["+string(j)
    4120                                                             +"][3]",olda));
     4139                                                          +"][3]",olda));
    41214140            LOC_EQS=insert(LOC_EQS,importdatum(S(i),"LOC_EQS["+string(j)
    4122                                                             +"]",olda),0);
     4141                                                          +"]",olda),0);
    41234142            BRANCHES=insert(BRANCHES,list(),0);
    41244143            setring S(i);
    … …  
    41404159              {
    41414160                Maux[ii,jj]=importdatum(S(i),"BRANCHES["+string(j)
    4142                                  +"][1]["+string(ii)+","+string(jj)+"]",olda);
     4161                               +"][1]["+string(ii)+","+string(jj)+"]",olda);
    41434162              }
    41444163            }
    … …  
    41634182              BRANCHES=insert(BRANCHES,conj_b(BRANCHES[piv],1),counter);
    41644183              PARAMETRIZATIONS=insert(PARAMETRIZATIONS,Frobenius(
    4165                                              PARAMETRIZATIONS[piv],1),counter);
     4184                                        PARAMETRIZATIONS[piv],1),counter);
    41664185            }
    41674186            setring S(i);
    … …  
    41724191        }
    41734192      }
    4174       kill(iw);
    4175       kill(paux);
    4176       if (typeof(CURVE[5][1])=="list")
    4177       {
    4178         def S(1)=CURVE[5][1][1];
    4179       }
    4180       else
    4181       {
    4182         ring S(1)=char(basering),t,ls;
    4183         list POINTS=list();
    4184         setring RatPl;
    4185       }
     4193    }
     4194    kill(iw);
     4195    kill(paux);
     4196
     4197    // finally add points from S(1)
     4198    if (typeof(CURVE[5][1])=="list")
     4199    {
     4200      def S(1)=CURVE[5][1][1];
    41864201      POINTS=imap(S(1),POINTS)+POINTS;
    41874202      LOC_EQS=imap(S(1),LOC_EQS)+LOC_EQS;
    41884203      BRANCHES=imap(S(1),BRANCHES)+BRANCHES;
    41894204      PARAMETRIZATIONS=imap(S(1),PARAMETRIZATIONS)+PARAMETRIZATIONS;
    4190       export(POINTS);
    4191       export(LOC_EQS);
    4192       export(BRANCHES);
    4193       export(PARAMETRIZATIONS);
    4194       int NrRatPl=size(POINTS);
    4195       ext_CURVE[2][3]=NrRatPl;
    4196       setring BR;
    4197       ext_CURVE[1][5]=RatPl;
    4198       ring r(d)=(char(basering),a),(x,y),lp;
    4199       execute("minpoly="+smin+";");
    4200       setring BR;
    4201       ext_CURVE[1][3]=r(d);
    4202       ring R(d)=(char(basering),a),(x,y,z),lp;
    4203       execute("minpoly="+smin+";");
    4204       setring BR;
    4205       ext_CURVE[1][4]=R(d);
    4206       dbprint(printlevel+1,"");
    4207       dbprint(printlevel+2,"Total number of rational places : NrRatPl = "
     4205    }
     4206
     4207    // prepare data for output
     4208    export(POINTS);
     4209    export(LOC_EQS);
     4210    export(BRANCHES);
     4211    export(PARAMETRIZATIONS);
     4212    int NrRatPl=size(POINTS);
     4213    ext_CURVE[2][3]=NrRatPl;
     4214    setring BR;
     4215    ext_CURVE[1][5]=RatPl;
     4216    ring r(d)=(char(basering),a),(x,y),lp;
     4217    execute("minpoly="+smin+";");
     4218    setring BR;
     4219    ext_CURVE[1][3]=r(d);
     4220    ring R(d)=(char(basering),a),(x,y,z),lp;
     4221    execute("minpoly="+smin+";");
     4222    setring BR;
     4223    ext_CURVE[1][4]=R(d);
     4224    dbprint(printlevel+1,"");
     4225    dbprint(printlevel+2,"Total number of rational places : NrRatPl = "
    42084226                                   +string(NrRatPl));
    4209       dbprint(printlevel+1,"");
    4210       kill(S(1));
    4211       kill(R(d));
    4212       kill(RatPl);
    4213       return(ext_CURVE);
    4214     }
    4215     else
    4216     {
    4217       ERROR("you must compute first all the places up to degree "+string(d));
    4218       return();
    4219     }
     4227    dbprint(printlevel+1,"");
     4228    kill(S(1));
     4229    kill(R(d));
     4230    kill(RatPl);
     4231    return(ext_CURVE);
    42204232  }
    42214233}
    … …  
    42274239  ring s=2,(x,y),lp;
    42284240  list C=Adj_div(x5+y2+y);
    4229   C=NSplaces(3,C);
     4241  C=NSplaces(1..4,C);
    42304242  // since we have all points up to degree 4, we can extend the curve
    42314243  // to that extension, in order to get rational points over F_16;
    … …  
    43634375  ring s=2,(x,y),lp;
    43644376  list HC=Adj_div(x3+y2+y);
    4365   HC=NSplaces(1,HC);
     4377  HC=NSplaces(1..2,HC);
    43664378  HC=extcurve(2,HC);
    43674379  def ER=HC[1][4];
    … …  
    45134525  ring s=2,(x,y),lp;
    45144526  list HC=Adj_div(x3+y2+y);
    4515   HC=NSplaces(1,HC);
     4527  HC=NSplaces(1..2,HC);
    45164528  HC=extcurve(2,HC);
    45174529  def ER=HC[1][4];
    … …  
    46494661  for (i=1;i<=m;i=i+1)
    46504662  {
    4651     for (j=i;j<=n;j=j+1)
     4663    for (j=i+1;j<=n;j=j+1)
    46524664    {
    46534665      A[i,j]=A[i,j]/A[i,i];
    46544666    }
     4667    A[i,i]=1;
    46554668  }
    46564669  // complete a block with the identity matrix
    … …  
    46594672    for (i=k+1;i<=m;i=i+1)
    46604673    {
    4661       for (j=i;j<=n;j=j+1)
     4674      for (j=i+1;j<=n;j=j+1)
    46624675      {
    46634676        A[k,j]=A[k,j]-A[i,j]*A[k,i];
    46644677      }
     4678      A[k,i]=0;
    46654679    }
    46664680  }
    … …  
    46884702  print(L[1]*transpose(L[2]));
    46894703}
     4704
     4705////////////// this procedure should move in hnoether.lib /////////
     4706static proc ratdevelop (poly chi)
     4707{
     4708  def r=basering;
     4709  int k1=res_deg();
     4710  list HND=essdevelop(chi);
     4711  int k2=res_deg();
     4712  if (k1<k2)
     4713  {
     4714    int N=size(HND);
     4715    list CB=list();
     4716    int i,j,k,d;
     4717    intvec dgs;
     4718    list auxL=list();
     4719    intvec auxiv;
     4720    for (i=1;i<=N;i++)
     4721    {
     4722      CB[i]=conj_bs(HND[i],k1);
     4723      dgs[i]=size(CB[i]);
     4724    }
     4725    for (i=1;i<N;i++)
     4726    {
     4727      for (j=i+1;j<=N;j++)
     4728      {
     4729        if (dgs[i]==dgs[j])
     4730        {
     4731          d=dgs[i];
     4732          for (k=1;k<=d;k++)
     4733          {
     4734            if (intersection(CB[i][1],CB[j][k])==-1)
     4735            {
     4736              HND=delete(HND,j);
     4737              CB=delete(CB,j);
     4738//              dgs=delete(dgs,j);
     4739              execute("auxL="+string(dgs)+";");
     4740              auxL=delete(auxL,j);
     4741              execute("dgs="+string(auxL)+";");
     4742              N=N-1;
     4743              j=j-1;
     4744              break;
     4745            }
     4746          }
     4747        }
     4748      }
     4749    }
     4750  }
     4751  keepring(HNEring);
     4752  return(HND);
     4753}
     4754;
     4755
     4756
     4757
     4758
    46904759///////////////////////////////////////////////////////////////////////////////
    46914760
    … …  
    47474816            how many other points you want to compute with NSplaces.
    47484817
    4749       (1.2) CURVE=NSplaces(range,CURVE);
    4750 
    4751             See help NSplaces tp know the meaning of "range";
    4752             for instance, if you have that the singular places
    4753             have degree 2 at most and you want all the places
    4754             up to degree 5, you must write range=3.
     4818      (1.2) CURVE=NSplaces(degrees,CURVE);
     4819
     4820            "degrees" is an intvec with the degrees we want to compute
    47554821
    47564822      (1.3) CURVE=extcurve(extension,CURVE);
    … …  
    48344900{
    48354901  list KLEIN=Adj_div(x3y+y3+x);
    4836   KLEIN=NSplaces(2,KLEIN);
     4902  KLEIN=NSplaces(1..3,KLEIN);
    48374903  KLEIN=extcurve(3,KLEIN);
    48384904  dbprint(printlevel+1,"Klein quartic over F_8 successfully constructed");
    … …  
    48454911  int r=p^m;
    48464912  list HERMITE=Adj_div(y^r+y-x^(r+1));
    4847   HERMITE=NSplaces(2*m-1,HERMITE);
     4913  HERMITE=NSplaces(1..2*m,HERMITE);
    48484914  HERMITE=extcurve(2*m,HERMITE);
    48494915  dbprint(printlevel+1,"Hermitian curve over F_("+string(r)+"^2)
    … …  
    48554921{
    48564922  list SUZUKI=Adj_div(x10+x3+y8+y);
    4857   SUZUKI=NSplaces(2,SUZUKI);
     4923  SUZUKI=NSplaces(1..3,SUZUKI);
    48584924  SUZUKI=extcurve(3,SUZUKI);
    48594925  dbprint(printlevel+1,"Suzuki curve over F_8 successfully constructed");
    … …  
    48664932
    48674933list CURVE=Adj_div(x5+y2+y);
    4868 CURVE=NSplaces(3,CURVE);
     4934CURVE=NSplaces(1..4,CURVE);
    48694935CURVE=extcurve(4,CURVE);
    48704936
    … …  
    48724938
    48734939list CURVE=Adj_div(y9+y8+xy6+x2y3+y2+x3);
    4874 CURVE=NSplaces(4,CURVE);
     4940intvec ww=1,2,3,6;
     4941CURVE=NSplaces(ww,CURVE);
    48754942CURVE=extcurve(6,CURVE);
    48764943
    48774944*/
    4878 ;
Note: See TracChangeset for help on using the changeset viewer.