fglmzero.cc File Reference

#include "kernel/mod2.h"
#include "factory/factory.h"
#include "factory/templates/ftmpl_list.h"
#include "factory/templates/ftmpl_list.cc"
#include "misc/options.h"
#include "misc/intvec.h"
#include "polys/monomials/maps.h"
#include "polys/monomials/ring.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "fglm.h"
#include "fglmvec.h"
#include "fglmgauss.h"

Go to the source code of this file.

Data Structures
struct	matElem
	The idealFunctionals. More...
struct	matHeader
class	idealFunctionals
class	borderElem
	The old basis. More...
class	fglmSdata
class	oldGaussElem
class	fglmDdata

Macros
#define	PROT(msg)
#define	STICKYPROT(msg)   if (BTEST1(OPT_PROT)) Print(msg)
#define	PROT2(msg, arg)
#define	STICKYPROT2(msg, arg)   if (BTEST1(OPT_PROT)) Print(msg,arg)
#define	fglmASSERT(ignore1, ignore2)

Functions
void	internalCalculateFunctionals (const ideal, idealFunctionals &l, fglmSdata &data)
static BOOLEAN	CalculateFunctionals (const ideal &theIdeal, idealFunctionals &l)
static BOOLEAN	CalculateFunctionals (const ideal &theIdeal, idealFunctionals &l, poly &p, fglmVector &v)
static ideal	GroebnerViaFunctionals (const idealFunctionals &l, fglmVector iv=fglmVector())
static ideal	FindUnivariatePolys (const idealFunctionals &l)
BOOLEAN	fglmzero (ring sourceRing, ideal &sourceIdeal, ring destRing, ideal &destIdeal, BOOLEAN switchBack, BOOLEAN deleteIdeal)
BOOLEAN	fglmquot (ideal sourceIdeal, poly quot, ideal &destIdeal)
BOOLEAN	FindUnivariateWrapper (ideal source, ideal &destIdeal)

---

Data Structure Documentation

matElem

struct matElem

The idealFunctionals.

Definition at line 61 of file fglmzero.cc.

Data Fields
number	elem
int	row

matHeader

struct matHeader

Definition at line 67 of file fglmzero.cc.

Data Fields
matElem *	elems
BOOLEAN	owner
int	size

Macro Definition Documentation

fglmASSERT

#define fglmASSERT	(		ignore1,
			ignore2
	)

Definition at line 52 of file fglmzero.cc.

PROT

#define PROT

(

msg

)

Definition at line 48 of file fglmzero.cc.

PROT2

#define PROT2	(		msg,
			arg
	)

Definition at line 50 of file fglmzero.cc.

STICKYPROT

#define STICKYPROT

(

msg

)

if (BTEST1(OPT_PROT)) Print(msg)

Definition at line 49 of file fglmzero.cc.

STICKYPROT2

#define STICKYPROT2	(		msg,
			arg
	)		if (BTEST1(OPT_PROT)) Print(msg,arg)

Definition at line 51 of file fglmzero.cc.

Function Documentation

CalculateFunctionals() [1/2]

static BOOLEAN CalculateFunctionals ( const ideal &  theIdeal, idealFunctionals &  l  )

static

Definition at line 673 of file fglmzero.cc.

{
    fglmSdata data( theIdeal );
    internalCalculateFunctionals( theIdeal, l, data );
    return ( data.state() );
}

CalculateFunctionals() [2/2]

static BOOLEAN CalculateFunctionals ( const ideal &  theIdeal, idealFunctionals &  l, poly &  p, fglmVector &  v  )

static

Definition at line 681 of file fglmzero.cc.

{
    fglmSdata data( theIdeal );
    internalCalculateFunctionals( theIdeal, l, data );
    //    STICKYPROT("Calculating vector rep\n");
    v = data.getVectorRep( p );
    // if ( v.isZero() )
    //   STICKYPROT("vectorrep is 0\n");
    return ( data.state() );
}

fglmquot()

BOOLEAN fglmquot	(	ideal	sourceIdeal,
		poly	quot,
		ideal &	destIdeal
	)

Definition at line 1218 of file fglmzero.cc.

{
    BOOLEAN fglmok;
    fglmVector v;
 
    idealFunctionals L( 100, (currRing->N) );
    // STICKYPROT("calculating normal form\n");
    // poly p = kNF( sourceIdeal, currRing->qideal, quot );
    // STICKYPROT("calculating functionals\n");
    fglmok = CalculateFunctionals( sourceIdeal, L, quot, v );
    if ( fglmok == TRUE ) {
      // STICKYPROT("calculating groebner basis\n");
        destIdeal= GroebnerViaFunctionals( L, v );
    }
    return fglmok;
}

fglmzero()

BOOLEAN fglmzero	(	ring	sourceRing,
		ideal &	sourceIdeal,
		ring	destRing,
		ideal &	destIdeal,
		BOOLEAN	switchBack,
		BOOLEAN	deleteIdeal
	)

Definition at line 1193 of file fglmzero.cc.

{
    ring initialRing = currRing;
    BOOLEAN fglmok;
 
    if ( currRing != sourceRing )
    {
        rChangeCurrRing( sourceRing );
    }
    idealFunctionals L( 100, rVar(currRing) );
    fglmok = CalculateFunctionals( sourceIdeal, L );
    if ( deleteIdeal == TRUE )
        idDelete( & sourceIdeal );
    rChangeCurrRing( destRing );
    if ( fglmok == TRUE )
    {
        L.map( sourceRing );
        destIdeal= GroebnerViaFunctionals( L );
    }
    if ( (switchBack) && (currRing != initialRing) )
      rChangeCurrRing( initialRing );
    return fglmok;
}

FindUnivariatePolys()

static ideal FindUnivariatePolys ( const idealFunctionals &  l )

static

Definition at line 1118 of file fglmzero.cc.

{
  fglmVector v;
  fglmVector p;
  ideal destIdeal = idInit( (currRing->N), 1 );
 
  int i;
  BOOLEAN isZero;
  int *varpermutation = (int*)omAlloc( ((currRing->N)+1)*sizeof(int) );
  ideal perm = idMaxIdeal(1);
  intvec *iv = idSort(perm,TRUE);
  idDelete(&perm);
  for(i = (currRing->N); i > 0; i--) varpermutation[(currRing->N)+1-i] = (*iv)[i-1];
  delete iv;
 
  for (i= 1; i <= (currRing->N); i++ )
  {
    // main loop
    STICKYPROT2( "(%i)", i /*varpermutation[i]*/);
    gaussReducer gauss( l.dimen() );
    isZero= FALSE;
    v= fglmVector( l.dimen(), 1 );
    while ( !isZero )
    {
      if ( (isZero= gauss.reduce( v )))
      {
        STICKYPROT( "+" );
        p= gauss.getDependence();
        number gcd= p.gcd();
        if ( ! nIsOne( gcd ) )
        {
          p /= gcd;
        }
        nDelete( & gcd );
        int k;
        poly temp = NULL;
        poly result=NULL;
        for ( k= p.size(); k > 0; k-- )
        {
          number n = nCopy( p.getconstelem( k ) );
          if ( ! nIsZero( n ) )
          {
            if ( temp == NULL )
            {
              result= pOne();
              temp= result;
            }
            else
            {
              temp->next= pOne();
              pIter( temp );
            }
            pSetCoeff( temp, n );
            pSetExp( temp, i /*varpermutation[i]*/, k-1 );
            pSetm( temp );
          }
        }
        if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
        (destIdeal->m)[i-1]= result;
      }
      else
      {
        STICKYPROT( "." );
        gauss.store();
        v= l.multiply( v, i /*varpermutation[i]*/ );
      }
    }
  }
  STICKYPROT( "\n" );
  omFreeSize( (ADDRESS)varpermutation, ((currRing->N)+1)*sizeof(int) );
  return destIdeal;
}

FindUnivariateWrapper()

BOOLEAN FindUnivariateWrapper	(	ideal	source,
		ideal &	destIdeal
	)

Definition at line 1236 of file fglmzero.cc.

{
    BOOLEAN fglmok;
 
    idealFunctionals L( 100, (currRing->N) );
    fglmok = CalculateFunctionals( source, L );
    if ( fglmok == TRUE ) {
        destIdeal= FindUnivariatePolys( L );
        return TRUE;
    }
    else
        return FALSE;
}

GroebnerViaFunctionals()

static ideal GroebnerViaFunctionals ( const idealFunctionals &  l, fglmVector  iv = fglmVector()  )

static

Definition at line 1046 of file fglmzero.cc.

{
    fglmDdata data( l.dimen() );
 
    // insert pOne() and update workinglist according to iv:
    fglmVector initv;
    if ( iv.isZero() ) {
      // STICKYPROT("initv is zero\n");
      initv = fglmVector( l.dimen(), 1 );
    }
    else {
      // STICKYPROT("initv is not zero\n");
      initv = iv;
    }
 
    poly one = pOne();
    data.updateCandidates( one, initv );
    number nOne = nInit( 1 );
    data.newBasisElem( one, initv, fglmVector( 1, 1 ), nOne );
    STICKYPROT( "." );
    while ( data.candidatesLeft() == TRUE ) {
        fglmDelem candidate = data.nextCandidate();
        if ( candidate.isBasisOrEdge() == TRUE ) {
            // Now we have the chance to find a new groebner polynomial
 
            // v is the vector-representation of candidate.monom
            // some elements of v are zeroed in data.gaussreduce(). Which
            // ones and how this was done is stored in p.
            // originalV contains the unchanged v, which is later inserted
            // into the working list (via data.updateCandidates().
            fglmVector v = l.multiply( candidate.v, candidate.var );
            fglmVector originalV = v;
            fglmVector p( data.getBasisSize()+1, data.getBasisSize()+1 );
            number pdenom = NULL;
            data.gaussreduce( v, p, pdenom );
            if ( v.isZero() ) {
                // Now v is linear dependent to the already found basis elements.
                // This means that v (resp. candidate.monom) is the leading
                // monomial of the next groebner-basis polynomial.
                data.newGroebnerPoly( p, candidate.monom );
                nDelete( & pdenom );
                STICKYPROT( "+" );
            }
            else {
                // no linear dependence could be found, so v ( rsp. monom )
                // is a basis monomial. We store the zeroed version ( i.e. v
                // and not originalV ) as well as p, the denomiator and all
                // the other stuff.
                // erst updateCandidates, dann newBasisELem!!!
                data.updateCandidates( candidate.monom, originalV );
                data.newBasisElem( candidate.monom, v, p, pdenom );
                STICKYPROT( "." );
            }
        }
        else {
            STICKYPROT( "-" );
            candidate.cleanup();
        }
    }  //. while data.candidatesLeft()
    STICKYPROT( "\n" );
    return ( data.buildIdeal() );
}

internalCalculateFunctionals()

void internalCalculateFunctionals	(	const	ideal,
		idealFunctionals &	l,
		fglmSdata &	data
	)

Definition at line 609 of file fglmzero.cc.

{
 
    // insert pOne() into basis and update the workingList:
    poly one = pOne();
    data.newBasisElem( one );
    data.updateCandidates();
 
    STICKYPROT(".");
    while ( data.candidatesLeft() == TRUE ) {
        fglmSelem candidate = data.nextCandidate();
        if ( candidate.isBasisOrEdge() == TRUE ) {
            int edge = data.getEdgeNumber( candidate.monom );
            if ( edge != 0 )
            {
                // now candidate is an edge, i.e. we know its normalform:
                // NF(p) = - ( tail(p)/LC(p) )
                poly nf = data.getSpanPoly( edge );
                pNorm( nf );
                pLmDelete(&nf);  //. deletes the leadingmonomial
                nf= pNeg( nf );
                fglmVector nfv = data.getVectorRep( nf );
                l.insertCols( candidate.divisors, nfv );
                data.newBorderElem( candidate.monom, nfv );
                pDelete( &nf );
                STICKYPROT( "+" );
            }
            else
            {
                int basis= data.newBasisElem( candidate.monom );
                data.updateCandidates();
                l.insertCols( candidate.divisors, basis );
                STICKYPROT( "." );
            }
        }
        else {
            int var = 0;
            fglmVector temp = data.getBorderDiv( candidate.monom, var );
            fglmASSERT( var > 0, "this should never happen" );
            fglmVector nfv = l.addCols( var, data.getBasisSize(), temp );
            data.newBorderElem( candidate.monom, nfv );
            l.insertCols( candidate.divisors, nfv );
            STICKYPROT( "-" );
        }
        candidate.cleanup();
    } //. while ( data.candidatesLeft() == TRUE )
    l.endofConstruction();
    STICKYPROT2( "\nvdim= %i\n", data.getBasisSize() );
    return;
}