# Sage Days in Le Teich (02/2025) :bird: :owl: :penguin: :eagle: :duck: 🦤 🦩 🦜 🪿 :turkey: :rooster: :chicken: 🦚 🦢 :dove_of_peace: This page is a description of the projects of the participants during [Sage Days 128](https://wiki.sagemath.org/days128). See also the pull requests with tag [sd128](https://github.com/sagemath/sage/pulls?q=label%3Asd128+) on github.  ## Epilogue: Final status report *In this section, the participants are invited to describe the progress made during the workshop.* ### Sage packaging for Guix *Participants*: Andreas Enge, Julian Rüth *Short Description*: SageMath has been made available as a package in the [Guix](https://guix.gnu.org/fr/) GNU/Linux distribution, which due to its functional nature (in the sense of functional programming languages), its focus on bootstrapping all software from source and its collaboration with Software Heritage, provides stronger guarantees for reproducible research than traditional distributions, and which has gained [track](https://hpc.guix.info/blog/2025/02/guix-hpc-activity-report-2024/) in the high performance computing community. Given the use of an isolated environment for compiling packages and the fact that each package and thus also the dependencies of Sage live in their own directory instead of being mixed into /usr, this has required a certain number of patches to the Sage source code. An additional package for Maxima being compiled with the Ecl Common Lisp implementation has been created, since the standard Maxima package uses the (a priori more efficient) Sbcl implementation. A number of patches not yet merged to the Sage codebase have also had to be identified for compatibility with more modern packages available in Guix as compared to the versions expected by Sage. The Sage package definition was [merged](https://issues.guix.gnu.org/76270) right after the SageDays. Guix being available on a number of high performance computing clusters and computing environments of research institutions, it has thus become available immediately for users of, among others, the tier 3 local centres [PlaFRIM](https://www.plafrim.fr/) at INRIA Bordeaux, the [Max Delbrück Center for Molecular Medicine](https://www.mdc-berlin.de/) and the [University of Tennessee Health Science Centre](https://uthsc.edu/) and the tier 2 regional centres [GRICAD](https://gricad-doc.univ-grenoble-alpes.fr/en/hpc/) in Grenoble and [GliCID](https://www.glicid.fr/) in Nantes, and the French national initiative [Grid'5000](https://www.grid5000.fr/w/Grid5000:Home). ### Package SageMath 10.5 for conda-forge *Participants*: Julian Rüth SageMath 10.5 is now in conda-forge for Linux and macOS and there's an updater installer for Linux and macOS at https://github.com/flatsurf/sage-flatsurf/releases/tag/0.7.3 and a clickable exe installer for Windows at https://github.com/flatsurf/sage-flatsurf/releases/tag/0.7.3. ### Algorithm Keyword *Participants*: Julian Rüth See description in the list below. Some progress was made but it's still only a Proof-of-Concept. ### Governance/Code of Conduct Session *Participants*: Julian Rüth, JP Labbé (and everybody else present) We had a session talking about the current state of the project, the challenges in the current governance system and possible ways to improve upon the status quo. ### Macaulay Matrix *Participants*: Mercedes Haiech (with help of Xavier Caruso) We created a new ticket [ Macaulay matrix for Sequence Multivariate Polynomials #39511 ](https://github.com/sagemath/sage/pull/39511) which added a function in the class`PolynomialSequence_generic` to compute the Macaulay matrix up to a certain degree of a sequence of polynomials. ### Witt vectors *Participants*: Rubén Muñoz-\-Bertrand I took care of the new ticket [#39355](https://github.com/sagemath/sage/pull/39355), it is a 1000 lines long pull request implementing Witt vectors. I hope it wil soon be reviewed and merged. ### A conjecture involving computation of Bruhat paths *Participants*: Lorenzo Perrone I've learned a lot about Sagemath (for instance, doctesting and profiling) thanks to Sébastien and Frédéric. As a result, my file to check the statement of the conjecture I am working on is much faster. Before SageDays128 it would take around 20 seconds to test it on the Coxeter group B3; with the last optimization it takes less than one second and I could finally test it on the bigger case of H3 for which the validity of the conjecture was not known yet. ### Playing with lattice genus *Participant*: Alice Pellet-Mary I have learned how to compute the genus of lattices in sage. In particular, I wanted to understand how the genus behaved for lattices arising as ideals of number fields. I have been able to play with this and understand the object much better. I have also send a small script to some co-authors so that they can play with it too. ### Computing conductors of non-maximal orders in number fields *Participant*: Alice Pellet-Mary I wanted to test what was the probability, when taking a "random" number field, that it contained a monogenic order with small index in the ring of integers (equivalently, this means that the conductor of the order has a small algebraic norm). I have started to write some code to compute this probability experimentally using Sage. So far, I am able to test number fields up to degree roughly 40. I will need to keep working on my code in order to reach higher degrees. ### General relation bases for polynomial matrices *Participant*: Vincent Neiger, Hugo Passe The project has been carried out in its entirety (relation bases and interpolant bases, with as much generality as hoped for). The pull request is here: [#39516](https://github.com/sagemath/sage/pull/39516) and is currently under review. Before adding these functionalities, we had some preliminary discussions, notably about whether we should integrate at the same time another, related, type of relations called "simultaneous Padé approximants" (and generalizations of it). In the end we have left this as a future task for the next couple of months. ### Integer matrices construction *Participant*: Hugo Passe (with help of Vincent Neiger) We resolved the ticket [#36104](https://github.com/sagemath/sage/issues/36104) with the pull request [#39488](https://github.com/sagemath/sage/pull/39488). Due to the migration from Python 2 to Python 3 some casts led to errors when constructing matrices over modular integers, from integer matrices with large entries. The goal was also to learn how to contribute to Sage. ### OM-algorithm and integral basis of fractional ideals *Participant*: Dounia Darkaoui, Xavier Caruso, Martin Weimann. A prototype of the OM-algorithm is available as a package https://gist.github.com/TristanVaccon/d3414cc7207c369bd05b8a6f703e7941 (mainly developed by Tristan Vaccon, based on https://www.fil.univ-lille.fr/~poteaux/fichiers/PoWe22b.pdf . We checked that this procedure is more efficient than the procedure mac_lane_approximants which is currently implemented in Sage. This package still need to be implemented in Sage. This project is going on with several people, a zulip channel is dedicated to it https://sagemath.zulipchat.com/#narrow/channel/271072-padics/topic/SageDaysFeburary2025. Feel free to join us ! We added a function *valuation* in Sage for the field of Laurent power series, this was missing. Dounia Darkaoui wrote the algorithm MaxMin from https://www.sciencedirect.com/science/article/pii/S0747717117300780?via%3Dihub . This is a crucial step towards an efficient algorithm that computes integral basis of fractional ideals. The implementation of the OM-algorithm in Sage will allow this procedure to be much more efficient. ### Generation of combinatorial maps (as `FatGraph`) *Participants*: Oscar Fontaine *Short Description*: For mathematical purpose, it is nice to have big examples of combinatorial maps and be able to manipulate them. My goal is to be able to generate big example of such maps with some constraints (genus, number of vertex and faces, list of vertex degrees,...) with a probabilistic method or a enumerative method. I create functions to generate trees with fixed list of node degrees using [ARS96](https://inria.hal.science/inria-00073765) and then i implemented a bijection between such trees with decorations and maps see [FuGu21](http://igm.univ-mlv.fr/~fusy/Articles/AllGenus.pdf). My code can be found on my [Github](https://github.com/Oscfon/Bigon). I will try to add it to flatsurf. ### Iterative version on some functions on trees *Participants*: Oscar Fontaine, Martin Rubey *Short Description*: The class `abstract_tree` in Sage used lot of recursive functions for basic statistic on trees like depth or number of nodes. On big trees, calling this functions reach the recursion limit. We implemented new iterative versions of this functions to avoid this problem. Our work can be found on this [pull request](https://github.com/sagemath/sage/pull/39519). ### Cut and project schemes *Participants*: Sébastien Labbé, Carole Porrier *Short Description*: The goal is to implement the construction of aperiodic point sets/tilings using Euclidean cut and project schemes. The window in the physical space and internal spaces will be given by polyhedron objects. Hopefully, we can reconstruct some basic examples during the week (Penrose tilings, Ammann tilings, Jeandel-Rao tilings, golden octogonal tilings, metallic-mean Wang tilings, etc.) *Status report* : We made progress in the cut and project scheme module of the [slabbe](https://gitlab.com/seblabbe/slabbe/) package. Here is a demo of what can now be done in the development version of the package: ```python sage: from slabbe import cut_and_project_schemes sage: c = cut_and_project_schemes.Penrose() sage: c 5-to-2 cut and project scheme sage: print(c) 5-to-2 cut and project scheme over Number Field in a with defining polynomial z^4 - 5*z^2 + 5 with a = 1.175570504584947? Projection to physical space: [ 1 -1/2*a^2 + 1 1/2*a^2 - 3/2 1/2*a^2 - 3/2 -1/2*a^2 + 1] [ 0 -1/2*a^3 + 3/2*a 1/2*a -1/2*a 1/2*a^3 - 3/2*a] Projection to internal space: [ 1 0 0 1 a^2 - 2] [ 0 1 0 -a^2 + 2 -a^2 + 2] [ 0 0 1 a^2 - 2 1] Lattice generated by the columns of: [1 0 0 0 0] [0 1 0 0 0] [0 0 1 0 0] [0 0 0 1 0] [0 0 0 0 1] sage: c.is_valid() True sage: m = c.canonical_model_set(shift=-vector((1,1,1,1,1))/100) sage: W = polytopes.hypercube(2, intervals=[(-10,10), (-10,10)]) sage: G = m.plot_in_physical_space(W) sage: G.show(aspect_ratio=1, figsize=20) Launched png viewer for Graphics object consisting of 934 graphics primitives ```  ### Colored Triangulations *Participants*: Fabien Vignes-Tourneret *Short description*: In the last 15 years or so, a new approach to quantum gravity has emerged. It relies on random tensor models and defines probability measures on families of colored triangulations in dimension D>2. These triangulations are dual to regular properly edge-colored graphs. I have written python and SageMath commands to deal with these graphs and the geometry of the corresponding spaces. I would like to clean and optimize the code in order to propose its inclusion into SageMath. *Status report*: The very first step was to implement exhaustive edge-colorings in Sage. After discussions with F. Chapoton and S. Labbé, I realized that the code I wrote ten years ago was way too complicated. A simple combination of all_edge_colorings and line_graph is enough. But to deal with graphs with multiple edges, I had to implement line_graph for such graphs. This was the object of the PR [#35918](https://github.com/sagemath/sage/pull/39518) which has been approved and merged a few days ago. Next step would be to speed up the edge-coloring algorithm either by generating only isomorph-free colorings or by better testing isomorphisms. ## Prologue: Proposed Projects *In this section, the participants are invited to describe the project they intend to work on during the workshop.* ### Operads - [#39299](https://github.com/sagemath/sage/pull/39299) *Participants*: Frédéric Chapoton, Martin Rubey *Short Description*: Try to advance the basic implementation of operads. Some implementation choices are questionable. - [ ] Fix the issue about PDF documentation. ### Graphs: immutable or not *Participants*: Frédéric Chapoton *Short Description*: review many recents pull requests about immutability in graphs by D. Coudert. This aims at a more coherent interface for graphs and digraphs. - [ ] [#39266](https://github.com/sagemath/sage/pull/39266) ### Algorithm Keyword *Participants*: Julian Rüth *Short Description*: often the default `algorithm` value is far from optimal. I want to finish work on a little auto-tuning framework to better select the default parameters. ### Finding short vectors in certain ideal lattices *Participants*: Alice Pellet-Mary *Short Description*: With Aurel, we have a project about accelerating the computation of short vectors in ideal lattices of certain number fields (in general this is very costly, but for some number fields we hope that it could be much better). Aurel started an implementation of the algorithm (in pari/gp), and my objective is to finish it and optimize it. ### Remove `ParentWithGens` *Participants*: Martin Rubey, Frédéric Chapoton, Julian Rüth *Short description*: The ancient class `ParentWithGens` is near the top of a hierarchy of classes, and in particular is used by the auld `Ring` class: - `Parent_old` - `ParentWithBase` - `ParentWithGens` - `Ring` - `CommutativeRing` - `Field` - `FiniteField` This is all dated historical stuff, before the implementation of the categories. Removing `ParentWithGens` may be over-ambitious, but some progress can be made towards the general use of the *Parent/Element* framework. One thing to do is to move methods away from the auld *Ring* class to the category framework. - [ ] [#39497](https://github.com/sagemath/sage/pull/39497) Moving *random_element* could be easy. - [ ] [#39531](https://github.com/sagemath/sage/pull/39531) Moving *is_field* could involve some refactoring of the p-adic rings. - [ ] Remove completely `groups/old.pyx` (too early, deprecated in 10.4 in July 2024) - [ ] [#39419](https://github.com/sagemath/sage/pull/39419) Try to get rid of the last `_coerce_c_impl` - [x] [#39311](https://github.com/sagemath/sage/pull/39311) - [x] [#39303](https://github.com/sagemath/sage/pull/39303) - [x] [#39302](https://github.com/sagemath/sage/pull/39302) - [ ] [#37158](https://github.com/sagemath/sage/pull/37158) Use `Parent` in quotient rings - [x] [#39394](https://github.com/sagemath/sage/pull/39394) Move some methods into category `Fields` ### Sanitize `InfinitePolynomialRing`: `_element_constructor_` and `gens` *Participants*: Martin Rubey, Julian Rüth *Short Description*: The `InfinitePolynomialRing` abuses `gens` to refer to its alphabets. Its `_element_constructor_` contains many comments saying that things don't work, and uses `sage_eval` in cases where it really shouldn't. Maybe one can manage to change the gens to return a `Family` instead. - [ ] Understand the purpose of `GenDictWithBasering` there. ### Check whether `define_implicitly` can be made to work with composition of species *Participants*: Martin Rubey *Short Description*: I hit a theoretical obstacle when trying to make a power series Ansatz for implicitly defining combinatorial species. It would be nice to check whether this can be circumvented. If not so, it would be good to document it as precisely as possible. ### Implementation of the OM-algorithm and its applications to compute integral basis and Riemann-Roch spaces *Participants*: Xavier Caruso, Dounia Darkaoui, Martin Weimann *Short Description*: We aim to implement the OM-algorithm to factorize polynomials over local fields. And then to use this procedure to compute integral basis and Riemann-Roch spaces on algebraic curves. ### Witt vectors *Participants*: Rubén Muñoz-\-Bertrand *Short description*: There is already a ticket ([#11457](https://github.com/sagemath/sage/pull/11457)) with commits on GitHub. It would be nice to close it. A refreshed branch is available at [#39355](https://github.com/sagemath/sage/pull/39355). I (Rubén) have also implemented a new algorithm, up to 100 times faster for some rings, for the addition and multiplication of these vectors. The code is on my web page, but I would like to format this code to put it in SageMath. ### Fast exponentiation of polynomials *Participants*: Rubén Muñoz-\-Bertrand *Short description*: To speed up the Witt vectors algorithm explained above, we need to fast exponentiation of polynomials. To my knowledge, Euler's method (explained by Knuth and sometimes called Miller's method) is not implemented in SageMath (but there is a SymPy ticket [#23665](https://github.com/sympy/sympy/issues/23665)), neither is its generalization to several variables by Horowitz. I would like to add that to the library too. ### General relation bases for polynomial matrices *Participants*: Vincent Neiger *Short description*: handle (at last) the ticket [#23645](https://github.com/sagemath/sage/issues/23645). *Longer description*: Many functionalities for polynomial matrices have been added since this ticket was created [(relevant doc page)](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/matrix_polynomial_dense.html), and we have now everything at hand for writing a first (not necessarily fast, but correct and convenient) implementation of a method that computes bases of relations for polynomial matrices. Currently, the only supported type of relations is approximant bases (related to Hermite-Padé approximation). The main goal is to provide a method that would be as general as possible; by relying either on the existing minimal kernel basis, or on the existing shifted Popov form computation, whichever that is faster. A secondary goal is to provide a method specialized to the interpolant basis case (a.k.a. vector rational interpolation or M-Padé approximation), which would either directly call the general relation basis code, or be written as a variation of the current approximant basis method, whichever that is faster. ### Hyperelliptic curves and Jacobian arithmetic *Participants*: Sabrina Kunzweiler *Short description*: Work on [#39161](https://github.com/sagemath/sage/pull/39161). *Long description*: In Sagemath, hyperelliptic curves are represented by a plane model with a singularity at infinity, and the arithmetic on the Jacobian is incorrect when the equation for the hyperelliptic curve has degree 2g+2. In [#39161](https://github.com/sagemath/sage/pull/39161), we use a smooth model in weighted projective space to represent hyperelliptic curves, and we add an implementation for the arithmetic on Jacobians of hyperelliptic curves with an equation of degree 2g+2. This is joint work with Giacomo Pope and Gareth Ma. The plan of the project is to keep working on this PR, and in particular add functionality about the Kummer surface. ### Colored Triangulations *Participants*: Fabien Vignes-Tourneret *Short description*: In the last 15 years or so, a new approach to quantum gravity has emerged. It relies on random tensor models and defines probability measures on families of colored triangulations in dimension D>2. These triangulations are dual to regular properly edge-colored graphs. I have written python and SageMath commands to deal with these graphs and the geometry of the corresponding spaces. I would like to clean and optimize the code in order to propose its inclusion into SageMath. ### A conjecture involving computation of Bruhat paths *Participants*: Lorenzo Perrone *Short Description*: Optimizing a function that given a finite Coxeter group *W*, checks if a certain conjecture, involving the weak order and the Bruhat graph of *W*, holds in that case. *Long Description*: The conjecture was formulated in 2011 by Matthew Dyer for an arbitrary Coxeter group. It is still open even in the finite cases and it would be nice to check its validity for the six exceptional groups, namely, *E6, E7, E8, F4, H3, H4*. The conjecture gives a characterization of the join of two elements in the (right) weak order of *W*. In particular, it states that the so called set of inversion of the join of *u* and *v* is given by the reflections that are vertices of *(u,v)*-Bruhat paths. Therefore, having to work with a lot of paths, there is a lot that can be adapted and optimized in order to reduce the computational cost that one faces when working with groups of high order. ### Sage integration of Pari functionalities *Participants*: Aurel Page + some Sage programmers (volunteer needed!) *Short Description*: Some functionalities of Pari are currently only available in Sage through explicit call of the gp function. It would be nice to implement better integration (with nice Sage classes, doc and tests). I think this would benefit both Pari and Sage. Examples: - [ ] ray class groups (bnrinit and friends) *Comment*: Something may be available in [#15829](https://github.com/sagemath/sage/issues/15829) -> Frédéric Chapoton created [this PR](https://github.com/sagemath/sage/pull/39525#issuecomment-2658715249) but more work is needed. - [ ] construction of class fields (bnrclassfield); in fact, even - [ ] Hecke Grossencharacters (gcharinit and friends) - [ ] central simple algebras over number fields (alginit and friends) in particular, improve quaternion algebras: - [x] review improvements to the ramification computations in progress in [this PR](https://github.com/sagemath/sage/pull/37173) - [ ] review construction from ramification in [this PR](https://github.com/sagemath/sage/pull/37189) - [ ] compute a maximal order - [ ] compute mod p splitting - [ ] compute Eichler orders - [ ] enumeration of number fields with given Galois group and discriminant (nflist) - [ ] modular forms via the trace formula (mfinit and friends) - [ ] S-units of number fields in product representation (bnfunits) (see [this issue](https://github.com/sagemath/sage/issues/31754)) - [ ] use `nfsplitting` in Sage's `splitting_field` (?) ### Central simple algebras of Pari *Participants*: Aurel Page *Short Description*: Pari has functionalities for central simple algebras (CSA), but some useful features are missing. I would like to work on some of them: - [x] implement Skolem--Noether theorem in CSA [commit](https://pari.math.u-bordeaux.fr/cgi-bin/sgitweb.cgi?p=pari.git;a=commit;h=ae33d0f2d6bb8a2ccfd9dadd845c2d5d67acd84f) - [x] test isomorphism of CSA [commit](https://pari.math.u-bordeaux.fr/cgi-bin/sgitweb.cgi?p=pari.git;a=commit;h=14a1978a2b3f1e7eafbcdbda935bc6a65baa91bf) - [ ] include Denis Simon and Péter Kutas's GP script to construct isomorphisms between quaternion algebras over $\mathbb{Q}$ - [ ] improve construction from Hasse invariants - [ ] faster reduced norm and charpoly - [ ] orders and ideals - [ ] splitting at infinity, LLL-reduction of the integral basis - [ ] include James Rickards's C code for fundamental domains [Code](https://github.com/JamesRickards-Canada/Fundamental-Domains-for-Shimura-curves) Also done: [two](https://pari.math.u-bordeaux.fr/cgi-bin/sgitweb.cgi?p=pari.git;a=commit;h=8048f941433fddeb8058e5b597989c7df683d64a) [bugfixes](https://pari.math.u-bordeaux.fr/cgi-bin/sgitweb.cgi?p=pari.git;a=commit;h=076b97f3a57d3a803cfdefc0ad63dcdb8aeac9f2) ### Implement "is_regular" for simplicial fans *Participants*: Jean-Philippe Labbé *Short Description*: Verifying whether a complete simplicial fan is regular can be done either by getting the dimension of a certain polyhedron (or equivalently by computing the feasibility of a certain LP). This is particularly interesting to know whether the simplicial fan is the normal fan of a polytope. *Comment*: What do you mean by "regular" here ? ### Implement Coxeter graphs (in the extended sense of Vinberg) *Participants*: Jean-Philippe Labbé *Short Description*: Coxeter matrices are already implemented for the desired behaviour. It would be great to have the equivalent module for Coxeter graphs in parallel. This requires a lot of thoughts on how to properly plan the implementation. *Comment*: See [Brocoli](https://github.com/jplab/brocoli) ### Modular symbols and harmonic cochains over function fields *Participants*: Cécile Armana *Short description*: - Have an implementation of modular symbols over function fields and Hecke operators on them in SageMath. Such modular symbols are related to harmonic cochains over $\mathbb{F}_{q}(T)$, which are some analogues of classical modular forms of weight $2$. I already have naive code: it needs to be cleaned up, optimized and extended (to non-prime level for instance). - Start an implementation of harmonic cochains over $\mathbb{F}_{q}(T)$ in SageMath. Previously some people wrote related code in Magma (Ralf Butenuth, Burak Cakir). *Comment*: In Pari or in SageMath ? *Cécile*: in SageMath (+ updated title and project description). ### Simplicial systems *Participants*: David Siukaev *Short description*: Explore an object in sage for simplicial systems, with its help check solutions of matrix equations, find restrictions on the labeling of the dual graph. *Status report*: The functions added to the class *SimplicialSystem* now find the dual labeling, invariant measure, and first Lyapunov exponent for the Triangle Map and Selmer algorithm in dim3. A graph has been constructed for the modified Triangle map in high dimensions. However, the calculations in Sage for the dual labeling are unfinished and require further work. More information about the class *SimplicialSystem* : https://gitlab.com/fougeroc/MCF/-/blob/master/simplicial.py?ref_type=heads ### Euclidean lattices and structured lattices *Participants*: Afonso Li *Short Description*: The goal is to become familiar with Sage, particularly with lattice representation in Sage. Then, the focus will shift to exploring the S-units of a number field. These units form what we call the log-S-unit lattice, and I want to compare them with other random lattices. What was done: Given as a number field K, I coded in sage the minimal S-unit lattice and studied the corresponding shortest. The problem is the code does not deal with principal ring of integers of K, which should be fixed soon. I also built some particular lattices in Sage namely SIS lattices to study their invariants and compare them with our S unit lattices. I also need to extend my code any finite set of prime ideals S for building S unit lattices. Update: The principal case was dealt, I am now focusing on relaxing the conditions on S. ### Support in rank metric *Participants*: Camille Garnier and Rubén Muñoz-\-Bertrand *Short Description*: The goal was to produce a function to compute the rank support of a vector. We wrote this function and added it in the file linear_rank_metric.py. The pull request is here : https://github.com/sagemath/sage/pull/39510/files ## Some pictures            (if anyone want those pictures in higher quality don't hesitate to ask Dounia)