Questions on Power Series ctx behavior, precision, and Polynomial Matrices types

[Dioprz]

Hello,

First of all, I wanted to thank you again for your previous guidance regarding multivariate power series at (#131). Thanks to python-flint, our migration of CryptographicEstimators from Sage to a pure Python library was successful, and we truly appreciate the work you've put into this project.

During the migration I collected a few questions regarding the use of power series and the future roadmap for python-flint, so I would like to ask for your orientation:

Currently, the ctx global variable seems to control the maximum number of computable coefficients for a power series, rather than the precision declared during series construction. This behavior raises a few questions for me:

1. Is there a low-level implementation reason for this? I've found it a bit tricky that if ctx.cap is set to 10 and a series is created with precision 15, the series effectively has precision 10. However, if ctx.cap is 10 and the series precision is 5, the series retains precision 5.
2. Beyond my curiosity, we've decided to set a large ctx.cap (20000) in our library's root __init__ to prevent new developers from needing to worry about this. Is this considered a bad practice? Should we anticipate any impact on overall library performance, such as overhead or slower utilization?

Additionally, I recall having to create a prec attribute in our classes that use power series because the only way I found to retrieve the precision directly from the series was by parsing its repr. Could you please clarify if there's another way to extract the precision for future use?

Finally, during our migration we needed to handle matrices of polynomials to calculate their determinants. I noticed that C-flint supports these types, but I didn't find them in the python-flint documentation the last time I checked. Is it in the feasible future roadmap to include these types in python-flint? We are currently using SymPy polynomials for these determinant calculations, but the final implementation is approximately 8x slower than the Sage version.

Thanks for your time and assistance.

[oscarbenjamin]

I think that the series interface is just not fully thought through.

Firstly we shouldn't use a global variable at all. The new interfaces based on the generics will have contexts for series. This is only provided experimentally for now and the interface will be redesigned in future but is a bit more like how it should work at least in terms of handling the cap:

In [13]: import flint.types._gr as gr

In [14]: QQ = gr.gr_fmpq_ctx

In [15]: QQR = gr.gr_series_ctx.new(QQ, 5)

In [16]: x = QQR.gen()

In [17]: (1 + x).sqrt()
Out[17]: 1 + (1/2)*x + (-1/8)*x^2 + (1/16)*x^3 + (-5/128)*x^4 + O(x^5)

You can set the cap to 20000 if you want but if you call a function like sqrt starting from an exact series then it is going to compute 20000 terms.

Once the generic interfaces are implemented it will be possible to have matrices of polynomials, series and other things. Currently matrices is the part that is not even exposed in the experimental interface unfortunately.

It is also worth noting that SymPy's DomainMatrix type will be able to use python-flint's multivariate polynomials under the hood soon. A GSOC project to do this is about to start.

[oscarbenjamin]

I'm not sure if there is any way to get the prec of e.g. an fmpq_series.

[Dioprz]

Amazing news, then!

I've created an issue in our repository to keep track of the new interface, so I will close this for now.

Thanks for the comprehensive answer, everything is clear now. Until next time 🚀

[oscarbenjamin]

Additionally, I recall having to create a prec attribute in our classes that use power series because the only way I found to retrieve the precision directly from the series was by parsing its repr. Could you please clarify if there's another way to extract the precision for future use?

I just added a .prec attribute in gh-289:

In [1]: import flint

In [2]: s = flint.fmpz_series([1, 2, 3], prec=6)

In [3]: s
Out[3]: 1 + 2*x + 3*x^2 + O(x^6)

In [4]: s.prec
Out[4]: 6

[Dioprz]

Much appreciated!