..nodoctest

Denominators

x.__init__(...) initializes x; see help(type(x)) for signature

recip.denominators.bruinier_yang_applies(K, proof=True, reason=False)

Return True if and only if the Bruinier-Yang results are proven for the input quartic CM field in Yang’s preprint.

With proof=False returns True only if the Bruinier-Yang results are formulated and conjectured for the input quartic CM field as in Yang’s preprint.

With reason=True also return a string with an explanation.

EXAMPLES:

sage: from recip import *
sage: bruinier_yang_applies(CM_Field([5,5,5]))
True

recip.denominators.bruinier_yang_bound(K, check=True, proof=True)

Returns the Bruinier-Yang bounds. Assumes that the input satisfies the hypotheses of the Bruinier-Yang conjecture. Bounds are proven only if bruinier_yang_applies returns True.

EXAMPLES:

sage: from recip import *
sage: bruinier_yang_bound(CM_Field([5,5,5]))
1

Let’s check for a few fields how sharp these denominators are. First, all elements of van Wamelen’s table where the conjecture has been proven.:

sage: lst = wamelen_dab_list()
sage: lst = [(DAB, CM_Field(DAB)) for DAB in lst]
sage: lst = [(DAB, K, bruinier_yang_applies(K, proof=True)) for (DAB, K) in lst if bruinier_yang_applies(K, proof=False)]
sage: len(lst)
6
sage: [(DAB, b) for (DAB, K, b) in lst]
[([5, 5, 5], True),
 ([13, 13, 13], True),
 ([29, 29, 29], True),
 ([37, 37, 333], True),
 ([53, 53, 53], True),
 ([61, 61, 549], True)]
sage: lst = [(K, denominator_bound(K, bound='by'), class_polynomials(K)) for (DAB, K, b) in lst if b] # long time
sage: len(lst) # long time
6
sage: [(K.DAB(), den.factor(), lcm([c.denominator() for c in flatten([list(p) for p in pols])]).factor()) for (K,den,pols) in lst] # long time
[([5, 5, 5], 2^14, 1), ([13, 13, 13], 2^14, 1), ([29, 29, 29], 2^14 * 5^4, 1), ([37, 37, 333], 2^14 * 3^4 * 11^4, 11^2), ([53, 53, 53], 2^14 * 17^4 * 29^4, 17^2 * 29^4), ([61, 61, 549], 2^14 * 3^8 * 5^4 * 41^4, 3^3 * 41^4)]

So we see that den contains too many 2’s, 5’s, 11’s in the first cases, but den is optimal wrt 29 and 41 in the last two cases. The 2, 3, 5, 11, 17 could be cancellation, but is still a bit fishy. Anyway, here is the list of 6 triples of class polynomials that we just proved:

sage: [(K.DAB(), pols) for (K,den,pols) in lst] # long time
[([5, 5, 5], [x, 0, 0]), ([13, 13, 13], [x + 7840, 102400, -204800000]), ([29, 29, 29], [x + 2589408, 131383296, -60466176000000]), ([37, 37, 333], [x + 505440, -810393600/121, 1642291200000]), ([53, 53, 53], [x + 16982274516480/14297, 30036725005359513600/204404209, -16680511371779820748800000/707281]), ([61, 61, 549], [x - 88833024/1681, -14055214415872/76295547, 9663676416000000/2825761])]

Here is the final curve in the author’s preprint with Florian Bouyer:

sage: K = CM_Field([389, 37, 245])
sage: class_polynomials(K, verbose=True)
starting with precision 50
output has 120.772235075431 too few bits of precision
increasing precision to 175
output has 4.22059275336305 more bits of precision than needed
Denominator: 11^2 * 19^6 * 29^4 out of 2^14 * 5^4 * 11^8 * 19^8 * 29^4
[x^2 - 502951680/303601*x - 215457915617280/5768419,
 102098407935836160/11153001631321*x + 1497833452550013478502400/4026233588906881,
 2213545771008000000/92173567201*x - 36646804488714190848000000/33274657759561]

recip.denominators.calI(delta, f_u=None, t_w=None, l=None, d_u=None, n_w=None, t_u=None, safe=True)

Returns calI(n, f_u) as in Theorem 2.1 of [LV].

recip.denominators.calIp(C, p, a1, a0, safe=True)

Returns calI_C^{(p)}(a1, a2) as in [LV, Thm 2.1]

With safe=True, an additional redundant slow step is done to verify the result.

recip.denominators.calIp_enumerate(C, p, a1, a0)

Returns calI_C^{(p)}(a1, a2) as in [LV, Thm 2.1], simple but slow implementation.

recip.denominators.calIp_fast(C, p, a1, a0)

Returns calI_C^{(p)}(a1, a2) as in [LV, Thm 2.1], complicated but fast implementation.

TESTS:

sage: from recip import *
sage: S = [(C, p, a1, a0) for C in srange(-1, 5) for p in [2,3,5] for a0 in srange(15) for a1 in srange(15)]
sage: [(C, p, a1, a0) for (C, p, a1, a0) in S if calIp_enumerate(C, p, a1, a0) != calIp_fast(C, p, a1, a0)]
[]

recip.denominators.calJ_bound(n, delta, Dtilde, d_u, f_u, d_x, t, l, D, safe=True, bound_calJ=1)

Returns the upper bound on calJ of [LV] given in Theorem 2.4 of [LV].

If safe is True, then also checks whether Conjecture 2.6 holds in this case and raises an error if it does not.

recip.denominators.calJ_bound_thm24(n, delta, Dtilde, d_u, f_u, d_x, t, l, D, safe=True)

Returns the upper bound on calJ from Theorem 2.4.

recip.denominators.calJ_conjecture(d1, d2, t, l)

Return the right hand side of Conjecture 2.6, or None if the hypothesis of the conjecture is not satisfied.

Also returns None if one of the Legendre symbols is ambiguous (i.e., if l>2 and 2 divides m).

Since this is a conjecture, it is only used as a check: counterexamples to the conjecture will be reported when safe=True in lauter_viray_bound, but otherwise nothing is done with this conjecture. If counterexamples are found, it is probably a good idea to check the code of this function, as not much care was given to it (it is only used as a redundant check).

recip.denominators.conductor(d)

Returns the largest integer f such that d/f^2 is a discriminant.

recip.denominators.count_ideals(disc, norm, safe=True)

Returns the number of invertible (equivalently: proper) ideals of the given norm in the quadratic order of the given discriminant.

If safe=True, then calculates it in a few (possibly slow) ways and checks whether the outputs agree.

recip.denominators.count_ideals1(disc, norm)

Returns the number of invertible ideals of the given norm inside the quadratic order of the given discriminant.

Does this quickly by checking some congruences if norm and the conductor of the order are coprime. Otherwise, falls back to a slower algorithm: count_ideals3().

EXAMPLE:

sage: from recip import *
sage: count_ideals1(-183, 3)
1
sage: count_ideals1(-183, 3*11*13)
4
sage: count_ideals1(-183, 7)
0

recip.denominators.count_ideals2(disc, norm)

Returns the number of invertible ideals of the given norm inside the quadratic order of the given discriminant.

This is a slow implementation, which counts binary quadratic forms. It is used only as a redundant safety check in count_ideals().

EXAMPLES:

Here is an example of an ideal of norm 3:

sage: QuadraticField(-183,'a').ideal(3).factor()[0][0].basis()
[3, 1/2*a + 3/2]

Let n=3, then this ideal is n*(tau*ZZ+ZZ), where tau = (a+3)/6 is a root of the primitive polynomial 3*x^2-3*x+16. So in the code of this function, this is given by A=3, B=-3, C=16. This is not in the form we are listing, but by changing tau by -1, we find tau=(a-3)/6, so B=3, with the same A and C. Also N=n/A=1. This is the only ideal of norm 3, since 3 is ramified. And indeed, we get:

sage: from recip import *
sage: count_ideals2(-183, 3)
1

recip.denominators.count_ideals3(disc, norm)

Returns the number of invertible ideals of the given norm inside the quadratic order of the given discriminant.

This is a slow implementation, which counts binary quadratic forms. It is used as a fall-back in difficult cases in count_ideals1().

EXAMPLES:

sage: from recip import *
sage: count_ideals3(-400*27, 5)
0
sage: count_ideals3(-400*27, 7)
2
sage: count_ideals3(-400*27, 7*11)
0
sage: count_ideals3(-400*27, 16)
6
sage: count_ideals3(-400*27, 32)
0
sage: count_ideals2(-400*27, 32)
0

recip.denominators.denominator_bound(K, c=16384, k=2, d=None, Phi=None, bound='default', check=True, safe=True)

If Phi is None, returns a positive integer \(D\) such that \(D N(f h_{10}^{-k}(Z))\) is integral whenever \(Z\) has CM by \(O_K\), \(c*f\) is a modular form of weight \(k\) and level \(1\) with integral Fourier coefficients, and \(d\) (if K/QQ is Galois) and \(2d\) (if K/QQ is non-Galois) is the degree of the algebraic number \(f h_{10}^{-k}(Z)\).

For the choice of invariants in the author’s thesis, take k=2 and c=2^14. These are also the defaults.

If Phi is a CM-type, returns a number \(D\) in the real quadratic subfield of the reflex field of Phi such that that \(D f h_{10}^{-k}(Z)\) is integral whenever \(Z\) has CM by \(O_K\) of type Phi and \(c*f\) is a modular form of weight \(k\) and level \(1\) with integral Fourier coefficients.

EXAMPLE:

The following example shows how horribly unusable the Goren-Lauter bounds are in practice. The additional number of digits (about 2000) needed to compute the class polynomial with certainty using the algorithm of the author’s thesis is huge even though it is also easy to see that actually the class polynomials are all equal to X, so the algorithm as given is not practical. The importance of the algorithm is in proving the asymptotic running time:

sage: from recip import *
sage: gl = denominator_bound(CM_Field([5,5,5]), bound='gl')
sage: gl.factor()
2^14 * 5^36 * 19^20 * 29^18 * 59^14 * 79^14 * 89^14 * 109^12 * 139^12 * 149^12 * 179^12 * 199^12 * 229^12 * 239^12 * 269^10 * 349^10 * 359^10 * 379^10 * 389^10 * 409^10 * 419^10 * 439^10 * 449^10 * 479^10 * 499^10 * 509^10 * 569^10 * 599^10 * 619^10 * 659^10 * 709^10 * 719^10 * 739^10 * 769^10 * 809^10 * 829^10 * 839^10 * 859^10 * 919^10 * 929^10 * 1009^8 * 1019^8 * 1039^8 * 1049^8 * 1069^8 * 1109^8 * 1129^8 * 1229^8 * 1249^8 * 1259^8 * 1279^8 * 1289^8 * 1319^8 * 1399^8 * 1409^8 * 1429^8 * 1439^8 * 1459^8 * 1489^8 * 1499^8 * 1549^8 * 1559^8 * 1579^8 * 1609^8 * 1619^8 * 1669^8 * 1699^8 * 1709^8 * 1759^8 * 1789^8 * 1879^8 * 1889^8 * 1949^8 * 1979^8 * 1999^8
sage: (log(gl)/log(10)).n()
1947.25745024934
sage: (log(gl)/log(2)).n()
6468.64923196203

Fortunately the Bruinier-Yang bounds apply:

sage: denominator_bound(CM_Field([5,5,5]), bound='by').factor()
2^14

Next, we try a different field:

sage: K = CM_Field((x^2+2)^2-2,'a')
sage: bruinier_yang_applies(K)
False
sage: gl = denominator_bound(K, bound='gl')
sage: (log(gl)/log(2)).n()
313.633570483095
sage: Z = K.one_period_matrix(); Z
Period Matrix
[ 0.?e-15 + 1.08239220029240?*I 0.414213562373095? + 0.?e-14*I]
[             0.41421356237310?            1.53073372946036?*I]
sage: h = igusa_modular_forms()
sage: v = [f(Z, prec=100, interval=True) for f in h]; v
[5.14511662180777441738853320? + 0.?e-28*I, 1.5657740361761366552190052? + 0.?e-27*I, -0.00110508779417351004090108656? + 0.?e-30*I, 0.0201781755750066641900463261? + 0.?e-29*I]
sage: w = igusa_modular_forms_to_absolute(v); w
[-7290.0000000000000000000000? + 0.?e-23*I, 437400.00000000000000000000? + 0.?e-21*I, 2.9524500000000000000000000?e9 + 0.?e-17*I]
sage: [(log((gl*y).real().absolute_diameter())/log(2)).n() for y in w]
[240.728133100306, 246.473959365695, 259.180686194823]

These numbers are very recognizable, but we need 346 more bits of output precision to prove they are correct.:

sage: v = [f(Z, prec=450, interval=True) for f in h]
sage: w = igusa_modular_forms_to_absolute(v)
sage: x = [gl*y.real() for y in w]
sage: [(log(y.absolute_diameter())/log(2)).n() for y in x]
[-107.565143763258, -101.889231246203, -89.1476167961862]

So now we have more than enough precision and can simply round:

sage: z = [y.real().unique_integer() for y in x]
sage: invs = [y/gl for y in z]; invs
[-7290, 437400, 2952450000]

These numbers are proven correct, so let’s prove the corresponding entry of van Wamelen’s table with it. First, we double-check that the curve in the table corresponds with the invariants given in the table:

sage: x = QQ['x'].gen()
sage: f = -x^5+3*x^4+2*x^3-6*x^2-3*x+1
sage: [I2,I4,I6,I10] = igusa_clebsch_invariants(f)
sage: (I2^5/I10) == 2^7*3^15
True
sage: I2^3*I4/I10 == 2^5*3^11*5
True
sage: I2^2*I6/I10 == 2^4*3^9*31
True

Next, we show that these invariants coincide with the value we just proved. This seems to be the first complete proof of correctness for any entry of van Wamelen’s table, other than the classical and easy QQ(zeta_5). It was already proven by van Wamelen that the curve \(y^2 = f\) has CM by an order of \(K\), and a sketch was given of how to extend these results to show the order is the maximal order. Now we have a complete proof (by different means).:

sage: I6pr = (I2*I4-3*I6)/2
sage: invs == [I4*I6pr/I10, I4^2*I2/I10, I4^5/I10^2]
True

Check that a bug with incorrect embeddings is fixed:

sage: K = CM_Field([5,26,149])
sage: denominator_bound(K, bound='by').factor()
2^14 * 5^4 * 7^4

Our implementation computes Lauter-Viray bounds faster than Bruinier-Yang bounds, but Bruinier-Yang bounds are significantly sharper, so we use them by default:

sage: K = CM_Field([389,37,245])
sage: D1 = denominator_bound(K, bound='lv') # less than a second
sage: D2 = denominator_bound(K, bound='by') # long time: 6 seconds
sage: class_polynomials(K, D=D1) # long time: 50 seconds
[x^2 - 502951680/303601*x - 215457915617280/5768419,
 102098407935836160/11153001631321*x + 1497833452550013478502400/4026233588906881,
 2213545771008000000/92173567201*x - 36646804488714190848000000/33274657759561]
sage: class_polynomials(K, D=D2) # still a long time, but only 26 seconds
[x^2 - 502951680/303601*x - 215457915617280/5768419,
 102098407935836160/11153001631321*x + 1497833452550013478502400/4026233588906881,
 2213545771008000000/92173567201*x - 36646804488714190848000000/33274657759561]

recip.denominators.find_eta(K, how_many=None, proof=True)

Given a primitive quartic CM-field K, returns a list [eta] of one element eta such that O_F[eta] = O_K, if it exists.

If not, then returns a list L of pairs (eta, S), where S is thet set of primes dividing [O_K : O_f[eta]]. The sets S don’t contain any primes <= D/4 (D = Disc(F)), and the intersection of all sets S is empty.

If how_many is None, use as few as possible. Otherwise, return that number.

EXAMPLE:

sage: from recip import *
sage: K = CM_Field((x^2+2)^2-3) # a biquadratic field
sage: find_eta(K)
[alpha]

recip.denominators.find_eta_coprime(K, Krel, F, D, rel_diff, prime_bound, proof=True)

recip.denominators.find_eta_pid(K, Krel, F, rel_diff)

Given a primitive quartic CM-field K with no roots of unity other than +/- 1, returns an element eta of K as a relative field such that O_F[eta] = O_K, if it exists, and return None otherwise. Assumes F is a PID. See the source code of find_eta for what the input is.

EXAMPLE:

sage: from recip import *
sage: K = CM_Field((x^2+2)^2-3) # a biquadratic field
sage: Krel = K.relative_field()
sage: find_eta_pid(K, Krel, K.real_field(), Krel.relative_different())
alpha

recip.denominators.find_eta_pid_old(K, Krel, F, D, rel_diff)

Given a primitive quartic CM-field K, returns an one-element list [eta] such that O_F[eta] = O_K, if it exists, and return None otherwise. Assumes F is a PID. See the source code of find_eta for what the input is.

THIS version had bugs and has been deprecated.

recip.denominators.goren_lauter_bound(K, Phi=None)

If Phi is None, returns a positive integer \(D\) such that \(c^l D^{dk} N(f h_{10}^{-k}(Z))\) is integral whenever \(Z\) has CM by \(O_K\), \(f\) is a modular form of weight \(k\) and level \(1\) with integral Fourier coefficients, and \(d\) (if K/QQ is Galois) and \(2d\) (if K/QQ is non-Galois) is the degree of the algebraic number \(f h_{10}^{-k}(Z)\).

Here l is the degree and is l=d if K/QQ is Galois and l=2*d otherwise.

For the choice of invariants in the author’s thesis, take k=2 and note that 2^14*i_n satisfies the hypotheses.

If Phi is a CM-type, returns a number \(D\) in the real quadratic subfield of the reflex field of Phi such that that \(D^k f h_{10}^{-k}(Z)\) is integral whenever \(Z\) has CM by \(O_K\) of type Phi and \(f\) is a modular form of weight \(k\) and level \(1\) with integral Fourier coefficients.

recip.denominators.hilbert_symbol_trivial_outside(a, b, l, negative=True)

Returns True if and only if (a,b)_p != -1 for all primes p not equal to l.

If negative=True, then only accepts inputs with a and b negative, and performs some additional checks.

recip.denominators.lauter_viray_bound(K, safe=True, num_etas=None, implementation='bound', bound_calJ=1, bound_two=2)

Returns a denominator bound for Igusa class polynomials based on [LV]. See below for the output format.

INPUT:

• \(K\) – a quartic CM-field

• \(safe\) – if True, do a few redundant computations, to detect possible

  bugs

• \(num_etas\) – if O_K is not of the form O_{K_0}[eta], how many etas

  with O_K containing O_{K_0}[eta] to use. If None, uses the default of find_eta()

• \(implementation\) – “bound” or “gjlsvw”, if “bound”, then output a

  bound, if “gjlsvw” and the code of [GJLSVW] is loaded into a Magma session in a global variable \(m\), then compute an exact denominator with the aid of that code (very slow).

• \(bound_calJ\) - where we use upper bounds for calJ (see [LV]) instead

  of exact numbers, multiply them by this number.

• \(bound_two\) - replace the number 2 in Theorems 2.1 and 2.3 of [LV]

  by this number.

OUTPUT:

• If O_K = O_{K_0}[eta] and implementation=”bound” and bound_calJ is an integer >= 1 and bound_two is an integer >= 2, then returns a multiple of the denominator of the Igusa class polynomials.
• If O_K is not of the form O_{K_0}[eta], takes a few values of eta such that O_K contains O_{K_0}[eta] and returns the output for each of those.
• If implementation=”gjlsvw”, does not return bounds, but returns actual values (if it returns anything at all), hardly tested!
• If bound_calJ and bound_two are polynomial variables, returns primes p and the orders e_p with which they appear in the denominators. Each e_p is of the form given, where 0<=bound_calJ<=1 and 0<=bound_two<=2 depend on p.

EXAMPLES:

sage: from recip import *

The following gave output 4147360000 for an older version of Sage. I don’t know whether that was correct too (it was a factor 5^4 lower).:

sage: lauter_viray_bound(CM_Field([5,11,29]), safe=True)
2592100000000

sage: P.<a,b> = QQ[]
sage: lauter_viray_bound(CM_Field([5,11,29]), safe=True, bound_two=b, bound_calJ=a)
[[2, 4], [5, 3*a + 1], [7, 1], [23, 1]]

sage: lauter_viray_bound(CM_Field([389,37,245]), safe=True)
1913578584632940061725625
sage: lauter_viray_bound(CM_Field([389,37,245]), safe=True, bound_two=b, bound_calJ=a)
[[5, b], [11, 2*b], [19, 2*b], [29, 1]]

The actual denominators in the class polynomials for the last one are: 11^2 * 19^6 * 29^4 A factor 4 and something related to the primes 2, 3, 5 can be expected, so really this is [[2, *], [3, *], [5, *], [11, 8*b], [19, 8*b], [29, 4]] The 29^4 is sharp, the 19^16 is quite far off, and the 11^16 even more. This can be due to cancellation, but probably isn’t.

sage: K = CM_Field([17, 255, 15300]) sage: lauter_viray_bound(K, safe=True, bound_two=b, bound_calJ=a) [[2, 20*a*b + 15*b],

[3, 16*a + 4], [5, 0], [13, 23*a + 2], [19, 4*a + 3], [67, 2], [83, 3*a + 3], [157, 8*a + 2], [883, 2]]

Observed denominator in class polynomial: 13^4 * 19^6 * 67^4 * 83^6 * 157^4 * 883^4 Seems to suggest cancellation at 3 and non-sharpness or cancellation at 2, 13, 19, 83, 157. When getting rid of all cancellation, but without caring too much for the small primes, we get something like: 2^(20/3) * 3^(2/3) * 13^2 * 19^4 * 67^2 * 83^4 * 157^2 * 883^2 for I10 (product over all curves) So we have non-sharpness for 13, 19, 83, 157 and maybe 2 and 3. We get for the prime 13 an exponent 23*a+2 = 2, so out of the 23 take 0. For the prime 83, we get 3*a+3 = 4, so out of 3, take only 1 For the prime 157, we get 8*a+2=2, so out of 8, take 0. The big discrepancy is in the prime 13.

In Magma, we get the following, which agrees with these conclusions. ListAllEmb(-1, 0, 319, -30, 17, 13); ... 2 ListAllEmb(-1, 0, 319, -30, 17, 19); ... 4

recip.denominators.lauter_viray_bound_given_eta(K, eta, safe=True, verbose=False, factor_two=True, bound_calJ=1, bound_two=2)

Returns a list of pairs (l_i, e_) such that sum of e_i with l_i=l is at least twice the right hand side of Theorem 2.1 or 2.3 of [LV].

If \(factor_two\) is True, uses Theorem 2.3, otherwise, uses Theorem 2.1.

INPUT:

• \(K\) – a quartic CM-field
• \(eta\) – an integral element of K, not in \(K_0\)

• \(safe\) – if True, do a few redundant computations, to detect possible

  bugs

• \(factor_two\) – If True, multiply by the factor two at the beginning of the right hand side as in Theorem 2.3 of [LV]. If False, use factors two as in Theorem 2.1.

recip.denominators.lauter_viray_win(K, eta, safe=True, verbose=False, factor_two=True, m=Magma, bound_calJ=1, bound_two=2)

Returns a list of pairs (l_i, e_) such that sum of e_i with l_i=l is at least twice the right hand side of Theorem 2.1 or 2.3 of [LV].

If \(factor_two\) is True, uses Theorem 2.3, otherwise, uses Theorem 2.1.

INPUT:

• \(K\) – a quartic CM-field
• \(eta\) – an integral element of K, not in \(K_0\)

• \(safe\) – if True, do a few redundant computations, to detect possible

  bugs

• \(factor_two\) – If True, multiply by the factor two at the beginning of the right hand side as in Theorem 2.3 of [LV]. If False, use factors two as in Theorem 2.1.
• bound_calJ and bound_two are not used.

TESTS:

sage: from recip import *
sage: magma.load("gjlsvw.magma") # optional - magma gjlsvw
'Loading "gjlsvw.magma"'
sage: set_recip_verbose(1)
sage: lauter_viray_bound(CM_Field([8,4,2]), safe=True, implementation="gjlsvw") # indirect doctest, long time 23 minutes, optional - magma gjlsvw
16

recip.denominators.next_prime_in_class(a, n, gen=False, allow_one=False)

Returns a prime P of prime norm p>n in the same ideal class as a.

If gen is True, also return an element y such that y*a=P.

If allow_one is True, then instead of a prime P, also allow P=1, regardless of n, if a is principal.

recip.denominators.rhotilde(d, s0, s1, l, part=0)

Returns rhotilde_d^(2)(s0, s1) from Theorem 2.4

If part=0, really returns rhotilde, if part equals 1 or 2, only returns the first or second factor.

recip.denominators.win_implementation(alpha0, alpha1, beta0, beta1, D, p, m)

Assumes the code from [GJLSVW] has been loaded into the Magma session m (requires magma). Returns the output of length of the output of ListAllEmb.