sca.h File Reference

#include "polys/nc/nc.h"
#include "misc/intvec.h"

Go to the source code of this file.

Functions
ideal	SCAQuotient (const ring r)
static short	scaFirstAltVar (ring r)
static short	scaLastAltVar (ring r)
static void	scaFirstAltVar (ring r, short n)
static void	scaLastAltVar (ring r, short n)
poly	sca_pp_Mult_xi_pp (short i, const poly pPoly, const ring rRing)
bool	p_IsBiHomogeneous (const poly p, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, int &dx, int &dy, const ring r)
bool	id_IsBiHomogeneous (const ideal id, const intvec *wx, const intvec *wy, const intvec *wCx, const intvec *wCy, const ring r)
intvec *	ivGetSCAXVarWeights (const ring r)
intvec *	ivGetSCAYVarWeights (const ring r)
static bool	p_IsSCAHomogeneous (const poly p, const intvec *wCx, const intvec *wCy, const ring r)
static bool	id_IsSCAHomogeneous (const ideal id, const intvec *wCx, const intvec *wCy, const ring r)
poly	p_KillSquares (const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
ideal	id_KillSquares (const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes=false)
bool	sca_Force (ring rGR, int b, int e)
void	sca_p_ProcsSet (ring rGR, p_Procs_s *p_Procs)
bool	sca_SetupQuotient (ring rGR, ring rG, bool bCopy)

Function Documentation

id_IsBiHomogeneous()

bool id_IsBiHomogeneous	(	const ideal	id,
		const intvec *	wx,
		const intvec *	wy,
		const intvec *	wCx,
		const intvec *	wCy,
		const ring	r
	)

Definition at line 1359 of file sca.cc.

{
  if (id == NULL) return true; // zero ideal
 
  const int iSize = IDELEMS(id);
 
  if (iSize == 0) return true;
 
  bool b = true;
  int x, y;
 
  for(int i = iSize - 1; (i >= 0 ) && b; i--)
    b = p_IsBiHomogeneous(id->m[i], wx, wy, wCx, wCy, x, y, r);
 
  return b;
}

id_IsSCAHomogeneous()

static bool id_IsSCAHomogeneous ( const ideal  id, const intvec *  wCx, const intvec *  wCy, const ring  r  )

inlinestatic

Definition at line 115 of file sca.h.

{
  // inefficient! don't use it in time-critical code!
  intvec *wx = ivGetSCAXVarWeights(r);
  intvec *wy = ivGetSCAYVarWeights(r);
 
  bool homog = id_IsBiHomogeneous( id, wx, wy, wCx, wCy, r );
 
  delete wx;
  delete wy;
 
  return homog;
}

id_KillSquares()

ideal id_KillSquares	(	const ideal	id,
		const short	iFirstAltVar,
		const short	iLastAltVar,
		const ring	r,
		const bool	bSkipZeroes = false
	)

Definition at line 1520 of file sca.cc.

{
  if (id == NULL) return id; // zero ideal
 
  assume( (iFirstAltVar >= 1) && (iLastAltVar <= rVar(r)) && (iFirstAltVar <= iLastAltVar) );
 
  const int iSize = IDELEMS(id);
 
  if (iSize == 0) return id;
 
  ideal temp = idInit(iSize, id->rank);
 
#if 0
   PrintS("<id_KillSquares>\n");
  {
    PrintS("ideal id: \n");
    for (unsigned int i = 0; i < IDELEMS(id); i++)
    {
      Print("; id[%d] = ", i+1);
      p_Write(id->m[i], r);
    }
    PrintS(";\n");
    PrintLn();
  }
#endif
 
 
  for (int j = 0; j < iSize; j++)
    temp->m[j] = p_KillSquares(id->m[j], iFirstAltVar, iLastAltVar, r);
 
  if( bSkipZeroes )
    idSkipZeroes(temp);
 
#if 0
   PrintS("<id_KillSquares>\n");
  {
    PrintS("ideal temp: \n");
    for (int i = 0; i < IDELEMS(temp); i++)
    {
      Print("; temp[%d] = ", i+1);
      p_Write(temp->m[i], r);
    }
    PrintS(";\n");
    PrintLn();
  }
   PrintS("</id_KillSquares>\n");
#endif
 
//  temp->rank = idRankFreeModule(temp, r);
 
  return temp;
}

ivGetSCAXVarWeights()

intvec * ivGetSCAXVarWeights

(

const ring

r

)

Definition at line 1383 of file sca.cc.

{
  const unsigned int N  = r->N;
 
  const int CommutativeVariable = 0; // bug correction!
  const int AntiCommutativeVariable = 0;
 
  intvec* w = new intvec(N, 1, CommutativeVariable);
 
  if(AntiCommutativeVariable != CommutativeVariable)
  if( rIsSCA(r) )
  {
    const unsigned int m_iFirstAltVar = scaFirstAltVar(r);
    const unsigned int m_iLastAltVar  = scaLastAltVar(r);
 
    for (unsigned int i = m_iFirstAltVar; i<= m_iLastAltVar; i++)
    {
      (*w)[i-1] = AntiCommutativeVariable;
    }
  }
 
  return w;
}

ivGetSCAYVarWeights()

intvec * ivGetSCAYVarWeights

(

const ring

r

)

Definition at line 1411 of file sca.cc.

{
  const unsigned int N  = r->N;
 
  const int CommutativeVariable = 0;
  const int AntiCommutativeVariable = 1;
 
  intvec* w = new intvec(N, 1, CommutativeVariable);
 
  if(AntiCommutativeVariable != CommutativeVariable)
  if( rIsSCA(r) )
  {
    const unsigned int m_iFirstAltVar = scaFirstAltVar(r);
    const unsigned int m_iLastAltVar  = scaLastAltVar(r);
 
    for (unsigned int i = m_iFirstAltVar; i<= m_iLastAltVar; i++)
    {
      (*w)[i-1] = AntiCommutativeVariable;
    }
  }
  return w;
}

p_IsBiHomogeneous()

bool p_IsBiHomogeneous	(	const poly	p,
		const intvec *	wx,
		const intvec *	wy,
		const intvec *	wCx,
		const intvec *	wCy,
		int &	dx,
		int &	dy,
		const ring	r
	)

Definition at line 1320 of file sca.cc.

{
  if( p == NULL )
  {
    dx = 0;
    dy = 0;
    return true;
  }
 
  poly q = p;
 
 
  int ddx, ddy;
 
  m_GetBiDegree( q, wx, wy, wCx, wCy, ddx, ddy, r); // get bi degree of lm(p)
 
  pIter(q);
 
  for(; q != NULL; pIter(q) )
  {
    int x, y;
 
    m_GetBiDegree( q, wx, wy, wCx, wCy, x, y, r); // get bi degree of q
 
    if ( (x != ddx) || (y != ddy) ) return false;
  }
 
  dx = ddx;
  dy = ddy;
 
  return true;
}

p_IsSCAHomogeneous()

static bool p_IsSCAHomogeneous ( const poly  p, const intvec *  wCx, const intvec *  wCy, const ring  r  )

inlinestatic

Definition at line 96 of file sca.h.

{
  // inefficient! don't use it in time-critical code!
  intvec *wx = ivGetSCAXVarWeights(r);
  intvec *wy = ivGetSCAYVarWeights(r);
 
  int x,y;
 
  bool homog = p_IsBiHomogeneous( p, wx, wy, wCx, wCy, x, y, r );
 
  delete wx;
  delete wy;
 
  return homog;
}

p_KillSquares()

poly p_KillSquares	(	const poly	p,
		const short	iFirstAltVar,
		const short	iLastAltVar,
		const ring	r
	)

Definition at line 1465 of file sca.cc.

{
#ifdef PDEBUG
  p_Test(p, r);
 
  assume( (iFirstAltVar >= 1) && (iLastAltVar <= r->N) && (iFirstAltVar <= iLastAltVar) );
 
#if 0
  PrintS("p_KillSquares, p = "); // !
  p_Write(p, r);
#endif
#endif
 
 
  if( p == NULL )
    return NULL;
 
  poly pResult = NULL;
  poly* ppPrev = &pResult;
 
  for( poly q = p; q!= NULL; pIter(q) )
  {
#ifdef PDEBUG
    p_Test(q, r);
#endif
 
    // terms will be in the same order because of quasi-ordering!
    poly v = m_KillSquares(q, iFirstAltVar, iLastAltVar, r);
 
    if( v != NULL )
    {
      *ppPrev = v;
      ppPrev = &pNext(v);
    }
 
  }
 
#ifdef PDEBUG
  p_Test(pResult, r);
#if 0
  PrintS("p_KillSquares => "); // !
  p_Write(pResult, r);
#endif
#endif
 
  return(pResult);
}

sca_Force()

bool sca_Force	(	ring	rGR,
		int	b,
		int	e
	)

Definition at line 1161 of file sca.cc.

{
  assume(rGR != NULL);
  assume(rIsPluralRing(rGR));
  assume(!rIsSCA(rGR));
 
  const int N = rGR->N;
 
//  ring rSaveRing = currRing;
//  if(rSaveRing != rGR)
//    rChangeCurrRing(rGR);
 
  const ideal idQuotient = rGR->qideal;
 
  ideal tempQ = idQuotient;
 
  if( b <= N && e >= 1 )
    tempQ = id_KillSquares(idQuotient, b, e, rGR);
 
  idSkipZeroes( tempQ );
 
  ncRingType( rGR, nc_exterior );
 
  if( idIs0(tempQ) )
    rGR->GetNC()->SCAQuotient() = NULL;
  else
    rGR->GetNC()->SCAQuotient() = tempQ;
 
 
  scaFirstAltVar( rGR, b );
  scaLastAltVar( rGR, e );
 
 
  nc_p_ProcsSet(rGR, rGR->p_Procs);
 
//  if(rSaveRing != rGR)
//    rChangeCurrRing(rSaveRing);
 
  return true;
}

sca_p_ProcsSet()

void sca_p_ProcsSet	(	ring	rGR,
		p_Procs_s *	p_Procs
	)

Definition at line 1225 of file sca.cc.

{
 
  // "commutative" procedures:
  rGR->p_Procs->p_Mult_mm     = sca_p_Mult_mm;
  rGR->p_Procs->pp_Mult_mm    = sca_pp_Mult_mm;
 
  p_Procs->p_Mult_mm          = sca_p_Mult_mm;
  p_Procs->pp_Mult_mm         = sca_pp_Mult_mm;
 
  // non-commutaitve
  p_Procs->p_mm_Mult          = sca_p_mm_Mult;
  p_Procs->pp_mm_Mult         = sca_pp_mm_Mult;
 
//   rGR->GetNC()->p_Procs.SPoly         = sca_SPoly;
//   rGR->GetNC()->p_Procs.ReduceSPoly   = sca_ReduceSpoly;
 
#if 0
 
        // Multiplication procedures:
 
        p_Procs->p_Mult_mm   = sca_p_Mult_mm;
        _p_procs->p_Mult_mm  = sca_p_Mult_mm;
 
        p_Procs->pp_Mult_mm  = sca_pp_Mult_mm;
        _p_procs->pp_Mult_mm = sca_pp_Mult_mm;
 
        r->GetNC()->mmMultP()     = sca_mm_Mult_p;
        r->GetNC()->mmMultPP()    = sca_mm_Mult_pp;
 
/*
        // ??????????????????????????????????????? coefficients swell...
        r->GetNC()->SPoly()         = sca_SPoly;
        r->GetNC()->ReduceSPoly()   = sca_ReduceSpoly;
*/
//         r->GetNC()->BucketPolyRed() = gnc_kBucketPolyRed;
//         r->GetNC()->BucketPolyRed_Z()= gnc_kBucketPolyRed_Z;
#endif
 
  // local ordering => Mora, otherwise - Buchberger!
  if (rHasLocalOrMixedOrdering(rGR))
    rGR->GetNC()->p_Procs.GB          = cast_A_to_vptr(sca_mora);
  else
    rGR->GetNC()->p_Procs.GB          = cast_A_to_vptr(sca_bba); // sca_gr_bba?
}

sca_pp_Mult_xi_pp()

poly sca_pp_Mult_xi_pp	(	short	i,
		const poly	pPoly,
		const ring	rRing
	)

Definition at line 1203 of file sca.cc.

{
  assume(1 <= i);
  assume(i <= rVar(rRing));
 
  if(rIsSCA(rRing))
    return sca_xi_Mult_pp(i, pPoly, rRing);
 
 
 
  poly xi =  p_One( rRing);
  p_SetExp(xi, i, 1, rRing);
  p_Setm(xi, rRing);
 
  poly pResult = pp_Mult_qq(xi, pPoly, rRing);
 
  p_Delete( &xi, rRing);
 
  return pResult;
 
}

sca_SetupQuotient()

bool sca_SetupQuotient	(	ring	rGR,
		ring	rG,
		bool	bCopy
	)

Definition at line 911 of file sca.cc.

{
 
  //////////////////////////////////////////////////////////////////////////
  // checks...
  //////////////////////////////////////////////////////////////////////////
  if( rG == NULL )
    rG = rGR;
 
  assume(rGR != NULL);
  assume(rG  != NULL);
  assume(rIsPluralRing(rG));
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  PrintS("sca_SetupQuotient(rGR, rG, bCopy)");
 
  {
    PrintS("\nrG: \n"); rWrite(rG);
    PrintS("\nrGR: \n"); rWrite(rGR);
    PrintLn();
  }
#endif
 
 
  if(bCopy)
  {
    if(rIsSCA(rG) && (rG != rGR))
      return sca_Force(rGR, scaFirstAltVar(rG), scaLastAltVar(rG));
    else
      return false;
  }
 
  assume(!bCopy);
 
  const int N = rG->N;
 
  if(N < 2)
    return false;
 
 
//  if( (ncRingType(rG) != nc_skew) || (ncRingType(rG) != nc_comm) )
//    return false;
 
#if OUTPUT
  PrintS("sca_SetupQuotient: qring?\n");
#endif
 
  if(rGR->qideal == NULL) // there should be a factor!
    return false;
 
#if OUTPUT
  PrintS("sca_SetupQuotient: qideal!!!\n");
#endif
 
//  if((rG->qideal != NULL) && (rG != rGR) ) // we cannot change from factor to factor at the time, sorry!
//    return false;
 
 
  int iAltVarEnd = -1;
  int iAltVarStart   = N+1;
 
  const nc_struct* NC = rG->GetNC();
  const ring rBase = rG; //NC->basering;
  const matrix C   = NC->C; // live in rBase!
  const matrix D   = NC->D; // live in rBase!
 
#if OUTPUT
  PrintS("sca_SetupQuotient: AltVars?!\n");
#endif
 
  for(int i = 1; i < N; i++)
  {
    for(int j = i + 1; j <= N; j++)
    {
      if( MATELEM(D,i,j) != NULL) // !!!???
      {
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
        Print("Nonzero D[%d, %d]\n", i, j);
#endif
        return false;
      }
 
 
      assume(MATELEM(C,i,j) != NULL); // after CallPlural!
      number c = p_GetCoeff(MATELEM(C,i,j), rBase);
 
      if( n_IsMOne(c, rBase->cf) ) // !!!???
      {
        if( i < iAltVarStart)
          iAltVarStart = i;
 
        if( j > iAltVarEnd)
          iAltVarEnd = j;
      } else
      {
        if( !n_IsOne(c, rBase->cf) )
        {
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
          Print("Wrong Coeff at: [%d, %d]\n", i, j);
#endif
          return false;
        }
      }
    }
  }
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  Print("AltVars?1: [%d, %d]\n", iAltVarStart, iAltVarEnd);
#endif
 
 
  if( (iAltVarEnd == -1) || (iAltVarStart == (N+1)) )
    return false; // either no alternating varables, or a single one => we are in commutative case!
 
 
  for(int i = 1; i < N; i++)
  {
    for(int j = i + 1; j <= N; j++)
    {
      assume(MATELEM(C,i,j) != NULL); // after CallPlural!
      number c = p_GetCoeff(MATELEM(C,i,j), rBase);
 
      if( (iAltVarStart <= i) && (j <= iAltVarEnd) ) // S <= i < j <= E
      { // anticommutative part
        if( !n_IsMOne(c, rBase->cf) )
        {
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
          Print("Wrong Coeff at: [%d, %d]\n", i, j);
#endif
          return false;
        }
      }
      else
      { // should commute
        if( !n_IsOne(c, rBase->cf) )
        {
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
          Print("Wrong Coeff at: [%d, %d]\n", i, j);
#endif
          return false;
        }
      }
    }
  }
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  Print("AltVars!?: [%d, %d]\n", iAltVarStart, iAltVarEnd);
#endif
 
  assume( 1            <= iAltVarStart );
  assume( iAltVarStart < iAltVarEnd   );
  assume( iAltVarEnd   <= N            );
 
 
//  ring rSaveRing = assureCurrentRing(rG);
 
 
  assume(rGR->qideal != NULL);
  assume(rGR->N == rG->N);
//  assume(rG->qideal == NULL); // ?
 
  const ideal idQuotient = rGR->qideal;
 
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  PrintS("Analyzing quotient ideal:\n");
  idPrint(idQuotient); // in rG!!!
#endif
 
 
  // check for
  // y_{iAltVarStart}^2, y_{iAltVarStart+1}^2, \ldots, y_{iAltVarEnd}^2  (iAltVarEnd > iAltVarStart)
  // to be within quotient ideal.
 
  int b = N+1;
  int e = -1;
 
  if(rIsSCA(rG))
  {
    b = si_min(b, scaFirstAltVar(rG));
    e = si_max(e, scaLastAltVar(rG));
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
    Print("AltVars!?: [%d, %d]\n", b, e);
#endif
  }
 
  for ( int i = iAltVarStart; (i <= iAltVarEnd); i++ )
    if( (i < b) || (i > e) ) // otherwise it's ok since rG is an SCA!
    {
      poly square = p_One( rG);
      p_SetExp(square, i, 2, rG); // square = var(i)^2.
      p_Setm(square, rG);
 
      // square = NF( var(i)^2 | Q )
      // NOTE: there is no better way to check this in general!
      square = nc_NF(idQuotient, NULL, square, 0, 1, rG); // must ran in currRing == rG!
 
      if( square != NULL ) // var(i)^2 is not in Q?
      {
        p_Delete(&square, rG);
        return false;
      }
    }
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  Print("ScaVars!: [%d, %d]\n", iAltVarStart, iAltVarEnd);
#endif
 
 
  //////////////////////////////////////////////////////////////////////////
  // ok... here we go. let's setup it!!!
  //////////////////////////////////////////////////////////////////////////
  ideal tempQ = id_KillSquares(idQuotient, iAltVarStart, iAltVarEnd, rG); // in rG!!!
 
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  PrintS("Quotient: \n");
  iiWriteMatrix((matrix)idQuotient,"__",1, rG, 0);
  PrintS("tempSCAQuotient: \n");
  iiWriteMatrix((matrix)tempQ,"__",1, rG, 0);
#endif
 
  idSkipZeroes( tempQ );
 
  ncRingType( rGR, nc_exterior );
 
  scaFirstAltVar( rGR, iAltVarStart );
  scaLastAltVar( rGR, iAltVarEnd );
 
  if( idIs0(tempQ) )
    rGR->GetNC()->SCAQuotient() = NULL;
  else
    rGR->GetNC()->SCAQuotient() = idrMoveR(tempQ, rG, rGR); // deletes tempQ!
 
  nc_p_ProcsSet(rGR, rGR->p_Procs); // !!!!!!!!!!!!!!!!!
 
 
#if ((defined(PDEBUG) && OUTPUT) || MYTEST)
  PrintS("SCAQuotient: \n");
  if(tempQ != NULL)
    iiWriteMatrix((matrix)tempQ,"__",1, rGR, 0);
  else
    PrintS("(NULL)\n");
#endif
 
  return true;
}

scaFirstAltVar() [1/2]

static short scaFirstAltVar ( ring  r )

inlinestatic

Definition at line 18 of file sca.h.

{
  assume(rIsSCA(r));
 
  return (r->GetNC()->FirstAltVar());
}

scaFirstAltVar() [2/2]

static void scaFirstAltVar ( ring  r, short  n  )

inlinestatic

Definition at line 34 of file sca.h.

{
  assume(rIsSCA(r));
 
  r->GetNC()->FirstAltVar() = n;
}

scaLastAltVar() [1/2]

static short scaLastAltVar ( ring  r )

inlinestatic

Definition at line 25 of file sca.h.

{
  assume(rIsSCA(r));
 
  return (r->GetNC()->LastAltVar());
}

scaLastAltVar() [2/2]

static void scaLastAltVar ( ring  r, short  n  )

inlinestatic

Definition at line 41 of file sca.h.

{
  assume(rIsSCA(r));
 
  r->GetNC()->LastAltVar() = n;
}

SCAQuotient()

ideal SCAQuotient ( const ring  r )

inline

Definition at line 10 of file sca.h.

{
  assume(rIsSCA(r));
  return r->GetNC()->SCAQuotient();
}