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

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

L ist eine Liste von Polynomen, q natürliche Zahl, R ein Ring (typischerweise der Polynomring ${}\mathbb {Q} [x,y,z]$ ), maxM natürliche Zahl.

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

${}\sum _{m=0}^{\rm {MaxM}}{\big (}h^{1}(S^{q}(Syz_{1})(m))-h^{0}(S^{q}(Syz_{1})(m))+\sum _{k=1}^{r}h^{0}(\bigwedge ^{k}Syz_{2}\otimes S^{q-k}({\mathcal {F}}_{2}){\big )}.\,$

Genauer sei

${}\ldots \longrightarrow F_{2}\longrightarrow F_{1}\longrightarrow R\,$

eine freie Auflösung des Ideals ${}I=(f_{1},\ldots f_{N})\subseteq R$ mit

${}F_{2}=\bigoplus _{i=1}^{n_{2}}R(-\beta _{i}).\,$

Dann liefert

${}{\rm {KSC}}(\{f_{1},\ldots ,f_{N}\},q,R,q\cdot {\rm {max}}_{i}\beta _{i})\,$

die q-te mehrfach korrigierte symmetrische Codimension von ${}I$ .

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)