-- -*- M2-comint -*- hash: 2622899595406644783

i1 : g=3

o1 = 3

i2 : LabBookProtocol(g)

            g=3
            kk= ZZ/101;
            elapsedTime (S,qq,R,u, M1,M2, Mu1, Mu2)=randomNicePencil(kk,g);
             -- 0.644455 seconds elapsed
            M=cliffordModule(Mu1,Mu2,R)
            Mor = vectorBundleOnE M.evenCenter;
            Mor1= vectorBundleOnE M.oddCenter;
            f = M.hyperellipticBranchEquation;
            assert(dim ideal jacobian ideal f ==0);
            elapsedTime while (        
                m1=randomLineBundle(g+(g%2),f);
                m2=randomLineBundle(g%2,f);
                m12=randomExtension(m1.yAction,m2.yAction);
                V = vectorBundleOnE m12;
                Ul=tensorProduct(Mor,V);
                Ul1=tensorProduct(Mor1,V);
                d0=unique degrees target Ul.yAction;
                d1=unique degrees target Ul1.yAction;
                #d1 >=3 or #d0 >=3) do ();
            -- 0.337555 seconds elapsed
            betti Ul.yAction, betti Ul1.yAction
            --further commands
            elapsedTime Ul = tensorProduct(M,V); -- the heaviest part computing the actions of generators
            -- 9.35977 seconds elapsed
            M1Ul=sum(#Ul.oddOperators,i->S_i*sub(Ul.oddOperators_i,S));
            r=2
            Ulrich := M1Ul^{r*2^g..(2*r)*2^g-1};
            Ulr=coker map(S^(r*2^g),,Ulrich);
            minimalBetti Ulr
            -- will give an Ulrich bundle, with betti table 
            -- 16 32 16

i3 : g=3

o3 = 3

i4 : kk= ZZ/101;

i5 : elapsedTime (S,qq,R,u, M1,M2, Mu1, Mu2)=randomNicePencil(kk,g);
 -- 1.17818s elapsed

i6 : M=cliffordModule(Mu1,Mu2,R)

o6 = CliffordModule{...6...}

o6 : CliffordModule

i7 : Mor = vectorBundleOnE M.evenCenter;

i8 : Mor1= vectorBundleOnE M.oddCenter;

i9 : f = M.hyperellipticBranchEquation;

i10 : assert(dim ideal jacobian ideal f ==0);

i11 : elapsedTime while (
          m1=randomLineBundle(g+(g%2),f);
          m2=randomLineBundle(g%2,f);
          m12=randomExtension(m1.yAction,m2.yAction);
          V = vectorBundleOnE m12;
          Ul=tensorProduct(Mor,V);
          Ul1=tensorProduct(Mor1,V);
          d0=unique degrees target Ul.yAction;
          d1=unique degrees target Ul1.yAction;
          #d1 >=3 or #d0 >=3) do ();
 -- .377576s elapsed

i12 : betti Ul.yAction, betti Ul1.yAction

               0  1          0  1
o12 = (total: 32 32, total: 32 32)
          -4: 16  .     -2: 32  .
          -3: 16  .     -1:  .  .
          -2:  .  .      0:  .  .
          -1:  . 16      1:  . 32
           0:  . 16

o12 : Sequence

i13 : elapsedTime Ul = tensorProduct(M,V); -- the heaviest part computing the actions of generators
 -- 18.0843s elapsed

i14 : M1Ul=sum(#Ul.oddOperators,i->S_i*sub(Ul.oddOperators_i,S));

              32      32
o14 : Matrix S   <-- S

i15 : r=2

o15 = 2

i16 : Ulrich := M1Ul^{r*2^g..(2*r)*2^g-1};

              16      32
o16 : Matrix S   <-- S

i17 : Ulr=coker map(S^(r*2^g),,Ulrich);

i18 : minimalBetti Ulr

              0  1  2
o18 = total: 16 32 16
          0: 16 32 16

o18 : BettiTally

i19 : (g,r)=(3,4)

o19 = (3, 4)

o19 : Sequence

i20 : LabBookProtocol(g,r)

    g=3
    r=4
    kk= ZZ/101;
    elapsedTime (S,qq,R,u, M1,M2, Mu1, Mu2)=randomNicePencil(kk,g);
    -- 0.623928 seconds elapsed
     P=kk[drop(gens S,-2)]
    gens P
    M=cliffordModule(Mu1,Mu2,R)
    Mor = vectorBundleOnE M.evenCenter;
    Mor1= vectorBundleOnE M.oddCenter;
    f = M.hyperellipticBranchEquation;
    assert(dim ideal jacobian ideal f ==0);
    degSeq={1,2,3,4}
    elapsedTime while (
        -- build a vector bundle V as extensions of line bundles of degrees in degSeq
        V=randomLineBundle(degSeq#0,f);
        for i from 1 to r-1 do(
            m1=randomLineBundle(degSeq#i,f); 
            m12=randomExtension(m1.yAction,V.yAction);
            V=vectorBundleOnE m12;
            ); 
        Ul=tensorProduct(Mor,V);
        Ul1=tensorProduct(Mor1,V);
        d0=unique degrees target Ul.yAction;
        d1=unique degrees target Ul1.yAction;
        #d1 >=3 or #d0 >=3) do ();
    -- 1.15312 seconds elapsed  
    betti Ul.yAction,betti Ul1.yAction
    --further commands
    elapsedTime Ul = tensorProduct(M,V); -- the heaviest part computing the actions of generators
    -- 87.5896 seconds elapsed
    M1Ul=sum(#Ul.oddOperators,i->S_i*sub(Ul.oddOperators_i,S));
    Ulrich = coker map(P^(r*2^g),,sub(M1Ul^{r*2^g..(2*r)*2^g-1},P));
    minimalBetti Ulrich
    -- Is an Ulrich bundle, with betti numbers
    -- r*2^g,(2*r)*2^g,r*2^g 
    elapsedTime qs=ann Ulrich
     -- 25.3661 seconds elapsed
    ideal sub(diff((vars S)_{2*g+2,2*g+3},qq),P)==qs   
    

i21 : 
