countingMaps-nonoriented3.html

The case of maps via our main approach (Thm 3.6)

> # This is the explicit (non-polynomial) recurrence to compute the numbers of maps by edges and genus
# and with a weight u/z per vertices/faces, obtained from the non-bipartite tau-function.
# This is Thm 3.6 in the paper. It computes the same value as the program HngW above
HHng:= proc(N,G)
local G0,G1, G2, G3;
option remember;

# Initial conditions
if N<0 or G<0 or 2*G>N then return 0:
elif G=0   and N=0 then return 0*u^2;
elif G=0   and N=1 then return u*z*(u+z);
elif G=0   and N=2 then return u*z*(u+2*z)*(2*u+z);
elif G=1/2 and N=1 then return u*z;
elif G=1/2 and N=2 then return 5*u*z*(z+u);
elif G=1   and N=2 then return 5*u*z;
# main case
else
1/(N+1)/(N) * (
2*N*(2*N-1)*( (z+4*u)*HHng(N-1,G) -2*HHng(N-1,G-1/2) )
+4*N*(2*N-3)*( 3*z*u*HHng(N-2,G) +(2*N-1)*(N-1)*HHng(N-2,G-1))
+6*N*add(add( (2*n1-1)*(2*(N-n1)-1)*HHng(N-n1-1,G-G1/2)*HHng(n1-1,G1/2),G1=0..2*G),n1=0..N)
-add(add(add(add(
      binomial(p,2+G1-G0)*(2)^(2+G1-G0)*(1+(-1)^(G0-G1))/2
      *coeff(coeff(HHngexclude(n1,G0/2,N,G),z,n1+2-G0-p),u,p)*z^(n1+2-G0-p)*u^(n1-G1+p-n1-2+G0)
      *(-(N-n1+1)/2*HHng((N-n1),G-G1/2)
        +(2*(N-n1)-1)*( (z+4*u)*HHng((N-n1)-1,(G-G1/2)) - 2* HHng((N-n1)-1,G-G1/2-1/2) )
        +(2*(N-n1)-1)*(2*(N-n1)-2)*(2*(N-n1)-3)*HHng((N-n1)-2,G-G1/2-1)
        +3*z*u*2*(2*(N-n1)-3)*HHng((N-n1)-2,(G-G1/2))
        +deltas(n1,G1/2,N,G,G0/2)
        +3*add(add( (2*n3-1)*(2*((N-n1)-n3)-1)*HHng(n3-1,G3/2)*HHng(((N-n1)-n3)-1,G-G1/2-G3/2),n3=0..N-n1), G3=0..2*(G-G1/2)) )
  ,p=1..n1+2-G0-1),G0=0..G1),G1=0..2*G),n1=1..N)) :
# inverting the differntial operator in the LHS:
return factor(add(coeff(%,u,k)*u^k /(1+k*(k-1)*3/N/(N+1)),k=0..degree(%,u)));
fi:
end:

# Contribution of Kronecker deltas in the theorem
deltas:=proc(n1,G1,N,G,G0)
if n1=N and G0<>G then
  if G1=G then return 3*(u)^2/2; fi;
  if G1=G-1/2 then return -3*(u)/2; fi;
elif n1=N-1 then
  if G1=G then return u*z*(4*u+z);
  elif G1=G-1/2 then return -2*u*z;
  fi;
elif n1=N-2 then
  if G1=G then return 3*u*z*u*z;
  elif G1=G-1 then return 3*u*z*2:
  fi:
fi:
return 0;
end:

# The term of index (N,G) appears in the RHS of the recurrence but is multiplied by 0.
# In order to prevent Maple from trying to evaluate it (before multiplication) we use HHngexclude instead:
HHngexclude:=proc(N,G,Nexclude, Gexclude)
if N=Nexclude and G=Gexclude then return 0;
else return HHng(N,G); fi;
end:

> # Note: it gives the same result as the previous one!
HHng(8,5/2);
HngW(8,5/2);

(2.2.1)