singular-data 4.0.3+ds-1 / usr / share / singular / LIB / aksaka.lib

////////////////////////////////////////////////////////////////////////////////
version="version aksaka.lib 4.0.0.1 Jun_2014 "; // $Id: bc74504c42ff955c330251e3f092f84d4c6c8a0d $
category="Teaching";
info="
LIBRARY: aksaka.lib     Procedures for primality testing after Agrawal, Saxena, Kayal
AUTHORS: Christoph Mang

OVERVIEW:
 Algorithms for primality testing in polynomial time
 based on the ideas of Agrawal, Saxena and  Kayal.

PROCEDURES:

fastExpt(a,m,n)         a^m for numbers a,m; if a^k>n n+1 is returned
log2(n)                    logarithm to basis 2 of n
PerfectPowerTest(n)        checks if there are a,b>1, so that a^b=n
wurzel(r)                  square root of number r
euler(r)                   phi-function of Euler
coeffmod(f,n)              polynomial f modulo number n (coefficients mod n)
powerpolyX(q,n,a,r)        (polynomial a)^q modulo (poly r,number n)
ask(n)                     ASK-Algorithm; deterministic Primality test
";

LIB "crypto.lib";
LIB "ntsolve.lib";

///////////////////////////////////////////////////////////////
//                                                           //
//   FAST (MODULAR) EXPONENTIATION                           //
//                                                           //
///////////////////////////////////////////////////////////////
proc fastExpt(bigint a,bigint m,bigint n)
"USAGE: fastExpt(a,m,n); a, m, n = number;
RETURN: the m-th power of a; if a^m>n the procedure returns n+1
NOTE:   uses fast exponentiation
EXAMPLE:example fastExpt; shows an example
"
{
  bigint b,c,d;
  c=m;
  b=a;
  d=1;
  while(c>=1)
  {
    if(b>n)
    {
      return(n+1);
    }
    if((c mod 2)==1)
    {
      d=d*b;
      if(d>n)
      {
        return(n+1);
      }
    }
    b=b^2;
    c=c div 2;
  }
  return(d)
}
example
{ "EXAMPLE:"; echo = 2;
   fastExpt(2,10,1022);
}
////////////////////////////////////////////////////////////////////////////
proc coeffmod(poly f,bigint n)
"USAGE: coeffmod(f,n);
ASSUME: poly f depends on at most var(1) of the basering
RETURN: poly f modulo number n
NOTE:   at first the coefficients of the monomials of the polynomial f are
        determined, then their remainder modulo n is calculated,
        after that the polynomial 'is put together' again
EXAMPLE:example coeffmod; shows an example
"
{
  matrix M=coeffs(f,var(1));         //Bestimmung der Polynomkoeffizienten
  int i=1;
  poly g;
  int o=nrows(M);

  while(i<=o)
  {
    g=g+(bigint(leadcoef(M[i,1])) mod n)*var(1)^(i-1) ;
                   // umwandeln der Koeffizienten in bigint,
                   // Berechnung der Reste dieser bigint modulo n,
                   // Polynom mit neuen Koeffizienten wieder zusammensetzen
    i++;
  }
  return(g);
}
example
{ "EXAMPLE:"; echo = 2;
   ring R = 0,x,dp;
   poly f=2457*x4+52345*x3-98*x2+5;
   bigint n=3;
   coeffmod(f,n);
}
//////////////////////////////////////////////////////////////////////////
proc powerpolyX(bigint q,bigint n,poly a,poly r)
"USAGE: powerpolyX(q,n,a,r);
RETURN: the q-th power of poly a modulo poly r and number n
EXAMPLE:example powerpolyX; shows an example
"
{
  ideal I=r;

  if(q==1){return(coeffmod(reduce(a,I),n));}
  if((q mod 5)==0){return(coeffmod(reduce(powerpolyX(q div 5,n,a,r)^5,I),n));}
  if((q mod 4)==0){return(coeffmod(reduce(powerpolyX(q div 4,n,a,r)^4,I),n));}
  if((q mod 3)==0){return(coeffmod(reduce(powerpolyX(q div 3,n,a,r)^3,I),n));}
  if((q mod 2)==0){return(coeffmod(reduce(powerpolyX(q div 2,n,a,r)^2,I),n));}

  return(coeffmod(reduce(a*powerpolyX(q-1,n,a,r),I),n));
}
example
{ "EXAMPLE:"; echo = 2;
   ring R=0,x,dp;
   poly a=3*x3-x2+5;
   poly r=x7-1;
   bigint q=123;
   bigint n=5;
   powerpolyX(q,n,a,r);
}
///////////////////////////////////////////////////////////////
//                                                           //
//   GENERAL PROCEDURES                                      //
//                                                           //
///////////////////////////////////////////////////////////////
proc log2(bigint xx)
"USAGE:  log2(x);
RETURN:  logarithm to basis 2 of x
NOTE:    calculates the natural logarithm of x with a power-series
         of the ln, then the basis is changed to 2
EXAMPLE: example log2; shows an example
"
{
  ring r=0,@x,dp;
  number b,c,d,t,l,x;
  x=number(xx);
  int k;
                                         // log2=logarithmus zur basis 2,
                                         // log=natuerlicher logarithmus
  b=100000000000000000000000000000000000000000000000000;
  c=141421356237309504880168872420969807856967187537695;    // c/b=sqrt(2)
  d=69314718055994530941723212145817656807550013436026;     // d/b=log(2)

  //bringen x zunaechst zwischen 1/sqrt(2) und sqrt(2), so dass Reihe schnell
  //konvergiert, berechnen dann Reihe bis 30. Summanden und letztendlich
  //log2(x)=log(x)/log(2)=(log(x/2^j)+j*log(2))/log(2)  fuer grosse x
  //log2(x)=log(x)/log(2)=(log(x*2^j)-j*log(2))/log(2)  fuer kleine x

  number j=0;
  if(x<(b/c))
  {
    while(x<(b/c))
    {
      x=x*2;
      j=j+1;
    }
    t=(x-1)/(x+1);
    k=0;
    l=0;
    while(k<30)       //fuer  x*2^j wird Reihe bis k-tem Summanden berechnet
    {
      l=l+2*(t^(2*k+1))/(2*k+1);      //l=log(x*2^j) nach k Summanden
      k=k+1;
    }
    return (intPart((l*b/d)-j));         //log2(x)=log(x*2^j)/log(2)-j wird ausgegeben
  }
  while(x>(c/b))
  {
    x=x/2;
    j=j+1;
  }
  t=(x-1)/(x+1);
  k=0;
  l=0;
  while(k<30)         //fuer  x/2^j wird Reihe bis k-tem Summanden berechnet
  {
    l=l+2*(t^(2*k+1))/(2*k+1);       //l=log(x/2^j) nach k Summanden
    k=k+1;
  }
  return(intPart(((l*b/d)+j)));     //hier wird log2(x)=log(x/2^j)/log(2)+j  ausgegeben
}
example
{ "EXAMPLE:"; echo = 2;
   log2(1024);
}
//////////////////////////////////////////////////////////////////////////
proc wurzel(number r)
"USAGE: wurzel(r);
ASSUME: characteristic of basering is 0, r>=0
RETURN: number, square root of r
EXAMPLE:example wurzel; shows an example
"
{
  poly f=var(1)^2-r;             //Wurzel wird als Nullstelle eines Polys
                                 //mit proc nt_solve genaehert
  def B=basering;
  ring R=(real,40),var(1),dp;
  poly g=imap(B,f);
  list l=nt_solve(g,1.1);
  number m=leadcoef(l[1][1]);
  setring B;
  return(imap(R,m));
}
example
{ "EXAMPLE:"; echo = 2;
   ring R = 0,x,dp;
   wurzel(7629412809180100);
}
//////////////////////////////////////////////////////////////////////////
proc euler(bigint r)
"USAGE: euler(r);
RETURN: bigint phi(r), where phi is Eulers phi-function
NOTE:   first r is factorized with proc PollardRho, then phi(r) is
        calculated with the help of phi(p) of every factor p;
EXAMPLE:example euler; shows an example
"
{
  list l=PollardRho(r,5000,1);           //bestimmen der Primfaktoren von r
  int k;
  bigint phi=r;
  for(k=1;k<=size(l);k++)
  {
    phi=phi-phi div l[k];       //berechnen phi(r) mit Hilfe der
  }                         //Primfaktoren und Eigenschaften der phi-Fktn
  return(phi);
}
example
{ "EXAMPLE:"; echo = 2;
   euler(99991);
}
///////////////////////////////////////////////////////////////
//                                                           //
//   PERFECT POWER TEST                                      //
//                                                           //
///////////////////////////////////////////////////////////////
proc PerfectPowerTest(bigint n)
"USAGE: PerfectPowerTest(n);
RETURN: 0 if there are numbers a,b>1 with a^b=n;
        1 if there are no numbers a,b>1 with a^b=n;
        if printlevel>=1 and there are a,b>1 with a^b=n,
        then a,b are printed
EXAMPLE:example PerfectPowerTest; shows an example
"
{
  bigint a,b,c,e,f,m,l,p;
  b=2;
  l=log2(n);
  e=0;
  f=1;

  while(b<=l)
  {
    a=1;
    c=n;

    while(c-a>=2)
    {
      m=(a+c) div 2;
      p=fastExpt(m,b,n);

      if(p==n)
      {
        if(printlevel>=1){"es existieren Zahlen a,b>1 mit a^b=n";
                      "a=";m;"b=";b;pause();}
        return(e);
      }

      if(p<n)
      {
        a=m;
      }
      else
      {
        c=m;
      }
    }
    b=b+1;
  }
  if(printlevel>=1){"es existieren keine Zahlen a,b>1  mit a^b=n";pause();}
  return(f);
}
example
{ "EXAMPLE:"; echo = 2;
   PerfectPowerTest(887503681);
}
///////////////////////////////////////////////////////////////
//                                                           //
//   ASK PRIMALITY TEST                                      //
//                                                           //
///////////////////////////////////////////////////////////////
proc ask(bigint n)
"USAGE: ask(n);
ASSUME: n>1
RETURN: 0 if n is composite;
        1 if n is prime;
        if printlevel>=1, you are informed what the procedure will do
        or has calculated
NOTE:   ASK-algorithm; uses proc powerpolyX for step 5
EXAMPLE:example ask; shows an example
"
{
  bigint c,p;
  c=0;
  p=1;

  if(n==2) { return(p); }
  if(printlevel>=1){"Beginn: Test ob a^b=n fuer a,b>1";pause();}
  if(0==PerfectPowerTest(n))             // Schritt1 des ASK-Alg.
  { return(c); }
  if(printlevel>=1)
  {
    "Beginn: Berechnung von r, so dass ord(n) in Z/rZ groesser log2(n)^2 ";
    pause();
  }
  bigint k,M,M2,b;
  int r;                          // Zeile 526-542: Schritt 2
  M=log2(n);                      // darin sind die Schritte
  M2=M^2;                         // 3 und 4 integriert
  r=2;

  if(gcd(n,r)!=1)   //falls ggt ungleich eins, Teiler von n gefunden,
                    // Schritt 3 des ASK-Alg.
  {
    if(printlevel>=1){"Zahl r gefunden mit r|n";"r=";r;pause();}
    return(c);
  }
  if(r==n-1)              // falls diese Bedingung erfuellt ist, ist
                         // ggT(a,n)=1 fuer 0<a<=r, schritt 4 des ASK-Alg.
  {
    if(printlevel>=1){"ggt(r,n)=1 fuer alle 1<r<n";pause();}
    return(p);
  }
  k=1;
  b=1;

  while(k<=M2)         //Beginn des Ordnungstests fuer aktuelles r
  {
    b=((b*n) mod r);
    if(b==1)   //tritt Bedingung ein so gilt fuer aktuelles r,k:
               //n^k=1 mod r
               //tritt Bedingung ein, wird wegen k<=M2=intPart(log2(n)^2)
               //r erhoeht,k=0 gesetzt und Ordnung erneut untersucht
               //tritt diese Bedingung beim groessten k=intPart(log2(n)^2)
               //nicht ein, so ist ord_r_(n)>log2(n)^2 und Schleife
               //wird nicht mehr ausgefuehrt
    {
      if(r==2147483647)
      {
        string e="error: r ueberschreitet integer Bereich und darf
                  nicht als Grad eines Polynoms verwendet werden";
        return(e);
      }
      r=r+1;
      if(gcd(n,r)!=1)   //falls ggt ungleich eins, Teiler von n gefunden,
                         //wird aufgrund von Schritt 3 des ASK-Alg. fuer
                         //jeden Kandidaten r getestet
      {
        if(printlevel>=1){"Zahl r gefunden mit r|n";"r=";r;pause();}
        return(c);
      }
      if(r==n-1)         //falls diese Bedingung erfuellt ist,
                         //ist n wegen Zeile 571 prim
                         //wird aufgrund von Schritt 4 des ASK-Alg. fuer
                         //jeden Kandidaten r getestet
      {
        if(printlevel>=1){"ggt(r,n)=1 fuer alle 1<r<n";pause();}
        return(p);
      }

      k=0;               //fuer neuen Kandidaten r, muss k fuer den
                         //Ordnungstest zurueckgesetzt werden
    }
    k=k+1;
  }
  if(printlevel>=1)
  {
    "Zahl r gefunden, so dass ord(n) in Z/rZ groesser log2(n)^2 ";
    "r=";r;pause();
  }
  ring @R=0,@x,dp;
  bigint l=1;                         // Zeile 603-628: Schritt 5
  poly f,g;                           // Zeile 618 ueberprueft Gleichungen fuer
                                      // das jeweilige a
  g=var(1)^r-1;
  bigint grenze=intPart(wurzel(euler(r))*M);

  if(printlevel>=1)
  {"Beginn: Ueberpruefung ob (x+a)^n kongruent x^n+a mod (x^r-1,n)
        fuer 0<a<=intPart(wurzel(phi(r))*log2(n))=";grenze;pause();
  }
  while(l<=grenze)          //
  {
    if(printlevel>=1){"a=";l;}
    f=var(1)+l;
    if(powerpolyX(bigint(n),bigint(n),f,g)!=(var(1)^(int((n mod r)))+l))
    {
      if(printlevel>=1)
      {"Fuer a=";l;"ist (x+a)^n nicht kongruent x^n+a mod (x^r-1,n)";
        pause();
      }
      return(c);
    }
    l=l+1;
  }
  if(printlevel>=1)
  {"(x+a)^n kongruent x^n+a mod (x^r-1,n) fuer 0<a<wurzel(phi(r))*log2(n)";
    pause();
  }
  return(p);       // Schritt 6
}
example
{ "EXAMPLE:"; echo = 2;
   //ask(100003);
   ask(32003);
}