Changeset 6ef8674 in git


Ignore:
Timestamp:
Dec 3, 2010, 10:56:57 PM (14 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '8c6038b526213d378981739e978a9f7b485dab94')
Children:
847e4798004881faf06e4e596f53ce3bcb968bc2
Parents:
f940e2c0b05dd0f0cd990ecd5cde281ac39d25a1
Message:
*levandov: some new procs isLieType,isInvolution,isAntiEndo, cleanup, better doc, assumes

git-svn-id: file:///usr/local/Singular/svn/trunk@13725 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/involut.lib

    rf940e2 r6ef8674  
    88@*        Viktor Levandovskyy,  levandov@mathematik.uni-kl.de
    99
    10 OVERVIEW:s
    11 Involution is an anti-isomorphism of a non-commutative K-algebra
     10OVERVIEW:
     11Involution is an anti-automorphism of a non-commutative K-algebra
    1212@* with the property that applied an involution twice, one gets an identity.
    1313@* Involution is linear with respect to the ground field. In this library we compute
     
    2727findAuto(n);          computes linear automorphisms of order n of a basering;
    2828ncdetection();        computes an ideal, presenting an involution map on some particular noncommutative algebras;
    29 involution(m,theta);  applies the involution to an object.
     29involution(m,theta);  applies the involution to an object;
     30isInvolution(F); check whether a map F in an involution;
     31isAntiEndo(F);   check whether a map F in an antiendomorphism.
    3032";
    3133
     34LIB "nctools.lib";
    3235LIB "ncalg.lib";
    3336LIB "poly.lib";
     
    433436@*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1]
    434437PURPOSE: computed the ideal of linear involutions of the basering
     438ASSUME: the relations on the algebra are of the form YX = XY + D, that is
     439the current ring is a G-algebra of Lie type.
    435440NOTE: for convenience, the full ideal of relations @code{idJ}
    436441and the initial matrix with indeterminates @code{matD} are exported in the output ring
     
    442447  int NVars = nvars(@B); //number of variables in basering
    443448  int i, j;
     449
     450  // check basering is of Lie type:
     451  if (!isLieType())
     452  {
     453    ERROR("Assume violated: basering is of non-Lie type");
     454  }
    444455
    445456  matrix Rel = RelMatr(); //the matrix of relations
     
    564575@*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1]
    565576PURPOSE: compute homothetic (diagonal) involutions of the basering
     577ASSUME: the relations on the algebra are of the form YX = XY + D, that is
     578the current ring is a G-algebra of Lie type.
    566579NOTE: for convenience, the full ideal of relations @code{idJ}
    567580and the initial matrix with indeterminates @code{matD} are exported in the output ring
     
    572585  int NVars = nvars(@B); //number of variables in basering
    573586  int i, j;
     587
     588  // check basering is of Lie type:
     589  if (!isLieType())
     590  {
     591    ERROR("Assume violated: basering is of non-Lie type");
     592  }
    574593
    575594  matrix Rel = RelMatr(); //the matrix of relations
     
    696715PURPOSE: compute the ideal of linear automorphisms of the basering,
    697716@*  given by a matrix, n-th power of which gives identity (i.e. unipotent matrix)
     717ASSUME: the relations on the algebra are of the form YX = XY + D, that is
     718the current ring is a G-algebra of Lie type.
    698719NOTE: if n=0, a matrix, defining an automorphism is not assumed to be unipotent
    699720@* but just non-degenerate. A nonzero parameter @code{@@p} is introduced as the value of
     
    709730    return(0);
    710731  }
     732
     733
    711734  def @B    = basering; //save the name of basering
    712735  int NVars = nvars(@B); //number of variables in basering
    713736  int i, j;
     737
     738  // check basering is of Lie type:
     739  if (!isLieType())
     740  {
     741    ERROR("Assume violated: basering is of non-Lie type");
     742  }
    714743
    715744  matrix Rel = RelMatr(); //the matrix of relations
     
    852881  det(L[1][2]-@p);  // check whether determinante is zero
    853882}
     883
     884
     885proc isAntiEndo(def F)
     886"USAGE: isAntiEndo(F); F is a map from current ring to itself
     887RETURN: integer, 1 if F determines an antiendomorphism of
     888current ring and 0 otherwise
     889ASSUME: F is a map from current ring to itself
     890SEE ALSO: isInvolution, involution, findInvo
     891EXAMPLE: example isAntiEndo; shows examples
     892"
     893{
     894  // assumes:
     895  // (1) F is from br to br
     896  // I don't see how to check it; in case of error it will happen in the body
     897  // (2) do not assume: F is linear, F is bijective
     898  int n = nvars(basering);
     899  int i,j;
     900  poly pi,pj,q;
     901  int answer=1;
     902  ideal @f = ideal(F); list L=@f[1..ncols(@f)];
     903  for (i=1; i<n; i++)
     904  {
     905    for (j=i+1; j<=n; j++)
     906    {
     907      // F( x_j x_i) =def= F(x_i) F(x_j)
     908      pi = var(i);
     909      pj = var(j);
     910      //      q = involution(pj*pi,F) - F(pi)*F(pj);
     911      q = In_Poly(pj*pi,L,n) - F[i]*F[j];
     912      if (q!=0)
     913      {
     914        answer=0; return(answer);
     915      }
     916    }
     917  }
     918  return(answer);
     919}
     920example
     921{"EXAMPLE:";echo = 2;
     922  def A = makeUsl(2); setring A;
     923  map I = A,-e,-f,-h; //correct antiauto involution
     924  isAntiEndo(I);
     925  map J = A,3*e,1/3*f,-h; // antiauto but not involution
     926  isAntiEndo(J);
     927  map K = A,f,e,-h; // not antiendo
     928  isAntiEndo(K);
     929};
     930
     931
     932proc isInvolution(def F)
     933"USAGE: isInvolution(F); F is a map from current ring to itself
     934RETURN: integer, 1 if F determines an involution and 0 otherwise
     935THEORY: involution is an antiautomorphism of order 2
     936ASSUME: F is a map from current ring to itself
     937SEE ALSO: involution, findInvo, isAntiEndo
     938EXAMPLE: example isInvolution; shows examples
     939"
     940{
     941  // does not assume: F is an antiautomorphism, can be antiendo
     942  // allows to detect endos which are not autos
     943  // isInvolution == ( F isAntiEndo && F(F)==id )
     944  if (!isAntiEndo(F))
     945  {
     946    return(0);
     947  }
     948  //  def G = F(F);
     949  int j; poly p; ideal @f = ideal(F); list L=@f[1..ncols(@f)];
     950  int nv = nvars(basering);
     951  for(j=nv; j>=1; j--)
     952  {
     953    //    p = var(j); p = F(p); p = F(p) - var(j);
     954    //p = G(p) - p;
     955    p = In_Poly(var(j),L,nv);
     956    p = In_Poly(p,L,nv) -var(j) ;
     957
     958    if (p!=0)
     959    {
     960      return(0);
     961    }
     962  }
     963  return(1);
     964}
     965example
     966{"EXAMPLE:";echo = 2;
     967  def A = makeUsl(2); setring A;
     968  map I = A,-e,-f,-h; //correct antiauto involution
     969  isInvolution(I);
     970  map J = A,3*e,1/3*f,-h; // antiauto but not involution
     971  isInvolution(J);
     972  map K = A,f,e,-h; // not antiauto
     973  isInvolution(K);
     974};
     975
     976
  • Singular/LIB/nctools.lib

    rf940e2 r6ef8674  
    2424findimAlgebra(M,[r]);     create finite dimensional algebra structure from the basering and the multiplication matrix M,
    2525superCommutative([b,e,Q]);  return qring, a super-commutative algebra over a basering,
    26 rightStd(I);              compute a right Groebner basis of an ideal,
    27 
     26rightStd(I);              compute right Groebner basis of an ideal,
     27rightNF(f,I);             compute right normal form wrt a submodule,
     28rightModulo(M,N);         compute kernel of a homomorphism of right modules,
    2829moduloSlim(A,B);     compute modulo command via slimgb
    2930ncRelations(r);      recover the non-commutative relations of a G-algebra,
     
    17791780}
    17801781
     1782proc isLieType()
     1783"USAGE:  isLieType();
     1784RETURN:  int, 1 if basering is a G-algebra of Lie type, 0 otherwise
     1785PURPOSE: G-algebra of Lie type has relations of the kind Y*X=X*Y+D
     1786EXAMPLE: example isLieType; shows an example
     1787"
     1788{
     1789  def @B    = basering; //save the name of basering
     1790  int NVars = nvars(@B); //number of variables in basering
     1791  int i, j;
     1792
     1793  int answer = 1; 
     1794
     1795  // check basering is of Lie type:
     1796  matrix @@CC[NVars][NVars];
     1797  for(i=1; i<NVars; i++)
     1798  {
     1799    for(j=i+1; j<=NVars; j++)
     1800    {
     1801      @@CC[i,j]=leadcoef(var(j)*var(i));
     1802    };
     1803  };
     1804  ideal @C@ = simplify(ideal(@@CC),2+4);// skip zeroes and repeated entries
     1805  if (  (size(@C@) >1 ) || ( (size(@C@)==1) && (@C@[1]!=1) )  )
     1806  {
     1807    answer = 0;
     1808  };
     1809  return(answer);
     1810}
     1811example
     1812{
     1813  "EXAMPLE:"; echo = 2;
     1814  ring r = 0,(x,y),dp;
     1815  y*x;
     1816  isLieType(); //yes
     1817  def D = Weyl(); setring D;
     1818  y*x;
     1819  isLieType(); //yes
     1820  setring r;
     1821  def R = nc_algebra(-3,0); setring R;
     1822  y*x;
     1823  isLieType(); // no
     1824  kill R; kill r;
     1825  ring s = (0,q),(x,y),dp;
     1826  def S = nc_algebra(q,0); setring S;
     1827  y*x;
     1828  isLieType(); //no
     1829  kill S; setring s;
     1830  def S = nc_algebra(q,y^2); setring S;
     1831  y*x;
     1832  isLieType(); //no
     1833}
Note: See TracChangeset for help on using the changeset viewer.