Projekt:Computeralgebra-Berechnungen/Symmetrische Hilbert-Kunz Theorie/KSC

Aus Wikiversity
Zur Navigation springen Zur Suche springen

Syntax: KSC(L, q, R, maxM)

L ist eine Liste von Polynomen, q natürliche Zahl, R ein Ring (typischerweise der Polynomring ), maxM natürliche Zahl.


Zur Berechnung der mehrfach korrigierten symmetrischen Codimension eines Ideals im Polynomring als

Genauer sei

eine freie Auflösung des Ideals mit

Dann liefert

die q-te mehrfach korrigierte symmetrische Codimension von .

Manchmal auch interessant, aber unten auskommentiert: Ausgabe der einzelnen Summanden.


SymIndexRecursive=(k,n)-> (if (k==1) then {{n}} 
        else (
                IndexSet:={}; 
                FirstIndex:={n};
                for i from 2 to k do FirstIndex=append(FirstIndex,0);
                IndexSet=append(IndexSet, FirstIndex);
                for i from 1 to n do (
                        CurrentIndex:={}; 
                        RecList:=SymIndexRecursive(k-1, i);
                        for Indx in RecList do (
                                Indx={n-i}|Indx;
                                CurrentIndex=append(CurrentIndex, Indx));
                        IndexSet=IndexSet|CurrentIndex);
                IndexSet))              


decreaseJthEntry=(L,j)-> (
        TheList:=new MutableList from L;
        TheList#(j-1)=TheList#(j-1) -1;
        TheList)

SymSyzHashT=(L,n)-> (
        k:=#L;
        IndexSetDomain:=SymIndexRecursive(k,n);
        IndexSetRange:=SymIndexRecursive(k,n-1);
        hashlist:={};
        for row in IndexSetRange do (
               rowvalue:={};
               for column in IndexSetDomain do
                     rowvalue=append(rowvalue, column=>0);
               rowvalue=new MutableHashTable from hashTable(rowvalue);
               hashlist=append(hashlist, row=>rowvalue));
        hashTM:=new MutableHashTable from hashTable(hashlist);
        for IndxD in IndexSetDomain do
               for j from 1 to k do (
                            IndxRM:=new MutableList from IndxD;
                            IndxRM#(j-1)=IndxRM#(j-1)-1;
                            IndxR:=new List from IndxRM;
                            if (hashTM#?IndxR) then 
                                      (hashTM#IndxR)#IndxD=L#(j-1));
        for IndxR in IndexSetRange do
              hashTM#IndxR=new HashTable from hashTM#IndxR;
        hashT:=new HashTable from hashTM;
hashT)

HashTableToMatrix=hashT->(
       m:=#hashT;
       IndexSetRange:=rsort keys(hashT);
       row0hashT:=hashT#(IndexSetRange#0);
       n:=#row0hashT;
       IndexSetDomain:=rsort keys(row0hashT);
       rlist:={};
       for j from 0 to m-1 do (
               keyj:=IndexSetRange#j;
               rowj:={};
               for i from 0 to n-1 do (
                     keyi:=IndexSetDomain#i;
                     ijentry:=(hashT#keyj)#keyi;        
             rowj=append(rowj, ijentry));            
             rlist=append(rlist, rowj));
             matrix(rlist))      

SymSyzMatrix=(L,n)-> (
       SHT:=SymSyzHashT(L,n);
       HashTableToMatrix(SHT))

SymTwists=(ListOfTwists, n)->(
        r=length(ListOfTwists);
        TheSymTwists=new MutableList from {};
        IndexSet=SymIndexRecursive(r,n);
        for Indx in IndexSet do (
                thesum=0;
                for i in 0..r-1 do thesum=thesum+Indx#i*ListOfTwists#i;
                TheSymTwists=append(TheSymTwists, thesum));
        L=new List from TheSymTwists;
        L)

SymSyzModule=(L,n, R)-> (
        LTwists=new MutableList from {};
        for f in L do LTwists=append(LTwists, -(first degree(f)));
        LTwists=new List from LTwists;
        DomTwists=SymTwists(LTwists, n);
        RangeTwists=SymTwists(LTwists, n-1);
        symMap=map(R^RangeTwists, R^DomTwists, SymSyzMatrix(L,n));
        kernel(symMap))

SymSyzSheaf=(L,n,R)->sheaf(SymSyzModule(L,n,R))
 
SC=(L,n, R)->(
        SnSyz=SymSyzSheaf(L,n,R);
        h=rank HH^1(SnSyz); 
        hsum=h;
        m=0;
        while (h!=0) do (
                m=m+1;
                h=rank HH^1(SnSyz(m));
                hsum=hsum+h);
        hsum)


KSC=(L, n, aRing, maxM)->(
        R=aRing;
        C=resolution(ideal(L));
        AbbMat=C.dd_2;
        F2Twists=new MutableList from {};
        degs=degrees(C_2);
        for degL in degs do F2Twists=append(F2Twists,-degL#0);
        F2Twists=new List from F2Twists;
--      print F2Twists;
        Syz2Module=kernel(AbbMat);
        Syz2Sheaf=sheaf(Syz2Module);
        rankSyz2=rank(Syz2Sheaf);
--      print rankSyz2;
        SnSyz1=SymSyzSheaf(L,n, R);
        sumH1SnSyz1=0;
        for m from 0 to maxM do sumH1SnSyz1=sumH1SnSyz1+rank HH^1(SnSyz1(m));
--      print sumH1SnSyz1;
        sumH0SnSyz1=0;
        for m from 0 to maxM do sumH0SnSyz1=sumH0SnSyz1-rank HH^0(SnSyz1(m));
--      print sumH0SnSyz1;
        WSumme=0;
        WSumme=sumH1SnSyz1+sumH0SnSyz1;
        for k from 0 to rankSyz2  do (
                WedgeSyz=exteriorPower(k,Syz2Sheaf);
                theTwists=SymTwists(F2Twists, n-k);
                currentSheaf=WedgeSyz**(OO_(Proj R)^theTwists);
                hsum=0;
                for m from 0 to maxM do (
                       h=rank HH^0(currentSheaf(m));
                        hsum=hsum+h);
                kthsummand=(-1)^k*hsum;     
--      print kthsummand;
        WSumme=WSumme+kthsummand);
        WSumme)