#16477: implement Dirichlet series
-------------------------------------+-------------------------------------
Reporter: rws | Owner:
Type: enhancement | Status: needs_work
Priority: major | Milestone: sage-wishlist
Component: number theory | Resolution:
Keywords: moebius, zeta, | Merged in:
sigma, euler_phi, euler | Reviewers:
Authors: Jonathan Hanke, | Work issues: use pari, g.f. input
Ralf Stephan | Commit:
Report Upstream: N/A | 949082ca407de7df7ae2ce31ecfad4f5d21f3ffa
Branch: public/dirichlet- | Stopgaps:
series |
Dependencies: #18038, #18041 |
-------------------------------------+-------------------------------------
Comment (by jj):
Replying to [comment:26 rws]:
> Replying to [comment:24 jj]:
> > {{{
> > f = DirichletSeries(id)*DirichletSeries(id)
> > f == DirichletSeries(sigma0)
> > f[91234154]
> > f // nice representations:
> > => sum_{n in Z} (sum_{d|n} 1)
> > or: sum_{n in Z} sigma0(n)
> > }}}
> > nice representations/output of coefficient functions after operations
(hard),
> That would first need conversion of the g.f. into divisor sum form.
Another ticket.
>
There are (at least) two different (exact) approaches:
- Coefficient functions
- Generating functions (as q-series?), I am not entirely sure what you
mean by it...
I was emphasizing on the coefficient function part.
Clearly it is possible to define dirichlet series by specifying the
coefficient function (as a normal function). It is even relatively simple
to implement all kind of operations.
Individual coefficients could also be calculated (up to some precision).
What is hard is getting a "nice representation" (e.g. a divisor sum form
as you mentioned above).
- One idea might be to somehow "decompile" a function into source code /
some at least nicer form.
- One idea might be to use symbolic expression (rather limited).
- Another idea might be to implement very basic coefficient functions and
allow all kind of operations with them (using ast(?)/whatever) to be as
flexible as possible with the combinations (include as many of the popular
examples as possible).
- Finally we could simply use the old representation by just calculating
the coefficients up to some precision. The advantage would be that
"precision" is no longer part of the series, only of the representation.
> > {{{
> > id = ArithmeticFunctions().id()
> > sigma0 = ArithmeticFunction(lambda n: sigma0(n))
> > id*id == sigma0 // Dirichlet convolution
> > }}}
> That would need ability to compute a g.f. from the coefficients. I think
this is possible but hard.
The relation between coefficient functions and generating series might be
a challenge. I wonder what approach is more suitable. Maybe the two
concepts both have interesting cases that cannot easily be translated to
the other way. So maybe both ways should be supported (?).
> > support functions from ideals (TODO: figure out the correct category
for the domain
> > of coefficient functions).
> And a third ticket.
>
> So this ticket would prepare for the others by providing creation from
expressions of a limited form (polynomial fractions with generator from
`zeta(a*s+b)` and `L(c)`).
I was thinking in very general terms ("any" function from Z). That should
be fairly simple (even with operations on series) and allow the
calculation of the coefficients up to an arbitrary precision. Example:
{{{
(F+G).cf = lambda n: F.cf(n) + G.cf(n)
(F*G).cf = lambda n: sum(F.cf(d)*G.cf(n/d) for d in divisors(n))
}}}
However it will be very hard to get "nice" representation of the
coefficient functions.
Maybe "polynomial fractions with genertore from zeta(a*s+b) and L(c)" is
more powerful, I don't know.
--
Ticket URL: <http://trac.sagemath.org/ticket/16477#comment:27>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.
