What is going on with the timings in the following examples?

sage: S = CuspForms(1728, 2)
sage: %time f = S.hecke_polynomial(2)
CPU times: user 17276.68 s, sys: 13.46 s, total: 17290.14 s
Wall time: 17293.59 s
sage: f
x^253 + x^251 - 2*x^249

(Meanwhile, in a separate Sage session...)

sage: %time M = ModularSymbols(1728, 2, 1)
CPU times: user 0.47 s, sys: 0.03 s, total: 0.50 s
Wall time: 0.54 s
sage: %time S = M.cuspidal_subspace()
CPU times: user 1.57 s, sys: 0.00 s, total: 1.57 s
Wall time: 1.54 s
sage: %time f = S.hecke_polynomial(2)
CPU times: user 19.09 s, sys: 0.00 s, total: 19.09 s
Wall time: 19.07 s
sage: f
x^253 + x^251 - 2*x^249

That's almost 5 hours using CuspForms() and just over 20 seconds using
ModularSymbols() directly. To compute the same thing. Is this expected
behavior? Am I being stupid somehow?

(Note: I did this on a "very old" (2 years) version of Sage. But as other
checks, I also tried the first method on a relatively up to date version on
my laptop and stopped after about 7 minutes when it was using 15% of my
ram. I also tried Magma, where the standard ModularForms(),
CuspidalSubspace(), HeckePolynomial() commands complete quickly, and I
tried cloud.sagemath.com, where I again killed the computation after a few
minutes. Maybe if I find an old enough version of Sage the computations
will be the same speed...)

For a long time, and until recently, I would have just tried the first
method, not knowing what I was doing, and would have said to myself
something like "I guess Sage is probably pretty good at computations with
trivial character, so this is probably just something that takes a long
time." Now instead I would guess that for at least some functionality the
ModularForms()/CuspForms() classes are so slow that they are effectively
broken (or, at least, not much more than a toy) and have been for a long
time. This is a shame, because I shouldn't even need to know that modular
symbols are a thing that exist if I just want to do some simple
computations like this.

I would expect ModularForms/CuspForms to mostly be a light wrapper around
ModularSymbols, but something else must be going on here. One explanation
would be that for some reason the first computation triggers some large
computation that would make all subsequent computations faster, but the
computation of hecke_polynomial(3) didn't seem like it was going to be
fast. (I didn't wait for it to finish.)

-- 
You received this message because you are subscribed to the Google Groups 
"sage-nt" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to sage-nt+unsubscr...@googlegroups.com.
To post to this group, send an email to sage-nt@googlegroups.com.
Visit this group at https://groups.google.com/group/sage-nt.
For more options, visit https://groups.google.com/d/optout.

Reply via email to