passagemath-singular 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage_wheels/share/singular/LIB/qmatrix.lib

@@ -0,0 +1,293 @@
+/////////////////////////////////////
+version="version qmatrix.lib 4.1.2.0 Feb_2019 "; // $Id: 00a06fcbbde913d58a44128194e4e7b7bdc08a6b $
+category="Noncommutative";
+info="
+LIBRARY: qmatrix.lib     Quantum matrices, quantum minors and symmetric groups
+AUTHORS: Lobillo, F.J.,  jlobillo@ugr.es
+@*       Rabelo, C.,     crabelo@ugr.es
+
+SUPPORT: 'Metodos algebraicos y efectivos en grupos cuanticos', BFM2001-3141, MCYT, Jose Gomez-Torrecillas (Main researcher).
+
+PROCEDURES:
+quantMat(n, [p]);          generates the quantum matrix ring of order n;
+qminor(u, v, nr);          calculate a quantum minor of a quantum matrix
+
+SymGroup(n);                generates an intmat containing S(n), each row is an element of S(n)
+LengthSymElement(v);        calculates the length of the element v of S(n)
+LengthSym(M);               calculates the length of each element of M, being M a subset of S(n)
+";
+
+LIB "ncalg.lib";
+LIB "nctools.lib";  // for rootofUnity
+///////////////////////////////////////////////////////////////////////////////
+
+proc SymGroup(int n)
+"USAGE:   SymGroup(n); n an integer (positive)
+RETURN:  intmat
+PURPOSE: represent the symmetric group S(n) via integer vectors (permutations)
+NOTE:    each row of the output integer matrix is an element of S(n)
+SEE ALSO: LengthSym, LengthSymElement
+EXAMPLE: example SymGroup; shows examples
+"{
+  if (n<=0)
+  {
+    "n must be positive";
+    intmat M[1][1]=0;
+  }
+  else
+  {
+    if (n==1)
+    {
+      intmat M[1][1]=1;
+    }
+    else
+    {
+      def N=SymGroup(n-1); // N is the symmetric group S(n-1)
+      int m=nrows(N); // The order of S(n-1)=(n-1)!
+      intmat M[m*n][n]; // Matrix to save S(n), m*n=n*(n-1)!=n!=#S(n)
+      int i,j,k;
+      for (i=1; i<=m; i++)
+      { // fixed an element i of S(n-1)
+        for (j=n; j>0; j--)
+        { // and fixed a position j to introduce an "n"
+          for (k=1; k<j; k++)
+          { // we want to copy the i-th element until position j-1
+            M[n*(i-1)+(n-j+1),k]=N[i,k];
+          }
+          M[n*(i-1)+(n-j+1),j]=n; // we write the "n" in the position j
+          for (k=j+1; k<=n; k++)
+          {
+            M[n*(i-1)+(n-j+1),k]=N[i,k-1]; // and we run until the end of copying
+          }
+        }
+      }
+    }
+  }
+  return (M);
+}
+example
+{
+  "EXAMPLE:";echo=2;
+  //  "S(3)={(1,2,3),(1,3,2),(3,1,2),(2,1,3),(2,3,1),(3,2,1)}";
+  SymGroup(3);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// This procedure calculates the length of an element v of a symmetric group
+// If size(v)=n, the group is S(n). The permutation is i->v[i].
+
+proc LengthSymElement(intvec v)
+"USAGE:  LengthSymElement(v); v intvec
+RETURN:  int
+PURPOSE: determine the length of the permutation given by v in some S(n)
+ASSUME:  v represents an element of S(n); otherwise the output may have no sense
+SEE ALSO: SymGroup, LengthSym
+EXAMPLE: example LengthSymElement; shows examples
+"{
+  int n=size(v);
+  int l=0;
+  int i,j;
+  for (i=1; i<n; i++)
+  {
+    for (j=i+1; j<=n; j++)
+    {
+      if (v[j]<v[i]) {l++;}
+    }
+  }
+  return (l);
+}
+example
+{
+  "EXAMPLE:";echo=2;
+  intvec v=1,3,4,2,8,9,6,5,7,10;
+  LengthSymElement(v);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+proc LengthSym(intmat M)
+"USAGE:   LengthSym(M); M an intmat
+RETURN:  intvec
+PURPOSE: determine a vector, where the i-th element is the length of the permutation of S(n) given by the i-th row of M
+ASSUME: M represents a subset of S(n) (each row must be an element of S(n)); otherwise, the output may have no sense
+SEE ALSO: SymGroup, LengthSymElement
+EXAMPLE: example LengthSym; shows examples
+"{
+  int n=ncols(M); // this n is the n of S(n)
+  int m=nrows(M); // m=num of element of S(n) in M, if M=S(n) m=n!
+  intvec L=0;
+  int i;
+  for (i=1; i<=m; i++)
+  {
+    L=L,LengthSymElement(intvec(M[i,1..n]));
+  }
+  L=L[2..size(L)];
+  return (L);
+}
+example
+{
+  "EXAMPLE:";echo=2;
+  def M = SymGroup(3); M;
+  LengthSym(M);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+proc quantMat(int n, list #)
+"USAGE:   quantMat(n [, p]); n integer (n>1), p an optional integer
+RETURN:  ring (of quantum matrices). If p is specified, the quantum parameter q
+@*       will be specialized at the p-th root of unity
+PURPOSE: compute the quantum matrix ring of order n
+NOTE:    activate this ring with the \"setring\" command.
+@*       The usual representation of the variables in this quantum
+@*       algebra is not used because double indexes are not allowed
+@*       in the variables. Instead the variables are listed by reading
+@*       the rows of the usual matrix representation, that is, there
+@*       will be n*n variables (one for each entry an n*N generic matrix),
+@*       listed row-wise
+SEE ALSO: qminor
+EXAMPLE: example quantMat; shows examples
+"{
+  if (n>1)
+  {
+    int nv=n^2;
+    intmat m[nv][nv];
+    int i,j;
+    for (i=1; i<=nv; i++)
+    {
+      m[i,nv+1-i]=1;
+    }
+    int chr = 0;
+    if ( size(#) > 0 )
+    {
+      if ( typeof( #[1] ) == "int" )
+      {
+        chr = #[1];
+      }
+    }
+    ring @rrr=(0,q),(y(1..nv)),Dp;
+    minpoly = rootofUnity(chr);
+    matrix C[nv][nv]=0;
+    matrix D[nv][nv]=0;
+    intvec idyi, idyj;
+    for (i=1; i<nv; i++)
+    {
+      for (j=i+1; j<=nv; j++)
+      {
+        idyi=itoij(i,n);
+        idyj=itoij(j,n);
+        if (idyi[1]==idyj[1] || idyi[2]==idyj[2])
+        {
+          C[i,j]=1/q;
+        }
+        else
+        {
+          if (idyi[2]<idyj[2])
+          {
+            C[i,j]=1;
+            D[i,j]=(1/q - q)*y(ijtoi(idyi[1],idyj[2],n))*y(ijtoi(idyj[1],idyi[2],n));
+          }
+          else
+          {
+            C[i,j]=1;
+          }
+        }
+      }
+    }
+    def @@rrr=nc_algebra(C,D);
+    return (@@rrr);
+  }
+  else
+  {
+    "ERROR: n must be greater than 1";
+    return();
+  }
+}
+example
+{
+  "EXAMPLE:"; echo=2;
+  def r = quantMat(2); // generate O_q(M_2) at q generic
+  setring r;   r;
+  kill r;
+  def r = quantMat(2,5); // generate O_q(M_2) at q^5=1
+  setring r;   r;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+proc qminor(intvec I, intvec J, int nr)
+"USAGE:        qminor(I,J,n); I,J intvec, n int
+RETURN: poly, the quantum minor of a generic n*n quantum matrix
+ASSUME: I is the ordered list of the rows to consider in the minor,
+@*      J is the ordered list of the columns to consider in the minor,
+@*      I and J must have the same number of elements,
+@*      n is the order of the quantum matrix algebra you are working with (quantMat(n)).
+@*      The base ring should be constructed using @code{quantMat}.
+SEE ALSO: quantMat
+EXAMPLE: example qminor; shows examples
+"{
+  poly d=0;
+  poly f=0;
+  int k=0;
+  int n=size(I);
+  if ( size(I)!=size(J) )
+  {
+    "#I must be equal to #J";
+  }
+  else
+  {
+    def Sn=SymGroup(n);
+    def L=LengthSym(Sn);
+    int m=size(L); // m is the order of S(n)
+    int i,j;
+    for (i=1; i<=m; i++)
+    {
+      f=(-q)^(L[i]);
+      for (j=1; j<=n; j++)
+      {
+        k=ijtoi(I[j],J[Sn[i,j]],nr);
+        f=f*y(k);
+      }
+      d=d+f;
+    }
+  }
+  return (d);
+}
+example
+{
+  "EXAMPLE:";
+  echo=2;
+  def r = quantMat(3); // let r be a quantum matrix of order 3
+  setring r;
+  intvec u = 1,2;
+  intvec v = 2,3;
+  intvec w = 1,2,3;
+  qminor(w,w,3);
+  qminor(u,v,3);
+  qminor(v,u,3);
+  qminor(u,u,3);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// For technical reasons we work with a list of variables {y(1)...y(n^2)}.
+// In quantum matrices the usual is to work with a square matrix of variables {y(ij)}.
+// The formulas are easier if we use matricial notation.
+// The following two procedures change the index of a list to a matrix and viceversa in order
+// to use matricial notation in the calculus but use list notation in input and output.
+// n is the order of the quantum matrix algebra where we are working.
+
+static proc itoij(int i,int n)
+{
+  intvec ij=0,0;
+  ij[1]=((i-1) div n)+1;
+  ij[2]=((i-1) mod n)+1;
+  return(ij);
+}
+
+static proc ijtoi(int i,int j,int n)
+{
+  return((j-1)+n*(i-1)+1);
+}
+///////////////////////////////////////////////////////////////////////////////