The case of maps: derivation and properties of the ODE (Prop 3.4, Thm 3.7, Thm 1.2, Cor 3.8) 

> # Proposition 3.4 (proved in the paper)
# computes recursively theta F_lambda as a differential polynomial in Theta(t).
# here L = [i,3^n3,2^n2,1^n1] and i<=7
# Computes \theta F_\lambda as a differential operator in \Theta(t,u,z)
Fth:=proc(L)
option remember;
local i,j,Lcut, Lcutj, res,n;
if nops(L)=0 then
 return Theta(t);
else
 i:=max(L)-2;
 Lcut:=subsop(ListTools:-Search(i+2, L)=NULL, L);
 for j from 1 to 3 do n[j]:=   ListTools:-Occurrences(j,Lcut); od;
 res:=
   2*
add(add(add(add(
     a*(i-a)*binomial(n[1],l1)*binomial(n[2],l2)*binomial(n[3],l3)
     *
Fth([a,seq(3,i=1..l3),seq(2,i=1..l2),seq(1,i=1..l1)])
     *
Fth([i-a,seq(3,i=1..n[3]-l3),seq(2,i=1..n[2]-l2),seq(1,i=1..n[1]-l1)])
    
,l1=0..n[1]),l2=0..n[2]),l3=0..n[3]),a=1..i-1)
  +2*
add(a*(i-a)*Fth([a,i-a,op(Lcut)]),a=1..i-1)
  +t*diff(
Fth(Lcut),t)-(n[1]+2*n[2]+3*n[3])*Fth(Lcut)
  -z *
add(a*Fth([a,op(Lcut)]),a=1..i);
  # this loop implements the sum over j=1..3 in the paper
  for j from 1 to 3 do
    if n[j]*(i+j)<>0 then
    # Lcut with one occurrence of j removed
     Lcutj:=subsop(ListTools:-Search(j, Lcut)=NULL, Lcut):
     res:= res+n[j]*(i+j)*
Fth([i+j,op(Lcutj)]):
    fi;
  od:
  # terms with Kronecker deltas
  if i>0 then
   res:=res+(2*u+i+1)*i*
Fth([i,op(Lcut)])
  fi;
  if n[2]=0 and n[3]=0 then
   if i=-1 and n[1]=1     then res:=res+1*u/2;
   elif i=-1 and  n[1]=0 then res:=res+z*u/2;
   elif i=0 and n[1]=0 then res:=res+(u+1)*u/2;
   fi:
  fi:
 return collect(simplify(res*t^2/(i+2)),diff);
fi;
end:

 

> #Example of result of computation
Fth([1]);
Fth([4]);
 

 

`+`(`*`(`^`(t, 3), `*`(diff(Theta(t), t))), `*`(`/`(1, 2), `*`(u, `*`(z, `*`(`^`(t, 2))))))
`+`(`*`(`/`(1, 2), `*`(`^`(t, 8), `*`(`^`(diff(Theta(t), t), 2)))), `*`(`/`(1, 8), `*`(`^`(t, 3), `*`(`+`(`*`(4, `*`(`^`(t, 4), `*`(u, `*`(z)))), `*`(8, `*`(`^`(t, 4))), `*`(4, `*`(`^`(t, 2), `*`(u)))...
`+`(`*`(`/`(1, 2), `*`(`^`(t, 8), `*`(`^`(diff(Theta(t), t), 2)))), `*`(`/`(1, 8), `*`(`^`(t, 3), `*`(`+`(`*`(4, `*`(`^`(t, 4), `*`(u, `*`(z)))), `*`(8, `*`(`^`(t, 4))), `*`(4, `*`(`^`(t, 2), `*`(u)))...
(3.1.1)
 

> # ODE of Theorem 3.7 -- automated computation via Prop 3.4
KP1:= - 4*Fth([3,1]) + 4*Fth([2,2])
       + 4/3*(6*Fth([1,1])^2+Fth([1,1,1,1])):

KP2:= - 4*Fth([4,1]) + 4*Fth([3,2])
       + 8/3*(6*Fth([2,1])*Fth([1,1])+Fth([2,1,1,1])):
KP3:= - 6*Fth([5,1]) + 4*Fth([4,2]) + 2*Fth([3,3])
       + 8/3*(6*Fth([3,1])*Fth([1,1])+Fth([3,1,1,1]))
       + 4*(4*Fth([2,1])^2+2*Fth([2,2])*Fth([1,1])+Fth([2,2,1,1]))
      + 4/45*(60*Fth([1,1])^3+30*Fth([1,1,1,1])*Fth([1,1])
               +Fth([1,1,1,1,1,1])):

t^6*diff(KP1,t)^2 -KP2^2 + KP1*
( KP3-1/2*KP2 -t^6*diff(KP1,t,t) -2*t^5*diff(KP1,t) -2*t^6*diff(Theta(t),t,t)*KP1 -4*t^5*diff(Theta(t),t)*KP1 -t^4*(u*z-4)*KP1 -t^2*(3*u+1-z)*KP1
):

bigODEmaps:=factor(%/t^9):

# this ODE has many terms !
nops(bigODEmaps);
 

689 (3.1.2)
 

> # Check of Thm 1.2
# To check the precise form of Thm 1.2 we need to examine the top-degree part of the ODE
# We scale the variables t,u,z by factors alpha, beta so that the exponents of alpha, beta
# mark the values of n and of 2g in the coefficients considered.
# This relies on Euler's formula 2g = 2+e-v-f.

ODEscaled:=
subs(u=u*beta,z=z*beta,t=t/alpha/beta,subs(subs(seq(((D@@i)(Theta))(t)=Theta[i]*alpha^i*beta^(2+i),i=1..20),convert(bigODEmaps,D))))*135:

# We check that there is a term realizing the highest power in BOTH alpha and beta
# This proves that we get a recurrence of the form
# H[n,g] = (expression involving only terms with g'<=g, n'<=n)
# which is what Thm 1.2 says
degree(ODEscaled,alpha),degree(ODEscaled,beta);
factor(coeff(coeff(ODEscaled,alpha,1),beta,5));

# The more precise form given in the proof of thm 1.2 (explicit expression of all terms involving the highest total size)
# is equivalent to knowing the highest alpha power:
collect(coeff(ODEscaled,alpha,1),beta);

 

 

 

1, 5
`+`(`-`(`*`(`+`(`*`(t, `*`(Theta[2])), `*`(3, `*`(Theta[1]))), `*`(`+`(`*`(`^`(t, 2), `*`(Theta[2])), `*`(3, `*`(t, `*`(Theta[1]))), `*`(42, `*`(`^`(u, 2))))))))
`+`(`*`(`+`(`-`(`*`(`^`(t, 3), `*`(`^`(Theta[2], 2)))), `-`(`*`(6, `*`(`^`(t, 2), `*`(Theta[1], `*`(Theta[2]))))), `-`(`*`(42, `*`(t, `*`(`^`(u, 2), `*`(Theta[2]))))), `-`(`*`(9, `*`(t, `*`(`^`(Theta[... (3.1.3)
 

> # Proof of Cor 3.8 (Ledoux's recursion, ODE form)
# We extract the one-face contribution.
subs(Theta(t)=z*f(t)+z^2*g(z,t),bigODEmaps):
factor(series(%,z=0,2)):
coeff(%,z,1)*(-1/u/(u-1)*45/14):
map(factor,collect(%,diff));


 

`+`(`*`(4, `*`(diff(diff(diff(diff(diff(diff(f(t), t), t), t), t), t), t), `*`(`^`(t, 13)))), `*`(120, `*`(`^`(t, 12), `*`(diff(diff(diff(diff(diff(f(t), t), t), t), t), t)))), `*`(5, `*`(`^`(t, 7), `...
`+`(`*`(4, `*`(diff(diff(diff(diff(diff(diff(f(t), t), t), t), t), t), t), `*`(`^`(t, 13)))), `*`(120, `*`(`^`(t, 12), `*`(diff(diff(diff(diff(diff(f(t), t), t), t), t), t)))), `*`(5, `*`(`^`(t, 7), `...
`+`(`*`(4, `*`(diff(diff(diff(diff(diff(diff(f(t), t), t), t), t), t), t), `*`(`^`(t, 13)))), `*`(120, `*`(`^`(t, 12), `*`(diff(diff(diff(diff(diff(f(t), t), t), t), t), t)))), `*`(5, `*`(`^`(t, 7), `...
(3.1.4)