Changeset 1f5565d in git

Timestamp:

Feb 22, 2012, 7:59:06 PM (11 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

762407dfdd4ce18e60ae114357800624f0b09308

Parents:

f23ccea9a38ee5dfa1e6454e84dd4bd11cd5ce90

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-02-22 19:59:06+01:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-02-23 20:35:09+01:00

Message:

added HWeyl

add: experimental handling of homogenized Weyl algebras (formulas/detection and related)

Location:

libpolys/polys/nc

Files:

• ncSACache.cc (modified) (1 diff)
• ncSAFormula.cc (modified) (8 diffs)
• ncSAFormula.h (modified) (2 diffs)
• ncSAMult.cc (modified) (5 diffs)
• ncSAMult.h (modified) (4 diffs)

libpolys/polys/nc/ncSACache.cc

@@ -23 +23 @@
 
 #ifndef NDEBUG
-#define OUTPUT 1
+#define OUTPUT MYTEST
 #else
 #define OUTPUT 0

libpolys/polys/nc/ncSAFormula.cc

@@ -27 +27 @@
 
 #ifndef NDEBUG
-#define OUTPUT 1
+#define OUTPUT MYTEST
 #else
 #define OUTPUT 0
@@ -52 +52 @@
 #if OUTPUT  
   Print("ncInitSpecialPowersMultiplication(ring), ring: \n");
-  rWrite(r);
+  rWrite(r, TRUE);
   PrintLn();
 #endif
@@ -77 +77 @@
 
 
+
+
+// TODO: return q-coeff?
+static inline BOOLEAN AreCommutingVariables(const ring r, int i, int j/*, number *qq*/)
+{
+#if OUTPUT  
+  Print("AreCommutingVariables(ring, k: %d, i: %d)!", j, i);
+  PrintLn();
+#endif
+
+  assume(i != j);
+
+  assume(i > 0);
+  assume(i <= r->N);
+
+
+  assume(j > 0);
+  assume(j <= r->N);
+
+  const BOOLEAN reverse = (i > j);
+
+  if (reverse) { int k = j; j = i; i = k; }
+
+  assume(i < j);
+
+  {
+    const poly d = GetD(r, i, j);
+
+#if OUTPUT  
+    Print("D_{%d, %d} = ", i, j); p_Write(d, r);
+#endif
+
+    if( d != NULL)
+      return FALSE;
+  }
+
+
+  {
+    const number q = p_GetCoeff(GetC(r, i, j), r);
+
+    if( !n_IsOne(q, r) ) 
+      return FALSE;
+  }
+
+  return TRUE; // [VAR(I), VAR(J)] = 0!!
+
+/*
+  if (reverse)
+    *qq = n_Invers(q, r);
+  else
+    *qq = n_Copy(q, r);
+  return TRUE;
+*/
+}
+
 static inline Enum_ncSAType AnalyzePairType(const ring r, int i, int j)
 {
 #if OUTPUT  
-  Print("AnalyzePair(ring, i: %d, j: %d)!", i, j);
+  Print("AnalyzePair(ring, i: %d, j: %d):", i, j);
   PrintLn();
 #endif
@@ -91 +146 @@
 
 
-  const number q = p_GetCoeff(GetC(r, i, j), r);
+  const poly c = GetC(r, i, j);
+  const number q = p_GetCoeff(c, r);
   const poly d = GetD(r, i, j);
 
-#if OUTPUT  
-  Print("C_{%d, %d} = ", i, j);  { number t = n_Copy(q, r);  n_Write(t, r);  n_Delete(&t, r); };
+#if 0 && OUTPUT  
+  Print("C_{%d, %d} = ", i, j); p_Write(c, r); PrintLn();
   Print("D_{%d, %d} = ", i, j); p_Write(d, r);
 #endif
@@ -107 +163 @@
       return _ncSA_1xy0x0y0;
 
-    if( n_IsMOne(q, r) )
+    if( n_IsMOne(q, r) ) // anti-commutative
       return _ncSA_Mxy0x0y0;
 
-    return _ncSA_Qxy0x0y0;
+    return _ncSA_Qxy0x0y0; // quasi-commutative
   } else
   {
     if( n_IsOne(q, r) ) // "Lie" case
     {
-      if( pNext(d) == NULL ) // Our Main Special Case! 
+      if( pNext(d) == NULL ) // Our Main Special Case: d is only a term!
       {
 //         const number g = p_GetCoeff(d, r); // not used for now
-         if( p_LmIsConstantComp(d, r) ) // Weyl
+        if( p_LmIsConstantComp(d, r) ) // Weyl
           return _ncSA_1xy0x0yG;
 
         const int k = p_IsPurePower(d, r); // k if not pure power
 
-        if( k > 0 )
-          if( p_GetExp(d, k, r) == 1 )
+        if( k > 0 ) // d = var(k)^??
+        {
+          const int exp = p_GetExp(d, k, r);
+          
+          if (exp == 1)
           {
-            if(k == i)
+            if(k == i) // 2 -ubalgebra in var(i) & var(j), with linear relation...?
               return _ncSA_1xyAx0y0;
 
             if(k == j)
               return _ncSA_1xy0xBy0;              
+          } else if ( exp == 2 && k!= i && k != j)  // Homogenized Weyl algebra [x, Dx] = t^2?
+          {
+//            number qi, qj;
+            if (AreCommutingVariables(r, k, i/*, &qi*/) && AreCommutingVariables(r, k, j/*, &qj*/) ) // [x, t] = [Dx, t] = 0?
+            {
+              const number g = p_GetCoeff(d, r);
+
+              if (n_IsOne(g, r)) 
+                return _ncSA_1xy0x0yT2; // save k!?, G = LC(d) == qi == qj == 1!!!
+            }
           }
+        }
       }
     }
-  }
+    // Hmm, what about a more general case of q != 1???
+  }
+#if OUTPUT  
+  Print("C_{%d, %d} = ", i, j); p_Write(c, r);
+  Print("D_{%d, %d} = ", i, j); p_Write(d, r);
+  PrintS("====>>>>_ncSA_notImplemented\n");
+#endif
 
   return _ncSA_notImplemented;
 }
-
 
 
@@ -371 +446 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////
+static inline poly ncSA_1xy0x0yT2(const int i, const int j, const int n, const int m, const int m_k, const ring r)
+{
+#if OUTPUT  
+  Print("ncSA_1xy0x0yT2(var(%d)^{%d}, var(%d)^{%d}, t: var(%d), r)!", j, m, i, n, m_k);  
+  PrintLn();
+#endif
+
+  int kn = n;
+  int km = m;
+
+  // k == 0!
+  number c = n_Init(1, r);
+
+  poly p = p_One( r );
+
+  p_SetExp(p, j, km--, r); // y ^ (m)
+  p_SetExp(p, i, kn--, r); // x ^ (n)
+//  p_SetExp(p, m_k, k << 1, r); // homogenization with var(m_k) ^ (2*k) 
+
+  p_Setm(p, r); // pResult = x^n * y^m
+
+
+  poly pResult = p;
+  poly pLast = p;
+
+  int min = si_min(m, n);
+
+  int k = 1;
+
+  for(; k < min; k++ )
+  {
+    number t = n_Init(km + 1, r);
+//    n_InpMult(t, m_g, r); // t = ((m - k) + 1) * gamma
+    n_InpMult(c, t, r);   // c = c'* ((m - k) + 1) * gamma
+    n_Delete(&t, r);
+
+    t = n_Init(kn + 1, r);
+    n_InpMult(c, t, r);   // c = (c'* ((m - k) + 1) * gamma) * ((n - k) + 1)
+    n_Delete(&t, r);
+
+    t = n_Init(k, r);
+    c = n_Div(c, t, r);
+    n_Delete(&t, r);
+
+// //    n_Normalize(c, r);
+
+    t = n_Copy(c, r); // not the last!
+
+    p = p_NSet(t, r);
+
+    p_SetExp(p, j, km--, r); // y ^ (m-k)
+    p_SetExp(p, i, kn--, r); // x ^ (n-k)
+
+    p_SetExp(p, m_k, k << 1, r); // homogenization with var(m_k) ^ (2*k) 
+    
+    p_Setm(p, r); // pResult = x^(n-k) * y^(m-k)
+
+    pNext(pLast) = p;
+    pLast = p;
+  }
+
+  assume(k == min);
+  assume((km == 0) || (kn == 0) );
+
+  {
+//    n_InpMult(c, m_g, r);   // c = c'* gamma
+
+    if( km > 0 )
+    {
+      number t = n_Init(km + 1, r);
+      n_InpMult(c, t, r);   // c = (c'* gamma) * (m - k + 1)
+      n_Delete(&t, r);
+    }
+
+    if( kn > 0 )
+    {
+      number t = n_Init(kn + 1, r);
+      n_InpMult(c, t, r);   // c = (c'* gamma) * (n - k + 1)
+      n_Delete(&t, r);
+    }
+
+    number t = n_Init(k, r); // c = ((c'* gamma) * ((n - k + 1) * (m - k + 1))) / k;
+    c = n_Div(c, t, r);
+    n_Delete(&t, r);
+  }
+
+  p = p_NSet(c, r);
+
+  p_SetExp(p, j, km, r); // y ^ (m-k)
+  p_SetExp(p, i, kn, r); // x ^ (n-k)
+
+  p_SetExp(p, m_k, k << 1, r); // homogenization with var(m_k) ^ (2*k) 
+
+  p_Setm(p, r); // 
+
+  pNext(pLast) = p;
+
+  CorrectPolyWRTOrdering(pResult, r);
+
+  return pResult;
+}
+///////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
 static inline poly ncSA_ShiftAx(int i, int j, int n, int m, const number m_shiftCoef, const ring r)
 {
@@ -501 +682 @@
   }
 
-  const number g = p_GetCoeff(GetD(r, i, j), r);
+  const poly d = GetD(r, i, j);
+  const number g = p_GetCoeff(d, r);
 
   if( type == _ncSA_1xy0x0yG ) // Weyl
     return ::ncSA_1xy0x0yG(i, j, n, m, g, r);
 
+  if( type == _ncSA_1xy0x0yT2 ) // Homogenous Weyl...
+    return ::ncSA_1xy0x0yT2(i, j, n, m, p_IsPurePower(d, r), r);
+  
   if( type == _ncSA_1xyAx0y0 ) // Shift 1
     return ::ncSA_1xyAx0y0(i, j, n, m, g, r);
@@ -557 +742 @@
 }
 
+poly CFormulaPowerMultiplier::ncSA_1xy0x0yT2(const int i, const int j, const int n, const int m, const int k, const ring r)
+{
+  return ::ncSA_1xy0x0yT2(i, j, n, m, k, r);
+}
+
 poly CFormulaPowerMultiplier::ncSA_1xyAx0y0(const int i, const int j, const int n, const int m, const number m_shiftCoef, const ring r)
 {

libpolys/polys/nc/ncSAFormula.h

@@ -19 +19 @@
 {
   _ncSA_notImplemented = -1,
-  _ncSA_1xy0x0y0 = 0, // commutative
-  _ncSA_Mxy0x0y0 = 1, // anti-commutative
-  _ncSA_Qxy0x0y0 = 2, // quasi-commutative
-  _ncSA_1xyAx0y0 = 10, // shift 1
-  _ncSA_1xy0xBy0 = 20, // shift 2
-  _ncSA_1xy0x0yG = 30 // Weyl  
+  _ncSA_1xy0x0y0 = 0x00, // commutative
+  _ncSA_Mxy0x0y0 = 0x01, // anti-commutative
+  _ncSA_Qxy0x0y0 = 0x02, // quasi-commutative
+  _ncSA_1xyAx0y0 = 0x10, // shift 1
+  _ncSA_1xy0xBy0 = 0x20, // shift 2
+  _ncSA_1xy0x0yG = 0x30, // Weyl  
+  _ncSA_1xy0x0yT2 = 0x100 // homogenized Weyl algebra?
 };
 
@@ -74 +75 @@
 
     static poly ncSA_1xy0x0yG(const int i, const int j, const int n, const int m, const number m_g, const ring r); 
+    static poly ncSA_1xy0x0yT2(const int i, const int j, const int n, const int m, const int k, const ring r); 
 
     static poly ncSA_1xyAx0y0(const int i, const int j, const int n, const int m, const number m_shiftCoef, const ring r);

libpolys/polys/nc/ncSAMult.cc

@@ -26 +26 @@
 
 #ifndef NDEBUG
-#define OUTPUT 1
+#define OUTPUT MYTEST
 #else
 #define OUTPUT 0
@@ -248 +248 @@
 #endif
 
-  if( p_Procs == NULL )
-    p_Procs = rGR->p_Procs;
+  assume( p_Procs != NULL );
   
   // "commutative"
@@ -265 +264 @@
 }
 
-bool ncInitSpecialPairMultiplication(ring r)
+BOOLEAN ncInitSpecialPairMultiplication(ring r)
 {
 #if OUTPUT  
   PrintS("ncInitSpecialPairMultiplication(ring), ring: \n");
-  rWrite(r);
-  PrintLn();
-#endif
-  
-  assume(rIsPluralRing(r));
-  assume(!rIsSCA(r));
+  rWrite(r, TRUE);
+  PrintLn();
+#endif
+  
+  if(!rIsPluralRing(r));
+    return TRUE;
+  
+  if(rIsSCA(r))
+    return TRUE;
 
   if( r->GetNC()->GetGlobalMultiplier() != NULL )
   {
     WarnS("Already defined!");
-    return false;
+    return TRUE;
   }
 
   r->GetNC()->GetGlobalMultiplier() = new CGlobalMultiplier(r);
 
-  ggnc_p_ProcsSet(r, NULL);
-  return true;
+  ggnc_p_ProcsSet(r, r->p_Procs);
+  return FALSE; // ok!
 }
 
@@ -654 +656 @@
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
+CHWeylSpecialPairMultiplier::CHWeylSpecialPairMultiplier(ring r, int i, int j, int k):
+    CSpecialPairMultiplier(r, i, j), m_k(k)
+{
+#if OUTPUT  
+  Print("CHWeylSpecialPairMultiplier::CHWeylSpecialPairMultiplier(ring, i: %d, j: %d, k: %d)!", i, j, k);
+  PrintLn();
+#endif
+}
+
+
+CHWeylSpecialPairMultiplier::~CHWeylSpecialPairMultiplier()
+{
+#if OUTPUT  
+  PrintS("CHWeylSpecialPairMultiplier::~CHWeylSpecialPairMultiplier()");
+  PrintLn();
+#endif
+}
+
+// Exponent * Exponent
+poly CHWeylSpecialPairMultiplier::MultiplyEE(const int expLeft, const int expRight)
+{
+#if OUTPUT  
+  Print("CHWeylSpecialPairMultiplier::MultiplyEE(var(%d)^{%d}, var(%d)^{%d})!", GetJ(), expLeft, GetI(), expRight);  
+  PrintLn();
+#endif
+  // Char == 0, otherwise - problem!
+
+
+  const ring r = GetBasering();
+
+  assume( expLeft*expRight > 0 );
+
+  return CFormulaPowerMultiplier::ncSA_1xy0x0yT2(GetI(), GetJ(), expRight, expLeft, m_k, r);
+}
+
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -781 +819 @@
   if( type == _ncSA_1xy0xBy0 ) // Shift 2
     return new CShiftSpecialPairMultiplier(r, i, j, j, g);
+
+  if( type == _ncSA_1xy0x0yT2 ) // simple homogenized Weyl algebra
+    return new CHWeylSpecialPairMultiplier(r, i, j, p_IsPurePower(d, r));
 
 }

libpolys/polys/nc/ncSAMult.h

@@ -25 +25 @@
 //
 
-bool ncInitSpecialPairMultiplication(ring r);
+BOOLEAN ncInitSpecialPairMultiplication(ring r);
 
 
@@ -32 +32 @@
 {
   protected:
-    ring m_basering;
-    int  m_NVars; // N = number of variables
+    const ring m_basering;
+    const int  m_NVars; // N = number of variables
 
   public:
@@ -100 +100 @@
 {
   private:
-    int m_i;
+    int m_i; // 2-gen subalgebra in these variables...
     int m_j;
 
@@ -557 +557 @@
 };
 
+//////////////////////////////////////////////////////////////////////////
+class CHWeylSpecialPairMultiplier: public CSpecialPairMultiplier
+{
+  private:
+    const int m_k;
+    // TODO: make cache for some 'good' powers!?
+
+  public:
+    CHWeylSpecialPairMultiplier(ring r, int i, int j, int k);
+    virtual ~CHWeylSpecialPairMultiplier();
+
+    // Exponent * Exponent
+    virtual poly MultiplyEE(const int expLeft, const int expRight);    
+};
+
 
 //////////////////////////////////////////////////////////////////////////