>

Isogeny Covariant Differential Modular Forms Modulo p^2

Supporting Computations

Chris Hurlburt

August, 2000

The purpose of this worksheet is to provide a check for many of the computations in the paper of the same name. Major sections will include the group law, the liftings, the substitutions, and transformations.

> restart;

>

The Elliptic Curve

We consider the projective curve given by the following diamond equation and then cover it with two affine open sets U and V corresponding to f and g respectively.

> diamond:=(X,Y,Z) -> Z*Y^2 - X^3 - a4*X*Z^2 - a6*Z^3;

> f:=diamond(x,y,1);

> g:=diamond(z,1,w);

>

>

>

p-derivation Function

This function was written in collaboration with Michael Wester. Note that it does not return a simplified (-1)^p = -1. This must be done after application.

>

> # ---------- Programming and Miscellaneous ----------
# Define a simple differentiation operator. This is
# most easily done with recursion!!! our friend.

pdiff:= proc(e) local oper, n;
oper:= op(0, e);
n:= nops(e);

# Start by making the derivative of a sum to be the
# sum of the derivatives.
if oper = `+` then
map(pdiff, e) + cpext(e)
# Actual value of cpext() ( map(x -> x^p, e) - e^p)/p

# Add the product rule.
elif oper = `*` then
pdiff(op(1, e)) * product((op(i, e))^p, i = 2..n) +
op(1, e)^p * pdiff(product(op(i, e), i = 2..n))
+ p*pdiff(op(1,e))*pdiff(product(op(i, e), i = 2..n))

# Before we define a p-derivation of an integer we
# add in this special case because p is always odd.
elif e = -1 then
0

# Now, make the derivative of a constant (c - c^p )/p.
elif oper=integer then
delta(e) # (e - e^p)/p

# Define the derivative of x with respect to x to be one.
elif oper = symbol then
delta (e)

# Enter the generalized power rule for positive powers.
elif oper = `^` and sign(op(2, e))>0 then
(1/p)*(-(op(1,e))^(op(2,e)*p) + ((op(1,e)^p + p*pdiff(op(1,e)))^op(2,e)))


# Enter the generalized power rule for negative powers.
elif oper = `^` and sign(op(2, e))<0 then
-pdiff(op(1,e)^(-(op(2,e))))/(op(1,e)^(-p*op(2,e))
*(op(1,e)^(-p*op(2,e)) + p*pdiff(op(1,e)^(-op(2,e)))))

# Enter the case to default to if none of the above are valid.
else
delta (e);

fi
end;

Now we do a small amount of testing because I still am leary of our package... it is still a new endevour.

> pdiff(x+y+z);

> pdiff(6*x+y);

> pdiff(x*y);

>

The First p-jet Space of the Elliptic Curve

This is defined by taking the p-jet spaces of the open affine sets U and V and then glueing them together via the maps given in the next section. The first p-jet space of U denoted U' is the space given by f and fprime. Similarly the first p-jet space of V is the space given by g and gprime.

> fprime:=collect(expand(subs((-1)^p=-1,pdiff(f))),[p,delta(y),delta(x)]);

> gprime:=collect(expand(subs((-1)^p=-1,pdiff(g))),[p,delta(w),delta(z)]);

>

>

Glueing Maps

We start with the glueing maps for the elliptic curve itself. Recall that the equations defining U and V are f and g respectively and the local coordinates of f are x and y, the local coordiantes of g are z,w with x being the local parameter in the first case and z being the local parameter in the second case. The sign conventions are to match those Silverman uses in The Arithmetic of Elliptic Curves.

> transVtoU:=[w=-1/y,z=-x/y];

> transUtoV:=[x=z/w,y=-1/w];

> quotientpdiff:=normal(expand(simplify(normal(pdiff(a/b)),power,symbolic)));

> wp:=subs(delta(1)=0,-subs([a=1,b=y],quotientpdiff));

> zp:=-subs([a=x,b=y],quotientpdiff);

> xp:=subs([a=z,b=w],quotientpdiff);

> yp:=subs(delta(1)=0,-subs([a=1,b=w],quotientpdiff));

>

The Group Law of the Elliptic Curve

In this section we simply state the equations for the group law in terms of w-z coordinates for the first p-jet space of the elliptic curve;

> g;

>

> alpha:= -(-3*w2^2*z1*a6*w1-w2^2*z1^2*a4-w2*z2+3*a6*w2*w1^2*z2+2*z1*w2+z1*w1-2*w1*z2+a4*w1^2*z2^2);

> beta:=3*w2*z2*z1^2-3*z1*w1*z2^2+z1*a4*w2^2*w1-w2^2+w1^2-w2*w1^2*z2*a4;

> mu:=-(3*z2*z1^2-a4*w2^2*z1+a4*w1^2*z2-3*a6*w2^2*w1+3*a6*w2*w1^2-w1+w2-3*z2^2*z1-2*a4*w2*w1*z2+2*a4*w2*w1*z1);

Note that z3= -alpha/mu and w3 = -beta/mu.

>

The Group Law of the First p-jet Space of the Elliptic Curve modulo p^2

In this section we extend the group law from the previous section to a group law of the first jet space by applying \delta to the appropriate equations.

Alpha

> firstrunalpha:=subs([(-1)^p=-1,(-2)^p=-2^p,delta(-2)=-delta(2),(-3)^p=-3^p,delta(-3)=-delta(3)],expand(pdiff(alpha))):

> dalpha:=collect(subs([p^5=0,p^4=0,p^3=0,p^2=0],firstrunalpha),p):

>

Beta

> firstrunbeta:=subs([(-1)^p=-1,(-2)^p=-2^p,delta(-2)=-delta(2),(-3)^p=-3^p,delta(-3)=-delta(3)],expand(pdiff(beta))):

> dbeta:=collect(subs([p^5=0,p^4=0,p^3=0,p^2=0],firstrunbeta),p):

Mu

> firstrunmu:=subs([(-1)^p=-1,(-2)^p=-2^p,delta(-2)=-delta(2),(-3)^p=-3^p,delta(-3)=-delta(3)],expand(pdiff(mu))):

> dmu:=collect(subs([p^5=0,p^4=0,p^3=0,p^2=0],firstrunmu),p):

Note: These three expressions must be combined appropriately using the pquotient to get the them for delta(z3) and delta(w3) under the group law for the first jet space. We now work on that part modulo p^2 for the delta(z3) term. We start by recalling that the p-derivative of a/b is

> quotientpdiff:=normal(expand(simplify(normal(pdiff(a/b)),power,symbolic)));

Then we invert the denominator p-adically modulo p^2 which is equvalent to solving the following equation for the appropriate terms for frieda and diego.

> expand((b^p+p*delta(b))*(frieda + p*diego));

Now we can see that if frieda = 1/b^p and diego = -delta(b)/b^(2*p) then the sum frieda + p*diego is the inverse of b^p+ p*delta(b). So the p-derivative of a/b modulo p^2 is

> tempquotientpdiffmodp2:=subs((b^p + p*delta(b))= 1/(1/b^p - p*delta(b)/b^(2*p)),quotientpdiff);

> quotientpdiffmodp2:=factor(normal(expand(tempquotientpdiffmodp2)));

>

Named Term Equivalences

This section is a compendium of the actual composition of terms represented by names in various parts of this document. The convention will be to label them with the usename appended by the word name. So for example the actual expression for fabian will be called fabianname.

P0 terms

> PU0name:=cpext(y^2-x^3-a4*x-a6)-delta(a4)*x^p-delta(a6);

> PV0name:=-delta(a4)*z^p*(w^2)^p-delta(a6)*(w^3)^p+cpext(w-z^3-a4*z*w^2-a6*w^3);

Now to write these without cpext

> phasename:=cpext(y^2-x^3-a4*x-a6);

> phaseVname:=cpext(w-z^3-a4*z*w^2-a6*w^3);

> PU0unextname := phase-delta(a4)*x^p-delta(a6);

> PV0unextname:= -delta(a4)*z^p*(w^2)^p-delta(a6)*(w^3)^p+phaseV;

R0 Terms

>

> RU0name:=cpext(Afx+Bfy) + Aquirk^p*(-delta(3)*x^(2*p) + cpext(-3*x^2 -a4)) + Bquirk^p*delta(2)*y^p;

> gigi:=[cpext(Afx+Bfy) = (Aquirk^p*fx^p + Bquirk^p*fy^p - 1)/p, cpext(-3*x^2 -a4)= (-3^p*x^(2*p) - a4^p - fx^p)/p];

> RU0expanded:=subs(fy^p = 2^p*y^p,expand(subs(gigi,RU0name)));

>

> RV0name:=cpext(Cgz+Dagw) + Cquirk^p*(-delta(3)*z^(2*p) + cpext(-3*z^2 - a4*w^2))+ Daquirk^p*(-delta(3)*a6^p*w^(2*p)-delta(2)*a4^p*z^p*w^p + cpext(1-3*a6*w^2-2*a4*z*w));

> gini:=[cpext(Cgz+Dagw)=(Cquirk^p*gz^p + Daquirk^p*gw^p - 1)/p, cpext(1-3*a6*w^2-2*a4*z*w) = (1 - 3^p*a6^p*w^(2*p)- 2^p*a4^p*z^p*w^p - gw^p)/p, cpext(-3*z^2-a4*w^2) = (-3^p*z^(2*p) - a4^p*w^(2*p) - gz^p)/p];

> RV0expanded:=expand(subs(gini,RV0name));

> giva:=[delta(2) = (2-2^p)/p,delta(3)=(3 - 3^p)/p];

>

> RU0belted:=expand(subs(giva,RU0expanded));

> RV0belted:=expand(subs(giva,RV0expanded));

P1 terms

>

> PU1name:=Pu0*(-3*x^p*Pu0*Aquirk^(2*p) + delta(a4)*Aquirk^p + Pu0*Bquirk^(2*p) - Ru0);

> PV1name:=Pv0*(-3*z^p*Pv0*Cquirk^(2*p) - 2*a4^p*w^p*Pv0*Daquirk^p*Cquirk^p + delta(a4)*w^(2*p)*Cquirk^p - (a4^p*z^p + 3*a6^p*w^p)*Pv0*Daquirk^(2*p) + (3*delta(a6)*w^(2*p) + 2*delta(a4)*z^p*w^p)*Daquirk^p - Rv0);

> PU1expanded:=subs(Ru0 = RU0belted ,PU1name);

> PV1expanded:=subs(Rv0 = RV0belted ,PV1name);

>

GCD terms

> Aquirkname:=16*(4*a4^2+6*a4*x^2-9*x*a6)/Delta;

> Bquirkname:=72*y*(2*a4*x-3*a6)/Delta;

> Cquirkname:=z*(-3/2*a6*w-a4*z);

> Daquirkname:=(-3/2)*a6*w^2 - w*a4*z+1;

> Baxname:=Bquirkname/y;

Partial Derivatives

>

> fxname:=diff(f,x);

> fyname:=diff(f,y);

> gzname:=diff(g,z);

> gwname:=diff(g,w);

> Remusname:=cpext(-6*a4*z*w^2-6*a6*w^3-6*z^3-2*w);

>

Translations of term equivalences

In this section we consider translations of termed equivalences from above in either U or V. We start by noting some of the following equivalences:

> Pu0nameinV:=Pv0/w^(3*p);

> simplify(subs(transVtoU,Pu0nameinV),power,symbolic);

> Pv0nameinU:=-Pu0/y^(3*p);

> AquirknameinV:=normal(subs(transUtoV,Aquirkname));

>

>

>

Sections to be subtracted under Group Law

The two sections we are talking about here are (z, w, z', w') where z' = delta(z) and w = delta(w) and (-x/y, -1/y, (x^p*y' - y^p*x')/(y^p*(y^p + p*y')), y'/y^p*(y^p + p*y')) ) where y' = delta(y) and x' = delta(x). Where the various parts here come from the lifting of delta a p-derivation. For now we are including the formulas. Making the appropriate adjustments for the fact that we are working modulo p^2.

>

> z1term:=-x/y;

> w1term:=-1/y;

> tempz1prime:=1/y^(3*p)*(-x^p*Bquirk^p + y^p*Aquirk^p)*(Pu0+p*Pu1)*(y^p + p*Bquirk^p*Pu0);

> temp2z1prime:=factor(normal(subs(p^2=0,expand(tempz1prime))));

Now we are going to replace the Pu0*y^p+Pu0^2*p*Bquirk^p+p*Pu1*y^p by the word fabian. This will help us later in simplifying terms.

> oldz1prime:=subs(Pu0*y^p+Pu0^2*p*Bquirk^p+p*Pu1*y^p=fabian,temp2z1prime);

> z1primemodp:=normal(subs(p^3=0, expand(p^2*temp2z1prime))/p^2);

> z1prime:=collect(normal(expand(subs(Pu1=PU1expanded,temp2z1prime))),p);

> tempw1prime:=-Bquirk^p*(Pu0+p*Pu1)*(y^p + p*Bquirk^p*Pu0)/y^(3*p);

> temp2w1prime:=factor(normal(subs(p^2=0,expand(tempw1prime))));

We do the same fabian substitution.

> oldw1prime:=subs(Pu0*y^p+Pu0^2*p*Bquirk^p+p*Pu1*y^p=fabian,temp2w1prime);

> w1primemodp:=normal(subs(p^3=0, expand(p^2*temp2w1prime))/p^2);

> w1prime:=collect(normal(expand(subs(Pu1=PU1expanded,temp2w1prime))),p);

> z2term:=-z;

> w2term:=-w;

> tempz2prime:=Cquirk^p*(Pv0 + p*Pv1);

> z2primemodp:=normal(subs(p^3=0, expand(p^2*tempz2prime))/p^2);

> z2prime:=collect(normal(expand(subs(Pv1=PV1expanded,tempz2prime))),p);

> tempw2prime:=Daquirk^p*(Pv0 + p*Pv1);

> w2primemodp:=normal(subs(p^3=0, expand(p^2*tempw2prime))/p^2);

> w2prime:=collect(normal(expand(subs(Pv1=PV1expanded,tempw2prime))),p);

Now we recall that under the group law

z3 = z3eq = -alpha/mu

w3 = w3eq = -beta/mu

delta(z3) = - (mu^p*delta(alpha) - alpha^p*delta(mu)/(mu^p*(mu^p+p*delta(mu)))

delta(w3) = - (mu^p*delta(beta) - beta^p*delta(mu)/(mu^p*(mu^p+p*delta(mu)))

>

>

>

Subtracting Sections Under the Group Law

Here we take the sections and actually plug them into the group law modulo p^2. We start by plugging into the various parts---alpha, mu, delta(alpha), delta(mu) and transforming the results into an expression on U or V as convenient. The substitution list is

> lucilla:=[z1=z1term,z2=z2term,w1=w1term,w2=w2term,delta(z1)=z1prime,delta(z2)=z2prime,delta(w1)=w1prime,delta(w2)=w2prime];

> lucillamodp:=[z1=z1term,z2=z2term,w1=w1term,w2=w2term,delta(z1)=z1primemodp,delta(z2)=z2primemodp,delta(w1)=w1primemodp,delta(w2)=w2primemodp];

alpha

> alpha;

> alphasubbed:=normal(subs(lucilla,alpha));

> alphatranslated:=subs(transUtoV,alphasubbed);

So we note that the alpha term is in fact 0 as it should be (since the sections are the same on the first two terms, we should get 0 from the goup law for the first two sections.)

> alphainsertterm:=alphatranslated;

mu

> mu;

> musubbed:=normal(subs(lucilla,mu));

> mutranslated:=normal(subs(transUtoV,musubbed));

> mutranslated := -6*a4*z*w^2-2*w-6*z^3-6*a6*w^3;

Now we recall that when working on V we are working modulo the relation w-z^3-a4*z*w^2-a6*w^3=0. So we may add or subtract multiples of g and still be in the same equivalence class. In this case we will subtract 6g to get the term for mu under the group law which is fortunately NOT 0.

> muinsertterm:=mutranslated - 6*g;

>

beta

This one is not necessary, but always a nice check.

> beta;

> betasubbed:=normal(subs(lucilla,beta));

> betatranslated:=subs(transUtoV,betasubbed);

So we note that the beta term is in fact 0 as it should be (since the sections are the same on the first two terms, we should get 0 from the goup law for the first two sections.)

> betainsertterm:=betatranslated;

>

delta(alpha)

> dalphasubbed:=normal(subs(lucilla,dalpha)):

Note that dalpha contains many places where it has a cpext(alpha) term and these under this substitution will become 0.

> dalphatranslated:=subs(transUtoV,dalphasubbed):

Now we simplify this term as much as possible by performing various substitutions etc.

> angel1:=subs([cpext(0)=0,(-w)^p=-w^p,(-z)^p=-z^p,(-1/w)^p=-(1/w)^p],dalphatranslated):

> angel2:=collect(normal(expand(simplify(angel1,power,symbolic))),p):

> angel3:=subs([p^3=0,p^2=0],angel2):

Undoubtably we will work more with these terms later....

> dalphainsertterm:=angel3;

> dalphainserttermmodpold:=subs(p^3=0,collect(expand(p^2*dalphainsertterm),p))/p^2:

>

We redo the mod p case using the techniques of the following section.

>

> dalphamodp:=subs(p^3=0,collect(expand(p^2*dalpha),p))/p^2:

>

> dalphasubbedmodp:=normal(subs(lucillamodp,dalphamodp)):

> dalphamodptranslated:=subs(transUtoV,dalphasubbedmodp):

Now we simplify this term as much as possible by performing various substitutions etc.

> alphsca1:=subs([(-w)^p=-w^p,(-z)^p=-z^p,(-1/w)^p=-(1/w)^p],dalphamodptranslated):

> alphsca2:=collect(normal(expand(simplify(alphsca1,power,symbolic))),p);

> alphsca3:=subs(cpext(0)=0,collect(expand(p^2*alphsca2),p))/p^2:

>

> dalphainserttermmodp:=alphsca3;

>

> dalphainserttermmodp- dalphainserttermmodpold:

>

delta(mu)

Note that since alphainstertterm=0, it is only neccessary to find this term modulo p since it is multiplied times p.

> dmumodp:=subs(p^3=0,collect(expand(p^2*dmu),p))/p^2:

>

> dmusubbed:=normal(subs(lucillamodp,dmumodp)):

> dmutranslated:=subs(transUtoV,dmusubbed):

Now we simplify this term as much as possible by performing various substitutions etc.

> musca1:=subs([(-w)^p=-w^p,(-z)^p=-z^p,(-1/w)^p=-(1/w)^p],dmutranslated):

> musca2:=collect(normal(expand(simplify(musca1,power,symbolic))),p):

Now we recall that we are working on d(mu) modulo p since the only term involving d(mu) has a p coefficient.

> musca3:=subs(p^3=0,collect(expand(p^2*musca2),p))/p^2:

Undoubtably we will work more with these terms later....

> dmuinsertterm:=musca3;

>

>

>

We are now going to substitute into quotientpdiffmodp2 in two stages. First we will substitute in for a and b and the we will substitute in for delta(a) and delta(b).

> quotientpdiffmodp2;

>

> tarts:=subs([delta(a)=ta,delta(b)=tb,a=alphainsertterm,b=muinsertterm],quotientpdiffmodp2);

> temple:=expand(subs([(-8*w)^p=-(8*w)^p],tarts));

We now make some observations. The first is that we should use both delta(alpha) modulo p^2 and delta(alpha) modulo p. The second is that we can analyze this in two parts. Part one would be the ta/8^pw^p. Part two would be the ta*p*tb/8^p2 w^p2. In fact we will now split this quotient into exactly those two expressions.

> partone1:= - ta/(8^p*w^p);

> parttwo1:= - ta*p*tb/((8^p)^2*(w^p)^2);

Then our second stage will be to substitute into these two terms and analyze the result.

> partone2:=subs(ta=dalphainsertterm,partone1):

> parttwo2:=subs([ta=dalphainserttermmodp,tb=dmuinsertterm],parttwo1):

>

>

Eliminating regular terms

Ok. This is the second time through this routine. However, it is necessary to try more exacting techniques to hopefully have less terms at the end.... We also note that we can replace w^p, z^p, x^p, and y^p since x, y, w, and z all occur only to some pth power.

> replacementlist:=[x^p=xpt, y^p=xpt, z^p=zpt, w^p=wpt, Aquirk^p = Aqpt, Bquirk^p=ypt*Baxpt, Cquirk^p=Cqpt,Daquirk^p=Daqpt];

> alttransUtoV:=[xpt=zpt/wpt, ypt = -1/wpt];

> alttransVtoU:=[wpt = -1/ypt, zpt = -xpt/ypt];

> altPv0nameinU:=-Pu0/ypt^(3);

> altPu0nameinV:=subs(replacementlist,expand(Pu0nameinV));

> altPU0unextname:=subs(replacementlist,PU0unextname);

> altPV0unextname:=subs(replacementlist,expand(simplify(PV0unextname,power,symbolic)));

> phaseshift:=[phase = phaseV/wpt^3];

> phasereverse:=[phaseV= - phase/ypt^3];

> phaseVname;

> subs(transVtoU,phaseVname);

> subs(transUtoV,phasename);

Part One Work

From now on we are going to give partone a slightly different name to avoid confusion with previous reductions and their variables....

> parta1:=partone2:

> parta2:=expand(subs(alttransVtoU,subs(replacementlist,parta1))):

> parta3:=collect(subs(Pv0=altPv0nameinU,parta2),ypt):

>

> degree(parta3,ypt);

> midus:=collect(parta3,ypt):

> midus1:=coeff(midus,ypt,3)*ypt^3 + coeff(midus,ypt,2)*ypt^2 + coeff(midus,ypt,1)*ypt + coeff(midus,ypt,0):

>

> parta4:=collect(expand((parta3-midus1)),ypt):

> degree(parta4,ypt);

> parta5:=collect(expand(subs(alttransUtoV,subs(Pu0=altPu0nameinV,parta4))),wpt):

> degree(parta5,wpt);

> laer:=coeff(parta5,wpt,5)*wpt^5 + coeff(parta5,wpt,4)*wpt^4 + coeff(parta5,wpt,3)*wpt^3 + coeff(parta5,wpt,2)*wpt^2 + coeff(parta5,wpt,1)*wpt^1 + coeff(parta5,wpt,0):

>

> laer1:=subs([Aqpt=0,Baxpt=0],laer):

> parta6:=collect(expand(parta5-laer1),wpt):

>

>

> parta7:=collect(expand(subs([delta(3)=(3-3^p)/p,delta(2)=(2-2^p)/p], parta6)),[p]):

>

>

> parta8:=collect(expand(subs(Pv0=altPV0unextname,parta7)),[wpt]):

> degree(parta8,wpt);

>

> lini:=coeff(parta8,wpt,7)*wpt^7 + coeff(parta8,wpt,6)*wpt^6 + coeff(parta8,wpt,5)*wpt^5 + coeff(parta8,wpt,4)*wpt^4 + coeff(parta8,wpt,3)*wpt^3 + coeff(parta8,wpt,2)*wpt^2 + coeff(parta8,wpt,1)*wpt^1 + coeff(parta8,wpt,0):

> lini7:=coeff(parta8,wpt,7)*wpt^7:

> degree(lini7,Aqpt);

> lini6:=coeff(parta8,wpt,6)*wpt^6:

> [degree(lini6,Aqpt),degree(lini6,Baxpt)];

> lini5:=coeff(parta8,wpt,5)*wpt^5:

> [degree(lini5,Aqpt),degree(lini5,Baxpt),coeff(lini5,Baxpt,2)]:

> lini4:=coeff(parta8,wpt,4)*wpt^4:

> [degree(lini4,Aqpt),degree(lini4,Baxpt)];

> degree(coeff(lini4,Aqpt,2),Baxpt);

> lini3temp:=coeff(parta8,wpt,3)*wpt^3:

> [degree(lini3temp,Aqpt),degree(lini3temp,Baxpt)];

> lini3:=collect(expand( lini3temp -(coeff(lini3temp,Aqpt,4)*Aqpt^4 + coeff(lini3temp,Aqpt,3)*Aqpt^3 + coeff(lini3temp,Aqpt,2)*Aqpt^2)),[wpt,Aqpt,Baxpt]):

> degree(coeff(lini3temp,Aqpt,1),Baxpt);

>

>

> lini2temp:=coeff(parta8,wpt,2)*wpt^2:

> [degree(lini2temp,Aqpt),degree(lini2temp,Baxpt)];

> lini2:=collect(expand( lini2temp -(coeff(lini2temp,Aqpt,4)*Aqpt^4 + coeff(lini2temp,Aqpt,3)*Aqpt^3 + coeff(lini2temp,Aqpt,2)*Aqpt^2) + coeff(coeff(lini2temp,Aqpt,1),Baxpt,1)*Aqpt*Baxpt),[wpt,Aqpt,Baxpt]):

>

> lini1temp:=coeff(parta8,wpt,1)*wpt:

> [degree(lini1temp,Aqpt),degree(lini1temp,Baxpt)];

> lini1:=collect(subs([Aqpt=0,Baxpt^2=0],lini1temp),[wpt,Baxpt]):

>

> lini0temp:=coeff(parta8,wpt,0):

> [degree(lini0temp,Aqpt),degree(lini0temp,Baxpt)];

> lini0:=collect(subs([Aqpt=0,Baxpt=0],lini0temp),[wpt,Baxpt]);

>

> parta9:=collect(subs(phasereverse,subs(alttransVtoU, expand(parta8 - lini7 - lini6 - lini5 - lini4 - lini3 - lini2 - lini1 - lini0))),[phase,p,ypt]):

>

>

> parta10:=collect(expand(subs(phase^2=phase*(ypt^2 - xpt^3 -a4^p*xpt - a6^p)/p,parta9)),[ypt,phase]):

> degree(parta10,ypt);

> ceres:=subs([Daqpt=0,Cqpt=0],coeff(parta10,ypt,1)*ypt):

> parta11:=collect(expand(parta10 - ceres),ypt):

> parta12:=collect(expand(subs(phaseshift,subs(alttransUtoV,parta11))),wpt):

> degree(parta12,wpt);

Now we note that Baxpt has a w^p in the denominator, Aqpt has a w^(2*p) in the denominator when written in terms of z and w. So if they are multiplied by a sufficient power of w, then they will be regular.

> laurel5:=collect(coeff(parta12,wpt,5)*wpt^5,[Aqpt,Baxpt]):

> laurel4:=collect(coeff(parta12,wpt,4)*wpt^4,[Aqpt,Baxpt]):

> laurel3:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0], coeff(parta12,wpt,3)*wpt^3),[Aqpt,Baxpt]):

> laurel2temp:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0], coeff(parta12,wpt,2)*wpt^2),[Aqpt,Baxpt]):

> laurel2:=collect(expand(laurel2temp - coeff( coeff(laurel2temp,Aqpt,1)*Aqpt,Baxpt,1)*Baxpt),[wpt,Aqpt,Baxpt]):

> laurel1:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0], coeff(parta12,wpt,1)*wpt),[Aqpt,Baxpt]):

> laurel0:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0, Baxpt=0], coeff(parta12,wpt,0)),[Aqpt,Baxpt]):

> parta13:=collect(collect( expand(parta12 - laurel5 - laurel4 - laurel3 - laurel2 - laurel1 - laurel0 ), wpt),[p,phaseV]):

Now we replace instances of p*phaseV with wpt - zpt^3 - a4^p*zpt*wpt^2 - a6^p * wpt^3.

> zackp1coeff:=subs(p^4=0,collect(expand(p^4*parta13),p))/p^4:

> zackp0coeff:=subs(p^5=0,collect(expand(p^4*parta13),p))/p^4:

> expand(parta13-zackp1coeff - zackp0coeff);

> newzack:=expand(subs(phaseV = (wpt - zpt^3 - a4^p*zpt*wpt^2 - a6^p * wpt^3)/p, zackp1coeff)):

> parta14:=collect(zackp0coeff + newzack, wpt):

Now we remove regular terms on V again

> laur5:=collect(coeff(parta14,wpt,5)*wpt^5,[Aqpt,Baxpt]):

> laur4:=collect(coeff(parta14,wpt,4)*wpt^4,[Aqpt,Baxpt]):

> laur3:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0], coeff(parta14,wpt,3)*wpt^3),[Aqpt,Baxpt]):

> laur2temp:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0], coeff(parta14,wpt,2)*wpt^2),[Aqpt,Baxpt]):

> laur2:=collect(expand(laur2temp - coeff( coeff(laur2temp,Aqpt,1)*Aqpt,Baxpt,1)*Baxpt),[wpt,Aqpt,Baxpt]):

> laur1:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0], coeff(parta14,wpt,1)*wpt),[Aqpt,Baxpt]):

> laur0:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0, Baxpt=0], coeff(parta14,wpt,0)),[Aqpt,Baxpt]):

> parta15:=collect(collect( expand(parta14 - laur5 - laur4 - laur3 - laur2 - laur1 - laur0 ), wpt),[p,phaseV]):

We switch to U and remove any more regular terms on U.

> parta16:=collect(expand(subs(phasereverse,subs(alttransVtoU,parta15))),ypt):

> passe:=subs([Daqpt=0,Cqpt=0],coeff(parta16,ypt,1)*ypt):

> parta17:=collect(expand(parta16-passe),ypt):

We now split parta into coefficients of powers of p. Therefore we are splitting it into two terms since we are working modulo p^2.

> partap1coeff:=subs(p^4=0,collect(expand(p^4*parta17),p))/p^4:

> partap0coeff:=subs(p^5=0,collect(expand(p^4*parta17),p))/p^4:

>

p1 Coefficient analysis

> yack:=[Aqpt=(16*(4*a4^(2*p) + 6*a4^p*xpt^(2)-9*xpt*a6^p)/Delta^p),Baxpt=72*(2*a4^p*xpt-3*a6^p)/Delta^p,Cqpt=(-1/2)*xpt*(3*a6^p+2*a4^p*xpt)/ypt^(2),Daqpt=(1/2)*(-3*a6^p-2*a4^p*xpt+2*ypt^(2))/ypt^(2)];

> nack:=[2^p=2,3^p=2];

> partap1coeff1:=subs(nack,partap1coeff):

> partap1coeff2:=subs(yack,partap1coeff1):

> partap1coeff3:=collect(expand(partap1coeff2),[ypt,xpt]):

Remember that working modulo p, xpt^3 = ypt^2 - a4^p*xpt - a6^p.

> simplifyeq:=[xpt^3=ypt^2 - a4^p*xpt -a6^p, xpt^4=xpt*(ypt^2 - a4^p*xpt -a6^p),xpt^5=xpt^2*(ypt^2 - a4^p*xpt -a6^p), xpt^6=(ypt^2 - a4^p*xpt -a6^p)^2, xpt^7=xpt*(ypt^2 - a4^p*xpt -a6^p)^2, xpt^8=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^2 , xpt^9=(ypt^2 - a4^p*xpt -a6^p)^3, xpt^10=xpt*(ypt^2 - a4^p*xpt -a6^p)^3, xpt^11=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^3, xpt^12=(ypt^2 - a4^p*xpt -a6^p)^4, xpt^13=xpt*(ypt^2 - a4^p*xpt -a6^p)^4, xpt^14=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^4 ];

> partap1coeff4:=collect(expand(subs(simplifyeq,partap1coeff3)),xpt):

> partap1coeff5:=collect(expand(subs(simplifyeq,partap1coeff4)),xpt):

> partap1coeff6:=collect(expand(subs(simplifyeq,partap1coeff5)),[xpt,ypt]):

Now we note that all the terms except those involving xpt^2/ypt are regular and we can remove all of them except for the xpt^2/ypt term.

> partap1coeff7:=collect(expand(coeff(coeff(partap1coeff6,xpt,2)*xpt^2, ypt, -1)/ypt),[p,xpt,ypt,delta(a4),delta(a6)]);

>

p0 Coefficient analysis

> partap0coeff1:=collect(partap0coeff, [phase,delta(a4),delta(a6)]):

> degree(partap0coeff1,delta(a4));

> degree(partap0coeff1,delta(a6));

> degree(partap0coeff1,phase);

> degree(coeff(partap0coeff1,delta(a6),1),delta(a4));

> degree(coeff(partap0coeff1,delta(a6),1),phase);

> degree(coeff(partap0coeff1,delta(a4),1),delta(a6));

> degree(coeff(partap0coeff1,delta(a4),1),phase);

> degree(coeff(partap0coeff1,phase,1),delta(a4));

> degree(coeff(partap0coeff1,phase,1),delta(a6));

>

Part Two Work

From now on we are going to give parttwo a slightly different name to avoid confusion with previous reductions and their variables....

> partb1:=parttwo2:

> partb2:=collect(subs(p^2=0,p^3=0,expand(subs(replacementlist,partb1))),[ypt,wpt]):

> degree(partb2,Pv1);

> partb3:=collect(expand(subs(Pu0=altPu0nameinV,partb2)),Pv0):

> partb4:=subs(alttransUtoV,partb3):

> midway:=collect(partb4,wpt):

> degree(midway,wpt);

> midway1:=coeff(midway,wpt,7)*wpt^7 +coeff(midway,wpt,6)*wpt^6 +coeff(midway,wpt,5)*wpt^5 +coeff(midway,wpt,4)*wpt^4 + coeff(midway,wpt,3)*wpt^3 + coeff(midway,wpt,2)*wpt^2 + coeff(midway,wpt,1)*wpt + coeff(midway,wpt,0):

> midway2:=subs([Aqpt=0,Baxpt=0],midway1):

> partb5:=collect(expand((partb4-midway2)),wpt):

> partb6:=collect(subs(alttransVtoU, subs(Pv0=altPv0nameinU,partb5)),ypt):

> degree(partb6,ypt);

> phoebs:=coeff(partb6,ypt,3)*ypt^3 + coeff(partb6,ypt,1)*ypt:

> partb7:=collect(expand(partb6-phoebs),ypt):

> partb8:=collect(expand(subs([delta(3)=(3-3^p)/p,delta(2)=(2-2^p)/p], partb7)),[Pu0,Aqpt,Baxpt]):

> partb9:=collect(expand(subs(Pu0=altPU0unextname,partb8)),[phase,Aqpt,Baxpt]):

> partb10:=collect(subs(alttransVtoU,expand(subs([phase^2=phase*(ypt^2 - xpt^3 -a4^p*xpt - a6^p)/p,cpext(6*a4*z*w^2 +6*a6*w^3 +6*z^3+2*w)= (6^p*a4^p*zpt*wpt^(2)+6^p*a6^p*wpt^(3)+6^p*zpt^(3)- 6^p*wpt)/p ],partb9))),[ypt,phase]):

> degree(partb10,ypt);

> cert:=subs([Daqpt=0,Cqpt=0],coeff(partb10,ypt,1)*ypt):

> partb11:=collect(expand(partb10 - cert),ypt):

> partb12:=collect(expand(subs(phaseshift,subs(alttransUtoV,partb11))),wpt):

> degree(partb12,Aqpt);

> degree(partb12,wpt);

Now we note that Baxpt has a w^p in the denominator, Aqpt has a w^(2*p) in the denominator when written in terms of z and w. So if they are multiplied by a sufficient power of w, then they will be regular.

> saurel9:=collect(coeff(partb12,wpt,9)*wpt^9,[Aqpt,Baxpt]):

> saurel8:=collect(coeff(partb12,wpt,8)*wpt^8,[Aqpt,Baxpt]):

> saurel7:=collect(coeff(partb12,wpt,7)*wpt^7,[Aqpt,Baxpt]):

> saurel6:=collect(coeff(partb12,wpt,6)*wpt^6,[Aqpt,Baxpt]):

> saurel5:=collect(subs([Aqpt^3=0, Aqpt^4=0], coeff(partb12,wpt,5)*wpt^5), [Aqpt,Baxpt]):

> saurel4temp:=collect(subs([Aqpt^3=0, Aqpt^4=0], coeff(partb12,wpt,4)*wpt^4),[Aqpt,Baxpt]):

> saurel4:=collect(expand(saurel4temp - coeff( coeff(saurel4temp,Aqpt,2)*Aqpt^2,Baxpt,1)*Baxpt),[wpt,Aqpt,Baxpt]):

> saurel3temp:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0], coeff(partb12,wpt,3)*wpt^3),[Aqpt,Baxpt]):

> saurel3:=collect(expand(saurel3temp - coeff( coeff(saurel3temp,Aqpt,1)*Aqpt,Baxpt,2)*Baxpt^2),[wpt,Aqpt,Baxpt]):

> saurel2temp:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0], coeff(partb12,wpt,2)*wpt^2),[Aqpt,Baxpt]):

> saurel2:=collect(expand(saurel2temp - coeff( coeff(saurel2temp,Aqpt,1)*Aqpt,Baxpt,1)*Baxpt-coeff( coeff(saurel2temp,Aqpt,1)*Aqpt,Baxpt,2)*Baxpt^2),[wpt,Aqpt,Baxpt]):

> saurel1:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0], coeff(partb12,wpt,1)*wpt),[Aqpt,Baxpt]):

> saurel0:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0, Baxpt=0], coeff(partb12,wpt,0)),[Aqpt,Baxpt]):

> partb13:=collect(collect( expand(partb12 - saurel9-saurel8- saurel7 - saurel6 - saurel5 - saurel4 - saurel3 - saurel2 - saurel1 - saurel0 ), wpt),[p,phaseV]):

Now we replace instances of p*phaseV with wpt - zpt^3 - a4^p*zpt*wpt^2 - a6^p * wpt^3.

> tackp1coeff:=subs(p^4=0,collect(expand(p^4*partb13),p))/p^4:

> tackp0coeff:=subs(p^5=0,collect(expand(p^4*partb13),p))/p^4:

> expand(partb13-tackp1coeff - tackp0coeff);

> newtack:=expand(subs(phaseV = (wpt - zpt^3 - a4^p*zpt*wpt^2 - a6^p * wpt^3)/p, tackp1coeff)):

> partb14:=collect(tackp0coeff + newtack, wpt):

> degree(partb14,wpt);

>

Now we remove regular terms on V again

> saur6:=collect(coeff(partb14,wpt,6)*wpt^6,[Aqpt,Baxpt]):

> saur5:=collect(subs([Aqpt^3=0, Aqpt^4=0], coeff(partb14,wpt,5)*wpt^5), [Aqpt,Baxpt]):

> saur4temp:=collect(subs([Aqpt^3=0, Aqpt^4=0], coeff(partb14,wpt,4)*wpt^4),[Aqpt,Baxpt]):

> saur4:=collect(expand(saur4temp - coeff( coeff(saur4temp,Aqpt,2)*Aqpt^2,Baxpt,1)*Baxpt),[wpt,Aqpt,Baxpt]):

> saur3temp:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0], coeff(partb14,wpt,3)*wpt^3),[Aqpt,Baxpt]):

> saur3:=collect(expand(saur3temp - coeff( coeff(saur3temp,Aqpt,1)*Aqpt,Baxpt,2)*Baxpt^2),[wpt,Aqpt,Baxpt]):

> saur2temp:=collect(subs([Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0], coeff(partb14,wpt,2)*wpt^2),[Aqpt,Baxpt]):

> saur2:=collect(expand(saur2temp-coeff(coeff(saur2temp,Aqpt,1)*Aqpt,Baxpt,1)*Baxpt - coeff( coeff(saur2temp,Aqpt,1)*Aqpt,Baxpt,2)*Baxpt^2),[wpt,Aqpt,Baxpt]):

> saur1:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0], coeff(partb14,wpt,1)*wpt),[Aqpt,Baxpt]):

> saur0:=collect(subs([Aqpt=0, Aqpt^2=0, Aqpt^3=0, Aqpt^4=0, Aqpt^5=0, Baxpt^2=0, Baxpt=0], coeff(parta14,wpt,0)),[Aqpt,Baxpt]):

> partb15:=collect(collect( expand(partb14 -saur6 - saur5 - saur4 - saur3 - saur2 - saur1 - saur0 ), wpt),[p,phaseV]):

We switch to U and remove any more regular terms on U.

> partb16:=collect(expand(subs(phasereverse,subs(alttransVtoU,partb15))),ypt):

> degree(partb16,ypt);

> sasse:=subs([Daqpt=0,Cqpt=0],coeff(partb16,ypt,1)*ypt):

> partb17:=collect(expand(partb16-sasse),ypt):

> collect(expand(8^(2*p)*partb17),ypt):

We now split parta into coefficients of powers of p. Therefore we are splitting it into two terms since we are working modulo p^2.

> partbp1coeff:=subs(p^4=0,collect(expand(p^4*partb17),p))/p^4:

> partbp0coeff:=subs(p^5=0,collect(expand(p^4*partb17),p))/p^4:

>

p1 Coefficient Analysis

>

> yack:=[Aqpt=(16*(4*a4^(2*p) + 6*a4^p*xpt^(2)-9*xpt*a6^p)/Delta^p),Baxpt=72*(2*a4^p*xpt-3*a6^p)/Delta^p,Cqpt=(-1/2)*xpt*(3*a6^p+2*a4^p*xpt)/ypt^(2),Daqpt=(1/2)*(-3*a6^p-2*a4^p*xpt+2*ypt^(2))/ypt^(2)];

> nack:=[2^p=2,3^p=2,8^p=8];

> partbp1coeff1:=subs(nack,partbp1coeff):

> partbp1coeff2:=subs(yack,partbp1coeff1):

> partbp1coeff3:=collect(expand(partbp1coeff2),[ypt,xpt]):

Remember that working modulo p, xpt^3 = ypt^2 - a4^p*xpt - a6^p.

> simplifyeq:=[xpt^3=ypt^2 - a4^p*xpt -a6^p, xpt^4=xpt*(ypt^2 - a4^p*xpt -a6^p),xpt^5=xpt^2*(ypt^2 - a4^p*xpt -a6^p), xpt^6=(ypt^2 - a4^p*xpt -a6^p)^2, xpt^7=xpt*(ypt^2 - a4^p*xpt -a6^p)^2, xpt^8=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^2 , xpt^9=(ypt^2 - a4^p*xpt -a6^p)^3, xpt^10=xpt*(ypt^2 - a4^p*xpt -a6^p)^3, xpt^11=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^3, xpt^12=(ypt^2 - a4^p*xpt -a6^p)^4, xpt^13=xpt*(ypt^2 - a4^p*xpt -a6^p)^4, xpt^14=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^4, xpt^15=(ypt^2 - a4^p*xpt -a6^p)^5, xpt^16=xpt*(ypt^2 - a4^p*xpt -a6^p)^5, xpt^17=xpt^2*(ypt^2 - a4^p*xpt -a6^p)^5, xpt^18=(ypt^2 - a4^p*xpt -a6^p)^6, xpt^19=xpt*(ypt^2 - a4^p*xpt -a6^p)^6]:

> partbp1coeff4:=collect(expand(subs(simplifyeq,partbp1coeff3)),xpt):

> partbp1coeff5:=collect(expand(subs(simplifyeq,partbp1coeff4)),xpt):

> partbp1coeff6:=collect(expand(subs(simplifyeq,partbp1coeff5)),[xpt,ypt]):

Now we note that all the terms except those involving xpt^2/ypt are regular and we can remove all of them except for the xpt^2/ypt term.

> partbp1coeff7:=collect(expand(coeff(coeff(partbp1coeff6,xpt,2)*xpt^2, ypt, -1)/ypt),[p,xpt,ypt,delta(a4),delta(a6)]):

> partap1coeff7;

>

p0 Coefficient Analysis

> partbp0coeff1:=collect(partbp0coeff, [phase,delta(a4),delta(a6)]):

> degree(partbp0coeff1,delta(a4));

> degree(partbp0coeff1,delta(a6));

> degree(partbp0coeff1,phase);

> degree(coeff(partbp0coeff1,delta(a6),1),delta(a4));

> degree(coeff(partbp0coeff1,delta(a6),1),phase);

> degree(coeff(partbp0coeff1,delta(a4),1),delta(a6));

> degree(coeff(partbp0coeff1,delta(a4),1),phase);

> degree(coeff(partbp0coeff1,phase,1),delta(a4));

> degree(coeff(partbp0coeff1,phase,1),delta(a6));

>

>

>

>

>

Combining like sections

In this section we take various types of terms contributiting based on the degree in delta(a4) and delta(a6), and work on those. We must also not forget to compensate for the fact that part b was computed with a factor 1/8^2p left out and part a was computed with a factor of 1/8^p. In fact in this section we will factor a 1/8^2p from both terms.

> degree2term:=partap1coeff7 + partbp1coeff7:

> degree2term1:=collect(expand(degree2term),[ypt,xpt,delta(a4),delta(a6)]);

> degree1a4term:=coeff(partap0coeff1,delta(a4),1) + coeff(partbp0coeff1,delta(a4),1):

> degree1a4term1:=collect(expand(degree1a4term),[ypt,xpt,Baxpt,Cqpt,Daqpt,Aqpt]):

> degree1a6term:=coeff(partap0coeff1,delta(a6),1) + coeff(partbp0coeff1,delta(a6),1):

> degree1a6term1:=collect(expand(degree1a6term),[ypt,xpt,Baxpt,Cqpt,Daqpt,Aqpt]):

> degree0term:=coeff(partap0coeff1,phase,1) + coeff(partbp0coeff1,phase,1):

> degree0term1:=collect(expand(degree0term),[ypt,xpt,Baxpt,Cqpt,Daqpt,Aqpt]):

>

> degree(degree1a4term1,Aqpt);

> degree(degree1a4term1,Baxpt);

> degree(degree1a4term1,Cqpt);

> degree(degree1a4term1,Daqpt);

>

> degree(degree1a6term1,Aqpt);

> degree(degree1a6term1,Baxpt);

> degree(degree1a6term1,Cqpt);

> degree(degree1a6term1,Daqpt);

>

>

>

Security Section

In this section we check to make sure that we get the correct result modulo p.

> yack;

> nack;

> axfour1:=collect(expand(subs(yack,degree1a4term1)),[xpt,ypt]):

> axfour2:=subs(8^p=8,subs(nack,axfour1)):

> simplifyeq;

> axfour3:=collect(expand(subs(simplifyeq,axfour2)),[xpt,ypt]):

> axfour4:=collect(expand(subs(simplifyeq,axfour3)),[xpt,ypt]):

> axfour5:=collect(expand(subs(simplifyeq,axfour4)),[xpt,ypt]):

> axfour6:=expand(coeff(coeff(axfour5,xpt,2)*xpt^2, ypt, -1)/ypt);

yuck. ok will have to check this. now for the a6 term..

> axsix1:=collect(expand(subs(yack,degree1a6term1)),[xpt,ypt]):

> axsix2:=subs(8^p=8,subs(nack,axsix1)):

> axsix3:=collect(expand(subs(simplifyeq,axsix2)),[xpt,ypt]):

> axsix4:=collect(expand(subs(simplifyeq,axsix3)),[xpt,ypt]):

> axsix5:=collect(expand(subs(simplifyeq,axsix4)),[xpt,ypt]):

> axsix6:=expand(coeff(coeff(axsix5,xpt,2)*xpt^2, ypt, -1)/ypt);

> Deltapname:=-64*(4*a4^(3*p) + 27*a6^(2*p));

> axfour7:=(4)*factor(normal(expand(subs(Delta^p = Deltapname,axfour6))));

> axsix7:=(4)*factor(normal(expand(subs(Delta^p = Deltapname,axsix6))));

>

>

>

> with(numtheory):

Warning, new definition for order

> divisors(315/9);

> hagis:=normal(subs(transUtoV,Aquirkname));

> banock:=normal(subs(transUtoV,Bquirkname/y));

> Cquirkname;

> Daquirkname;

> g;

> normal(expand(hagis^4));

>

> g;

> expand(Cquirkname^2 + g*a4^2*z);

>